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