gdb/compile/compile.c

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