gdb/compile/compile.c

   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 \f
  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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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 \f
 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
 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
 275 compile_file_command (const char *args, int from_tty)
 276 {
 277   scoped_restore save_async = make_scoped_restore (&current_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
 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
 327 compile_code_command (const char *args, int from_tty)
 328 {
 329   scoped_restore save_async = make_scoped_restore (&current_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
 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
 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
 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 (&current_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
 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 *
 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
 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 *
 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 std::string compile_args =
 499   /* Override flags possibly coming from DW_AT_producer.  */
 500   "-O0 -gdwarf-4"
 501   /* We use -fPIE Otherwise GDB would need to reserve space large enough for
 502      any object file in the inferior in advance to get the final address when
 503      to link the object file to and additionally the default system linker
 504      script would need to be modified so that one can specify there the
 505      absolute target address.
 506      -fPIC is not used at is would require from GDB to generate .got.  */
 507   " -fPIE"
 508   /* We want warnings, except for some commonly happening for GDB commands.  */
 509   " -Wall "
 510   " -Wno-unused-but-set-variable"
 511   " -Wno-unused-variable"
 512   /* Override CU's possible -fstack-protector-strong.  */
 513   " -fno-stack-protector";
 514
 515 /* Parsed form of COMPILE_ARGS.  */
 516 static gdb_argv compile_args_argv;
 517
 518 /* Implement 'set compile-args'.  */
 519
 520 static void
 521 set_compile_args (const char *args, int from_tty, struct cmd_list_element *c)
 522 {
 523   compile_args_argv = gdb_argv (compile_args.c_str ());
 524 }
 525
 526 /* Implement 'show compile-args'.  */
 527
 528 static void
 529 show_compile_args (struct ui_file *file, int from_tty,
 530                    struct cmd_list_element *c, const char *value)
 531 {
 532   fprintf_filtered (file, _("Compile command command-line arguments "
 533                             "are \"%s\".\n"),
 534                     value);
 535 }
 536
 537 /* String for 'set compile-gcc' and 'show compile-gcc'.  */
 538 static std::string compile_gcc;
 539
 540 /* Implement 'show compile-gcc'.  */
 541
 542 static void
 543 show_compile_gcc (struct ui_file *file, int from_tty,
 544                   struct cmd_list_element *c, const char *value)
 545 {
 546   fprintf_filtered (file, _("Compile command GCC driver filename is \"%s\".\n"),
 547                     value);
 548 }
 549
 550 /* Return DW_AT_producer parsed for get_selected_frame () (if any).
 551    Return NULL otherwise.
 552
 553    GCC already filters its command-line arguments only for the suitable ones to
 554    put into DW_AT_producer - see GCC function gen_producer_string.  */
 555
 556 static const char *
 557 get_selected_pc_producer_options (void)
 558 {
 559   CORE_ADDR pc = get_frame_pc (get_selected_frame (NULL));
 560   struct compunit_symtab *symtab = find_pc_compunit_symtab (pc);
 561   const char *cs;
 562
 563   if (symtab == NULL || symtab->producer == NULL
 564       || !startswith (symtab->producer, "GNU "))
 565     return NULL;
 566
 567   cs = symtab->producer;
 568   while (*cs != 0 && *cs != '-')
 569     cs = skip_spaces (skip_to_space (cs));
 570   if (*cs != '-')
 571     return NULL;
 572   return cs;
 573 }
 574
 575 /* Filter out unwanted options from ARGV.  */
 576
 577 static void
 578 filter_args (char **argv)
 579 {
 580   char **destv;
 581
 582   for (destv = argv; *argv != NULL; argv++)
 583     {
 584       /* -fpreprocessed may get in commonly from ccache.  */
 585       if (strcmp (*argv, "-fpreprocessed") == 0)
 586         {
 587           xfree (*argv);
 588           continue;
 589         }
 590       *destv++ = *argv;
 591     }
 592   *destv = NULL;
 593 }
 594
 595 /* Produce final vector of GCC compilation options.
 596
 597    The first element of the combined argument vector are arguments
 598    relating to the target size ("-m64", "-m32" etc.).  These are
 599    sourced from the inferior's architecture.
 600
 601    The second element of the combined argument vector are arguments
 602    stored in the inferior DW_AT_producer section.  If these are stored
 603    in the inferior (there is no guarantee that they are), they are
 604    added to the vector.
 605
 606    The third element of the combined argument vector are argument
 607    supplied by the language implementation provided by
 608    compile-{lang}-support.  These contain language specific arguments.
 609
 610    The final element of the combined argument vector are arguments
 611    supplied by the "set compile-args" command.  These are always
 612    appended last so as to override any of the arguments automatically
 613    generated above.  */
 614
 615 static gdb_argv
 616 get_args (const compile_instance *compiler, struct gdbarch *gdbarch)
 617 {
 618   const char *cs_producer_options;
 619   gdb_argv result;
 620
 621   std::string gcc_options = gdbarch_gcc_target_options (gdbarch);
 622
 623   /* Make sure we have a non-empty set of options, otherwise GCC will
 624      error out trying to look for a filename that is an empty string.  */
 625   if (!gcc_options.empty ())
 626     result = gdb_argv (gcc_options.c_str ());
 627
 628   cs_producer_options = get_selected_pc_producer_options ();
 629   if (cs_producer_options != NULL)
 630     {
 631       gdb_argv argv_producer (cs_producer_options);
 632       filter_args (argv_producer.get ());
 633
 634       result.append (std::move (argv_producer));
 635     }
 636
 637   result.append (gdb_argv (compiler->gcc_target_options ().c_str ()));
 638   result.append (compile_args_argv);
 639
 640   return result;
 641 }
 642
 643 /* A helper function suitable for use as the "print_callback" in the
 644    compiler object.  */
 645
 646 static void
 647 print_callback (void *ignore, const char *message)
 648 {
 649   fputs_filtered (message, gdb_stderr);
 650 }
 651
 652 /* Process the compilation request.  On success it returns the object
 653    and source file names.  On an error condition, error () is
 654    called.  */
 655
 656 static compile_file_names
 657 compile_to_object (struct command_line *cmd, const char *cmd_string,
 658                    enum compile_i_scope_types scope)
 659 {
 660   const struct block *expr_block;
 661   CORE_ADDR trash_pc, expr_pc;
 662   int ok;
 663   struct gdbarch *gdbarch = get_current_arch ();
 664   std::string triplet_rx;
 665
 666   if (!target_has_execution ())
 667     error (_("The program must be running for the compile command to "\
 668              "work."));
 669
 670   expr_block = get_expr_block_and_pc (&trash_pc);
 671   expr_pc = get_frame_address_in_block (get_selected_frame (NULL));
 672
 673   /* Set up instance and context for the compiler.  */
 674   std::unique_ptr<compile_instance> compiler
 675     = current_language->get_compile_instance ();
 676   if (compiler == nullptr)
 677     error (_("No compiler support for language %s."),
 678            current_language->name ());
 679   compiler->set_print_callback (print_callback, NULL);
 680   compiler->set_scope (scope);
 681   compiler->set_block (expr_block);
 682
 683   /* From the provided expression, build a scope to pass to the
 684      compiler.  */
 685
 686   string_file input_buf;
 687   const char *input;
 688
 689   if (cmd != NULL)
 690     {
 691       struct command_line *iter;
 692
 693       for (iter = cmd->body_list_0.get (); iter; iter = iter->next)
 694         {
 695           input_buf.puts (iter->line);
 696           input_buf.puts ("\n");
 697         }
 698
 699       input = input_buf.c_str ();
 700     }
 701   else if (cmd_string != NULL)
 702     input = cmd_string;
 703   else
 704     error (_("Neither a simple expression, or a multi-line specified."));
 705
 706   std::string code
 707     = current_language->compute_program (compiler.get (), input, gdbarch,
 708                                          expr_block, expr_pc);
 709   if (compile_debug)
 710     fprintf_unfiltered (gdb_stdlog, "debug output:\n\n%s", code.c_str ());
 711
 712   compiler->set_verbose (compile_debug);
 713
 714   if (!compile_gcc.empty ())
 715     {
 716       if (compiler->version () < GCC_FE_VERSION_1)
 717         error (_("Command 'set compile-gcc' requires GCC version 6 or higher "
 718                  "(libcc1 interface version 1 or higher)"));
 719
 720       compiler->set_driver_filename (compile_gcc.c_str ());
 721     }
 722   else
 723     {
 724       const char *os_rx = osabi_triplet_regexp (gdbarch_osabi (gdbarch));
 725       const char *arch_rx = gdbarch_gnu_triplet_regexp (gdbarch);
 726
 727       /* Allow triplets with or without vendor set.  */
 728       triplet_rx = std::string (arch_rx) + "(-[^-]*)?-";
 729       if (os_rx != nullptr)
 730         triplet_rx += os_rx;
 731       compiler->set_triplet_regexp (triplet_rx.c_str ());
 732     }
 733
 734   /* Set compiler command-line arguments.  */
 735   gdb_argv argv_holder = get_args (compiler.get (), gdbarch);
 736   int argc = argv_holder.count ();
 737   char **argv = argv_holder.get ();
 738
 739   gdb::unique_xmalloc_ptr<char> error_message
 740     = compiler->set_arguments (argc, argv, triplet_rx.c_str ());
 741
 742   if (error_message != NULL)
 743     error ("%s", error_message.get ());
 744
 745   if (compile_debug)
 746     {
 747       int argi;
 748
 749       fprintf_unfiltered (gdb_stdlog, "Passing %d compiler options:\n", argc);
 750       for (argi = 0; argi < argc; argi++)
 751         fprintf_unfiltered (gdb_stdlog, "Compiler option %d: <%s>\n",
 752                             argi, argv[argi]);
 753     }
 754
 755   compile_file_names fnames = get_new_file_names ();
 756
 757   gdb::optional<gdb::unlinker> source_remover;
 758
 759   {
 760     gdb_file_up src = gdb_fopen_cloexec (fnames.source_file (), "w");
 761     if (src == NULL)
 762       perror_with_name (_("Could not open source file for writing"));
 763
 764     source_remover.emplace (fnames.source_file ());
 765
 766     if (fputs (code.c_str (), src.get ()) == EOF)
 767       perror_with_name (_("Could not write to source file"));
 768   }
 769
 770   if (compile_debug)
 771     fprintf_unfiltered (gdb_stdlog, "source file produced: %s\n\n",
 772                         fnames.source_file ());
 773
 774   /* If we don't do this, then GDB simply exits
 775      when the compiler dies.  */
 776   scoped_ignore_sigpipe ignore_sigpipe;
 777
 778   /* Call the compiler and start the compilation process.  */
 779   compiler->set_source_file (fnames.source_file ());
 780   ok = compiler->compile (fnames.object_file (), compile_debug);
 781   if (!ok)
 782     error (_("Compilation failed."));
 783
 784   if (compile_debug)
 785     fprintf_unfiltered (gdb_stdlog, "object file produced: %s\n\n",
 786                         fnames.object_file ());
 787
 788   /* Keep the source file.  */
 789   source_remover->keep ();
 790   return fnames;
 791 }
 792
 793 /* The "compile" prefix command.  */
 794
 795 static void
 796 compile_command (const char *args, int from_tty)
 797 {
 798   /* If a sub-command is not specified to the compile prefix command,
 799      assume it is a direct code compilation.  */
 800   compile_code_command (args, from_tty);
 801 }
 802
 803 /* See compile.h.  */
 804
 805 void
 806 eval_compile_command (struct command_line *cmd, const char *cmd_string,
 807                       enum compile_i_scope_types scope, void *scope_data)
 808 {
 809   compile_file_names fnames = compile_to_object (cmd, cmd_string, scope);
 810
 811   gdb::unlinker object_remover (fnames.object_file ());
 812   gdb::unlinker source_remover (fnames.source_file ());
 813
 814   compile_module_up compile_module = compile_object_load (fnames, scope,
 815                                                           scope_data);
 816   if (compile_module == NULL)
 817     {
 818       gdb_assert (scope == COMPILE_I_PRINT_ADDRESS_SCOPE);
 819       eval_compile_command (cmd, cmd_string,
 820                             COMPILE_I_PRINT_VALUE_SCOPE, scope_data);
 821       return;
 822     }
 823
 824   /* Keep the files.  */
 825   source_remover.keep ();
 826   object_remover.keep ();
 827
 828   compile_object_run (std::move (compile_module));
 829 }
 830
 831 /* See compile/compile-internal.h.  */
 832
 833 std::string
 834 compile_register_name_mangled (struct gdbarch *gdbarch, int regnum)
 835 {
 836   const char *regname = gdbarch_register_name (gdbarch, regnum);
 837
 838   return string_printf ("__%s", regname);
 839 }
 840
 841 /* See compile/compile-internal.h.  */
 842
 843 int
 844 compile_register_name_demangle (struct gdbarch *gdbarch,
 845                                  const char *regname)
 846 {
 847   int regnum;
 848
 849   if (regname[0] != '_' || regname[1] != '_')
 850     error (_("Invalid register name \"%s\"."), regname);
 851   regname += 2;
 852
 853   for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
 854     if (strcmp (regname, gdbarch_register_name (gdbarch, regnum)) == 0)
 855       return regnum;
 856
 857   error (_("Cannot find gdbarch register \"%s\"."), regname);
 858 }
 859
 860 /* Forwards to the plug-in.  */
 861
 862 #define FORWARD(OP,...) (m_gcc_fe->ops->OP (m_gcc_fe, ##__VA_ARGS__))
 863
 864 /* See compile-internal.h.  */
 865
 866 void
 867 compile_instance::set_print_callback
 868   (void (*print_function) (void *, const char *), void *datum)
 869 {
 870   FORWARD (set_print_callback, print_function, datum);
 871 }
 872
 873 /* See compile-internal.h.  */
 874
 875 unsigned int
 876 compile_instance::version () const
 877 {
 878   return m_gcc_fe->ops->version;
 879 }
 880
 881 /* See compile-internal.h.  */
 882
 883 void
 884 compile_instance::set_verbose (int level)
 885 {
 886   if (version () >= GCC_FE_VERSION_1)
 887     FORWARD (set_verbose, level);
 888 }
 889
 890 /* See compile-internal.h.  */
 891
 892 void
 893 compile_instance::set_driver_filename (const char *filename)
 894 {
 895   if (version () >= GCC_FE_VERSION_1)
 896     FORWARD (set_driver_filename, filename);
 897 }
 898
 899 /* See compile-internal.h.  */
 900
 901 void
 902 compile_instance::set_triplet_regexp (const char *regexp)
 903 {
 904   if (version () >= GCC_FE_VERSION_1)
 905     FORWARD (set_triplet_regexp, regexp);
 906 }
 907
 908 /* See compile-internal.h.  */
 909
 910 gdb::unique_xmalloc_ptr<char>
 911 compile_instance::set_arguments (int argc, char **argv, const char *regexp)
 912 {
 913   if (version () >= GCC_FE_VERSION_1)
 914     return gdb::unique_xmalloc_ptr<char> (FORWARD (set_arguments, argc, argv));
 915   else
 916     return gdb::unique_xmalloc_ptr<char> (FORWARD (set_arguments_v0, regexp,
 917                                                    argc, argv));
 918 }
 919
 920 /* See compile-internal.h.  */
 921
 922 void
 923 compile_instance::set_source_file (const char *filename)
 924 {
 925   FORWARD (set_source_file, filename);
 926 }
 927
 928 /* See compile-internal.h.  */
 929
 930 bool
 931 compile_instance::compile (const char *filename, int verbose_level)
 932 {
 933   if (version () >= GCC_FE_VERSION_1)
 934     return FORWARD (compile, filename);
 935   else
 936     return FORWARD (compile_v0, filename, verbose_level);
 937 }
 938
 939 #undef FORWARD
 940
 941 /* See compile.h.  */
 942 cmd_list_element *compile_cmd_element = nullptr;
 943
 944 void _initialize_compile ();
 945 void
 946 _initialize_compile ()
 947 {
 948   struct cmd_list_element *c = NULL;
 949
 950   compile_cmd_element = add_prefix_cmd ("compile", class_obscure,
 951                                         compile_command, _("\
 952 Command to compile source code and inject it into the inferior."),
 953                   &compile_command_list, 1, &cmdlist);
 954   add_com_alias ("expression", compile_cmd_element, class_obscure, 0);
 955
 956   const auto compile_opts = make_compile_options_def_group (nullptr);
 957
 958   static const std::string compile_code_help
 959     = gdb::option::build_help (_("\
 960 Compile, inject, and execute code.\n\
 961 \n\
 962 Usage: compile code [OPTION]... [CODE]\n\
 963 \n\
 964 Options:\n\
 965 %OPTIONS%\n\
 966 \n\
 967 The source code may be specified as a simple one line expression, e.g.:\n\
 968 \n\
 969     compile code printf(\"Hello world\\n\");\n\
 970 \n\
 971 Alternatively, you can type a multiline expression by invoking\n\
 972 this command with no argument.  GDB will then prompt for the\n\
 973 expression interactively; type a line containing \"end\" to\n\
 974 indicate the end of the expression."),
 975                                compile_opts);
 976
 977   c = add_cmd ("code", class_obscure, compile_code_command,
 978                compile_code_help.c_str (),
 979                &compile_command_list);
 980   set_cmd_completer_handle_brkchars (c, compile_code_command_completer);
 981
 982 static const std::string compile_file_help
 983     = gdb::option::build_help (_("\
 984 Evaluate a file containing source code.\n\
 985 \n\
 986 Usage: compile file [OPTION].. [FILENAME]\n\
 987 \n\
 988 Options:\n\
 989 %OPTIONS%"),
 990                                compile_opts);
 991
 992   c = add_cmd ("file", class_obscure, compile_file_command,
 993                compile_file_help.c_str (),
 994                &compile_command_list);
 995   set_cmd_completer_handle_brkchars (c, compile_file_command_completer);
 996
 997   const auto compile_print_opts = make_value_print_options_def_group (nullptr);
 998
 999   static const std::string compile_print_help
1000     = gdb::option::build_help (_("\
1001 Evaluate EXPR by using the compiler and print result.\n\
1002 \n\
1003 Usage: compile print [[OPTION]... --] [/FMT] [EXPR]\n\
1004 \n\
1005 Options:\n\
1006 %OPTIONS%\n\
1007 \n\
1008 Note: because this command accepts arbitrary expressions, if you\n\
1009 specify any command option, you must use a double dash (\"--\")\n\
1010 to mark the end of option processing.  E.g.: \"compile print -o -- myobj\".\n\
1011 \n\
1012 The expression may be specified on the same line as the command, e.g.:\n\
1013 \n\
1014     compile print i\n\
1015 \n\
1016 Alternatively, you can type a multiline expression by invoking\n\
1017 this command with no argument.  GDB will then prompt for the\n\
1018 expression interactively; type a line containing \"end\" to\n\
1019 indicate the end of the expression.\n\
1020 \n\
1021 EXPR may be preceded with /FMT, where FMT is a format letter\n\
1022 but no count or size letter (see \"x\" command)."),
1023                                compile_print_opts);
1024
1025   c = add_cmd ("print", class_obscure, compile_print_command,
1026                compile_print_help.c_str (),
1027                &compile_command_list);
1028   set_cmd_completer_handle_brkchars (c, print_command_completer);
1029
1030   add_setshow_boolean_cmd ("compile", class_maintenance, &compile_debug, _("\
1031 Set compile command debugging."), _("\
1032 Show compile command debugging."), _("\
1033 When on, compile command debugging is enabled."),
1034                            NULL, show_compile_debug,
1035                            &setdebuglist, &showdebuglist);
1036
1037   add_setshow_string_cmd ("compile-args", class_support,
1038                           &compile_args,
1039                           _("Set compile command GCC command-line arguments."),
1040                           _("Show compile command GCC command-line arguments."),
1041                           _("\
1042 Use options like -I (include file directory) or ABI settings.\n\
1043 String quoting is parsed like in shell, for example:\n\
1044   -mno-align-double \"-I/dir with a space/include\""),
1045                           set_compile_args, show_compile_args, &setlist, &showlist);
1046
1047
1048   /* Initialize compile_args_argv.  */
1049   set_compile_args (compile_args.c_str (), 0, NULL);
1050
1051   add_setshow_optional_filename_cmd ("compile-gcc", class_support,
1052                                      &compile_gcc,
1053                                      _("Set compile command "
1054                                        "GCC driver filename."),
1055                                      _("Show compile command "
1056                                        "GCC driver filename."),
1057                                      _("\
1058 It should be absolute filename of the gcc executable.\n\
1059 If empty the default target triplet will be searched in $PATH."),
1060                                      NULL, show_compile_gcc, &setlist,
1061                                      &showlist);
1062 }