/* General Compile and inject code
- Copyright (C) 2014-2017 Free Software Foundation, Inc.
+ Copyright (C) 2014-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "command.h"
#include "cli/cli-script.h"
#include "cli/cli-utils.h"
+#include "cli/cli-option.h"
#include "completer.h"
#include "gdbcmd.h"
#include "compile.h"
#include "source.h"
#include "block.h"
#include "arch-utils.h"
-#include "filestuff.h"
+#include "gdbsupport/filestuff.h"
#include "target.h"
#include "osabi.h"
-#include "gdb_wait.h"
+#include "gdbsupport/gdb_wait.h"
#include "valprint.h"
-#include "common/gdb_optional.h"
-#include "common/gdb_unlinker.h"
+#include "gdbsupport/gdb_optional.h"
+#include "gdbsupport/gdb_unlinker.h"
+#include "gdbsupport/pathstuff.h"
\f
/* Debug flag for "compile" commands. */
-int compile_debug;
+bool compile_debug;
+
+/* Object of this type are stored in the compiler's symbol_err_map. */
+
+struct symbol_error
+{
+ /* The symbol. */
+
+ const struct symbol *sym;
+
+ /* The error message to emit. This is malloc'd and owned by the
+ hash table. */
+
+ char *message;
+};
+
+/* Hash a type_map_instance. */
+
+static hashval_t
+hash_type_map_instance (const void *p)
+{
+ const struct type_map_instance *inst = (const struct type_map_instance *) p;
+
+ return htab_hash_pointer (inst->type);
+}
+
+/* Check two type_map_instance objects for equality. */
+
+static int
+eq_type_map_instance (const void *a, const void *b)
+{
+ const struct type_map_instance *insta = (const struct type_map_instance *) a;
+ const struct type_map_instance *instb = (const struct type_map_instance *) b;
+
+ return insta->type == instb->type;
+}
+
+/* Hash function for struct symbol_error. */
+
+static hashval_t
+hash_symbol_error (const void *a)
+{
+ const struct symbol_error *se = (const struct symbol_error *) a;
+
+ return htab_hash_pointer (se->sym);
+}
+
+/* Equality function for struct symbol_error. */
+
+static int
+eq_symbol_error (const void *a, const void *b)
+{
+ const struct symbol_error *sea = (const struct symbol_error *) a;
+ const struct symbol_error *seb = (const struct symbol_error *) b;
+
+ return sea->sym == seb->sym;
+}
+
+/* Deletion function for struct symbol_error. */
+
+static void
+del_symbol_error (void *a)
+{
+ struct symbol_error *se = (struct symbol_error *) a;
+
+ xfree (se->message);
+ xfree (se);
+}
+
+/* Constructor for compile_instance. */
+
+compile_instance::compile_instance (struct gcc_base_context *gcc_fe,
+ const char *options)
+ : m_gcc_fe (gcc_fe), m_gcc_target_options (options),
+ m_type_map (htab_create_alloc (10, hash_type_map_instance,
+ eq_type_map_instance,
+ xfree, xcalloc, xfree)),
+ m_symbol_err_map (htab_create_alloc (10, hash_symbol_error,
+ eq_symbol_error, del_symbol_error,
+ xcalloc, xfree))
+{
+}
+
+/* See compile-internal.h. */
+
+bool
+compile_instance::get_cached_type (struct type *type, gcc_type *ret) const
+{
+ struct type_map_instance inst, *found;
+
+ inst.type = type;
+ found = (struct type_map_instance *) htab_find (m_type_map.get (), &inst);
+ if (found != NULL)
+ {
+ *ret = found->gcc_type_handle;
+ return true;
+ }
+
+ return false;
+}
+
+/* See compile-internal.h. */
+
+void
+compile_instance::insert_type (struct type *type, gcc_type gcc_type)
+{
+ struct type_map_instance inst, *add;
+ void **slot;
+
+ inst.type = type;
+ inst.gcc_type_handle = gcc_type;
+ slot = htab_find_slot (m_type_map.get (), &inst, INSERT);
+
+ add = (struct type_map_instance *) *slot;
+ /* The type might have already been inserted in order to handle
+ recursive types. */
+ if (add != NULL && add->gcc_type_handle != gcc_type)
+ error (_("Unexpected type id from GCC, check you use recent enough GCC."));
+
+ if (add == NULL)
+ {
+ add = XNEW (struct type_map_instance);
+ *add = inst;
+ *slot = add;
+ }
+}
+
+/* See compile-internal.h. */
+
+void
+compile_instance::insert_symbol_error (const struct symbol *sym,
+ const char *text)
+{
+ struct symbol_error e;
+ void **slot;
+
+ e.sym = sym;
+ slot = htab_find_slot (m_symbol_err_map.get (), &e, INSERT);
+ if (*slot == NULL)
+ {
+ struct symbol_error *ep = XNEW (struct symbol_error);
+
+ ep->sym = sym;
+ ep->message = xstrdup (text);
+ *slot = ep;
+ }
+}
+
+/* See compile-internal.h. */
+
+void
+compile_instance::error_symbol_once (const struct symbol *sym)
+{
+ struct symbol_error search;
+ struct symbol_error *err;
+
+ if (m_symbol_err_map == NULL)
+ return;
+
+ search.sym = sym;
+ err = (struct symbol_error *) htab_find (m_symbol_err_map.get (), &search);
+ if (err == NULL || err->message == NULL)
+ return;
+
+ gdb::unique_xmalloc_ptr<char> message (err->message);
+ err->message = NULL;
+ error (_("%s"), message.get ());
+}
/* Implement "show debug compile". */
\f
-/* Check *ARG for a "-raw" or "-r" argument. Return 0 if not seen.
- Return 1 if seen and update *ARG. */
+/* Options for the compile command. */
-static int
-check_raw_argument (const char **arg)
+struct compile_options
{
- *arg = skip_spaces (*arg);
+ /* For -raw. */
+ bool raw = false;
+};
+
+using compile_flag_option_def
+ = gdb::option::flag_option_def<compile_options>;
+
+static const gdb::option::option_def compile_command_option_defs[] = {
- if (arg != NULL
- && (check_for_argument (arg, "-raw", sizeof ("-raw") - 1)
- || check_for_argument (arg, "-r", sizeof ("-r") - 1)))
- return 1;
- return 0;
+ compile_flag_option_def {
+ "raw",
+ [] (compile_options *opts) { return &opts->raw; },
+ N_("Suppress automatic 'void _gdb_expr () { CODE }' wrapping."),
+ },
+
+};
+
+/* Create an option_def_group for the "compile" command's options,
+ with OPTS as context. */
+
+static gdb::option::option_def_group
+make_compile_options_def_group (compile_options *opts)
+{
+ return {{compile_command_option_defs}, opts};
}
/* Handle the input from the 'compile file' command. The "compile
that may contain calls to the GCC compiler. */
static void
-compile_file_command (const char *arg, int from_tty)
+compile_file_command (const char *args, int from_tty)
{
- enum compile_i_scope_types scope = COMPILE_I_SIMPLE_SCOPE;
-
scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
- /* Check the user did not just <enter> after command. */
- if (arg == NULL)
- error (_("You must provide a filename for this command."));
+ /* Check if a -raw option is provided. */
- /* Check if a raw (-r|-raw) argument is provided. */
- if (arg != NULL && check_raw_argument (&arg))
- {
- scope = COMPILE_I_RAW_SCOPE;
- arg = skip_spaces (arg);
- }
+ compile_options options;
- /* After processing arguments, check there is a filename at the end
- of the command. */
- if (arg[0] == '\0')
- error (_("You must provide a filename with the raw option set."));
+ const gdb::option::option_def_group group
+ = make_compile_options_def_group (&options);
+ gdb::option::process_options
+ (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR,
+ group);
- if (arg[0] == '-')
- error (_("Unknown argument specified."));
+ enum compile_i_scope_types scope
+ = options.raw ? COMPILE_I_RAW_SCOPE : COMPILE_I_SIMPLE_SCOPE;
+
+ args = skip_spaces (args);
+
+ /* After processing options, check whether we have a filename. */
+ if (args == nullptr || args[0] == '\0')
+ error (_("You must provide a filename for this command."));
- arg = skip_spaces (arg);
- gdb::unique_xmalloc_ptr<char> abspath = gdb_abspath (arg);
+ args = skip_spaces (args);
+ gdb::unique_xmalloc_ptr<char> abspath = gdb_abspath (args);
std::string buffer = string_printf ("#include \"%s\"\n", abspath.get ());
eval_compile_command (NULL, buffer.c_str (), scope, NULL);
}
+/* Completer for the "compile file" command. */
+
+static void
+compile_file_command_completer (struct cmd_list_element *ignore,
+ completion_tracker &tracker,
+ const char *text, const char *word)
+{
+ const gdb::option::option_def_group group
+ = make_compile_options_def_group (nullptr);
+ if (gdb::option::complete_options
+ (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR, group))
+ return;
+
+ word = advance_to_filename_complete_word_point (tracker, text);
+ filename_completer (ignore, tracker, text, word);
+}
+
/* Handle the input from the 'compile code' command. The
"compile code" command is used to evaluate 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_code_command (const char *arg, int from_tty)
+compile_code_command (const char *args, int from_tty)
{
- enum compile_i_scope_types scope = COMPILE_I_SIMPLE_SCOPE;
-
scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
- if (arg != NULL && check_raw_argument (&arg))
- {
- scope = COMPILE_I_RAW_SCOPE;
- arg = skip_spaces (arg);
- }
+ compile_options options;
- arg = skip_spaces (arg);
+ const gdb::option::option_def_group group
+ = make_compile_options_def_group (&options);
+ gdb::option::process_options
+ (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR, group);
- if (arg != NULL && !check_for_argument (&arg, "--", sizeof ("--") - 1))
- {
- if (arg[0] == '-')
- error (_("Unknown argument specified."));
- }
+ enum compile_i_scope_types scope
+ = options.raw ? COMPILE_I_RAW_SCOPE : COMPILE_I_SIMPLE_SCOPE;
- if (arg && *arg)
- eval_compile_command (NULL, arg, scope, NULL);
+ if (args && *args)
+ eval_compile_command (NULL, args, scope, NULL);
else
{
- command_line_up l = get_command_line (compile_control, "");
+ counted_command_line l = get_command_line (compile_control, "");
l->control_u.compile.scope = scope;
execute_control_command_untraced (l.get ());
}
}
+/* Completer for the "compile code" command. */
+
+static void
+compile_code_command_completer (struct cmd_list_element *ignore,
+ completion_tracker &tracker,
+ const char *text, const char *word)
+{
+ const gdb::option::option_def_group group
+ = make_compile_options_def_group (nullptr);
+ if (gdb::option::complete_options
+ (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR, group))
+ return;
+
+ word = advance_to_expression_complete_word_point (tracker, text);
+ symbol_completer (ignore, tracker, text, word);
+}
+
/* Callback for compile_print_command. */
void
compile_print_value (struct value *val, void *data_voidp)
{
- const struct format_data *fmtp = (const struct format_data *) data_voidp;
+ const value_print_options *print_opts = (value_print_options *) data_voidp;
- print_value (val, fmtp);
+ print_value (val, *print_opts);
}
/* Handle the input from the 'compile print' command. The "compile
compile_print_command (const char *arg, int from_tty)
{
enum compile_i_scope_types scope = COMPILE_I_PRINT_ADDRESS_SCOPE;
- struct format_data fmt;
+ value_print_options print_opts;
scoped_restore save_async = make_scoped_restore (¤t_ui->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);
+ get_user_print_options (&print_opts);
+ /* Override global settings with explicit options, if any. */
+ auto group = make_value_print_options_def_group (&print_opts);
+ gdb::option::process_options
+ (&arg, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER, group);
+
+ print_command_parse_format (&arg, "compile print", &print_opts);
+
+ /* Passing &PRINT_OPTS as SCOPE_DATA is safe as do_module_cleanup
+ will not touch the stale pointer if compile_object_run has
+ already quit. */
if (arg && *arg)
- eval_compile_command (NULL, arg, scope, &fmt);
+ eval_compile_command (NULL, arg, scope, &print_opts);
else
{
- command_line_up l = get_command_line (compile_control, "");
+ counted_command_line l = get_command_line (compile_control, "");
l->control_u.compile.scope = scope;
- l->control_u.compile.scope_data = &fmt;
+ l->control_u.compile.scope_data = &print_opts;
execute_control_command_untraced (l.get ());
}
}
strcpy (tname, TEMPLATE);
#undef TEMPLATE
-#ifdef HAVE_MKDTEMP
tempdir_name = mkdtemp (tname);
-#else
- error (_("Command not supported on this host."));
-#endif
if (tempdir_name == NULL)
perror_with_name (_("Could not make temporary directory"));
block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
STATIC_BLOCK);
if (block != NULL)
- *pc = BLOCK_START (block);
+ *pc = BLOCK_ENTRY_PC (block);
}
else
- *pc = BLOCK_START (block);
+ *pc = BLOCK_ENTRY_PC (block);
return block;
}
*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. */
+/* Produce final vector of GCC compilation options.
+
+ The first element of the combined argument vector are arguments
+ relating to the target size ("-m64", "-m32" etc.). These are
+ sourced from the inferior's architecture.
+
+ The second element of the combined argument vector are arguments
+ stored in the inferior DW_AT_producer section. If these are stored
+ in the inferior (there is no guarantee that they are), they are
+ added to the vector.
+
+ The third element of the combined argument vector are argument
+ supplied by the language implementation provided by
+ compile-{lang}-support. These contain language specific arguments.
+
+ The final element of the combined argument vector are arguments
+ supplied by the "set compile-args" command. These are always
+ appended last so as to override any of the arguments automatically
+ generated above. */
static void
-get_args (const struct compile_instance *compiler, struct gdbarch *gdbarch,
+get_args (const compile_instance *compiler, struct gdbarch *gdbarch,
int *argcp, char ***argvp)
{
const char *cs_producer_options;
int argc_compiler;
char **argv_compiler;
- build_argc_argv (gdbarch_gcc_target_options (gdbarch),
+ build_argc_argv (gdbarch_gcc_target_options (gdbarch).c_str (),
argcp, argvp);
cs_producer_options = get_selected_pc_producer_options ();
freeargv (argv_producer);
}
- build_argc_argv (compiler->gcc_target_options,
+ build_argc_argv (compiler->gcc_target_options ().c_str (),
&argc_compiler, &argv_compiler);
append_args (argcp, argvp, argc_compiler, argv_compiler);
freeargv (argv_compiler);
append_args (argcp, argvp, compile_args_argc, compile_args_argv);
}
-/* A cleanup function to destroy a gdb_gcc_instance. */
-
-static void
-cleanup_compile_instance (void *arg)
-{
- struct compile_instance *inst = (struct compile_instance *) arg;
-
- inst->destroy (inst);
-}
-
/* A helper function suitable for use as the "print_callback" in the
compiler object. */
compile_to_object (struct command_line *cmd, const char *cmd_string,
enum compile_i_scope_types scope)
{
- struct compile_instance *compiler;
- struct cleanup *cleanup;
const struct block *expr_block;
CORE_ADDR trash_pc, expr_pc;
int argc;
char **argv;
int ok;
- FILE *src;
struct gdbarch *gdbarch = get_current_arch ();
- char *triplet_rx;
- char *error_message;
+ std::string triplet_rx;
if (!target_has_execution)
error (_("The program must be running for the compile command to "\
if (current_language->la_get_compile_instance == NULL)
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);
- compiler->fe->ops->set_print_callback (compiler->fe, print_callback, NULL);
-
- compiler->scope = scope;
- compiler->block = expr_block;
+ compile_instance *compiler_instance
+ = current_language->la_get_compile_instance ();
+ std::unique_ptr<compile_instance> compiler (compiler_instance);
+ compiler->set_print_callback (print_callback, NULL);
+ compiler->set_scope (scope);
+ compiler->set_block (expr_block);
/* From the provided expression, build a scope to pass to the
compiler. */
{
struct command_line *iter;
- for (iter = cmd->body_list[0]; iter; iter = iter->next)
+ for (iter = cmd->body_list_0.get (); iter; iter = iter->next)
{
input_buf.puts (iter->line);
input_buf.puts ("\n");
error (_("Neither a simple expression, or a multi-line specified."));
std::string code
- = current_language->la_compute_program (compiler, input, gdbarch,
+ = current_language->la_compute_program (compiler.get (), input, gdbarch,
expr_block, expr_pc);
if (compile_debug)
fprintf_unfiltered (gdb_stdlog, "debug output:\n\n%s", code.c_str ());
- if (compiler->fe->ops->version >= GCC_FE_VERSION_1)
- compiler->fe->ops->set_verbose (compiler->fe, compile_debug);
+ compiler->set_verbose (compile_debug);
if (compile_gcc[0] != 0)
{
- if (compiler->fe->ops->version < GCC_FE_VERSION_1)
+ if (compiler->version () < GCC_FE_VERSION_1)
error (_("Command 'set compile-gcc' requires GCC version 6 or higher "
"(libcc1 interface version 1 or higher)"));
- compiler->fe->ops->set_driver_filename (compiler->fe, compile_gcc);
+ compiler->set_driver_filename (compile_gcc);
}
else
{
const char *arch_rx = gdbarch_gnu_triplet_regexp (gdbarch);
/* Allow triplets with or without vendor set. */
- triplet_rx = concat (arch_rx, "(-[^-]*)?-", os_rx, (char *) NULL);
- make_cleanup (xfree, triplet_rx);
-
- if (compiler->fe->ops->version >= GCC_FE_VERSION_1)
- compiler->fe->ops->set_triplet_regexp (compiler->fe, triplet_rx);
+ triplet_rx = std::string (arch_rx) + "(-[^-]*)?-" + os_rx;
+ compiler->set_triplet_regexp (triplet_rx.c_str ());
}
/* Set compiler command-line arguments. */
- get_args (compiler, gdbarch, &argc, &argv);
+ get_args (compiler.get (), gdbarch, &argc, &argv);
gdb_argv argv_holder (argv);
- if (compiler->fe->ops->version >= GCC_FE_VERSION_1)
- error_message = compiler->fe->ops->set_arguments (compiler->fe, argc, argv);
- else
- error_message = compiler->fe->ops->set_arguments_v0 (compiler->fe, triplet_rx,
- argc, argv);
+ gdb::unique_xmalloc_ptr<char> error_message;
+ error_message.reset (compiler->set_arguments (argc, argv,
+ triplet_rx.c_str ()));
+
if (error_message != NULL)
- {
- make_cleanup (xfree, error_message);
- error ("%s", error_message);
- }
+ error ("%s", error_message.get ());
if (compile_debug)
{
fnames.source_file ());
/* Call the compiler and start the compilation process. */
- compiler->fe->ops->set_source_file (compiler->fe, fnames.source_file ());
-
- if (compiler->fe->ops->version >= GCC_FE_VERSION_1)
- ok = compiler->fe->ops->compile (compiler->fe, fnames.object_file ());
- else
- ok = compiler->fe->ops->compile_v0 (compiler->fe, fnames.object_file (),
- compile_debug);
+ compiler->set_source_file (fnames.source_file ());
+ ok = compiler->compile (fnames.object_file (), compile_debug);
if (!ok)
error (_("Compilation failed."));
/* Keep the source file. */
source_remover->keep ();
-
- do_cleanups (cleanup);
-
return fnames;
}
error (_("Cannot find gdbarch register \"%s\"."), regname);
}
+/* Forwards to the plug-in. */
+
+#define FORWARD(OP,...) (m_gcc_fe->ops->OP (m_gcc_fe, ##__VA_ARGS__))
+
+/* See compile-internal.h. */
+
+void
+compile_instance::set_print_callback
+ (void (*print_function) (void *, const char *), void *datum)
+{
+ FORWARD (set_print_callback, print_function, datum);
+}
+
+/* See compile-internal.h. */
+
+unsigned int
+compile_instance::version () const
+{
+ return m_gcc_fe->ops->version;
+}
+
+/* See compile-internal.h. */
+
+void
+compile_instance::set_verbose (int level)
+{
+ if (version () >= GCC_FE_VERSION_1)
+ FORWARD (set_verbose, level);
+}
+
+/* See compile-internal.h. */
+
+void
+compile_instance::set_driver_filename (const char *filename)
+{
+ if (version () >= GCC_FE_VERSION_1)
+ FORWARD (set_driver_filename, filename);
+}
+
+/* See compile-internal.h. */
+
+void
+compile_instance::set_triplet_regexp (const char *regexp)
+{
+ if (version () >= GCC_FE_VERSION_1)
+ FORWARD (set_triplet_regexp, regexp);
+}
+
+/* See compile-internal.h. */
+
+char *
+compile_instance::set_arguments (int argc, char **argv, const char *regexp)
+{
+ if (version () >= GCC_FE_VERSION_1)
+ return FORWARD (set_arguments, argc, argv);
+ else
+ return FORWARD (set_arguments_v0, regexp, argc, argv);
+}
+
+/* See compile-internal.h. */
+
+void
+compile_instance::set_source_file (const char *filename)
+{
+ FORWARD (set_source_file, filename);
+}
+
+/* See compile-internal.h. */
+
+bool
+compile_instance::compile (const char *filename, int verbose_level)
+{
+ if (version () >= GCC_FE_VERSION_1)
+ return FORWARD (compile, filename);
+ else
+ return FORWARD (compile_v0, filename, verbose_level);
+}
+
+#undef FORWARD
+
+/* See compile.h. */
+cmd_list_element *compile_cmd_element = nullptr;
+
void
_initialize_compile (void)
{
struct cmd_list_element *c = NULL;
- add_prefix_cmd ("compile", class_obscure, compile_command,
- _("\
+ compile_cmd_element = add_prefix_cmd ("compile", class_obscure,
+ compile_command, _("\
Command to compile source code and inject it into the inferior."),
&compile_command_list, "compile ", 1, &cmdlist);
add_com_alias ("expression", "compile", class_obscure, 0);
- add_cmd ("code", class_obscure, compile_code_command,
- _("\
+ const auto compile_opts = make_compile_options_def_group (nullptr);
+
+ static const std::string compile_code_help
+ = gdb::option::build_help (_("\
Compile, inject, and execute code.\n\
\n\
-Usage: compile code [-r|-raw] [--] [CODE]\n\
--r|-raw: Suppress automatic 'void _gdb_expr () { CODE }' wrapping.\n\
---: Do not parse any options beyond this delimiter. All text to the\n\
- right will be treated as source code.\n\
+Usage: compile code [OPTION]... [CODE]\n\
+\n\
+Options:\n\
+%OPTIONS%\n\
\n\
The source code may be specified as a simple one line expression, e.g.:\n\
\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);
+ compile_opts);
- c = add_cmd ("file", class_obscure, compile_file_command,
- _("\
+ c = add_cmd ("code", class_obscure, compile_code_command,
+ compile_code_help.c_str (),
+ &compile_command_list);
+ set_cmd_completer_handle_brkchars (c, compile_code_command_completer);
+
+static const std::string compile_file_help
+ = gdb::option::build_help (_("\
Evaluate a file containing source code.\n\
\n\
-Usage: compile file [-r|-raw] [filename]\n\
--r|-raw: Suppress automatic 'void _gdb_expr () { CODE }' wrapping."),
+Usage: compile file [OPTION].. [FILENAME]\n\
+\n\
+Options:\n\
+%OPTIONS%"),
+ compile_opts);
+
+ c = add_cmd ("file", class_obscure, compile_file_command,
+ compile_file_help.c_str (),
&compile_command_list);
- set_cmd_completer (c, filename_completer);
+ set_cmd_completer_handle_brkchars (c, compile_file_command_completer);
- add_cmd ("print", class_obscure, compile_print_command,
- _("\
+ const auto compile_print_opts = make_value_print_options_def_group (nullptr);
+
+ static const std::string compile_print_help
+ = gdb::option::build_help (_("\
Evaluate EXPR by using the compiler and print result.\n\
\n\
-Usage: compile print[/FMT] [EXPR]\n\
+Usage: compile print [[OPTION]... --] [/FMT] [EXPR]\n\
+\n\
+Options:\n\
+%OPTIONS%\n\
+\n\
+Note: because this command accepts arbitrary expressions, if you\n\
+specify any command option, you must use a double dash (\"--\")\n\
+to mark the end of option processing. E.g.: \"compile print -o -- myobj\".\n\
\n\
The expression may be specified on the same line as the command, e.g.:\n\
\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);
+ compile_print_opts);
+
+ c = add_cmd ("print", class_obscure, compile_print_command,
+ compile_print_help.c_str (),
+ &compile_command_list);
+ set_cmd_completer_handle_brkchars (c, print_command_completer);
add_setshow_boolean_cmd ("compile", class_maintenance, &compile_debug, _("\
Set compile command debugging."), _("\
add_setshow_string_cmd ("compile-args", class_support,
&compile_args,
- _("Set compile command GCC command-line arguments"),
- _("Show compile command GCC command-line arguments"),
+ _("Set compile command GCC command-line arguments."),
+ _("Show compile command GCC command-line arguments."),
_("\
Use options like -I (include file directory) or ABI settings.\n\
String quoting is parsed like in shell, for example:\n\
" -fPIE"
/* 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. */
add_setshow_optional_filename_cmd ("compile-gcc", class_support,
&compile_gcc,
_("Set compile command "
- "GCC driver filename"),
+ "GCC driver filename."),
_("Show compile command "
- "GCC driver filename"),
+ "GCC driver filename."),
_("\
It should be absolute filename of the gcc executable.\n\
If empty the default target triplet will be searched in $PATH."),