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