1 /* General Compile and inject code
3 Copyright (C) 2014-2021 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 "cli/cli-option.h"
27 #include "completer.h"
30 #include "compile-internal.h"
31 #include "compile-object-load.h"
32 #include "compile-object-run.h"
37 #include "arch-utils.h"
38 #include "gdbsupport/filestuff.h"
41 #include "gdbsupport/gdb_wait.h"
43 #include "gdbsupport/gdb_optional.h"
44 #include "gdbsupport/gdb_unlinker.h"
45 #include "gdbsupport/pathstuff.h"
50 /* Initial filename for temporary files. */
52 #define TMP_PREFIX "/tmp/gdbobj-"
54 /* Hold "compile" commands. */
56 static struct cmd_list_element
*compile_command_list
;
58 /* Debug flag for "compile" commands. */
62 /* Object of this type are stored in the compiler's symbol_err_map. */
68 const struct symbol
*sym
;
70 /* The error message to emit. This is malloc'd and owned by the
76 /* Hash a type_map_instance. */
79 hash_type_map_instance (const void *p
)
81 const struct type_map_instance
*inst
= (const struct type_map_instance
*) p
;
83 return htab_hash_pointer (inst
->type
);
86 /* Check two type_map_instance objects for equality. */
89 eq_type_map_instance (const void *a
, const void *b
)
91 const struct type_map_instance
*insta
= (const struct type_map_instance
*) a
;
92 const struct type_map_instance
*instb
= (const struct type_map_instance
*) b
;
94 return insta
->type
== instb
->type
;
97 /* Hash function for struct symbol_error. */
100 hash_symbol_error (const void *a
)
102 const struct symbol_error
*se
= (const struct symbol_error
*) a
;
104 return htab_hash_pointer (se
->sym
);
107 /* Equality function for struct symbol_error. */
110 eq_symbol_error (const void *a
, const void *b
)
112 const struct symbol_error
*sea
= (const struct symbol_error
*) a
;
113 const struct symbol_error
*seb
= (const struct symbol_error
*) b
;
115 return sea
->sym
== seb
->sym
;
118 /* Deletion function for struct symbol_error. */
121 del_symbol_error (void *a
)
123 struct symbol_error
*se
= (struct symbol_error
*) a
;
129 /* Constructor for compile_instance. */
131 compile_instance::compile_instance (struct gcc_base_context
*gcc_fe
,
133 : m_gcc_fe (gcc_fe
), m_gcc_target_options (options
),
134 m_type_map (htab_create_alloc (10, hash_type_map_instance
,
135 eq_type_map_instance
,
136 xfree
, xcalloc
, xfree
)),
137 m_symbol_err_map (htab_create_alloc (10, hash_symbol_error
,
138 eq_symbol_error
, del_symbol_error
,
143 /* See compile-internal.h. */
146 compile_instance::get_cached_type (struct type
*type
, gcc_type
*ret
) const
148 struct type_map_instance inst
, *found
;
151 found
= (struct type_map_instance
*) htab_find (m_type_map
.get (), &inst
);
154 *ret
= found
->gcc_type_handle
;
161 /* See compile-internal.h. */
164 compile_instance::insert_type (struct type
*type
, gcc_type gcc_type
)
166 struct type_map_instance inst
, *add
;
170 inst
.gcc_type_handle
= gcc_type
;
171 slot
= htab_find_slot (m_type_map
.get (), &inst
, INSERT
);
173 add
= (struct type_map_instance
*) *slot
;
174 /* The type might have already been inserted in order to handle
176 if (add
!= NULL
&& add
->gcc_type_handle
!= gcc_type
)
177 error (_("Unexpected type id from GCC, check you use recent enough GCC."));
181 add
= XNEW (struct type_map_instance
);
187 /* See compile-internal.h. */
190 compile_instance::insert_symbol_error (const struct symbol
*sym
,
193 struct symbol_error e
;
197 slot
= htab_find_slot (m_symbol_err_map
.get (), &e
, INSERT
);
200 struct symbol_error
*ep
= XNEW (struct symbol_error
);
203 ep
->message
= xstrdup (text
);
208 /* See compile-internal.h. */
211 compile_instance::error_symbol_once (const struct symbol
*sym
)
213 struct symbol_error search
;
214 struct symbol_error
*err
;
216 if (m_symbol_err_map
== NULL
)
220 err
= (struct symbol_error
*) htab_find (m_symbol_err_map
.get (), &search
);
221 if (err
== NULL
|| err
->message
== NULL
)
224 gdb::unique_xmalloc_ptr
<char> message (err
->message
);
226 error (_("%s"), message
.get ());
229 /* Implement "show debug compile". */
232 show_compile_debug (struct ui_file
*file
, int from_tty
,
233 struct cmd_list_element
*c
, const char *value
)
235 fprintf_filtered (file
, _("Compile debugging is %s.\n"), value
);
240 /* Options for the compile command. */
242 struct compile_options
248 using compile_flag_option_def
249 = gdb::option::flag_option_def
<compile_options
>;
251 static const gdb::option::option_def compile_command_option_defs
[] = {
253 compile_flag_option_def
{
255 [] (compile_options
*opts
) { return &opts
->raw
; },
256 N_("Suppress automatic 'void _gdb_expr () { CODE }' wrapping."),
261 /* Create an option_def_group for the "compile" command's options,
262 with OPTS as context. */
264 static gdb::option::option_def_group
265 make_compile_options_def_group (compile_options
*opts
)
267 return {{compile_command_option_defs
}, opts
};
270 /* Handle the input from the 'compile file' command. The "compile
271 file" command is used to evaluate an expression contained in a file
272 that may contain calls to the GCC compiler. */
275 compile_file_command (const char *args
, int from_tty
)
277 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
279 /* Check if a -raw option is provided. */
281 compile_options options
;
283 const gdb::option::option_def_group group
284 = make_compile_options_def_group (&options
);
285 gdb::option::process_options
286 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
,
289 enum compile_i_scope_types scope
290 = options
.raw
? COMPILE_I_RAW_SCOPE
: COMPILE_I_SIMPLE_SCOPE
;
292 args
= skip_spaces (args
);
294 /* After processing options, check whether we have a filename. */
295 if (args
== nullptr || args
[0] == '\0')
296 error (_("You must provide a filename for this command."));
298 args
= skip_spaces (args
);
299 gdb::unique_xmalloc_ptr
<char> abspath
= gdb_abspath (args
);
300 std::string buffer
= string_printf ("#include \"%s\"\n", abspath
.get ());
301 eval_compile_command (NULL
, buffer
.c_str (), scope
, NULL
);
304 /* Completer for the "compile file" command. */
307 compile_file_command_completer (struct cmd_list_element
*ignore
,
308 completion_tracker
&tracker
,
309 const char *text
, const char *word
)
311 const gdb::option::option_def_group group
312 = make_compile_options_def_group (nullptr);
313 if (gdb::option::complete_options
314 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
))
317 word
= advance_to_filename_complete_word_point (tracker
, text
);
318 filename_completer (ignore
, tracker
, text
, word
);
321 /* Handle the input from the 'compile code' command. The
322 "compile code" command is used to evaluate an expression that may
323 contain calls to the GCC compiler. The language expected in this
324 compile command is the language currently set in GDB. */
327 compile_code_command (const char *args
, int from_tty
)
329 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
331 compile_options options
;
333 const gdb::option::option_def_group group
334 = make_compile_options_def_group (&options
);
335 gdb::option::process_options
336 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
);
338 enum compile_i_scope_types scope
339 = options
.raw
? COMPILE_I_RAW_SCOPE
: COMPILE_I_SIMPLE_SCOPE
;
342 eval_compile_command (NULL
, args
, scope
, NULL
);
345 counted_command_line l
= get_command_line (compile_control
, "");
347 l
->control_u
.compile
.scope
= scope
;
348 execute_control_command_untraced (l
.get ());
352 /* Completer for the "compile code" command. */
355 compile_code_command_completer (struct cmd_list_element
*ignore
,
356 completion_tracker
&tracker
,
357 const char *text
, const char *word
)
359 const gdb::option::option_def_group group
360 = make_compile_options_def_group (nullptr);
361 if (gdb::option::complete_options
362 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
))
365 word
= advance_to_expression_complete_word_point (tracker
, text
);
366 symbol_completer (ignore
, tracker
, text
, word
);
369 /* Callback for compile_print_command. */
372 compile_print_value (struct value
*val
, void *data_voidp
)
374 const value_print_options
*print_opts
= (value_print_options
*) data_voidp
;
376 print_value (val
, *print_opts
);
379 /* Handle the input from the 'compile print' command. The "compile
380 print" command is used to evaluate and print an expression that may
381 contain calls to the GCC compiler. The language expected in this
382 compile command is the language currently set in GDB. */
385 compile_print_command (const char *arg
, int from_tty
)
387 enum compile_i_scope_types scope
= COMPILE_I_PRINT_ADDRESS_SCOPE
;
388 value_print_options print_opts
;
390 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
392 get_user_print_options (&print_opts
);
393 /* Override global settings with explicit options, if any. */
394 auto group
= make_value_print_options_def_group (&print_opts
);
395 gdb::option::process_options
396 (&arg
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
);
398 print_command_parse_format (&arg
, "compile print", &print_opts
);
400 /* Passing &PRINT_OPTS as SCOPE_DATA is safe as do_module_cleanup
401 will not touch the stale pointer if compile_object_run has
405 eval_compile_command (NULL
, arg
, scope
, &print_opts
);
408 counted_command_line l
= get_command_line (compile_control
, "");
410 l
->control_u
.compile
.scope
= scope
;
411 l
->control_u
.compile
.scope_data
= &print_opts
;
412 execute_control_command_untraced (l
.get ());
416 /* A cleanup function to remove a directory and all its contents. */
421 const char *dir
= (const char *) arg
;
425 gdb_assert (startswith (dir
, TMP_PREFIX
));
426 zap
= concat ("rm -rf ", dir
, (char *) NULL
);
427 wstat
= system (zap
);
428 if (wstat
== -1 || !WIFEXITED (wstat
) || WEXITSTATUS (wstat
) != 0)
429 warning (_("Could not remove temporary directory %s"), dir
);
433 /* Return the name of the temporary directory to use for .o files, and
434 arrange for the directory to be removed at shutdown. */
437 get_compile_file_tempdir (void)
439 static char *tempdir_name
;
441 #define TEMPLATE TMP_PREFIX "XXXXXX"
442 char tname
[sizeof (TEMPLATE
)];
444 if (tempdir_name
!= NULL
)
447 strcpy (tname
, TEMPLATE
);
449 tempdir_name
= mkdtemp (tname
);
450 if (tempdir_name
== NULL
)
451 perror_with_name (_("Could not make temporary directory"));
453 tempdir_name
= xstrdup (tempdir_name
);
454 make_final_cleanup (do_rmdir
, tempdir_name
);
458 /* Compute the names of source and object files to use. */
460 static compile_file_names
461 get_new_file_names ()
464 const char *dir
= get_compile_file_tempdir ();
468 return compile_file_names (string_printf ("%s%sout%d.c",
469 dir
, SLASH_STRING
, seq
),
470 string_printf ("%s%sout%d.o",
471 dir
, SLASH_STRING
, seq
));
474 /* Get the block and PC at which to evaluate an expression. */
476 static const struct block
*
477 get_expr_block_and_pc (CORE_ADDR
*pc
)
479 const struct block
*block
= get_selected_block (pc
);
483 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
486 block
= BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal
.symtab
),
489 *pc
= BLOCK_ENTRY_PC (block
);
492 *pc
= BLOCK_ENTRY_PC (block
);
497 /* String for 'set compile-args' and 'show compile-args'. */
498 static char *compile_args
;
500 /* Parsed form of COMPILE_ARGS. */
501 static gdb_argv compile_args_argv
;
503 /* Implement 'set compile-args'. */
506 set_compile_args (const char *args
, int from_tty
, struct cmd_list_element
*c
)
508 compile_args_argv
= gdb_argv (compile_args
);
511 /* Implement 'show compile-args'. */
514 show_compile_args (struct ui_file
*file
, int from_tty
,
515 struct cmd_list_element
*c
, const char *value
)
517 fprintf_filtered (file
, _("Compile command command-line arguments "
522 /* String for 'set compile-gcc' and 'show compile-gcc'. */
523 static char *compile_gcc
;
525 /* Implement 'show compile-gcc'. */
528 show_compile_gcc (struct ui_file
*file
, int from_tty
,
529 struct cmd_list_element
*c
, const char *value
)
531 fprintf_filtered (file
, _("Compile command GCC driver filename is \"%s\".\n"),
535 /* Return DW_AT_producer parsed for get_selected_frame () (if any).
536 Return NULL otherwise.
538 GCC already filters its command-line arguments only for the suitable ones to
539 put into DW_AT_producer - see GCC function gen_producer_string. */
542 get_selected_pc_producer_options (void)
544 CORE_ADDR pc
= get_frame_pc (get_selected_frame (NULL
));
545 struct compunit_symtab
*symtab
= find_pc_compunit_symtab (pc
);
548 if (symtab
== NULL
|| symtab
->producer
== NULL
549 || !startswith (symtab
->producer
, "GNU "))
552 cs
= symtab
->producer
;
553 while (*cs
!= 0 && *cs
!= '-')
554 cs
= skip_spaces (skip_to_space (cs
));
560 /* Filter out unwanted options from ARGV. */
563 filter_args (char **argv
)
567 for (destv
= argv
; *argv
!= NULL
; argv
++)
569 /* -fpreprocessed may get in commonly from ccache. */
570 if (strcmp (*argv
, "-fpreprocessed") == 0)
580 /* Produce final vector of GCC compilation options.
582 The first element of the combined argument vector are arguments
583 relating to the target size ("-m64", "-m32" etc.). These are
584 sourced from the inferior's architecture.
586 The second element of the combined argument vector are arguments
587 stored in the inferior DW_AT_producer section. If these are stored
588 in the inferior (there is no guarantee that they are), they are
591 The third element of the combined argument vector are argument
592 supplied by the language implementation provided by
593 compile-{lang}-support. These contain language specific arguments.
595 The final element of the combined argument vector are arguments
596 supplied by the "set compile-args" command. These are always
597 appended last so as to override any of the arguments automatically
601 get_args (const compile_instance
*compiler
, struct gdbarch
*gdbarch
)
603 const char *cs_producer_options
;
606 std::string gcc_options
= gdbarch_gcc_target_options (gdbarch
);
608 /* Make sure we have a non-empty set of options, otherwise GCC will
609 error out trying to look for a filename that is an empty string. */
610 if (!gcc_options
.empty ())
611 result
= gdb_argv (gcc_options
.c_str ());
613 cs_producer_options
= get_selected_pc_producer_options ();
614 if (cs_producer_options
!= NULL
)
616 gdb_argv
argv_producer (cs_producer_options
);
617 filter_args (argv_producer
.get ());
619 result
.append (std::move (argv_producer
));
622 result
.append (gdb_argv (compiler
->gcc_target_options ().c_str ()));
623 result
.append (compile_args_argv
);
628 /* A helper function suitable for use as the "print_callback" in the
632 print_callback (void *ignore
, const char *message
)
634 fputs_filtered (message
, gdb_stderr
);
637 /* RAII class used to ignore SIGPIPE in a scope. */
639 class scoped_ignore_sigpipe
642 scoped_ignore_sigpipe ()
645 m_osigpipe
= signal (SIGPIPE
, SIG_IGN
);
649 ~scoped_ignore_sigpipe ()
652 signal (SIGPIPE
, m_osigpipe
);
656 DISABLE_COPY_AND_ASSIGN (scoped_ignore_sigpipe
);
660 sighandler_t m_osigpipe
= NULL
;
664 /* Process the compilation request. On success it returns the object
665 and source file names. On an error condition, error () is
668 static compile_file_names
669 compile_to_object (struct command_line
*cmd
, const char *cmd_string
,
670 enum compile_i_scope_types scope
)
672 const struct block
*expr_block
;
673 CORE_ADDR trash_pc
, expr_pc
;
675 struct gdbarch
*gdbarch
= get_current_arch ();
676 std::string triplet_rx
;
678 if (!target_has_execution ())
679 error (_("The program must be running for the compile command to "\
682 expr_block
= get_expr_block_and_pc (&trash_pc
);
683 expr_pc
= get_frame_address_in_block (get_selected_frame (NULL
));
685 /* Set up instance and context for the compiler. */
686 std::unique_ptr
<compile_instance
> compiler
687 = current_language
->get_compile_instance ();
688 if (compiler
== nullptr)
689 error (_("No compiler support for language %s."),
690 current_language
->name ());
691 compiler
->set_print_callback (print_callback
, NULL
);
692 compiler
->set_scope (scope
);
693 compiler
->set_block (expr_block
);
695 /* From the provided expression, build a scope to pass to the
698 string_file input_buf
;
703 struct command_line
*iter
;
705 for (iter
= cmd
->body_list_0
.get (); iter
; iter
= iter
->next
)
707 input_buf
.puts (iter
->line
);
708 input_buf
.puts ("\n");
711 input
= input_buf
.c_str ();
713 else if (cmd_string
!= NULL
)
716 error (_("Neither a simple expression, or a multi-line specified."));
719 = current_language
->compute_program (compiler
.get (), input
, gdbarch
,
720 expr_block
, expr_pc
);
722 fprintf_unfiltered (gdb_stdlog
, "debug output:\n\n%s", code
.c_str ());
724 compiler
->set_verbose (compile_debug
);
726 if (compile_gcc
[0] != 0)
728 if (compiler
->version () < GCC_FE_VERSION_1
)
729 error (_("Command 'set compile-gcc' requires GCC version 6 or higher "
730 "(libcc1 interface version 1 or higher)"));
732 compiler
->set_driver_filename (compile_gcc
);
736 const char *os_rx
= osabi_triplet_regexp (gdbarch_osabi (gdbarch
));
737 const char *arch_rx
= gdbarch_gnu_triplet_regexp (gdbarch
);
739 /* Allow triplets with or without vendor set. */
740 triplet_rx
= std::string (arch_rx
) + "(-[^-]*)?-";
741 if (os_rx
!= nullptr)
743 compiler
->set_triplet_regexp (triplet_rx
.c_str ());
746 /* Set compiler command-line arguments. */
747 gdb_argv argv_holder
= get_args (compiler
.get (), gdbarch
);
748 int argc
= argv_holder
.count ();
749 char **argv
= argv_holder
.get ();
751 gdb::unique_xmalloc_ptr
<char> error_message
752 = compiler
->set_arguments (argc
, argv
, triplet_rx
.c_str ());
754 if (error_message
!= NULL
)
755 error ("%s", error_message
.get ());
761 fprintf_unfiltered (gdb_stdlog
, "Passing %d compiler options:\n", argc
);
762 for (argi
= 0; argi
< argc
; argi
++)
763 fprintf_unfiltered (gdb_stdlog
, "Compiler option %d: <%s>\n",
767 compile_file_names fnames
= get_new_file_names ();
769 gdb::optional
<gdb::unlinker
> source_remover
;
772 gdb_file_up src
= gdb_fopen_cloexec (fnames
.source_file (), "w");
774 perror_with_name (_("Could not open source file for writing"));
776 source_remover
.emplace (fnames
.source_file ());
778 if (fputs (code
.c_str (), src
.get ()) == EOF
)
779 perror_with_name (_("Could not write to source file"));
783 fprintf_unfiltered (gdb_stdlog
, "source file produced: %s\n\n",
784 fnames
.source_file ());
786 /* If we don't do this, then GDB simply exits
787 when the compiler dies. */
788 scoped_ignore_sigpipe ignore_sigpipe
;
790 /* Call the compiler and start the compilation process. */
791 compiler
->set_source_file (fnames
.source_file ());
792 ok
= compiler
->compile (fnames
.object_file (), compile_debug
);
794 error (_("Compilation failed."));
797 fprintf_unfiltered (gdb_stdlog
, "object file produced: %s\n\n",
798 fnames
.object_file ());
800 /* Keep the source file. */
801 source_remover
->keep ();
805 /* The "compile" prefix command. */
808 compile_command (const char *args
, int from_tty
)
810 /* If a sub-command is not specified to the compile prefix command,
811 assume it is a direct code compilation. */
812 compile_code_command (args
, from_tty
);
818 eval_compile_command (struct command_line
*cmd
, const char *cmd_string
,
819 enum compile_i_scope_types scope
, void *scope_data
)
821 compile_file_names fnames
= compile_to_object (cmd
, cmd_string
, scope
);
823 gdb::unlinker
object_remover (fnames
.object_file ());
824 gdb::unlinker
source_remover (fnames
.source_file ());
826 compile_module_up compile_module
= compile_object_load (fnames
, scope
,
828 if (compile_module
== NULL
)
830 gdb_assert (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
);
831 eval_compile_command (cmd
, cmd_string
,
832 COMPILE_I_PRINT_VALUE_SCOPE
, scope_data
);
836 /* Keep the files. */
837 source_remover
.keep ();
838 object_remover
.keep ();
840 compile_object_run (std::move (compile_module
));
843 /* See compile/compile-internal.h. */
846 compile_register_name_mangled (struct gdbarch
*gdbarch
, int regnum
)
848 const char *regname
= gdbarch_register_name (gdbarch
, regnum
);
850 return string_printf ("__%s", regname
);
853 /* See compile/compile-internal.h. */
856 compile_register_name_demangle (struct gdbarch
*gdbarch
,
861 if (regname
[0] != '_' || regname
[1] != '_')
862 error (_("Invalid register name \"%s\"."), regname
);
865 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
866 if (strcmp (regname
, gdbarch_register_name (gdbarch
, regnum
)) == 0)
869 error (_("Cannot find gdbarch register \"%s\"."), regname
);
872 /* Forwards to the plug-in. */
874 #define FORWARD(OP,...) (m_gcc_fe->ops->OP (m_gcc_fe, ##__VA_ARGS__))
876 /* See compile-internal.h. */
879 compile_instance::set_print_callback
880 (void (*print_function
) (void *, const char *), void *datum
)
882 FORWARD (set_print_callback
, print_function
, datum
);
885 /* See compile-internal.h. */
888 compile_instance::version () const
890 return m_gcc_fe
->ops
->version
;
893 /* See compile-internal.h. */
896 compile_instance::set_verbose (int level
)
898 if (version () >= GCC_FE_VERSION_1
)
899 FORWARD (set_verbose
, level
);
902 /* See compile-internal.h. */
905 compile_instance::set_driver_filename (const char *filename
)
907 if (version () >= GCC_FE_VERSION_1
)
908 FORWARD (set_driver_filename
, filename
);
911 /* See compile-internal.h. */
914 compile_instance::set_triplet_regexp (const char *regexp
)
916 if (version () >= GCC_FE_VERSION_1
)
917 FORWARD (set_triplet_regexp
, regexp
);
920 /* See compile-internal.h. */
922 gdb::unique_xmalloc_ptr
<char>
923 compile_instance::set_arguments (int argc
, char **argv
, const char *regexp
)
925 if (version () >= GCC_FE_VERSION_1
)
926 return gdb::unique_xmalloc_ptr
<char> (FORWARD (set_arguments
, argc
, argv
));
928 return gdb::unique_xmalloc_ptr
<char> (FORWARD (set_arguments_v0
, regexp
,
932 /* See compile-internal.h. */
935 compile_instance::set_source_file (const char *filename
)
937 FORWARD (set_source_file
, filename
);
940 /* See compile-internal.h. */
943 compile_instance::compile (const char *filename
, int verbose_level
)
945 if (version () >= GCC_FE_VERSION_1
)
946 return FORWARD (compile
, filename
);
948 return FORWARD (compile_v0
, filename
, verbose_level
);
954 cmd_list_element
*compile_cmd_element
= nullptr;
956 void _initialize_compile ();
958 _initialize_compile ()
960 struct cmd_list_element
*c
= NULL
;
962 compile_cmd_element
= add_prefix_cmd ("compile", class_obscure
,
963 compile_command
, _("\
964 Command to compile source code and inject it into the inferior."),
965 &compile_command_list
, 1, &cmdlist
);
966 add_com_alias ("expression", compile_cmd_element
, class_obscure
, 0);
968 const auto compile_opts
= make_compile_options_def_group (nullptr);
970 static const std::string compile_code_help
971 = gdb::option::build_help (_("\
972 Compile, inject, and execute code.\n\
974 Usage: compile code [OPTION]... [CODE]\n\
979 The source code may be specified as a simple one line expression, e.g.:\n\
981 compile code printf(\"Hello world\\n\");\n\
983 Alternatively, you can type a multiline expression by invoking\n\
984 this command with no argument. GDB will then prompt for the\n\
985 expression interactively; type a line containing \"end\" to\n\
986 indicate the end of the expression."),
989 c
= add_cmd ("code", class_obscure
, compile_code_command
,
990 compile_code_help
.c_str (),
991 &compile_command_list
);
992 set_cmd_completer_handle_brkchars (c
, compile_code_command_completer
);
994 static const std::string compile_file_help
995 = gdb::option::build_help (_("\
996 Evaluate a file containing source code.\n\
998 Usage: compile file [OPTION].. [FILENAME]\n\
1004 c
= add_cmd ("file", class_obscure
, compile_file_command
,
1005 compile_file_help
.c_str (),
1006 &compile_command_list
);
1007 set_cmd_completer_handle_brkchars (c
, compile_file_command_completer
);
1009 const auto compile_print_opts
= make_value_print_options_def_group (nullptr);
1011 static const std::string compile_print_help
1012 = gdb::option::build_help (_("\
1013 Evaluate EXPR by using the compiler and print result.\n\
1015 Usage: compile print [[OPTION]... --] [/FMT] [EXPR]\n\
1020 Note: because this command accepts arbitrary expressions, if you\n\
1021 specify any command option, you must use a double dash (\"--\")\n\
1022 to mark the end of option processing. E.g.: \"compile print -o -- myobj\".\n\
1024 The expression may be specified on the same line as the command, e.g.:\n\
1028 Alternatively, you can type a multiline expression by invoking\n\
1029 this command with no argument. GDB will then prompt for the\n\
1030 expression interactively; type a line containing \"end\" to\n\
1031 indicate the end of the expression.\n\
1033 EXPR may be preceded with /FMT, where FMT is a format letter\n\
1034 but no count or size letter (see \"x\" command)."),
1035 compile_print_opts
);
1037 c
= add_cmd ("print", class_obscure
, compile_print_command
,
1038 compile_print_help
.c_str (),
1039 &compile_command_list
);
1040 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
1042 add_setshow_boolean_cmd ("compile", class_maintenance
, &compile_debug
, _("\
1043 Set compile command debugging."), _("\
1044 Show compile command debugging."), _("\
1045 When on, compile command debugging is enabled."),
1046 NULL
, show_compile_debug
,
1047 &setdebuglist
, &showdebuglist
);
1049 add_setshow_string_cmd ("compile-args", class_support
,
1051 _("Set compile command GCC command-line arguments."),
1052 _("Show compile command GCC command-line arguments."),
1054 Use options like -I (include file directory) or ABI settings.\n\
1055 String quoting is parsed like in shell, for example:\n\
1056 -mno-align-double \"-I/dir with a space/include\""),
1057 set_compile_args
, show_compile_args
, &setlist
, &showlist
);
1059 /* Override flags possibly coming from DW_AT_producer. */
1060 compile_args
= xstrdup ("-O0 -gdwarf-4"
1061 /* We use -fPIE Otherwise GDB would need to reserve space large enough for
1062 any object file in the inferior in advance to get the final address when
1063 to link the object file to and additionally the default system linker
1064 script would need to be modified so that one can specify there the
1065 absolute target address.
1066 -fPIC is not used at is would require from GDB to generate .got. */
1068 /* We want warnings, except for some commonly happening for GDB commands. */
1070 " -Wno-unused-but-set-variable"
1071 " -Wno-unused-variable"
1072 /* Override CU's possible -fstack-protector-strong. */
1073 " -fno-stack-protector"
1075 set_compile_args (compile_args
, 0, NULL
);
1077 add_setshow_optional_filename_cmd ("compile-gcc", class_support
,
1079 _("Set compile command "
1080 "GCC driver filename."),
1081 _("Show compile command "
1082 "GCC driver filename."),
1084 It should be absolute filename of the gcc executable.\n\
1085 If empty the default target triplet will be searched in $PATH."),
1086 NULL
, show_compile_gcc
, &setlist
,
1088 compile_gcc
= xstrdup ("");