1 /* General Compile and inject code
3 Copyright (C) 2014-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "cli/cli-script.h"
25 #include "cli/cli-utils.h"
26 #include "completer.h"
29 #include "compile-internal.h"
30 #include "compile-object-load.h"
31 #include "compile-object-run.h"
36 #include "arch-utils.h"
37 #include "filestuff.h"
45 /* Initial filename for temporary files. */
47 #define TMP_PREFIX "/tmp/gdbobj-"
49 /* Hold "compile" commands. */
51 static struct cmd_list_element *compile_command_list;
53 /* Debug flag for "compile" commands. */
57 /* Implement "show debug compile". */
60 show_compile_debug (struct ui_file *file, int from_tty,
61 struct cmd_list_element *c, const char *value)
63 fprintf_filtered (file, _("Compile debugging is %s.\n"), value);
68 /* Check *ARG for a "-raw" or "-r" argument. Return 0 if not seen.
69 Return 1 if seen and update *ARG. */
72 check_raw_argument (char **arg)
74 *arg = skip_spaces (*arg);
77 && (check_for_argument (arg, "-raw", sizeof ("-raw") - 1)
78 || check_for_argument (arg, "-r", sizeof ("-r") - 1)))
83 /* Handle the input from the 'compile file' command. The "compile
84 file" command is used to evaluate an expression contained in a file
85 that may contain calls to the GCC compiler. */
88 compile_file_command (char *arg, int from_tty)
90 enum compile_i_scope_types scope = COMPILE_I_SIMPLE_SCOPE;
92 struct cleanup *cleanup;
94 scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
96 /* Check the user did not just <enter> after command. */
98 error (_("You must provide a filename for this command."));
100 /* Check if a raw (-r|-raw) argument is provided. */
101 if (arg != NULL && check_raw_argument (&arg))
103 scope = COMPILE_I_RAW_SCOPE;
104 arg = skip_spaces (arg);
107 /* After processing arguments, check there is a filename at the end
110 error (_("You must provide a filename with the raw option set."));
113 error (_("Unknown argument specified."));
115 arg = skip_spaces (arg);
116 arg = gdb_abspath (arg);
117 cleanup = make_cleanup (xfree, arg);
118 buffer = xstrprintf ("#include \"%s\"\n", arg);
119 make_cleanup (xfree, buffer);
120 eval_compile_command (NULL, buffer, scope, NULL);
121 do_cleanups (cleanup);
124 /* Handle the input from the 'compile code' command. The
125 "compile code" command is used to evaluate an expression that may
126 contain calls to the GCC compiler. The language expected in this
127 compile command is the language currently set in GDB. */
130 compile_code_command (char *arg, int from_tty)
132 enum compile_i_scope_types scope = COMPILE_I_SIMPLE_SCOPE;
134 scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
136 if (arg != NULL && check_raw_argument (&arg))
138 scope = COMPILE_I_RAW_SCOPE;
139 arg = skip_spaces (arg);
142 arg = skip_spaces (arg);
144 if (arg != NULL && !check_for_argument (&arg, "--", sizeof ("--") - 1))
147 error (_("Unknown argument specified."));
151 eval_compile_command (NULL, arg, scope, NULL);
154 command_line_up l = get_command_line (compile_control, "");
156 l->control_u.compile.scope = scope;
157 execute_control_command_untraced (l.get ());
161 /* Callback for compile_print_command. */
164 compile_print_value (struct value *val, void *data_voidp)
166 const struct format_data *fmtp = (const struct format_data *) data_voidp;
168 print_value (val, fmtp);
171 /* Handle the input from the 'compile print' command. The "compile
172 print" command is used to evaluate and print an expression that may
173 contain calls to the GCC compiler. The language expected in this
174 compile command is the language currently set in GDB. */
177 compile_print_command (char *arg_param, int from_tty)
179 const char *arg = arg_param;
180 enum compile_i_scope_types scope = COMPILE_I_PRINT_ADDRESS_SCOPE;
181 struct format_data fmt;
183 scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
185 /* Passing &FMT as SCOPE_DATA is safe as do_module_cleanup will not
186 touch the stale pointer if compile_object_run has already quit. */
187 print_command_parse_format (&arg, "compile print", &fmt);
190 eval_compile_command (NULL, arg, scope, &fmt);
193 command_line_up l = get_command_line (compile_control, "");
195 l->control_u.compile.scope = scope;
196 l->control_u.compile.scope_data = &fmt;
197 execute_control_command_untraced (l.get ());
201 /* A cleanup function to remove a directory and all its contents. */
206 const char *dir = (const char *) arg;
210 gdb_assert (startswith (dir, TMP_PREFIX));
211 zap = concat ("rm -rf ", dir, (char *) NULL);
212 wstat = system (zap);
213 if (wstat == -1 || !WIFEXITED (wstat) || WEXITSTATUS (wstat) != 0)
214 warning (_("Could not remove temporary directory %s"), dir);
218 /* Return the name of the temporary directory to use for .o files, and
219 arrange for the directory to be removed at shutdown. */
222 get_compile_file_tempdir (void)
224 static char *tempdir_name;
226 #define TEMPLATE TMP_PREFIX "XXXXXX"
227 char tname[sizeof (TEMPLATE)];
229 if (tempdir_name != NULL)
232 strcpy (tname, TEMPLATE);
235 tempdir_name = mkdtemp (tname);
237 error (_("Command not supported on this host."));
239 if (tempdir_name == NULL)
240 perror_with_name (_("Could not make temporary directory"));
242 tempdir_name = xstrdup (tempdir_name);
243 make_final_cleanup (do_rmdir, tempdir_name);
247 /* Compute the names of source and object files to use. */
249 static compile_file_names
250 get_new_file_names ()
253 const char *dir = get_compile_file_tempdir ();
257 return compile_file_names (string_printf ("%s%sout%d.c",
258 dir, SLASH_STRING, seq),
259 string_printf ("%s%sout%d.o",
260 dir, SLASH_STRING, seq));
263 /* Get the block and PC at which to evaluate an expression. */
265 static const struct block *
266 get_expr_block_and_pc (CORE_ADDR *pc)
268 const struct block *block = get_selected_block (pc);
272 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
275 block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
278 *pc = BLOCK_START (block);
281 *pc = BLOCK_START (block);
286 /* Call gdb_buildargv, set its result for S into *ARGVP but calculate also the
287 number of parsed arguments into *ARGCP. If gdb_buildargv has returned NULL
288 then *ARGCP is set to zero. */
291 build_argc_argv (const char *s, int *argcp, char ***argvp)
293 *argvp = gdb_buildargv (s);
294 *argcp = countargv (*argvp);
297 /* String for 'set compile-args' and 'show compile-args'. */
298 static char *compile_args;
300 /* Parsed form of COMPILE_ARGS. COMPILE_ARGS_ARGV is NULL terminated. */
301 static int compile_args_argc;
302 static char **compile_args_argv;
304 /* Implement 'set compile-args'. */
307 set_compile_args (char *args, int from_tty, struct cmd_list_element *c)
309 freeargv (compile_args_argv);
310 build_argc_argv (compile_args, &compile_args_argc, &compile_args_argv);
313 /* Implement 'show compile-args'. */
316 show_compile_args (struct ui_file *file, int from_tty,
317 struct cmd_list_element *c, const char *value)
319 fprintf_filtered (file, _("Compile command command-line arguments "
324 /* Append ARGC and ARGV (as parsed by build_argc_argv) to *ARGCP and *ARGVP.
325 ARGCP+ARGVP can be zero+NULL and also ARGC+ARGV can be zero+NULL. */
328 append_args (int *argcp, char ***argvp, int argc, char **argv)
332 *argvp = XRESIZEVEC (char *, *argvp, (*argcp + argc + 1));
334 for (argi = 0; argi < argc; argi++)
335 (*argvp)[(*argcp)++] = xstrdup (argv[argi]);
336 (*argvp)[(*argcp)] = NULL;
339 /* Return DW_AT_producer parsed for get_selected_frame () (if any).
340 Return NULL otherwise.
342 GCC already filters its command-line arguments only for the suitable ones to
343 put into DW_AT_producer - see GCC function gen_producer_string. */
346 get_selected_pc_producer_options (void)
348 CORE_ADDR pc = get_frame_pc (get_selected_frame (NULL));
349 struct compunit_symtab *symtab = find_pc_compunit_symtab (pc);
352 if (symtab == NULL || symtab->producer == NULL
353 || !startswith (symtab->producer, "GNU "))
356 cs = symtab->producer;
357 while (*cs != 0 && *cs != '-')
358 cs = skip_spaces_const (skip_to_space_const (cs));
364 /* Filter out unwanted options from *ARGCP and ARGV. */
367 filter_args (int *argcp, char **argv)
371 for (destv = argv; *argv != NULL; argv++)
373 /* -fpreprocessed may get in commonly from ccache. */
374 if (strcmp (*argv, "-fpreprocessed") == 0)
385 /* Produce final vector of GCC compilation options. First element is target
386 size ("-m64", "-m32" etc.), optionally followed by DW_AT_producer options
387 and then compile-args string GDB variable. */
390 get_args (const struct compile_instance *compiler, struct gdbarch *gdbarch,
391 int *argcp, char ***argvp)
393 const char *cs_producer_options;
395 char **argv_compiler;
397 build_argc_argv (gdbarch_gcc_target_options (gdbarch),
400 cs_producer_options = get_selected_pc_producer_options ();
401 if (cs_producer_options != NULL)
404 char **argv_producer;
406 build_argc_argv (cs_producer_options, &argc_producer, &argv_producer);
407 filter_args (&argc_producer, argv_producer);
408 append_args (argcp, argvp, argc_producer, argv_producer);
409 freeargv (argv_producer);
412 build_argc_argv (compiler->gcc_target_options,
413 &argc_compiler, &argv_compiler);
414 append_args (argcp, argvp, argc_compiler, argv_compiler);
415 freeargv (argv_compiler);
417 append_args (argcp, argvp, compile_args_argc, compile_args_argv);
420 /* A cleanup function to destroy a gdb_gcc_instance. */
423 cleanup_compile_instance (void *arg)
425 struct compile_instance *inst = (struct compile_instance *) arg;
427 inst->destroy (inst);
430 /* A cleanup function to unlink a file. */
433 cleanup_unlink_file (void *arg)
435 const char *filename = (const char *) arg;
440 /* A helper function suitable for use as the "print_callback" in the
444 print_callback (void *ignore, const char *message)
446 fputs_filtered (message, gdb_stderr);
449 /* Process the compilation request. On success it returns the object
450 and source file names. On an error condition, error () is
453 static compile_file_names
454 compile_to_object (struct command_line *cmd, const char *cmd_string,
455 enum compile_i_scope_types scope)
457 struct compile_instance *compiler;
458 struct cleanup *cleanup, *inner_cleanup;
459 const struct block *expr_block;
460 CORE_ADDR trash_pc, expr_pc;
465 struct gdbarch *gdbarch = get_current_arch ();
471 if (!target_has_execution)
472 error (_("The program must be running for the compile command to "\
475 expr_block = get_expr_block_and_pc (&trash_pc);
476 expr_pc = get_frame_address_in_block (get_selected_frame (NULL));
478 /* Set up instance and context for the compiler. */
479 if (current_language->la_get_compile_instance == NULL)
480 error (_("No compiler support for language %s."),
481 current_language->la_name);
482 compiler = current_language->la_get_compile_instance ();
483 cleanup = make_cleanup (cleanup_compile_instance, compiler);
485 compiler->fe->ops->set_print_callback (compiler->fe, print_callback, NULL);
487 compiler->scope = scope;
488 compiler->block = expr_block;
490 /* From the provided expression, build a scope to pass to the
493 string_file input_buf;
498 struct command_line *iter;
500 for (iter = cmd->body_list[0]; iter; iter = iter->next)
502 input_buf.puts (iter->line);
503 input_buf.puts ("\n");
506 input = input_buf.c_str ();
508 else if (cmd_string != NULL)
511 error (_("Neither a simple expression, or a multi-line specified."));
514 = current_language->la_compute_program (compiler, input, gdbarch,
515 expr_block, expr_pc);
517 fprintf_unfiltered (gdb_stdlog, "debug output:\n\n%s", code.c_str ());
519 os_rx = osabi_triplet_regexp (gdbarch_osabi (gdbarch));
520 arch_rx = gdbarch_gnu_triplet_regexp (gdbarch);
522 /* Allow triplets with or without vendor set. */
523 triplet_rx = concat (arch_rx, "(-[^-]*)?-", os_rx, (char *) NULL);
524 make_cleanup (xfree, triplet_rx);
526 /* Set compiler command-line arguments. */
527 get_args (compiler, gdbarch, &argc, &argv);
528 make_cleanup_freeargv (argv);
530 error_message = compiler->fe->ops->set_arguments (compiler->fe, triplet_rx,
532 if (error_message != NULL)
534 make_cleanup (xfree, error_message);
535 error ("%s", error_message);
542 fprintf_unfiltered (gdb_stdlog, "Passing %d compiler options:\n", argc);
543 for (argi = 0; argi < argc; argi++)
544 fprintf_unfiltered (gdb_stdlog, "Compiler option %d: <%s>\n",
548 compile_file_names fnames = get_new_file_names ();
550 src = gdb_fopen_cloexec (fnames.source_file (), "w");
552 perror_with_name (_("Could not open source file for writing"));
553 inner_cleanup = make_cleanup (cleanup_unlink_file,
554 (void *) fnames.source_file ());
555 if (fputs (code.c_str (), src) == EOF)
556 perror_with_name (_("Could not write to source file"));
560 fprintf_unfiltered (gdb_stdlog, "source file produced: %s\n\n",
561 fnames.source_file ());
563 /* Call the compiler and start the compilation process. */
564 compiler->fe->ops->set_source_file (compiler->fe, fnames.source_file ());
566 if (!compiler->fe->ops->compile (compiler->fe, fnames.object_file (),
568 error (_("Compilation failed."));
571 fprintf_unfiltered (gdb_stdlog, "object file produced: %s\n\n",
572 fnames.object_file ());
574 discard_cleanups (inner_cleanup);
575 do_cleanups (cleanup);
580 /* The "compile" prefix command. */
583 compile_command (char *args, int from_tty)
585 /* If a sub-command is not specified to the compile prefix command,
586 assume it is a direct code compilation. */
587 compile_code_command (args, from_tty);
593 eval_compile_command (struct command_line *cmd, const char *cmd_string,
594 enum compile_i_scope_types scope, void *scope_data)
596 struct cleanup *cleanup_unlink;
597 struct compile_module *compile_module;
599 compile_file_names fnames = compile_to_object (cmd, cmd_string, scope);
601 cleanup_unlink = make_cleanup (cleanup_unlink_file,
602 (void *) fnames.object_file ());
603 make_cleanup (cleanup_unlink_file, (void *) fnames.source_file ());
604 compile_module = compile_object_load (fnames, scope, scope_data);
605 if (compile_module == NULL)
607 gdb_assert (scope == COMPILE_I_PRINT_ADDRESS_SCOPE);
608 eval_compile_command (cmd, cmd_string,
609 COMPILE_I_PRINT_VALUE_SCOPE, scope_data);
612 discard_cleanups (cleanup_unlink);
613 compile_object_run (compile_module);
616 /* See compile/compile-internal.h. */
619 compile_register_name_mangled (struct gdbarch *gdbarch, int regnum)
621 const char *regname = gdbarch_register_name (gdbarch, regnum);
623 return xstrprintf ("__%s", regname);
626 /* See compile/compile-internal.h. */
629 compile_register_name_demangle (struct gdbarch *gdbarch,
634 if (regname[0] != '_' || regname[1] != '_')
635 error (_("Invalid register name \"%s\"."), regname);
638 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
639 if (strcmp (regname, gdbarch_register_name (gdbarch, regnum)) == 0)
642 error (_("Cannot find gdbarch register \"%s\"."), regname);
645 extern initialize_file_ftype _initialize_compile;
648 _initialize_compile (void)
650 struct cmd_list_element *c = NULL;
652 add_prefix_cmd ("compile", class_obscure, compile_command,
654 Command to compile source code and inject it into the inferior."),
655 &compile_command_list, "compile ", 1, &cmdlist);
656 add_com_alias ("expression", "compile", class_obscure, 0);
658 add_cmd ("code", class_obscure, compile_code_command,
660 Compile, inject, and execute code.\n\
662 Usage: compile code [-r|-raw] [--] [CODE]\n\
663 -r|-raw: Suppress automatic 'void _gdb_expr () { CODE }' wrapping.\n\
664 --: Do not parse any options beyond this delimiter. All text to the\n\
665 right will be treated as source code.\n\
667 The source code may be specified as a simple one line expression, e.g.:\n\
669 compile code printf(\"Hello world\\n\");\n\
671 Alternatively, you can type a multiline expression by invoking\n\
672 this command with no argument. GDB will then prompt for the\n\
673 expression interactively; type a line containing \"end\" to\n\
674 indicate the end of the expression."),
675 &compile_command_list);
677 c = add_cmd ("file", class_obscure, compile_file_command,
679 Evaluate a file containing source code.\n\
681 Usage: compile file [-r|-raw] [filename]\n\
682 -r|-raw: Suppress automatic 'void _gdb_expr () { CODE }' wrapping."),
683 &compile_command_list);
684 set_cmd_completer (c, filename_completer);
686 add_cmd ("print", class_obscure, compile_print_command,
688 Evaluate EXPR by using the compiler and print result.\n\
690 Usage: compile print[/FMT] [EXPR]\n\
692 The expression may be specified on the same line as the command, e.g.:\n\
696 Alternatively, you can type a multiline expression by invoking\n\
697 this command with no argument. GDB will then prompt for the\n\
698 expression interactively; type a line containing \"end\" to\n\
699 indicate the end of the expression.\n\
701 EXPR may be preceded with /FMT, where FMT is a format letter\n\
702 but no count or size letter (see \"x\" command)."),
703 &compile_command_list);
705 add_setshow_boolean_cmd ("compile", class_maintenance, &compile_debug, _("\
706 Set compile command debugging."), _("\
707 Show compile command debugging."), _("\
708 When on, compile command debugging is enabled."),
709 NULL, show_compile_debug,
710 &setdebuglist, &showdebuglist);
712 add_setshow_string_cmd ("compile-args", class_support,
714 _("Set compile command GCC command-line arguments"),
715 _("Show compile command GCC command-line arguments"),
717 Use options like -I (include file directory) or ABI settings.\n\
718 String quoting is parsed like in shell, for example:\n\
719 -mno-align-double \"-I/dir with a space/include\""),
720 set_compile_args, show_compile_args, &setlist, &showlist);
722 /* Override flags possibly coming from DW_AT_producer. */
723 compile_args = xstrdup ("-O0 -gdwarf-4"
724 /* We use -fPIE Otherwise GDB would need to reserve space large enough for
725 any object file in the inferior in advance to get the final address when
726 to link the object file to and additionally the default system linker
727 script would need to be modified so that one can specify there the
728 absolute target address.
729 -fPIC is not used at is would require from GDB to generate .got. */
731 /* We want warnings, except for some commonly happening for GDB commands. */
733 " -Wno-implicit-function-declaration"
734 " -Wno-unused-but-set-variable"
735 " -Wno-unused-variable"
736 /* Override CU's possible -fstack-protector-strong. */
737 " -fno-stack-protector"
739 set_compile_args (compile_args, 0, NULL);