1 /* General Compile and inject code
2
3 Copyright (C) 2014-2021 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20 #include "defs.h"
21 #include "top.h"
22 #include "ui-out.h"
23 #include "command.h"
24 #include "cli/cli-script.h"
25 #include "cli/cli-utils.h"
26 #include "cli/cli-option.h"
27 #include "completer.h"
28 #include "gdbcmd.h"
29 #include "compile.h"
30 #include "compile-internal.h"
31 #include "compile-object-load.h"
32 #include "compile-object-run.h"
33 #include "language.h"
34 #include "frame.h"
35 #include "source.h"
36 #include "block.h"
37 #include "arch-utils.h"
38 #include "gdbsupport/filestuff.h"
39 #include "target.h"
40 #include "osabi.h"
41 #include "gdbsupport/gdb_wait.h"
42 #include "valprint.h"
43 #include "gdbsupport/gdb_optional.h"
44 #include "gdbsupport/gdb_unlinker.h"
45 #include "gdbsupport/pathstuff.h"
46 #include "gdbsupport/scoped_ignore_signal.h"
47
48
49
50 /* Initial filename for temporary files. */
51
52 #define TMP_PREFIX "/tmp/gdbobj-"
53
54 /* Hold "compile" commands. */
55
56 static struct cmd_list_element *compile_command_list;
57
58 /* Debug flag for "compile" commands. */
59
60 bool compile_debug;
61
62 /* Object of this type are stored in the compiler's symbol_err_map. */
63
64 struct symbol_error
65 {
66 /* The symbol. */
67
68 const struct symbol *sym;
69
70 /* The error message to emit. This is malloc'd and owned by the
71 hash table. */
72
73 char *message;
74 };
75
76 /* Hash a type_map_instance. */
77
78 static hashval_t
hash_type_map_instance(const void * p)79 hash_type_map_instance (const void *p)
80 {
81 const struct type_map_instance *inst = (const struct type_map_instance *) p;
82
83 return htab_hash_pointer (inst->type);
84 }
85
86 /* Check two type_map_instance objects for equality. */
87
88 static int
eq_type_map_instance(const void * a,const void * b)89 eq_type_map_instance (const void *a, const void *b)
90 {
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;
93
94 return insta->type == instb->type;
95 }
96
97 /* Hash function for struct symbol_error. */
98
99 static hashval_t
hash_symbol_error(const void * a)100 hash_symbol_error (const void *a)
101 {
102 const struct symbol_error *se = (const struct symbol_error *) a;
103
104 return htab_hash_pointer (se->sym);
105 }
106
107 /* Equality function for struct symbol_error. */
108
109 static int
eq_symbol_error(const void * a,const void * b)110 eq_symbol_error (const void *a, const void *b)
111 {
112 const struct symbol_error *sea = (const struct symbol_error *) a;
113 const struct symbol_error *seb = (const struct symbol_error *) b;
114
115 return sea->sym == seb->sym;
116 }
117
118 /* Deletion function for struct symbol_error. */
119
120 static void
del_symbol_error(void * a)121 del_symbol_error (void *a)
122 {
123 struct symbol_error *se = (struct symbol_error *) a;
124
125 xfree (se->message);
126 xfree (se);
127 }
128
129 /* Constructor for compile_instance. */
130
compile_instance(struct gcc_base_context * gcc_fe,const char * options)131 compile_instance::compile_instance (struct gcc_base_context *gcc_fe,
132 const char *options)
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,
139 xcalloc, xfree))
140 {
141 }
142
143 /* See compile-internal.h. */
144
145 bool
get_cached_type(struct type * type,gcc_type * ret)146 compile_instance::get_cached_type (struct type *type, gcc_type *ret) const
147 {
148 struct type_map_instance inst, *found;
149
150 inst.type = type;
151 found = (struct type_map_instance *) htab_find (m_type_map.get (), &inst);
152 if (found != NULL)
153 {
154 *ret = found->gcc_type_handle;
155 return true;
156 }
157
158 return false;
159 }
160
161 /* See compile-internal.h. */
162
163 void
insert_type(struct type * type,gcc_type gcc_type)164 compile_instance::insert_type (struct type *type, gcc_type gcc_type)
165 {
166 struct type_map_instance inst, *add;
167 void **slot;
168
169 inst.type = type;
170 inst.gcc_type_handle = gcc_type;
171 slot = htab_find_slot (m_type_map.get (), &inst, INSERT);
172
173 add = (struct type_map_instance *) *slot;
174 /* The type might have already been inserted in order to handle
175 recursive types. */
176 if (add != NULL && add->gcc_type_handle != gcc_type)
177 error (_("Unexpected type id from GCC, check you use recent enough GCC."));
178
179 if (add == NULL)
180 {
181 add = XNEW (struct type_map_instance);
182 *add = inst;
183 *slot = add;
184 }
185 }
186
187 /* See compile-internal.h. */
188
189 void
insert_symbol_error(const struct symbol * sym,const char * text)190 compile_instance::insert_symbol_error (const struct symbol *sym,
191 const char *text)
192 {
193 struct symbol_error e;
194 void **slot;
195
196 e.sym = sym;
197 slot = htab_find_slot (m_symbol_err_map.get (), &e, INSERT);
198 if (*slot == NULL)
199 {
200 struct symbol_error *ep = XNEW (struct symbol_error);
201
202 ep->sym = sym;
203 ep->message = xstrdup (text);
204 *slot = ep;
205 }
206 }
207
208 /* See compile-internal.h. */
209
210 void
error_symbol_once(const struct symbol * sym)211 compile_instance::error_symbol_once (const struct symbol *sym)
212 {
213 struct symbol_error search;
214 struct symbol_error *err;
215
216 if (m_symbol_err_map == NULL)
217 return;
218
219 search.sym = sym;
220 err = (struct symbol_error *) htab_find (m_symbol_err_map.get (), &search);
221 if (err == NULL || err->message == NULL)
222 return;
223
224 gdb::unique_xmalloc_ptr<char> message (err->message);
225 err->message = NULL;
226 error (_("%s"), message.get ());
227 }
228
229 /* Implement "show debug compile". */
230
231 static void
show_compile_debug(struct ui_file * file,int from_tty,struct cmd_list_element * c,const char * value)232 show_compile_debug (struct ui_file *file, int from_tty,
233 struct cmd_list_element *c, const char *value)
234 {
235 fprintf_filtered (file, _("Compile debugging is %s.\n"), value);
236 }
237
238
239
240 /* Options for the compile command. */
241
242 struct compile_options
243 {
244 /* For -raw. */
245 bool raw = false;
246 };
247
248 using compile_flag_option_def
249 = gdb::option::flag_option_def<compile_options>;
250
251 static const gdb::option::option_def compile_command_option_defs[] = {
252
253 compile_flag_option_def {
254 "raw",
255 [] (compile_options *opts) { return &opts->raw; },
256 N_("Suppress automatic 'void _gdb_expr () { CODE }' wrapping."),
257 },
258
259 };
260
261 /* Create an option_def_group for the "compile" command's options,
262 with OPTS as context. */
263
264 static gdb::option::option_def_group
make_compile_options_def_group(compile_options * opts)265 make_compile_options_def_group (compile_options *opts)
266 {
267 return {{compile_command_option_defs}, opts};
268 }
269
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. */
273
274 static void
compile_file_command(const char * args,int from_tty)275 compile_file_command (const char *args, int from_tty)
276 {
277 scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
278
279 /* Check if a -raw option is provided. */
280
281 compile_options options;
282
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,
287 group);
288
289 enum compile_i_scope_types scope
290 = options.raw ? COMPILE_I_RAW_SCOPE : COMPILE_I_SIMPLE_SCOPE;
291
292 args = skip_spaces (args);
293
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."));
297
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);
302 }
303
304 /* Completer for the "compile file" command. */
305
306 static void
compile_file_command_completer(struct cmd_list_element * ignore,completion_tracker & tracker,const char * text,const char * word)307 compile_file_command_completer (struct cmd_list_element *ignore,
308 completion_tracker &tracker,
309 const char *text, const char *word)
310 {
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))
315 return;
316
317 word = advance_to_filename_complete_word_point (tracker, text);
318 filename_completer (ignore, tracker, text, word);
319 }
320
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. */
325
326 static void
compile_code_command(const char * args,int from_tty)327 compile_code_command (const char *args, int from_tty)
328 {
329 scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
330
331 compile_options options;
332
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);
337
338 enum compile_i_scope_types scope
339 = options.raw ? COMPILE_I_RAW_SCOPE : COMPILE_I_SIMPLE_SCOPE;
340
341 if (args && *args)
342 eval_compile_command (NULL, args, scope, NULL);
343 else
344 {
345 counted_command_line l = get_command_line (compile_control, "");
346
347 l->control_u.compile.scope = scope;
348 execute_control_command_untraced (l.get ());
349 }
350 }
351
352 /* Completer for the "compile code" command. */
353
354 static void
compile_code_command_completer(struct cmd_list_element * ignore,completion_tracker & tracker,const char * text,const char * word)355 compile_code_command_completer (struct cmd_list_element *ignore,
356 completion_tracker &tracker,
357 const char *text, const char *word)
358 {
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))
363 return;
364
365 word = advance_to_expression_complete_word_point (tracker, text);
366 symbol_completer (ignore, tracker, text, word);
367 }
368
369 /* Callback for compile_print_command. */
370
371 void
compile_print_value(struct value * val,void * data_voidp)372 compile_print_value (struct value *val, void *data_voidp)
373 {
374 const value_print_options *print_opts = (value_print_options *) data_voidp;
375
376 print_value (val, *print_opts);
377 }
378
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. */
383
384 static void
compile_print_command(const char * arg,int from_tty)385 compile_print_command (const char *arg, int from_tty)
386 {
387 enum compile_i_scope_types scope = COMPILE_I_PRINT_ADDRESS_SCOPE;
388 value_print_options print_opts;
389
390 scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
391
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);
397
398 print_command_parse_format (&arg, "compile print", &print_opts);
399
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
402 already quit. */
403
404 if (arg && *arg)
405 eval_compile_command (NULL, arg, scope, &print_opts);
406 else
407 {
408 counted_command_line l = get_command_line (compile_control, "");
409
410 l->control_u.compile.scope = scope;
411 l->control_u.compile.scope_data = &print_opts;
412 execute_control_command_untraced (l.get ());
413 }
414 }
415
416 /* A cleanup function to remove a directory and all its contents. */
417
418 static void
do_rmdir(void * arg)419 do_rmdir (void *arg)
420 {
421 const char *dir = (const char *) arg;
422 char *zap;
423 int wstat;
424
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);
430 XDELETEVEC (zap);
431 }
432
433 /* Return the name of the temporary directory to use for .o files, and
434 arrange for the directory to be removed at shutdown. */
435
436 static const char *
get_compile_file_tempdir(void)437 get_compile_file_tempdir (void)
438 {
439 static char *tempdir_name;
440
441 #define TEMPLATE TMP_PREFIX "XXXXXX"
442 char tname[sizeof (TEMPLATE)];
443
444 if (tempdir_name != NULL)
445 return tempdir_name;
446
447 strcpy (tname, TEMPLATE);
448 #undef TEMPLATE
449 tempdir_name = mkdtemp (tname);
450 if (tempdir_name == NULL)
451 perror_with_name (_("Could not make temporary directory"));
452
453 tempdir_name = xstrdup (tempdir_name);
454 make_final_cleanup (do_rmdir, tempdir_name);
455 return tempdir_name;
456 }
457
458 /* Compute the names of source and object files to use. */
459
460 static compile_file_names
get_new_file_names()461 get_new_file_names ()
462 {
463 static int seq;
464 const char *dir = get_compile_file_tempdir ();
465
466 ++seq;
467
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));
472 }
473
474 /* Get the block and PC at which to evaluate an expression. */
475
476 static const struct block *
get_expr_block_and_pc(CORE_ADDR * pc)477 get_expr_block_and_pc (CORE_ADDR *pc)
478 {
479 const struct block *block = get_selected_block (pc);
480
481 if (block == NULL)
482 {
483 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
484
485 if (cursal.symtab)
486 block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
487 STATIC_BLOCK);
488 if (block != NULL)
489 *pc = BLOCK_ENTRY_PC (block);
490 }
491 else
492 *pc = BLOCK_ENTRY_PC (block);
493
494 return block;
495 }
496
497 /* String for 'set compile-args' and 'show compile-args'. */
498 static char *compile_args;
499
500 /* Parsed form of COMPILE_ARGS. */
501 static gdb_argv compile_args_argv;
502
503 /* Implement 'set compile-args'. */
504
505 static void
set_compile_args(const char * args,int from_tty,struct cmd_list_element * c)506 set_compile_args (const char *args, int from_tty, struct cmd_list_element *c)
507 {
508 compile_args_argv = gdb_argv (compile_args);
509 }
510
511 /* Implement 'show compile-args'. */
512
513 static void
show_compile_args(struct ui_file * file,int from_tty,struct cmd_list_element * c,const char * value)514 show_compile_args (struct ui_file *file, int from_tty,
515 struct cmd_list_element *c, const char *value)
516 {
517 fprintf_filtered (file, _("Compile command command-line arguments "
518 "are \"%s\".\n"),
519 value);
520 }
521
522 /* String for 'set compile-gcc' and 'show compile-gcc'. */
523 static char *compile_gcc;
524
525 /* Implement 'show compile-gcc'. */
526
527 static void
show_compile_gcc(struct ui_file * file,int from_tty,struct cmd_list_element * c,const char * value)528 show_compile_gcc (struct ui_file *file, int from_tty,
529 struct cmd_list_element *c, const char *value)
530 {
531 fprintf_filtered (file, _("Compile command GCC driver filename is \"%s\".\n"),
532 value);
533 }
534
535 /* Return DW_AT_producer parsed for get_selected_frame () (if any).
536 Return NULL otherwise.
537
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. */
540
541 static const char *
get_selected_pc_producer_options(void)542 get_selected_pc_producer_options (void)
543 {
544 CORE_ADDR pc = get_frame_pc (get_selected_frame (NULL));
545 struct compunit_symtab *symtab = find_pc_compunit_symtab (pc);
546 const char *cs;
547
548 if (symtab == NULL || symtab->producer == NULL
549 || !startswith (symtab->producer, "GNU "))
550 return NULL;
551
552 cs = symtab->producer;
553 while (*cs != 0 && *cs != '-')
554 cs = skip_spaces (skip_to_space (cs));
555 if (*cs != '-')
556 return NULL;
557 return cs;
558 }
559
560 /* Filter out unwanted options from ARGV. */
561
562 static void
filter_args(char ** argv)563 filter_args (char **argv)
564 {
565 char **destv;
566
567 for (destv = argv; *argv != NULL; argv++)
568 {
569 /* -fpreprocessed may get in commonly from ccache. */
570 if (strcmp (*argv, "-fpreprocessed") == 0)
571 {
572 xfree (*argv);
573 continue;
574 }
575 *destv++ = *argv;
576 }
577 *destv = NULL;
578 }
579
580 /* Produce final vector of GCC compilation options.
581
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.
585
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
589 added to the vector.
590
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.
594
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
598 generated above. */
599
600 static gdb_argv
get_args(const compile_instance * compiler,struct gdbarch * gdbarch)601 get_args (const compile_instance *compiler, struct gdbarch *gdbarch)
602 {
603 const char *cs_producer_options;
604 gdb_argv result;
605
606 std::string gcc_options = gdbarch_gcc_target_options (gdbarch);
607
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 ());
612
613 cs_producer_options = get_selected_pc_producer_options ();
614 if (cs_producer_options != NULL)
615 {
616 gdb_argv argv_producer (cs_producer_options);
617 filter_args (argv_producer.get ());
618
619 result.append (std::move (argv_producer));
620 }
621
622 result.append (gdb_argv (compiler->gcc_target_options ().c_str ()));
623 result.append (compile_args_argv);
624
625 return result;
626 }
627
628 /* A helper function suitable for use as the "print_callback" in the
629 compiler object. */
630
631 static void
print_callback(void * ignore,const char * message)632 print_callback (void *ignore, const char *message)
633 {
634 fputs_filtered (message, gdb_stderr);
635 }
636
637 /* Process the compilation request. On success it returns the object
638 and source file names. On an error condition, error () is
639 called. */
640
641 static compile_file_names
compile_to_object(struct command_line * cmd,const char * cmd_string,enum compile_i_scope_types scope)642 compile_to_object (struct command_line *cmd, const char *cmd_string,
643 enum compile_i_scope_types scope)
644 {
645 const struct block *expr_block;
646 CORE_ADDR trash_pc, expr_pc;
647 int ok;
648 struct gdbarch *gdbarch = get_current_arch ();
649 std::string triplet_rx;
650
651 if (!target_has_execution ())
652 error (_("The program must be running for the compile command to "\
653 "work."));
654
655 expr_block = get_expr_block_and_pc (&trash_pc);
656 expr_pc = get_frame_address_in_block (get_selected_frame (NULL));
657
658 /* Set up instance and context for the compiler. */
659 std::unique_ptr<compile_instance> compiler
660 = current_language->get_compile_instance ();
661 if (compiler == nullptr)
662 error (_("No compiler support for language %s."),
663 current_language->name ());
664 compiler->set_print_callback (print_callback, NULL);
665 compiler->set_scope (scope);
666 compiler->set_block (expr_block);
667
668 /* From the provided expression, build a scope to pass to the
669 compiler. */
670
671 string_file input_buf;
672 const char *input;
673
674 if (cmd != NULL)
675 {
676 struct command_line *iter;
677
678 for (iter = cmd->body_list_0.get (); iter; iter = iter->next)
679 {
680 input_buf.puts (iter->line);
681 input_buf.puts ("\n");
682 }
683
684 input = input_buf.c_str ();
685 }
686 else if (cmd_string != NULL)
687 input = cmd_string;
688 else
689 error (_("Neither a simple expression, or a multi-line specified."));
690
691 std::string code
692 = current_language->compute_program (compiler.get (), input, gdbarch,
693 expr_block, expr_pc);
694 if (compile_debug)
695 fprintf_unfiltered (gdb_stdlog, "debug output:\n\n%s", code.c_str ());
696
697 compiler->set_verbose (compile_debug);
698
699 if (compile_gcc[0] != 0)
700 {
701 if (compiler->version () < GCC_FE_VERSION_1)
702 error (_("Command 'set compile-gcc' requires GCC version 6 or higher "
703 "(libcc1 interface version 1 or higher)"));
704
705 compiler->set_driver_filename (compile_gcc);
706 }
707 else
708 {
709 const char *os_rx = osabi_triplet_regexp (gdbarch_osabi (gdbarch));
710 const char *arch_rx = gdbarch_gnu_triplet_regexp (gdbarch);
711
712 /* Allow triplets with or without vendor set. */
713 triplet_rx = std::string (arch_rx) + "(-[^-]*)?-";
714 if (os_rx != nullptr)
715 triplet_rx += os_rx;
716 compiler->set_triplet_regexp (triplet_rx.c_str ());
717 }
718
719 /* Set compiler command-line arguments. */
720 gdb_argv argv_holder = get_args (compiler.get (), gdbarch);
721 int argc = argv_holder.count ();
722 char **argv = argv_holder.get ();
723
724 gdb::unique_xmalloc_ptr<char> error_message
725 = compiler->set_arguments (argc, argv, triplet_rx.c_str ());
726
727 if (error_message != NULL)
728 error ("%s", error_message.get ());
729
730 if (compile_debug)
731 {
732 int argi;
733
734 fprintf_unfiltered (gdb_stdlog, "Passing %d compiler options:\n", argc);
735 for (argi = 0; argi < argc; argi++)
736 fprintf_unfiltered (gdb_stdlog, "Compiler option %d: <%s>\n",
737 argi, argv[argi]);
738 }
739
740 compile_file_names fnames = get_new_file_names ();
741
742 gdb::optional<gdb::unlinker> source_remover;
743
744 {
745 gdb_file_up src = gdb_fopen_cloexec (fnames.source_file (), "w");
746 if (src == NULL)
747 perror_with_name (_("Could not open source file for writing"));
748
749 source_remover.emplace (fnames.source_file ());
750
751 if (fputs (code.c_str (), src.get ()) == EOF)
752 perror_with_name (_("Could not write to source file"));
753 }
754
755 if (compile_debug)
756 fprintf_unfiltered (gdb_stdlog, "source file produced: %s\n\n",
757 fnames.source_file ());
758
759 /* If we don't do this, then GDB simply exits
760 when the compiler dies. */
761 scoped_ignore_sigpipe ignore_sigpipe;
762
763 /* Call the compiler and start the compilation process. */
764 compiler->set_source_file (fnames.source_file ());
765 ok = compiler->compile (fnames.object_file (), compile_debug);
766 if (!ok)
767 error (_("Compilation failed."));
768
769 if (compile_debug)
770 fprintf_unfiltered (gdb_stdlog, "object file produced: %s\n\n",
771 fnames.object_file ());
772
773 /* Keep the source file. */
774 source_remover->keep ();
775 return fnames;
776 }
777
778 /* The "compile" prefix command. */
779
780 static void
compile_command(const char * args,int from_tty)781 compile_command (const char *args, int from_tty)
782 {
783 /* If a sub-command is not specified to the compile prefix command,
784 assume it is a direct code compilation. */
785 compile_code_command (args, from_tty);
786 }
787
788 /* See compile.h. */
789
790 void
eval_compile_command(struct command_line * cmd,const char * cmd_string,enum compile_i_scope_types scope,void * scope_data)791 eval_compile_command (struct command_line *cmd, const char *cmd_string,
792 enum compile_i_scope_types scope, void *scope_data)
793 {
794 compile_file_names fnames = compile_to_object (cmd, cmd_string, scope);
795
796 gdb::unlinker object_remover (fnames.object_file ());
797 gdb::unlinker source_remover (fnames.source_file ());
798
799 compile_module_up compile_module = compile_object_load (fnames, scope,
800 scope_data);
801 if (compile_module == NULL)
802 {
803 gdb_assert (scope == COMPILE_I_PRINT_ADDRESS_SCOPE);
804 eval_compile_command (cmd, cmd_string,
805 COMPILE_I_PRINT_VALUE_SCOPE, scope_data);
806 return;
807 }
808
809 /* Keep the files. */
810 source_remover.keep ();
811 object_remover.keep ();
812
813 compile_object_run (std::move (compile_module));
814 }
815
816 /* See compile/compile-internal.h. */
817
818 std::string
compile_register_name_mangled(struct gdbarch * gdbarch,int regnum)819 compile_register_name_mangled (struct gdbarch *gdbarch, int regnum)
820 {
821 const char *regname = gdbarch_register_name (gdbarch, regnum);
822
823 return string_printf ("__%s", regname);
824 }
825
826 /* See compile/compile-internal.h. */
827
828 int
compile_register_name_demangle(struct gdbarch * gdbarch,const char * regname)829 compile_register_name_demangle (struct gdbarch *gdbarch,
830 const char *regname)
831 {
832 int regnum;
833
834 if (regname[0] != '_' || regname[1] != '_')
835 error (_("Invalid register name \"%s\"."), regname);
836 regname += 2;
837
838 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
839 if (strcmp (regname, gdbarch_register_name (gdbarch, regnum)) == 0)
840 return regnum;
841
842 error (_("Cannot find gdbarch register \"%s\"."), regname);
843 }
844
845 /* Forwards to the plug-in. */
846
847 #define FORWARD(OP,...) (m_gcc_fe->ops->OP (m_gcc_fe, ##__VA_ARGS__))
848
849 /* See compile-internal.h. */
850
851 void
set_print_callback(void (* print_function)(void *,const char *),void * datum)852 compile_instance::set_print_callback
853 (void (*print_function) (void *, const char *), void *datum)
854 {
855 FORWARD (set_print_callback, print_function, datum);
856 }
857
858 /* See compile-internal.h. */
859
860 unsigned int
version()861 compile_instance::version () const
862 {
863 return m_gcc_fe->ops->version;
864 }
865
866 /* See compile-internal.h. */
867
868 void
set_verbose(int level)869 compile_instance::set_verbose (int level)
870 {
871 if (version () >= GCC_FE_VERSION_1)
872 FORWARD (set_verbose, level);
873 }
874
875 /* See compile-internal.h. */
876
877 void
set_driver_filename(const char * filename)878 compile_instance::set_driver_filename (const char *filename)
879 {
880 if (version () >= GCC_FE_VERSION_1)
881 FORWARD (set_driver_filename, filename);
882 }
883
884 /* See compile-internal.h. */
885
886 void
set_triplet_regexp(const char * regexp)887 compile_instance::set_triplet_regexp (const char *regexp)
888 {
889 if (version () >= GCC_FE_VERSION_1)
890 FORWARD (set_triplet_regexp, regexp);
891 }
892
893 /* See compile-internal.h. */
894
895 gdb::unique_xmalloc_ptr<char>
set_arguments(int argc,char ** argv,const char * regexp)896 compile_instance::set_arguments (int argc, char **argv, const char *regexp)
897 {
898 if (version () >= GCC_FE_VERSION_1)
899 return gdb::unique_xmalloc_ptr<char> (FORWARD (set_arguments, argc, argv));
900 else
901 return gdb::unique_xmalloc_ptr<char> (FORWARD (set_arguments_v0, regexp,
902 argc, argv));
903 }
904
905 /* See compile-internal.h. */
906
907 void
set_source_file(const char * filename)908 compile_instance::set_source_file (const char *filename)
909 {
910 FORWARD (set_source_file, filename);
911 }
912
913 /* See compile-internal.h. */
914
915 bool
compile(const char * filename,int verbose_level)916 compile_instance::compile (const char *filename, int verbose_level)
917 {
918 if (version () >= GCC_FE_VERSION_1)
919 return FORWARD (compile, filename);
920 else
921 return FORWARD (compile_v0, filename, verbose_level);
922 }
923
924 #undef FORWARD
925
926 /* See compile.h. */
927 cmd_list_element *compile_cmd_element = nullptr;
928
929 void _initialize_compile ();
930 void
_initialize_compile()931 _initialize_compile ()
932 {
933 struct cmd_list_element *c = NULL;
934
935 compile_cmd_element = add_prefix_cmd ("compile", class_obscure,
936 compile_command, _("\
937 Command to compile source code and inject it into the inferior."),
938 &compile_command_list, 1, &cmdlist);
939 add_com_alias ("expression", compile_cmd_element, class_obscure, 0);
940
941 const auto compile_opts = make_compile_options_def_group (nullptr);
942
943 static const std::string compile_code_help
944 = gdb::option::build_help (_("\
945 Compile, inject, and execute code.\n\
946 \n\
947 Usage: compile code [OPTION]... [CODE]\n\
948 \n\
949 Options:\n\
950 %OPTIONS%\n\
951 \n\
952 The source code may be specified as a simple one line expression, e.g.:\n\
953 \n\
954 compile code printf(\"Hello world\\n\");\n\
955 \n\
956 Alternatively, you can type a multiline expression by invoking\n\
957 this command with no argument. GDB will then prompt for the\n\
958 expression interactively; type a line containing \"end\" to\n\
959 indicate the end of the expression."),
960 compile_opts);
961
962 c = add_cmd ("code", class_obscure, compile_code_command,
963 compile_code_help.c_str (),
964 &compile_command_list);
965 set_cmd_completer_handle_brkchars (c, compile_code_command_completer);
966
967 static const std::string compile_file_help
968 = gdb::option::build_help (_("\
969 Evaluate a file containing source code.\n\
970 \n\
971 Usage: compile file [OPTION].. [FILENAME]\n\
972 \n\
973 Options:\n\
974 %OPTIONS%"),
975 compile_opts);
976
977 c = add_cmd ("file", class_obscure, compile_file_command,
978 compile_file_help.c_str (),
979 &compile_command_list);
980 set_cmd_completer_handle_brkchars (c, compile_file_command_completer);
981
982 const auto compile_print_opts = make_value_print_options_def_group (nullptr);
983
984 static const std::string compile_print_help
985 = gdb::option::build_help (_("\
986 Evaluate EXPR by using the compiler and print result.\n\
987 \n\
988 Usage: compile print [[OPTION]... --] [/FMT] [EXPR]\n\
989 \n\
990 Options:\n\
991 %OPTIONS%\n\
992 \n\
993 Note: because this command accepts arbitrary expressions, if you\n\
994 specify any command option, you must use a double dash (\"--\")\n\
995 to mark the end of option processing. E.g.: \"compile print -o -- myobj\".\n\
996 \n\
997 The expression may be specified on the same line as the command, e.g.:\n\
998 \n\
999 compile print i\n\
1000 \n\
1001 Alternatively, you can type a multiline expression by invoking\n\
1002 this command with no argument. GDB will then prompt for the\n\
1003 expression interactively; type a line containing \"end\" to\n\
1004 indicate the end of the expression.\n\
1005 \n\
1006 EXPR may be preceded with /FMT, where FMT is a format letter\n\
1007 but no count or size letter (see \"x\" command)."),
1008 compile_print_opts);
1009
1010 c = add_cmd ("print", class_obscure, compile_print_command,
1011 compile_print_help.c_str (),
1012 &compile_command_list);
1013 set_cmd_completer_handle_brkchars (c, print_command_completer);
1014
1015 add_setshow_boolean_cmd ("compile", class_maintenance, &compile_debug, _("\
1016 Set compile command debugging."), _("\
1017 Show compile command debugging."), _("\
1018 When on, compile command debugging is enabled."),
1019 NULL, show_compile_debug,
1020 &setdebuglist, &showdebuglist);
1021
1022 add_setshow_string_cmd ("compile-args", class_support,
1023 &compile_args,
1024 _("Set compile command GCC command-line arguments."),
1025 _("Show compile command GCC command-line arguments."),
1026 _("\
1027 Use options like -I (include file directory) or ABI settings.\n\
1028 String quoting is parsed like in shell, for example:\n\
1029 -mno-align-double \"-I/dir with a space/include\""),
1030 set_compile_args, show_compile_args, &setlist, &showlist);
1031
1032 /* Override flags possibly coming from DW_AT_producer. */
1033 compile_args = xstrdup ("-O0 -gdwarf-4"
1034 /* We use -fPIE Otherwise GDB would need to reserve space large enough for
1035 any object file in the inferior in advance to get the final address when
1036 to link the object file to and additionally the default system linker
1037 script would need to be modified so that one can specify there the
1038 absolute target address.
1039 -fPIC is not used at is would require from GDB to generate .got. */
1040 " -fPIE"
1041 /* We want warnings, except for some commonly happening for GDB commands. */
1042 " -Wall "
1043 " -Wno-unused-but-set-variable"
1044 " -Wno-unused-variable"
1045 /* Override CU's possible -fstack-protector-strong. */
1046 " -fno-stack-protector"
1047 );
1048 set_compile_args (compile_args, 0, NULL);
1049
1050 add_setshow_optional_filename_cmd ("compile-gcc", class_support,
1051 &compile_gcc,
1052 _("Set compile command "
1053 "GCC driver filename."),
1054 _("Show compile command "
1055 "GCC driver filename."),
1056 _("\
1057 It should be absolute filename of the gcc executable.\n\
1058 If empty the default target triplet will be searched in $PATH."),
1059 NULL, show_compile_gcc, &setlist,
1060 &showlist);
1061 compile_gcc = xstrdup ("");
1062 }
1063