gdb/compile/compile.c

   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 \f
  48
  49 /* Initial filename for temporary files.  */
  50
  51 #define TMP_PREFIX "/tmp/gdbobj-"
  52
  53 /* Hold "compile" commands.  */
  54
  55 static struct cmd_list_element *compile_command_list;
  56
  57 /* Debug flag for "compile" commands.  */
  58
  59 bool compile_debug;
  60
  61 /* Object of this type are stored in the compiler's symbol_err_map.  */
  62
  63 struct 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
  77 static hashval_t
  78 hash_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
  87 static int
  88 eq_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
  98 static hashval_t
  99 hash_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
 108 static int
 109 eq_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
 119 static void
 120 del_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
 130 compile_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
 144 bool
 145 compile_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
 162 void
 163 compile_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
 188 void
 189 compile_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
 209 void
 210 compile_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
 230 static void
 231 show_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 \f
 238
 239 /* Options for the compile command.  */
 240
 241 struct compile_options
 242 {
 243   /* For -raw.  */
 244   bool raw = false;
 245 };
 246
 247 using compile_flag_option_def
 248   = gdb::option::flag_option_def<compile_options>;
 249
 250 static 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
 263 static gdb::option::option_def_group
 264 make_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
 273 static void
 274 compile_file_command (const char *args, int from_tty)
 275 {
 276   scoped_restore save_async = make_scoped_restore (&current_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
 305 static void
 306 compile_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
 325 static void
 326 compile_code_command (const char *args, int from_tty)
 327 {
 328   scoped_restore save_async = make_scoped_restore (&current_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
 353 static void
 354 compile_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
 370 void
 371 compile_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
 383 static void
 384 compile_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 (&current_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
 417 static void
 418 do_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
 435 static const char *
 436 get_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
 459 static compile_file_names
 460 get_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
 475 static const struct block *
 476 get_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
 500 static void
 501 build_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'.  */
 510 static char *compile_args;
 511
 512 /* Parsed form of COMPILE_ARGS.  COMPILE_ARGS_ARGV is NULL terminated.  */
 513 static int compile_args_argc;
 514 static char **compile_args_argv;
 515
 516 /* Implement 'set compile-args'.  */
 517
 518 static void
 519 set_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
 527 static void
 528 show_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
 539 static void
 540 append_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'.  */
 552 static char *compile_gcc;
 553
 554 /* Implement 'show compile-gcc'.  */
 555
 556 static void
 557 show_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
 570 static const char *
 571 get_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
 591 static void
 592 filter_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
 630 static void
 631 get_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
 664 static void
 665 print_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
 674 static compile_file_names
 675 compile_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
 809 static void
 810 compile_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
 819 void
 820 eval_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
 848 std::string
 849 compile_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
 858 int
 859 compile_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
 881 void
 882 compile_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
 890 unsigned int
 891 compile_instance::version () const
 892 {
 893   return m_gcc_fe->ops->version;
 894 }
 895
 896 /* See compile-internal.h.  */
 897
 898 void
 899 compile_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
 907 void
 908 compile_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
 916 void
 917 compile_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
 925 char *
 926 compile_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
 936 void
 937 compile_instance::set_source_file (const char *filename)
 938 {
 939   FORWARD (set_source_file, filename);
 940 }
 941
 942 /* See compile-internal.h.  */
 943
 944 bool
 945 compile_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.  */
 956 cmd_list_element *compile_cmd_element = nullptr;
 957
 958 void _initialize_compile ();
 959 void
 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, _("\
 966 Command 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 (_("\
 974 Compile, inject, and execute code.\n\
 975 \n\
 976 Usage: compile code [OPTION]... [CODE]\n\
 977 \n\
 978 Options:\n\
 979 %OPTIONS%\n\
 980 \n\
 981 The 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\
 985 Alternatively, you can type a multiline expression by invoking\n\
 986 this command with no argument.  GDB will then prompt for the\n\
 987 expression interactively; type a line containing \"end\" to\n\
 988 indicate 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
 996 static const std::string compile_file_help
 997     = gdb::option::build_help (_("\
 998 Evaluate a file containing source code.\n\
 999 \n\
1000 Usage: compile file [OPTION].. [FILENAME]\n\
1001 \n\
1002 Options:\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 (_("\
1015 Evaluate EXPR by using the compiler and print result.\n\
1016 \n\
1017 Usage: compile print [[OPTION]... --] [/FMT] [EXPR]\n\
1018 \n\
1019 Options:\n\
1020 %OPTIONS%\n\
1021 \n\
1022 Note: because this command accepts arbitrary expressions, if you\n\
1023 specify any command option, you must use a double dash (\"--\")\n\
1024 to mark the end of option processing.  E.g.: \"compile print -o -- myobj\".\n\
1025 \n\
1026 The expression may be specified on the same line as the command, e.g.:\n\
1027 \n\
1028     compile print i\n\
1029 \n\
1030 Alternatively, you can type a multiline expression by invoking\n\
1031 this command with no argument.  GDB will then prompt for the\n\
1032 expression interactively; type a line containing \"end\" to\n\
1033 indicate the end of the expression.\n\
1034 \n\
1035 EXPR may be preceded with /FMT, where FMT is a format letter\n\
1036 but 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, _("\
1045 Set compile command debugging."), _("\
1046 Show compile command debugging."), _("\
1047 When 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                           _("\
1056 Use options like -I (include file directory) or ABI settings.\n\
1057 String 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                                      _("\
1086 It should be absolute filename of the gcc executable.\n\
1087 If empty the default target triplet will be searched in $PATH."),
1088                                      NULL, show_compile_gcc, &setlist,
1089                                      &showlist);
1090   compile_gcc = xstrdup ("");
1091 }