gdb/compile/compile.c

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