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
  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   string_file input_buf;
 498   const char *input;
 499
 500   if (cmd != NULL)
 501     {
 502       struct command_line *iter;
 503
 504       for (iter = cmd->body_list[0]; iter; iter = iter->next)
 505         {
 506           input_buf.puts (iter->line);
 507           input_buf.puts ("\n");
 508         }
 509
 510       input = input_buf.c_str ();
 511     }
 512   else if (cmd_string != NULL)
 513     input = cmd_string;
 514   else
 515     error (_("Neither a simple expression, or a multi-line specified."));
 516
 517   std::string code
 518     = current_language->la_compute_program (compiler, input, gdbarch,
 519                                             expr_block, expr_pc);
 520   if (compile_debug)
 521     fprintf_unfiltered (gdb_stdlog, "debug output:\n\n%s", code.c_str ());
 522
 523   os_rx = osabi_triplet_regexp (gdbarch_osabi (gdbarch));
 524   arch_rx = gdbarch_gnu_triplet_regexp (gdbarch);
 525
 526   /* Allow triplets with or without vendor set.  */
 527   triplet_rx = concat (arch_rx, "(-[^-]*)?-", os_rx, (char *) NULL);
 528   make_cleanup (xfree, triplet_rx);
 529
 530   /* Set compiler command-line arguments.  */
 531   get_args (compiler, gdbarch, &argc, &argv);
 532   make_cleanup_freeargv (argv);
 533
 534   error_message = compiler->fe->ops->set_arguments (compiler->fe, triplet_rx,
 535                                                     argc, argv);
 536   if (error_message != NULL)
 537     {
 538       make_cleanup (xfree, error_message);
 539       error ("%s", error_message);
 540     }
 541
 542   if (compile_debug)
 543     {
 544       int argi;
 545
 546       fprintf_unfiltered (gdb_stdlog, "Passing %d compiler options:\n", argc);
 547       for (argi = 0; argi < argc; argi++)
 548         fprintf_unfiltered (gdb_stdlog, "Compiler option %d: <%s>\n",
 549                             argi, argv[argi]);
 550     }
 551
 552   compile_file_names fnames = get_new_file_names ();
 553
 554   src = gdb_fopen_cloexec (fnames.source_file (), "w");
 555   if (src == NULL)
 556     perror_with_name (_("Could not open source file for writing"));
 557   inner_cleanup = make_cleanup (cleanup_unlink_file,
 558                                 (void *) fnames.source_file ());
 559   if (fputs (code.c_str (), src) == EOF)
 560     perror_with_name (_("Could not write to source file"));
 561   fclose (src);
 562
 563   if (compile_debug)
 564     fprintf_unfiltered (gdb_stdlog, "source file produced: %s\n\n",
 565                         fnames.source_file ());
 566
 567   /* Call the compiler and start the compilation process.  */
 568   compiler->fe->ops->set_source_file (compiler->fe, fnames.source_file ());
 569
 570   if (!compiler->fe->ops->compile (compiler->fe, fnames.object_file (),
 571                                    compile_debug))
 572     error (_("Compilation failed."));
 573
 574   if (compile_debug)
 575     fprintf_unfiltered (gdb_stdlog, "object file produced: %s\n\n",
 576                         fnames.object_file ());
 577
 578   discard_cleanups (inner_cleanup);
 579   do_cleanups (cleanup);
 580
 581   return fnames;
 582 }
 583
 584 /* The "compile" prefix command.  */
 585
 586 static void
 587 compile_command (char *args, int from_tty)
 588 {
 589   /* If a sub-command is not specified to the compile prefix command,
 590      assume it is a direct code compilation.  */
 591   compile_code_command (args, from_tty);
 592 }
 593
 594 /* See compile.h.  */
 595
 596 void
 597 eval_compile_command (struct command_line *cmd, const char *cmd_string,
 598                       enum compile_i_scope_types scope, void *scope_data)
 599 {
 600   struct cleanup *cleanup_unlink;
 601   struct compile_module *compile_module;
 602
 603   compile_file_names fnames = compile_to_object (cmd, cmd_string, scope);
 604
 605   cleanup_unlink = make_cleanup (cleanup_unlink_file,
 606                                  (void *) fnames.object_file ());
 607   make_cleanup (cleanup_unlink_file, (void *) fnames.source_file ());
 608   compile_module = compile_object_load (fnames, scope, scope_data);
 609   if (compile_module == NULL)
 610     {
 611       gdb_assert (scope == COMPILE_I_PRINT_ADDRESS_SCOPE);
 612       eval_compile_command (cmd, cmd_string,
 613                             COMPILE_I_PRINT_VALUE_SCOPE, scope_data);
 614       return;
 615     }
 616   discard_cleanups (cleanup_unlink);
 617   compile_object_run (compile_module);
 618 }
 619
 620 /* See compile/compile-internal.h.  */
 621
 622 char *
 623 compile_register_name_mangled (struct gdbarch *gdbarch, int regnum)
 624 {
 625   const char *regname = gdbarch_register_name (gdbarch, regnum);
 626
 627   return xstrprintf ("__%s", regname);
 628 }
 629
 630 /* See compile/compile-internal.h.  */
 631
 632 int
 633 compile_register_name_demangle (struct gdbarch *gdbarch,
 634                                  const char *regname)
 635 {
 636   int regnum;
 637
 638   if (regname[0] != '_' || regname[1] != '_')
 639     error (_("Invalid register name \"%s\"."), regname);
 640   regname += 2;
 641
 642   for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
 643     if (strcmp (regname, gdbarch_register_name (gdbarch, regnum)) == 0)
 644       return regnum;
 645
 646   error (_("Cannot find gdbarch register \"%s\"."), regname);
 647 }
 648
 649 extern initialize_file_ftype _initialize_compile;
 650
 651 void
 652 _initialize_compile (void)
 653 {
 654   struct cmd_list_element *c = NULL;
 655
 656   add_prefix_cmd ("compile", class_obscure, compile_command,
 657                   _("\
 658 Command to compile source code and inject it into the inferior."),
 659                   &compile_command_list, "compile ", 1, &cmdlist);
 660   add_com_alias ("expression", "compile", class_obscure, 0);
 661
 662   add_cmd ("code", class_obscure, compile_code_command,
 663            _("\
 664 Compile, inject, and execute code.\n\
 665 \n\
 666 Usage: compile code [-r|-raw] [--] [CODE]\n\
 667 -r|-raw: Suppress automatic 'void _gdb_expr () { CODE }' wrapping.\n\
 668 --: Do not parse any options beyond this delimiter.  All text to the\n\
 669     right will be treated as source code.\n\
 670 \n\
 671 The source code may be specified as a simple one line expression, e.g.:\n\
 672 \n\
 673     compile code printf(\"Hello world\\n\");\n\
 674 \n\
 675 Alternatively, you can type a multiline expression by invoking\n\
 676 this command with no argument.  GDB will then prompt for the\n\
 677 expression interactively; type a line containing \"end\" to\n\
 678 indicate the end of the expression."),
 679            &compile_command_list);
 680
 681   c = add_cmd ("file", class_obscure, compile_file_command,
 682                _("\
 683 Evaluate a file containing source code.\n\
 684 \n\
 685 Usage: compile file [-r|-raw] [filename]\n\
 686 -r|-raw: Suppress automatic 'void _gdb_expr () { CODE }' wrapping."),
 687                &compile_command_list);
 688   set_cmd_completer (c, filename_completer);
 689
 690   add_cmd ("print", class_obscure, compile_print_command,
 691            _("\
 692 Evaluate EXPR by using the compiler and print result.\n\
 693 \n\
 694 Usage: compile print[/FMT] [EXPR]\n\
 695 \n\
 696 The expression may be specified on the same line as the command, e.g.:\n\
 697 \n\
 698     compile print i\n\
 699 \n\
 700 Alternatively, you can type a multiline expression by invoking\n\
 701 this command with no argument.  GDB will then prompt for the\n\
 702 expression interactively; type a line containing \"end\" to\n\
 703 indicate the end of the expression.\n\
 704 \n\
 705 EXPR may be preceded with /FMT, where FMT is a format letter\n\
 706 but no count or size letter (see \"x\" command)."),
 707            &compile_command_list);
 708
 709   add_setshow_boolean_cmd ("compile", class_maintenance, &compile_debug, _("\
 710 Set compile command debugging."), _("\
 711 Show compile command debugging."), _("\
 712 When on, compile command debugging is enabled."),
 713                            NULL, show_compile_debug,
 714                            &setdebuglist, &showdebuglist);
 715
 716   add_setshow_string_cmd ("compile-args", class_support,
 717                           &compile_args,
 718                           _("Set compile command GCC command-line arguments"),
 719                           _("Show compile command GCC command-line arguments"),
 720                           _("\
 721 Use options like -I (include file directory) or ABI settings.\n\
 722 String quoting is parsed like in shell, for example:\n\
 723   -mno-align-double \"-I/dir with a space/include\""),
 724                           set_compile_args, show_compile_args, &setlist, &showlist);
 725
 726   /* Override flags possibly coming from DW_AT_producer.  */
 727   compile_args = xstrdup ("-O0 -gdwarf-4"
 728   /* We use -fPIE Otherwise GDB would need to reserve space large enough for
 729      any object file in the inferior in advance to get the final address when
 730      to link the object file to and additionally the default system linker
 731      script would need to be modified so that one can specify there the
 732      absolute target address.
 733      -fPIC is not used at is would require from GDB to generate .got.  */
 734                          " -fPIE"
 735   /* We want warnings, except for some commonly happening for GDB commands.  */
 736                          " -Wall "
 737                          " -Wno-implicit-function-declaration"
 738                          " -Wno-unused-but-set-variable"
 739                          " -Wno-unused-variable"
 740   /* Override CU's possible -fstack-protector-strong.  */
 741                          " -fno-stack-protector"
 742   );
 743   set_compile_args (compile_args, 0, NULL);
 744 }