gdb/compile/compile.c

   1 /* General Compile and inject code
   2
   3    Copyright (C) 2014-2017 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 "completer.h"
  27 #include "gdbcmd.h"
  28 #include "compile.h"
  29 #include "compile-internal.h"
  30 #include "compile-object-load.h"
  31 #include "compile-object-run.h"
  32 #include "language.h"
  33 #include "frame.h"
  34 #include "source.h"
  35 #include "block.h"
  36 #include "arch-utils.h"
  37 #include "filestuff.h"
  38 #include "target.h"
  39 #include "osabi.h"
  40 #include "gdb_wait.h"
  41 #include "valprint.h"
  42 #include "common/gdb_optional.h"
  43 #include "common/gdb_unlinker.h"
  44
  45 \f
  46
  47 /* Initial filename for temporary files.  */
  48
  49 #define TMP_PREFIX "/tmp/gdbobj-"
  50
  51 /* Hold "compile" commands.  */
  52
  53 static struct cmd_list_element *compile_command_list;
  54
  55 /* Debug flag for "compile" commands.  */
  56
  57 int compile_debug;
  58
  59 /* Implement "show debug compile".  */
  60
  61 static void
  62 show_compile_debug (struct ui_file *file, int from_tty,
  63                     struct cmd_list_element *c, const char *value)
  64 {
  65   fprintf_filtered (file, _("Compile debugging is %s.\n"), value);
  66 }
  67
  68 \f
  69
  70 /* Check *ARG for a "-raw" or "-r" argument.  Return 0 if not seen.
  71    Return 1 if seen and update *ARG.  */
  72
  73 static int
  74 check_raw_argument (char **arg)
  75 {
  76   *arg = skip_spaces (*arg);
  77
  78   if (arg != NULL
  79       && (check_for_argument (arg, "-raw", sizeof ("-raw") - 1)
  80           || check_for_argument (arg, "-r", sizeof ("-r") - 1)))
  81       return 1;
  82   return 0;
  83 }
  84
  85 /* Handle the input from the 'compile file' command.  The "compile
  86    file" command is used to evaluate an expression contained in a file
  87    that may contain calls to the GCC compiler.  */
  88
  89 static void
  90 compile_file_command (char *arg, int from_tty)
  91 {
  92   enum compile_i_scope_types scope = COMPILE_I_SIMPLE_SCOPE;
  93
  94   scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
  95
  96   /* Check the user did not just <enter> after command.  */
  97   if (arg == NULL)
  98     error (_("You must provide a filename for this command."));
  99
 100   /* Check if a raw (-r|-raw) argument is provided.  */
 101   if (arg != NULL && check_raw_argument (&arg))
 102     {
 103       scope = COMPILE_I_RAW_SCOPE;
 104       arg = skip_spaces (arg);
 105     }
 106
 107   /* After processing arguments, check there is a filename at the end
 108      of the command.  */
 109   if (arg[0] == '\0')
 110     error (_("You must provide a filename with the raw option set."));
 111
 112   if (arg[0] == '-')
 113     error (_("Unknown argument specified."));
 114
 115   arg = skip_spaces (arg);
 116   gdb::unique_xmalloc_ptr<char> abspath = gdb_abspath (arg);
 117   std::string buffer = string_printf ("#include \"%s\"\n", abspath.get ());
 118   eval_compile_command (NULL, buffer.c_str (), scope, NULL);
 119 }
 120
 121 /* Handle the input from the 'compile code' command.  The
 122    "compile code" command is used to evaluate an expression that may
 123    contain calls to the GCC compiler.  The language expected in this
 124    compile command is the language currently set in GDB.  */
 125
 126 static void
 127 compile_code_command (char *arg, int from_tty)
 128 {
 129   enum compile_i_scope_types scope = COMPILE_I_SIMPLE_SCOPE;
 130
 131   scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
 132
 133   if (arg != NULL && check_raw_argument (&arg))
 134     {
 135       scope = COMPILE_I_RAW_SCOPE;
 136       arg = skip_spaces (arg);
 137     }
 138
 139   arg = skip_spaces (arg);
 140
 141   if (arg != NULL && !check_for_argument (&arg, "--", sizeof ("--") - 1))
 142     {
 143       if (arg[0] == '-')
 144         error (_("Unknown argument specified."));
 145     }
 146
 147   if (arg && *arg)
 148     eval_compile_command (NULL, arg, scope, NULL);
 149   else
 150     {
 151       command_line_up l = get_command_line (compile_control, "");
 152
 153       l->control_u.compile.scope = scope;
 154       execute_control_command_untraced (l.get ());
 155     }
 156 }
 157
 158 /* Callback for compile_print_command.  */
 159
 160 void
 161 compile_print_value (struct value *val, void *data_voidp)
 162 {
 163   const struct format_data *fmtp = (const struct format_data *) data_voidp;
 164
 165   print_value (val, fmtp);
 166 }
 167
 168 /* Handle the input from the 'compile print' command.  The "compile
 169    print" command is used to evaluate and print an expression that may
 170    contain calls to the GCC compiler.  The language expected in this
 171    compile command is the language currently set in GDB.  */
 172
 173 static void
 174 compile_print_command (char *arg_param, int from_tty)
 175 {
 176   const char *arg = arg_param;
 177   enum compile_i_scope_types scope = COMPILE_I_PRINT_ADDRESS_SCOPE;
 178   struct format_data fmt;
 179
 180   scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
 181
 182   /* Passing &FMT as SCOPE_DATA is safe as do_module_cleanup will not
 183      touch the stale pointer if compile_object_run has already quit.  */
 184   print_command_parse_format (&arg, "compile print", &fmt);
 185
 186   if (arg && *arg)
 187     eval_compile_command (NULL, arg, scope, &fmt);
 188   else
 189     {
 190       command_line_up l = get_command_line (compile_control, "");
 191
 192       l->control_u.compile.scope = scope;
 193       l->control_u.compile.scope_data = &fmt;
 194       execute_control_command_untraced (l.get ());
 195     }
 196 }
 197
 198 /* A cleanup function to remove a directory and all its contents.  */
 199
 200 static void
 201 do_rmdir (void *arg)
 202 {
 203   const char *dir = (const char *) arg;
 204   char *zap;
 205   int wstat;
 206
 207   gdb_assert (startswith (dir, TMP_PREFIX));
 208   zap = concat ("rm -rf ", dir, (char *) NULL);
 209   wstat = system (zap);
 210   if (wstat == -1 || !WIFEXITED (wstat) || WEXITSTATUS (wstat) != 0)
 211     warning (_("Could not remove temporary directory %s"), dir);
 212   XDELETEVEC (zap);
 213 }
 214
 215 /* Return the name of the temporary directory to use for .o files, and
 216    arrange for the directory to be removed at shutdown.  */
 217
 218 static const char *
 219 get_compile_file_tempdir (void)
 220 {
 221   static char *tempdir_name;
 222
 223 #define TEMPLATE TMP_PREFIX "XXXXXX"
 224   char tname[sizeof (TEMPLATE)];
 225
 226   if (tempdir_name != NULL)
 227     return tempdir_name;
 228
 229   strcpy (tname, TEMPLATE);
 230 #undef TEMPLATE
 231 #ifdef HAVE_MKDTEMP
 232   tempdir_name = mkdtemp (tname);
 233 #else
 234   error (_("Command not supported on this host."));
 235 #endif
 236   if (tempdir_name == NULL)
 237     perror_with_name (_("Could not make temporary directory"));
 238
 239   tempdir_name = xstrdup (tempdir_name);
 240   make_final_cleanup (do_rmdir, tempdir_name);
 241   return tempdir_name;
 242 }
 243
 244 /* Compute the names of source and object files to use.  */
 245
 246 static compile_file_names
 247 get_new_file_names ()
 248 {
 249   static int seq;
 250   const char *dir = get_compile_file_tempdir ();
 251
 252   ++seq;
 253
 254   return compile_file_names (string_printf ("%s%sout%d.c",
 255                                             dir, SLASH_STRING, seq),
 256                              string_printf ("%s%sout%d.o",
 257                                             dir, SLASH_STRING, seq));
 258 }
 259
 260 /* Get the block and PC at which to evaluate an expression.  */
 261
 262 static const struct block *
 263 get_expr_block_and_pc (CORE_ADDR *pc)
 264 {
 265   const struct block *block = get_selected_block (pc);
 266
 267   if (block == NULL)
 268     {
 269       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 270
 271       if (cursal.symtab)
 272         block = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
 273                                    STATIC_BLOCK);
 274       if (block != NULL)
 275         *pc = BLOCK_START (block);
 276     }
 277   else
 278     *pc = BLOCK_START (block);
 279
 280   return block;
 281 }
 282
 283 /* Call buildargv (via gdb_argv), set its result for S into *ARGVP but
 284    calculate also the number of parsed arguments into *ARGCP.  If
 285    buildargv has returned NULL then *ARGCP is set to zero.  */
 286
 287 static void
 288 build_argc_argv (const char *s, int *argcp, char ***argvp)
 289 {
 290   gdb_argv args (s);
 291
 292   *argcp = args.count ();
 293   *argvp = args.release ();
 294 }
 295
 296 /* String for 'set compile-args' and 'show compile-args'.  */
 297 static char *compile_args;
 298
 299 /* Parsed form of COMPILE_ARGS.  COMPILE_ARGS_ARGV is NULL terminated.  */
 300 static int compile_args_argc;
 301 static char **compile_args_argv;
 302
 303 /* Implement 'set compile-args'.  */
 304
 305 static void
 306 set_compile_args (char *args, int from_tty, struct cmd_list_element *c)
 307 {
 308   freeargv (compile_args_argv);
 309   build_argc_argv (compile_args, &compile_args_argc, &compile_args_argv);
 310 }
 311
 312 /* Implement 'show compile-args'.  */
 313
 314 static void
 315 show_compile_args (struct ui_file *file, int from_tty,
 316                    struct cmd_list_element *c, const char *value)
 317 {
 318   fprintf_filtered (file, _("Compile command command-line arguments "
 319                             "are \"%s\".\n"),
 320                     value);
 321 }
 322
 323 /* Append ARGC and ARGV (as parsed by build_argc_argv) to *ARGCP and *ARGVP.
 324    ARGCP+ARGVP can be zero+NULL and also ARGC+ARGV can be zero+NULL.  */
 325
 326 static void
 327 append_args (int *argcp, char ***argvp, int argc, char **argv)
 328 {
 329   int argi;
 330
 331   *argvp = XRESIZEVEC (char *, *argvp, (*argcp + argc + 1));
 332
 333   for (argi = 0; argi < argc; argi++)
 334     (*argvp)[(*argcp)++] = xstrdup (argv[argi]);
 335   (*argvp)[(*argcp)] = NULL;
 336 }
 337
 338 /* String for 'set compile-gcc' and 'show compile-gcc'.  */
 339 static char *compile_gcc;
 340
 341 /* Implement 'show compile-gcc'.  */
 342
 343 static void
 344 show_compile_gcc (struct ui_file *file, int from_tty,
 345                   struct cmd_list_element *c, const char *value)
 346 {
 347   fprintf_filtered (file, _("Compile command GCC driver filename is \"%s\".\n"),
 348                     value);
 349 }
 350
 351 /* Return DW_AT_producer parsed for get_selected_frame () (if any).
 352    Return NULL otherwise.
 353
 354    GCC already filters its command-line arguments only for the suitable ones to
 355    put into DW_AT_producer - see GCC function gen_producer_string.  */
 356
 357 static const char *
 358 get_selected_pc_producer_options (void)
 359 {
 360   CORE_ADDR pc = get_frame_pc (get_selected_frame (NULL));
 361   struct compunit_symtab *symtab = find_pc_compunit_symtab (pc);
 362   const char *cs;
 363
 364   if (symtab == NULL || symtab->producer == NULL
 365       || !startswith (symtab->producer, "GNU "))
 366     return NULL;
 367
 368   cs = symtab->producer;
 369   while (*cs != 0 && *cs != '-')
 370     cs = skip_spaces (skip_to_space (cs));
 371   if (*cs != '-')
 372     return NULL;
 373   return cs;
 374 }
 375
 376 /* Filter out unwanted options from *ARGCP and ARGV.  */
 377
 378 static void
 379 filter_args (int *argcp, char **argv)
 380 {
 381   char **destv;
 382
 383   for (destv = argv; *argv != NULL; argv++)
 384     {
 385       /* -fpreprocessed may get in commonly from ccache.  */
 386       if (strcmp (*argv, "-fpreprocessed") == 0)
 387         {
 388           xfree (*argv);
 389           (*argcp)--;
 390           continue;
 391         }
 392       *destv++ = *argv;
 393     }
 394   *destv = NULL;
 395 }
 396
 397 /* Produce final vector of GCC compilation options.  First element is target
 398    size ("-m64", "-m32" etc.), optionally followed by DW_AT_producer options
 399    and then compile-args string GDB variable.  */
 400
 401 static void
 402 get_args (const struct compile_instance *compiler, struct gdbarch *gdbarch,
 403           int *argcp, char ***argvp)
 404 {
 405   const char *cs_producer_options;
 406   int argc_compiler;
 407   char **argv_compiler;
 408
 409   build_argc_argv (gdbarch_gcc_target_options (gdbarch),
 410                    argcp, argvp);
 411
 412   cs_producer_options = get_selected_pc_producer_options ();
 413   if (cs_producer_options != NULL)
 414     {
 415       int argc_producer;
 416       char **argv_producer;
 417
 418       build_argc_argv (cs_producer_options, &argc_producer, &argv_producer);
 419       filter_args (&argc_producer, argv_producer);
 420       append_args (argcp, argvp, argc_producer, argv_producer);
 421       freeargv (argv_producer);
 422     }
 423
 424   build_argc_argv (compiler->gcc_target_options,
 425                    &argc_compiler, &argv_compiler);
 426   append_args (argcp, argvp, argc_compiler, argv_compiler);
 427   freeargv (argv_compiler);
 428
 429   append_args (argcp, argvp, compile_args_argc, compile_args_argv);
 430 }
 431
 432 /* A cleanup function to destroy a gdb_gcc_instance.  */
 433
 434 static void
 435 cleanup_compile_instance (void *arg)
 436 {
 437   struct compile_instance *inst = (struct compile_instance *) arg;
 438
 439   inst->destroy (inst);
 440 }
 441
 442 /* A helper function suitable for use as the "print_callback" in the
 443    compiler object.  */
 444
 445 static void
 446 print_callback (void *ignore, const char *message)
 447 {
 448   fputs_filtered (message, gdb_stderr);
 449 }
 450
 451 /* Process the compilation request.  On success it returns the object
 452    and source file names.  On an error condition, error () is
 453    called.  */
 454
 455 static compile_file_names
 456 compile_to_object (struct command_line *cmd, const char *cmd_string,
 457                    enum compile_i_scope_types scope)
 458 {
 459   struct compile_instance *compiler;
 460   struct cleanup *cleanup;
 461   const struct block *expr_block;
 462   CORE_ADDR trash_pc, expr_pc;
 463   int argc;
 464   char **argv;
 465   int ok;
 466   FILE *src;
 467   struct gdbarch *gdbarch = get_current_arch ();
 468   char *triplet_rx;
 469   char *error_message;
 470
 471   if (!target_has_execution)
 472     error (_("The program must be running for the compile command to "\
 473              "work."));
 474
 475   expr_block = get_expr_block_and_pc (&trash_pc);
 476   expr_pc = get_frame_address_in_block (get_selected_frame (NULL));
 477
 478   /* Set up instance and context for the compiler.  */
 479   if (current_language->la_get_compile_instance == NULL)
 480     error (_("No compiler support for language %s."),
 481            current_language->la_name);
 482   compiler = current_language->la_get_compile_instance ();
 483   cleanup = make_cleanup (cleanup_compile_instance, compiler);
 484
 485   compiler->fe->ops->set_print_callback (compiler->fe, print_callback, NULL);
 486
 487   compiler->scope = scope;
 488   compiler->block = expr_block;
 489
 490   /* From the provided expression, build a scope to pass to the
 491      compiler.  */
 492
 493   string_file input_buf;
 494   const char *input;
 495
 496   if (cmd != NULL)
 497     {
 498       struct command_line *iter;
 499
 500       for (iter = cmd->body_list[0]; iter; iter = iter->next)
 501         {
 502           input_buf.puts (iter->line);
 503           input_buf.puts ("\n");
 504         }
 505
 506       input = input_buf.c_str ();
 507     }
 508   else if (cmd_string != NULL)
 509     input = cmd_string;
 510   else
 511     error (_("Neither a simple expression, or a multi-line specified."));
 512
 513   std::string code
 514     = current_language->la_compute_program (compiler, input, gdbarch,
 515                                             expr_block, expr_pc);
 516   if (compile_debug)
 517     fprintf_unfiltered (gdb_stdlog, "debug output:\n\n%s", code.c_str ());
 518
 519   if (compiler->fe->ops->version >= GCC_FE_VERSION_1)
 520     compiler->fe->ops->set_verbose (compiler->fe, compile_debug);
 521
 522   if (compile_gcc[0] != 0)
 523     {
 524       if (compiler->fe->ops->version < GCC_FE_VERSION_1)
 525         error (_("Command 'set compile-gcc' requires GCC version 6 or higher "
 526                  "(libcc1 interface version 1 or higher)"));
 527
 528       compiler->fe->ops->set_driver_filename (compiler->fe, compile_gcc);
 529     }
 530   else
 531     {
 532       const char *os_rx = osabi_triplet_regexp (gdbarch_osabi (gdbarch));
 533       const char *arch_rx = gdbarch_gnu_triplet_regexp (gdbarch);
 534
 535       /* Allow triplets with or without vendor set.  */
 536       triplet_rx = concat (arch_rx, "(-[^-]*)?-", os_rx, (char *) NULL);
 537       make_cleanup (xfree, triplet_rx);
 538
 539       if (compiler->fe->ops->version >= GCC_FE_VERSION_1)
 540         compiler->fe->ops->set_triplet_regexp (compiler->fe, triplet_rx);
 541     }
 542
 543   /* Set compiler command-line arguments.  */
 544   get_args (compiler, gdbarch, &argc, &argv);
 545   gdb_argv argv_holder (argv);
 546
 547   if (compiler->fe->ops->version >= GCC_FE_VERSION_1)
 548     error_message = compiler->fe->ops->set_arguments (compiler->fe, argc, argv);
 549   else
 550     error_message = compiler->fe->ops->set_arguments_v0 (compiler->fe, triplet_rx,
 551                                                          argc, argv);
 552   if (error_message != NULL)
 553     {
 554       make_cleanup (xfree, error_message);
 555       error ("%s", error_message);
 556     }
 557
 558   if (compile_debug)
 559     {
 560       int argi;
 561
 562       fprintf_unfiltered (gdb_stdlog, "Passing %d compiler options:\n", argc);
 563       for (argi = 0; argi < argc; argi++)
 564         fprintf_unfiltered (gdb_stdlog, "Compiler option %d: <%s>\n",
 565                             argi, argv[argi]);
 566     }
 567
 568   compile_file_names fnames = get_new_file_names ();
 569
 570   gdb::optional<gdb::unlinker> source_remover;
 571
 572   {
 573     gdb_file_up src = gdb_fopen_cloexec (fnames.source_file (), "w");
 574     if (src == NULL)
 575       perror_with_name (_("Could not open source file for writing"));
 576
 577     source_remover.emplace (fnames.source_file ());
 578
 579     if (fputs (code.c_str (), src.get ()) == EOF)
 580       perror_with_name (_("Could not write to source file"));
 581   }
 582
 583   if (compile_debug)
 584     fprintf_unfiltered (gdb_stdlog, "source file produced: %s\n\n",
 585                         fnames.source_file ());
 586
 587   /* Call the compiler and start the compilation process.  */
 588   compiler->fe->ops->set_source_file (compiler->fe, fnames.source_file ());
 589
 590   if (compiler->fe->ops->version >= GCC_FE_VERSION_1)
 591     ok = compiler->fe->ops->compile (compiler->fe, fnames.object_file ());
 592   else
 593     ok = compiler->fe->ops->compile_v0 (compiler->fe, fnames.object_file (),
 594                                         compile_debug);
 595   if (!ok)
 596     error (_("Compilation failed."));
 597
 598   if (compile_debug)
 599     fprintf_unfiltered (gdb_stdlog, "object file produced: %s\n\n",
 600                         fnames.object_file ());
 601
 602   /* Keep the source file.  */
 603   source_remover->keep ();
 604
 605   do_cleanups (cleanup);
 606
 607   return fnames;
 608 }
 609
 610 /* The "compile" prefix command.  */
 611
 612 static void
 613 compile_command (char *args, int from_tty)
 614 {
 615   /* If a sub-command is not specified to the compile prefix command,
 616      assume it is a direct code compilation.  */
 617   compile_code_command (args, from_tty);
 618 }
 619
 620 /* See compile.h.  */
 621
 622 void
 623 eval_compile_command (struct command_line *cmd, const char *cmd_string,
 624                       enum compile_i_scope_types scope, void *scope_data)
 625 {
 626   struct compile_module *compile_module;
 627
 628   compile_file_names fnames = compile_to_object (cmd, cmd_string, scope);
 629
 630   gdb::unlinker object_remover (fnames.object_file ());
 631   gdb::unlinker source_remover (fnames.source_file ());
 632
 633   compile_module = compile_object_load (fnames, scope, scope_data);
 634   if (compile_module == NULL)
 635     {
 636       gdb_assert (scope == COMPILE_I_PRINT_ADDRESS_SCOPE);
 637       eval_compile_command (cmd, cmd_string,
 638                             COMPILE_I_PRINT_VALUE_SCOPE, scope_data);
 639       return;
 640     }
 641
 642   /* Keep the files.  */
 643   source_remover.keep ();
 644   object_remover.keep ();
 645
 646   compile_object_run (compile_module);
 647 }
 648
 649 /* See compile/compile-internal.h.  */
 650
 651 std::string
 652 compile_register_name_mangled (struct gdbarch *gdbarch, int regnum)
 653 {
 654   const char *regname = gdbarch_register_name (gdbarch, regnum);
 655
 656   return string_printf ("__%s", regname);
 657 }
 658
 659 /* See compile/compile-internal.h.  */
 660
 661 int
 662 compile_register_name_demangle (struct gdbarch *gdbarch,
 663                                  const char *regname)
 664 {
 665   int regnum;
 666
 667   if (regname[0] != '_' || regname[1] != '_')
 668     error (_("Invalid register name \"%s\"."), regname);
 669   regname += 2;
 670
 671   for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
 672     if (strcmp (regname, gdbarch_register_name (gdbarch, regnum)) == 0)
 673       return regnum;
 674
 675   error (_("Cannot find gdbarch register \"%s\"."), regname);
 676 }
 677
 678 void
 679 _initialize_compile (void)
 680 {
 681   struct cmd_list_element *c = NULL;
 682
 683   add_prefix_cmd ("compile", class_obscure, compile_command,
 684                   _("\
 685 Command to compile source code and inject it into the inferior."),
 686                   &compile_command_list, "compile ", 1, &cmdlist);
 687   add_com_alias ("expression", "compile", class_obscure, 0);
 688
 689   add_cmd ("code", class_obscure, compile_code_command,
 690            _("\
 691 Compile, inject, and execute code.\n\
 692 \n\
 693 Usage: compile code [-r|-raw] [--] [CODE]\n\
 694 -r|-raw: Suppress automatic 'void _gdb_expr () { CODE }' wrapping.\n\
 695 --: Do not parse any options beyond this delimiter.  All text to the\n\
 696     right will be treated as source code.\n\
 697 \n\
 698 The source code may be specified as a simple one line expression, e.g.:\n\
 699 \n\
 700     compile code printf(\"Hello world\\n\");\n\
 701 \n\
 702 Alternatively, you can type a multiline expression by invoking\n\
 703 this command with no argument.  GDB will then prompt for the\n\
 704 expression interactively; type a line containing \"end\" to\n\
 705 indicate the end of the expression."),
 706            &compile_command_list);
 707
 708   c = add_cmd ("file", class_obscure, compile_file_command,
 709                _("\
 710 Evaluate a file containing source code.\n\
 711 \n\
 712 Usage: compile file [-r|-raw] [filename]\n\
 713 -r|-raw: Suppress automatic 'void _gdb_expr () { CODE }' wrapping."),
 714                &compile_command_list);
 715   set_cmd_completer (c, filename_completer);
 716
 717   add_cmd ("print", class_obscure, compile_print_command,
 718            _("\
 719 Evaluate EXPR by using the compiler and print result.\n\
 720 \n\
 721 Usage: compile print[/FMT] [EXPR]\n\
 722 \n\
 723 The expression may be specified on the same line as the command, e.g.:\n\
 724 \n\
 725     compile print i\n\
 726 \n\
 727 Alternatively, you can type a multiline expression by invoking\n\
 728 this command with no argument.  GDB will then prompt for the\n\
 729 expression interactively; type a line containing \"end\" to\n\
 730 indicate the end of the expression.\n\
 731 \n\
 732 EXPR may be preceded with /FMT, where FMT is a format letter\n\
 733 but no count or size letter (see \"x\" command)."),
 734            &compile_command_list);
 735
 736   add_setshow_boolean_cmd ("compile", class_maintenance, &compile_debug, _("\
 737 Set compile command debugging."), _("\
 738 Show compile command debugging."), _("\
 739 When on, compile command debugging is enabled."),
 740                            NULL, show_compile_debug,
 741                            &setdebuglist, &showdebuglist);
 742
 743   add_setshow_string_cmd ("compile-args", class_support,
 744                           &compile_args,
 745                           _("Set compile command GCC command-line arguments"),
 746                           _("Show compile command GCC command-line arguments"),
 747                           _("\
 748 Use options like -I (include file directory) or ABI settings.\n\
 749 String quoting is parsed like in shell, for example:\n\
 750   -mno-align-double \"-I/dir with a space/include\""),
 751                           set_compile_args, show_compile_args, &setlist, &showlist);
 752
 753   /* Override flags possibly coming from DW_AT_producer.  */
 754   compile_args = xstrdup ("-O0 -gdwarf-4"
 755   /* We use -fPIE Otherwise GDB would need to reserve space large enough for
 756      any object file in the inferior in advance to get the final address when
 757      to link the object file to and additionally the default system linker
 758      script would need to be modified so that one can specify there the
 759      absolute target address.
 760      -fPIC is not used at is would require from GDB to generate .got.  */
 761                          " -fPIE"
 762   /* We want warnings, except for some commonly happening for GDB commands.  */
 763                          " -Wall "
 764                          " -Wno-implicit-function-declaration"
 765                          " -Wno-unused-but-set-variable"
 766                          " -Wno-unused-variable"
 767   /* Override CU's possible -fstack-protector-strong.  */
 768                          " -fno-stack-protector"
 769   );
 770   set_compile_args (compile_args, 0, NULL);
 771
 772   add_setshow_optional_filename_cmd ("compile-gcc", class_support,
 773                                      &compile_gcc,
 774                                      _("Set compile command "
 775                                        "GCC driver filename"),
 776                                      _("Show compile command "
 777                                        "GCC driver filename"),
 778                                      _("\
 779 It should be absolute filename of the gcc executable.\n\
 780 If empty the default target triplet will be searched in $PATH."),
 781                                      NULL, show_compile_gcc, &setlist,
 782                                      &showlist);
 783   compile_gcc = xstrdup ("");
 784 }