binutils-gdb/gdb/compile/compile.c
Sergio Durigan Junior b4987c956d Create new common/pathstuff.[ch]
This commit moves the path manipulation routines found on utils.c to a
new common/pathstuff.c, and updates the Makefile.in's accordingly.
The routines moved are "gdb_realpath", "gdb_realpath_keepfile" and
"gdb_abspath".

This will be needed because gdbserver will have to call "gdb_abspath"
on my next patch, which implements a way to expand the path of the
inferior provided by the user in order to allow specifying just the
binary name when starting gdbserver, like:

  $ gdbserver :1234 a.out

With the recent addition of the startup-with-shell feature on
gdbserver, this scenario doesn't work anymore if the user doesn't have
the current directory listed in the PATH variable.

I had to do a minor adjustment on "gdb_abspath" because we don't have
access to "tilde_expand" on gdbserver, so now the function is using
"gdb_tilde_expand" instead.  Otherwise, the code is the same.

Regression tested on the BuildBot, without regressions.

gdb/ChangeLog:
2018-02-28  Sergio Durigan Junior  <sergiodj@redhat.com>

	* Makefile.in (COMMON_SFILES): Add "common/pathstuff.c".
	(HFILES_NO_SRCDIR): Add "common/pathstuff.h".
	* auto-load.c: Include "common/pathstuff.h".
	* common/common-def.h (current_directory): Move here.
	* common/gdb_tilde_expand.c (gdb_tilde_expand_up): New
	function.
	* common/gdb_tilde_expand.h (gdb_tilde_expand_up): New
	prototype.
	* common/pathstuff.c: New file.
	* common/pathstuff.h: New file.
	* compile/compile.c: Include "common/pathstuff.h".
	* defs.h (current_directory): Move to "common/common-defs.h".
	* dwarf2read.c: Include "common/pathstuff.h".
	* exec.c: Likewise.
	* guile/scm-safe-call.c: Likewise.
	* linux-thread-db.c: Likewise.
	* main.c: Likewise.
	* nto-tdep.c: Likewise.
	* objfiles.c: Likewise.
	* source.c: Likewise.
	* symtab.c: Likewise.
	* utils.c: Include "common/pathstuff.h".
	(gdb_realpath): Move to "common/pathstuff.c".
	(gdb_realpath_keepfile): Likewise.
	(gdb_abspath): Likewise.
	* utils.h (gdb_realpath): Move to "common/pathstuff.h".
	(gdb_realpath_keepfile): Likewise.
	(gdb_abspath): Likewise.

gdb/gdbserver/ChangeLog:
2018-02-28  Sergio Durigan Junior  <sergiodj@redhat.com>

	* Makefile.in (SFILES): Add "$(srcdir)/common/pathstuff.c".
	(OBJS): Add "pathstuff.o".
	* server.c (current_directory): New global variable.
	(captured_main): Initialize "current_directory".
2018-02-28 11:34:39 -05:00

801 lines
23 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* General Compile and inject code
Copyright (C) 2014-2018 Free Software Foundation, Inc.
This file is part of GDB.
This program 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 of the License, or
(at your option) any later version.
This program 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 this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "top.h"
#include "ui-out.h"
#include "command.h"
#include "cli/cli-script.h"
#include "cli/cli-utils.h"
#include "completer.h"
#include "gdbcmd.h"
#include "compile.h"
#include "compile-internal.h"
#include "compile-object-load.h"
#include "compile-object-run.h"
#include "language.h"
#include "frame.h"
#include "source.h"
#include "block.h"
#include "arch-utils.h"
#include "filestuff.h"
#include "target.h"
#include "osabi.h"
#include "gdb_wait.h"
#include "valprint.h"
#include "common/gdb_optional.h"
#include "common/gdb_unlinker.h"
#include "common/pathstuff.h"
/* Initial filename for temporary files. */
#define TMP_PREFIX "/tmp/gdbobj-"
/* Hold "compile" commands. */
static struct cmd_list_element *compile_command_list;
/* Debug flag for "compile" commands. */
int compile_debug;
/* Implement "show debug compile". */
static void
show_compile_debug (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Compile debugging is %s.\n"), value);
}
/* Check *ARG for a "-raw" or "-r" argument. Return 0 if not seen.
Return 1 if seen and update *ARG. */
static int
check_raw_argument (const char **arg)
{
*arg = skip_spaces (*arg);
if (arg != NULL
&& (check_for_argument (arg, "-raw", sizeof ("-raw") - 1)
|| check_for_argument (arg, "-r", sizeof ("-r") - 1)))
return 1;
return 0;
}
/* Handle the input from the 'compile file' command. The "compile
file" command is used to evaluate an expression contained in a file
that may contain calls to the GCC compiler. */
static void
compile_file_command (const char *arg, int from_tty)
{
enum compile_i_scope_types scope = COMPILE_I_SIMPLE_SCOPE;
scoped_restore save_async = make_scoped_restore (&current_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 (-r|-raw) argument is provided. */
if (arg != NULL && check_raw_argument (&arg))
{
scope = COMPILE_I_RAW_SCOPE;
arg = skip_spaces (arg);
}
/* 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."));
if (arg[0] == '-')
error (_("Unknown argument specified."));
arg = skip_spaces (arg);
gdb::unique_xmalloc_ptr<char> abspath = gdb_abspath (arg);
std::string buffer = string_printf ("#include \"%s\"\n", abspath.get ());
eval_compile_command (NULL, buffer.c_str (), scope, NULL);
}
/* 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)
{
enum compile_i_scope_types scope = COMPILE_I_SIMPLE_SCOPE;
scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
if (arg != NULL && check_raw_argument (&arg))
{
scope = COMPILE_I_RAW_SCOPE;
arg = skip_spaces (arg);
}
arg = skip_spaces (arg);
if (arg != NULL && !check_for_argument (&arg, "--", sizeof ("--") - 1))
{
if (arg[0] == '-')
error (_("Unknown argument specified."));
}
if (arg && *arg)
eval_compile_command (NULL, arg, scope, NULL);
else
{
command_line_up l = get_command_line (compile_control, "");
l->control_u.compile.scope = scope;
execute_control_command_untraced (l.get ());
}
}
/* 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;
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 (const char *arg, int from_tty)
{
enum compile_i_scope_types scope = COMPILE_I_PRINT_ADDRESS_SCOPE;
struct format_data fmt;
scoped_restore save_async = make_scoped_restore (&current_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);
if (arg && *arg)
eval_compile_command (NULL, arg, scope, &fmt);
else
{
command_line_up l = get_command_line (compile_control, "");
l->control_u.compile.scope = scope;
l->control_u.compile.scope_data = &fmt;
execute_control_command_untraced (l.get ());
}
}
/* A cleanup function to remove a directory and all its contents. */
static void
do_rmdir (void *arg)
{
const char *dir = (const char *) arg;
char *zap;
int wstat;
gdb_assert (startswith (dir, TMP_PREFIX));
zap = concat ("rm -rf ", dir, (char *) NULL);
wstat = system (zap);
if (wstat == -1 || !WIFEXITED (wstat) || WEXITSTATUS (wstat) != 0)
warning (_("Could not remove temporary directory %s"), dir);
XDELETEVEC (zap);
}
/* Return the name of the temporary directory to use for .o files, and
arrange for the directory to be removed at shutdown. */
static const char *
get_compile_file_tempdir (void)
{
static char *tempdir_name;
#define TEMPLATE TMP_PREFIX "XXXXXX"
char tname[sizeof (TEMPLATE)];
if (tempdir_name != NULL)
return tempdir_name;
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"));
tempdir_name = xstrdup (tempdir_name);
make_final_cleanup (do_rmdir, tempdir_name);
return tempdir_name;
}
/* Compute the names of source and object files to use. */
static compile_file_names
get_new_file_names ()
{
static int seq;
const char *dir = get_compile_file_tempdir ();
++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. */
static const struct block *
get_expr_block_and_pc (CORE_ADDR *pc)
{
const struct block *block = get_selected_block (pc);
if (block == NULL)
{
struct symtab_and_line cursal = get_current_source_symtab_and_line ();
if (cursal.symtab)
block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
STATIC_BLOCK);
if (block != NULL)
*pc = BLOCK_START (block);
}
else
*pc = BLOCK_START (block);
return block;
}
/* Call buildargv (via gdb_argv), set its result for S into *ARGVP but
calculate also the number of parsed arguments into *ARGCP. If
buildargv has returned NULL then *ARGCP is set to zero. */
static void
build_argc_argv (const char *s, int *argcp, char ***argvp)
{
gdb_argv args (s);
*argcp = args.count ();
*argvp = args.release ();
}
/* String for 'set compile-args' and 'show compile-args'. */
static char *compile_args;
/* Parsed form of COMPILE_ARGS. COMPILE_ARGS_ARGV is NULL terminated. */
static int compile_args_argc;
static char **compile_args_argv;
/* Implement 'set compile-args'. */
static void
set_compile_args (const char *args, int from_tty, struct cmd_list_element *c)
{
freeargv (compile_args_argv);
build_argc_argv (compile_args, &compile_args_argc, &compile_args_argv);
}
/* Implement 'show compile-args'. */
static void
show_compile_args (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Compile command command-line arguments "
"are \"%s\".\n"),
value);
}
/* Append ARGC and ARGV (as parsed by build_argc_argv) to *ARGCP and *ARGVP.
ARGCP+ARGVP can be zero+NULL and also ARGC+ARGV can be zero+NULL. */
static void
append_args (int *argcp, char ***argvp, int argc, char **argv)
{
int argi;
*argvp = XRESIZEVEC (char *, *argvp, (*argcp + argc + 1));
for (argi = 0; argi < argc; argi++)
(*argvp)[(*argcp)++] = xstrdup (argv[argi]);
(*argvp)[(*argcp)] = NULL;
}
/* String for 'set compile-gcc' and 'show compile-gcc'. */
static char *compile_gcc;
/* Implement 'show compile-gcc'. */
static void
show_compile_gcc (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Compile command GCC driver filename is \"%s\".\n"),
value);
}
/* Return DW_AT_producer parsed for get_selected_frame () (if any).
Return NULL otherwise.
GCC already filters its command-line arguments only for the suitable ones to
put into DW_AT_producer - see GCC function gen_producer_string. */
static const char *
get_selected_pc_producer_options (void)
{
CORE_ADDR pc = get_frame_pc (get_selected_frame (NULL));
struct compunit_symtab *symtab = find_pc_compunit_symtab (pc);
const char *cs;
if (symtab == NULL || symtab->producer == NULL
|| !startswith (symtab->producer, "GNU "))
return NULL;
cs = symtab->producer;
while (*cs != 0 && *cs != '-')
cs = skip_spaces (skip_to_space (cs));
if (*cs != '-')
return NULL;
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.
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,
int *argcp, char ***argvp)
{
const char *cs_producer_options;
int argc_compiler;
char **argv_compiler;
build_argc_argv (gdbarch_gcc_target_options (gdbarch),
argcp, argvp);
cs_producer_options = get_selected_pc_producer_options ();
if (cs_producer_options != NULL)
{
int argc_producer;
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);
}
build_argc_argv (compiler->gcc_target_options,
&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. */
static void
print_callback (void *ignore, const char *message)
{
fputs_filtered (message, gdb_stderr);
}
/* Process the compilation request. On success it returns the object
and source file names. On an error condition, error () is
called. */
static compile_file_names
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;
struct gdbarch *gdbarch = get_current_arch ();
std::string triplet_rx;
char *error_message;
if (!target_has_execution)
error (_("The program must be running for the compile command to "\
"work."));
expr_block = get_expr_block_and_pc (&trash_pc);
expr_pc = get_frame_address_in_block (get_selected_frame (NULL));
/* Set up instance and context for the compiler. */
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;
/* From the provided expression, build a scope to pass to the
compiler. */
string_file input_buf;
const char *input;
if (cmd != NULL)
{
struct command_line *iter;
for (iter = cmd->body_list[0]; iter; iter = iter->next)
{
input_buf.puts (iter->line);
input_buf.puts ("\n");
}
input = input_buf.c_str ();
}
else if (cmd_string != NULL)
input = cmd_string;
else
error (_("Neither a simple expression, or a multi-line specified."));
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.c_str ());
if (compiler->fe->ops->version >= GCC_FE_VERSION_1)
compiler->fe->ops->set_verbose (compiler->fe, compile_debug);
if (compile_gcc[0] != 0)
{
if (compiler->fe->ops->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);
}
else
{
const char *os_rx = osabi_triplet_regexp (gdbarch_osabi (gdbarch));
const char *arch_rx = gdbarch_gnu_triplet_regexp (gdbarch);
/* Allow triplets with or without vendor set. */
triplet_rx = std::string (arch_rx) + "(-[^-]*)?-" + os_rx;
if (compiler->fe->ops->version >= GCC_FE_VERSION_1)
compiler->fe->ops->set_triplet_regexp (compiler->fe,
triplet_rx.c_str ());
}
/* Set compiler command-line arguments. */
get_args (compiler, 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.c_str (),
argc, argv);
if (error_message != NULL)
{
make_cleanup (xfree, error_message);
error ("%s", error_message);
}
if (compile_debug)
{
int argi;
fprintf_unfiltered (gdb_stdlog, "Passing %d compiler options:\n", argc);
for (argi = 0; argi < argc; argi++)
fprintf_unfiltered (gdb_stdlog, "Compiler option %d: <%s>\n",
argi, argv[argi]);
}
compile_file_names fnames = get_new_file_names ();
gdb::optional<gdb::unlinker> source_remover;
{
gdb_file_up src = gdb_fopen_cloexec (fnames.source_file (), "w");
if (src == NULL)
perror_with_name (_("Could not open source file for writing"));
source_remover.emplace (fnames.source_file ());
if (fputs (code.c_str (), src.get ()) == EOF)
perror_with_name (_("Could not write to source file"));
}
if (compile_debug)
fprintf_unfiltered (gdb_stdlog, "source file produced: %s\n\n",
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);
if (!ok)
error (_("Compilation failed."));
if (compile_debug)
fprintf_unfiltered (gdb_stdlog, "object file produced: %s\n\n",
fnames.object_file ());
/* Keep the source file. */
source_remover->keep ();
do_cleanups (cleanup);
return fnames;
}
/* The "compile" prefix command. */
static void
compile_command (const char *args, int from_tty)
{
/* If a sub-command is not specified to the compile prefix command,
assume it is a direct code compilation. */
compile_code_command (args, from_tty);
}
/* See compile.h. */
void
eval_compile_command (struct command_line *cmd, const char *cmd_string,
enum compile_i_scope_types scope, void *scope_data)
{
struct compile_module *compile_module;
compile_file_names fnames = compile_to_object (cmd, cmd_string, scope);
gdb::unlinker object_remover (fnames.object_file ());
gdb::unlinker source_remover (fnames.source_file ());
compile_module = compile_object_load (fnames, scope, scope_data);
if (compile_module == NULL)
{
gdb_assert (scope == COMPILE_I_PRINT_ADDRESS_SCOPE);
eval_compile_command (cmd, cmd_string,
COMPILE_I_PRINT_VALUE_SCOPE, scope_data);
return;
}
/* Keep the files. */
source_remover.keep ();
object_remover.keep ();
compile_object_run (compile_module);
}
/* See compile/compile-internal.h. */
std::string
compile_register_name_mangled (struct gdbarch *gdbarch, int regnum)
{
const char *regname = gdbarch_register_name (gdbarch, regnum);
return string_printf ("__%s", regname);
}
/* See compile/compile-internal.h. */
int
compile_register_name_demangle (struct gdbarch *gdbarch,
const char *regname)
{
int regnum;
if (regname[0] != '_' || regname[1] != '_')
error (_("Invalid register name \"%s\"."), regname);
regname += 2;
for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
if (strcmp (regname, gdbarch_register_name (gdbarch, regnum)) == 0)
return regnum;
error (_("Cannot find gdbarch register \"%s\"."), regname);
}
void
_initialize_compile (void)
{
struct cmd_list_element *c = NULL;
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,
_("\
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\
\n\
The source code may be specified as a simple one line expression, e.g.:\n\
\n\
compile code printf(\"Hello world\\n\");\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."),
&compile_command_list);
c = add_cmd ("file", class_obscure, compile_file_command,
_("\
Evaluate a file containing source code.\n\
\n\
Usage: compile file [-r|-raw] [filename]\n\
-r|-raw: Suppress automatic 'void _gdb_expr () { CODE }' wrapping."),
&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."), _("\
When on, compile command debugging is enabled."),
NULL, show_compile_debug,
&setdebuglist, &showdebuglist);
add_setshow_string_cmd ("compile-args", class_support,
&compile_args,
_("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\
-mno-align-double \"-I/dir with a space/include\""),
set_compile_args, show_compile_args, &setlist, &showlist);
/* Override flags possibly coming from DW_AT_producer. */
compile_args = xstrdup ("-O0 -gdwarf-4"
/* We use -fPIE Otherwise GDB would need to reserve space large enough for
any object file in the inferior in advance to get the final address when
to link the object file to and additionally the default system linker
script would need to be modified so that one can specify there the
absolute target address.
-fPIC is not used at is would require from GDB to generate .got. */
" -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. */
" -fno-stack-protector"
);
set_compile_args (compile_args, 0, NULL);
add_setshow_optional_filename_cmd ("compile-gcc", class_support,
&compile_gcc,
_("Set compile command "
"GCC driver filename"),
_("Show compile command "
"GCC driver filename"),
_("\
It should be absolute filename of the gcc executable.\n\
If empty the default target triplet will be searched in $PATH."),
NULL, show_compile_gcc, &setlist,
&showlist);
compile_gcc = xstrdup ("");
}