1 /* General Compile and inject code
3 Copyright (C) 2014-2016 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 struct command_line *l = get_command_line (compile_control, "");
155 struct cleanup *cleanup = make_cleanup_free_command_lines (&l);
157 l->control_u.compile.scope = scope;
158 execute_control_command_untraced (l);
159 do_cleanups (cleanup);
163 /* Callback for compile_print_command. */
166 compile_print_value (struct value *val, void *data_voidp)
168 const struct format_data *fmtp = (const struct format_data *) data_voidp;
170 print_value (val, fmtp);
173 /* Handle the input from the 'compile print' command. The "compile
174 print" command is used to evaluate and print an expression that may
175 contain calls to the GCC compiler. The language expected in this
176 compile command is the language currently set in GDB. */
179 compile_print_command (char *arg_param, int from_tty)
181 const char *arg = arg_param;
182 enum compile_i_scope_types scope = COMPILE_I_PRINT_ADDRESS_SCOPE;
183 struct format_data fmt;
185 scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
187 /* Passing &FMT as SCOPE_DATA is safe as do_module_cleanup will not
188 touch the stale pointer if compile_object_run has already quit. */
189 print_command_parse_format (&arg, "compile print", &fmt);
192 eval_compile_command (NULL, arg, scope, &fmt);
195 struct command_line *l = get_command_line (compile_control, "");
196 struct cleanup *cleanup = make_cleanup_free_command_lines (&l);
198 l->control_u.compile.scope = scope;
199 l->control_u.compile.scope_data = &fmt;
200 execute_control_command_untraced (l);
201 do_cleanups (cleanup);
205 /* A cleanup function to remove a directory and all its contents. */
210 const char *dir = (const char *) arg;
214 gdb_assert (startswith (dir, TMP_PREFIX));
215 zap = concat ("rm -rf ", dir, (char *) NULL);
216 wstat = system (zap);
217 if (wstat == -1 || !WIFEXITED (wstat) || WEXITSTATUS (wstat) != 0)
218 warning (_("Could not remove temporary directory %s"), dir);
222 /* Return the name of the temporary directory to use for .o files, and
223 arrange for the directory to be removed at shutdown. */
226 get_compile_file_tempdir (void)
228 static char *tempdir_name;
230 #define TEMPLATE TMP_PREFIX "XXXXXX"
231 char tname[sizeof (TEMPLATE)];
233 if (tempdir_name != NULL)
236 strcpy (tname, TEMPLATE);
239 tempdir_name = mkdtemp (tname);
241 error (_("Command not supported on this host."));
243 if (tempdir_name == NULL)
244 perror_with_name (_("Could not make temporary directory"));
246 tempdir_name = xstrdup (tempdir_name);
247 make_final_cleanup (do_rmdir, tempdir_name);
251 /* Compute the names of source and object files to use. */
253 static compile_file_names
254 get_new_file_names ()
257 const char *dir = get_compile_file_tempdir ();
261 return compile_file_names (string_printf ("%s%sout%d.c",
262 dir, SLASH_STRING, seq),
263 string_printf ("%s%sout%d.o",
264 dir, SLASH_STRING, seq));
267 /* Get the block and PC at which to evaluate an expression. */
269 static const struct block *
270 get_expr_block_and_pc (CORE_ADDR *pc)
272 const struct block *block = get_selected_block (pc);
276 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
279 block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
282 *pc = BLOCK_START (block);
285 *pc = BLOCK_START (block);
290 /* Call gdb_buildargv, set its result for S into *ARGVP but calculate also the
291 number of parsed arguments into *ARGCP. If gdb_buildargv has returned NULL
292 then *ARGCP is set to zero. */
295 build_argc_argv (const char *s, int *argcp, char ***argvp)
297 *argvp = gdb_buildargv (s);
298 *argcp = countargv (*argvp);
301 /* String for 'set compile-args' and 'show compile-args'. */
302 static char *compile_args;
304 /* Parsed form of COMPILE_ARGS. COMPILE_ARGS_ARGV is NULL terminated. */
305 static int compile_args_argc;
306 static char **compile_args_argv;
308 /* Implement 'set compile-args'. */
311 set_compile_args (char *args, int from_tty, struct cmd_list_element *c)
313 freeargv (compile_args_argv);
314 build_argc_argv (compile_args, &compile_args_argc, &compile_args_argv);
317 /* Implement 'show compile-args'. */
320 show_compile_args (struct ui_file *file, int from_tty,
321 struct cmd_list_element *c, const char *value)
323 fprintf_filtered (file, _("Compile command command-line arguments "
328 /* Append ARGC and ARGV (as parsed by build_argc_argv) to *ARGCP and *ARGVP.
329 ARGCP+ARGVP can be zero+NULL and also ARGC+ARGV can be zero+NULL. */
332 append_args (int *argcp, char ***argvp, int argc, char **argv)
336 *argvp = XRESIZEVEC (char *, *argvp, (*argcp + argc + 1));
338 for (argi = 0; argi < argc; argi++)
339 (*argvp)[(*argcp)++] = xstrdup (argv[argi]);
340 (*argvp)[(*argcp)] = NULL;
343 /* Return DW_AT_producer parsed for get_selected_frame () (if any).
344 Return NULL otherwise.
346 GCC already filters its command-line arguments only for the suitable ones to
347 put into DW_AT_producer - see GCC function gen_producer_string. */
350 get_selected_pc_producer_options (void)
352 CORE_ADDR pc = get_frame_pc (get_selected_frame (NULL));
353 struct compunit_symtab *symtab = find_pc_compunit_symtab (pc);
356 if (symtab == NULL || symtab->producer == NULL
357 || !startswith (symtab->producer, "GNU "))
360 cs = symtab->producer;
361 while (*cs != 0 && *cs != '-')
362 cs = skip_spaces_const (skip_to_space_const (cs));
368 /* Filter out unwanted options from *ARGCP and ARGV. */
371 filter_args (int *argcp, char **argv)
375 for (destv = argv; *argv != NULL; argv++)
377 /* -fpreprocessed may get in commonly from ccache. */
378 if (strcmp (*argv, "-fpreprocessed") == 0)
389 /* Produce final vector of GCC compilation options. First element is target
390 size ("-m64", "-m32" etc.), optionally followed by DW_AT_producer options
391 and then compile-args string GDB variable. */
394 get_args (const struct compile_instance *compiler, struct gdbarch *gdbarch,
395 int *argcp, char ***argvp)
397 const char *cs_producer_options;
399 char **argv_compiler;
401 build_argc_argv (gdbarch_gcc_target_options (gdbarch),
404 cs_producer_options = get_selected_pc_producer_options ();
405 if (cs_producer_options != NULL)
408 char **argv_producer;
410 build_argc_argv (cs_producer_options, &argc_producer, &argv_producer);
411 filter_args (&argc_producer, argv_producer);
412 append_args (argcp, argvp, argc_producer, argv_producer);
413 freeargv (argv_producer);
416 build_argc_argv (compiler->gcc_target_options,
417 &argc_compiler, &argv_compiler);
418 append_args (argcp, argvp, argc_compiler, argv_compiler);
419 freeargv (argv_compiler);
421 append_args (argcp, argvp, compile_args_argc, compile_args_argv);
424 /* A cleanup function to destroy a gdb_gcc_instance. */
427 cleanup_compile_instance (void *arg)
429 struct compile_instance *inst = (struct compile_instance *) arg;
431 inst->destroy (inst);
434 /* A cleanup function to unlink a file. */
437 cleanup_unlink_file (void *arg)
439 const char *filename = (const char *) arg;
444 /* A helper function suitable for use as the "print_callback" in the
448 print_callback (void *ignore, const char *message)
450 fputs_filtered (message, gdb_stderr);
453 /* Process the compilation request. On success it returns the object
454 and source file names. On an error condition, error () is
457 static compile_file_names
458 compile_to_object (struct command_line *cmd, const char *cmd_string,
459 enum compile_i_scope_types scope)
461 struct compile_instance *compiler;
462 struct cleanup *cleanup, *inner_cleanup;
463 const struct block *expr_block;
464 CORE_ADDR trash_pc, expr_pc;
469 struct gdbarch *gdbarch = get_current_arch ();
475 if (!target_has_execution)
476 error (_("The program must be running for the compile command to "\
479 expr_block = get_expr_block_and_pc (&trash_pc);
480 expr_pc = get_frame_address_in_block (get_selected_frame (NULL));
482 /* Set up instance and context for the compiler. */
483 if (current_language->la_get_compile_instance == NULL)
484 error (_("No compiler support for language %s."),
485 current_language->la_name);
486 compiler = current_language->la_get_compile_instance ();
487 cleanup = make_cleanup (cleanup_compile_instance, compiler);
489 compiler->fe->ops->set_print_callback (compiler->fe, print_callback, NULL);
491 compiler->scope = scope;
492 compiler->block = expr_block;
494 /* From the provided expression, build a scope to pass to the
497 std::string input_buf;
502 struct ui_file *stream = mem_fileopen ();
503 struct command_line *iter;
505 make_cleanup_ui_file_delete (stream);
506 for (iter = cmd->body_list[0]; iter; iter = iter->next)
508 fputs_unfiltered (iter->line, stream);
509 fputs_unfiltered ("\n", stream);
512 input_buf = ui_file_as_string (stream);
513 input = input_buf.c_str ();
515 else if (cmd_string != NULL)
518 error (_("Neither a simple expression, or a multi-line specified."));
521 = current_language->la_compute_program (compiler, input, gdbarch,
522 expr_block, expr_pc);
524 fprintf_unfiltered (gdb_stdlog, "debug output:\n\n%s", code.c_str ());
526 os_rx = osabi_triplet_regexp (gdbarch_osabi (gdbarch));
527 arch_rx = gdbarch_gnu_triplet_regexp (gdbarch);
529 /* Allow triplets with or without vendor set. */
530 triplet_rx = concat (arch_rx, "(-[^-]*)?-", os_rx, (char *) NULL);
531 make_cleanup (xfree, triplet_rx);
533 /* Set compiler command-line arguments. */
534 get_args (compiler, gdbarch, &argc, &argv);
535 make_cleanup_freeargv (argv);
537 error_message = compiler->fe->ops->set_arguments (compiler->fe, triplet_rx,
539 if (error_message != NULL)
541 make_cleanup (xfree, error_message);
542 error ("%s", error_message);
549 fprintf_unfiltered (gdb_stdlog, "Passing %d compiler options:\n", argc);
550 for (argi = 0; argi < argc; argi++)
551 fprintf_unfiltered (gdb_stdlog, "Compiler option %d: <%s>\n",
555 compile_file_names fnames = get_new_file_names ();
557 src = gdb_fopen_cloexec (fnames.source_file (), "w");
559 perror_with_name (_("Could not open source file for writing"));
560 inner_cleanup = make_cleanup (cleanup_unlink_file,
561 (void *) fnames.source_file ());
562 if (fputs (code.c_str (), src) == EOF)
563 perror_with_name (_("Could not write to source file"));
567 fprintf_unfiltered (gdb_stdlog, "source file produced: %s\n\n",
568 fnames.source_file ());
570 /* Call the compiler and start the compilation process. */
571 compiler->fe->ops->set_source_file (compiler->fe, fnames.source_file ());
573 if (!compiler->fe->ops->compile (compiler->fe, fnames.object_file (),
575 error (_("Compilation failed."));
578 fprintf_unfiltered (gdb_stdlog, "object file produced: %s\n\n",
579 fnames.object_file ());
581 discard_cleanups (inner_cleanup);
582 do_cleanups (cleanup);
587 /* The "compile" prefix command. */
590 compile_command (char *args, int from_tty)
592 /* If a sub-command is not specified to the compile prefix command,
593 assume it is a direct code compilation. */
594 compile_code_command (args, from_tty);
600 eval_compile_command (struct command_line *cmd, const char *cmd_string,
601 enum compile_i_scope_types scope, void *scope_data)
603 struct cleanup *cleanup_unlink;
604 struct compile_module *compile_module;
606 compile_file_names fnames = compile_to_object (cmd, cmd_string, scope);
608 cleanup_unlink = make_cleanup (cleanup_unlink_file,
609 (void *) fnames.object_file ());
610 make_cleanup (cleanup_unlink_file, (void *) fnames.source_file ());
611 compile_module = compile_object_load (fnames, scope, scope_data);
612 if (compile_module == NULL)
614 gdb_assert (scope == COMPILE_I_PRINT_ADDRESS_SCOPE);
615 eval_compile_command (cmd, cmd_string,
616 COMPILE_I_PRINT_VALUE_SCOPE, scope_data);
619 discard_cleanups (cleanup_unlink);
620 compile_object_run (compile_module);
623 /* See compile/compile-internal.h. */
626 compile_register_name_mangled (struct gdbarch *gdbarch, int regnum)
628 const char *regname = gdbarch_register_name (gdbarch, regnum);
630 return xstrprintf ("__%s", regname);
633 /* See compile/compile-internal.h. */
636 compile_register_name_demangle (struct gdbarch *gdbarch,
641 if (regname[0] != '_' || regname[1] != '_')
642 error (_("Invalid register name \"%s\"."), regname);
645 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
646 if (strcmp (regname, gdbarch_register_name (gdbarch, regnum)) == 0)
649 error (_("Cannot find gdbarch register \"%s\"."), regname);
652 extern initialize_file_ftype _initialize_compile;
655 _initialize_compile (void)
657 struct cmd_list_element *c = NULL;
659 add_prefix_cmd ("compile", class_obscure, compile_command,
661 Command to compile source code and inject it into the inferior."),
662 &compile_command_list, "compile ", 1, &cmdlist);
663 add_com_alias ("expression", "compile", class_obscure, 0);
665 add_cmd ("code", class_obscure, compile_code_command,
667 Compile, inject, and execute code.\n\
669 Usage: compile code [-r|-raw] [--] [CODE]\n\
670 -r|-raw: Suppress automatic 'void _gdb_expr () { CODE }' wrapping.\n\
671 --: Do not parse any options beyond this delimiter. All text to the\n\
672 right will be treated as source code.\n\
674 The source code may be specified as a simple one line expression, e.g.:\n\
676 compile code printf(\"Hello world\\n\");\n\
678 Alternatively, you can type a multiline expression by invoking\n\
679 this command with no argument. GDB will then prompt for the\n\
680 expression interactively; type a line containing \"end\" to\n\
681 indicate the end of the expression."),
682 &compile_command_list);
684 c = add_cmd ("file", class_obscure, compile_file_command,
686 Evaluate a file containing source code.\n\
688 Usage: compile file [-r|-raw] [filename]\n\
689 -r|-raw: Suppress automatic 'void _gdb_expr () { CODE }' wrapping."),
690 &compile_command_list);
691 set_cmd_completer (c, filename_completer);
693 add_cmd ("print", class_obscure, compile_print_command,
695 Evaluate EXPR by using the compiler and print result.\n\
697 Usage: compile print[/FMT] [EXPR]\n\
699 The expression may be specified on the same line as the command, e.g.:\n\
703 Alternatively, you can type a multiline expression by invoking\n\
704 this command with no argument. GDB will then prompt for the\n\
705 expression interactively; type a line containing \"end\" to\n\
706 indicate the end of the expression.\n\
708 EXPR may be preceded with /FMT, where FMT is a format letter\n\
709 but no count or size letter (see \"x\" command)."),
710 &compile_command_list);
712 add_setshow_boolean_cmd ("compile", class_maintenance, &compile_debug, _("\
713 Set compile command debugging."), _("\
714 Show compile command debugging."), _("\
715 When on, compile command debugging is enabled."),
716 NULL, show_compile_debug,
717 &setdebuglist, &showdebuglist);
719 add_setshow_string_cmd ("compile-args", class_support,
721 _("Set compile command GCC command-line arguments"),
722 _("Show compile command GCC command-line arguments"),
724 Use options like -I (include file directory) or ABI settings.\n\
725 String quoting is parsed like in shell, for example:\n\
726 -mno-align-double \"-I/dir with a space/include\""),
727 set_compile_args, show_compile_args, &setlist, &showlist);
729 /* Override flags possibly coming from DW_AT_producer. */
730 compile_args = xstrdup ("-O0 -gdwarf-4"
731 /* We use -fPIE Otherwise GDB would need to reserve space large enough for
732 any object file in the inferior in advance to get the final address when
733 to link the object file to and additionally the default system linker
734 script would need to be modified so that one can specify there the
735 absolute target address.
736 -fPIC is not used at is would require from GDB to generate .got. */
738 /* We want warnings, except for some commonly happening for GDB commands. */
740 " -Wno-implicit-function-declaration"
741 " -Wno-unused-but-set-variable"
742 " -Wno-unused-variable"
743 /* Override CU's possible -fstack-protector-strong. */
744 " -fno-stack-protector"
746 set_compile_args (compile_args, 0, NULL);