1 /* Compiler driver program that can handle many languages. 2 Copyright (C) 1987-2018 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 /* This program is the user interface to the C compiler and possibly to 21 other compilers. It is used because compilation is a complicated procedure 22 which involves running several programs and passing temporary files between 23 them, forwarding the users switches to those programs selectively, 24 and deleting the temporary files at the end. 25 26 CC recognizes how to compile each input file by suffixes in the file names. 27 Once it knows which kind of compilation to perform, the procedure for 28 compilation is specified by a string called a "spec". */ 29 30 #include "config.h" 31 #include "system.h" 32 #include "coretypes.h" 33 #include "multilib.h" /* before tm.h */ 34 #include "tm.h" 35 #include "xregex.h" 36 #include "obstack.h" 37 #include "intl.h" 38 #include "prefix.h" 39 #include "gcc.h" 40 #include "diagnostic.h" 41 #include "flags.h" 42 #include "opts.h" 43 #include "params.h" 44 #include "filenames.h" 45 #include "spellcheck.h" 46 47 48 49 /* Manage the manipulation of env vars. 50 51 We poison "getenv" and "putenv", so that all enviroment-handling is 52 done through this class. Note that poisoning happens in the 53 preprocessor at the identifier level, and doesn't distinguish between 54 env.getenv (); 55 and 56 getenv (); 57 Hence we need to use "get" for the accessor method, not "getenv". */ 58 59 class env_manager 60 { 61 public: 62 void init (bool can_restore, bool debug); 63 const char *get (const char *name); 64 void xput (const char *string); 65 void restore (); 66 67 private: 68 bool m_can_restore; 69 bool m_debug; 70 struct kv 71 { 72 char *m_key; 73 char *m_value; 74 }; 75 vec<kv> m_keys; 76 77 }; 78 79 /* The singleton instance of class env_manager. */ 80 81 static env_manager env; 82 83 /* Initializer for class env_manager. 84 85 We can't do this as a constructor since we have a statically 86 allocated instance ("env" above). */ 87 88 void 89 env_manager::init (bool can_restore, bool debug) 90 { 91 m_can_restore = can_restore; 92 m_debug = debug; 93 } 94 95 /* Get the value of NAME within the environment. Essentially 96 a wrapper for ::getenv, but adding logging, and the possibility 97 of caching results. */ 98 99 const char * 100 env_manager::get (const char *name) 101 { 102 const char *result = ::getenv (name); 103 if (m_debug) 104 fprintf (stderr, "env_manager::getenv (%s) -> %s\n", name, result); 105 return result; 106 } 107 108 /* Put the given KEY=VALUE entry STRING into the environment. 109 If the env_manager was initialized with CAN_RESTORE set, then 110 also record the old value of KEY within the environment, so that it 111 can be later restored. */ 112 113 void 114 env_manager::xput (const char *string) 115 { 116 if (m_debug) 117 fprintf (stderr, "env_manager::xput (%s)\n", string); 118 if (verbose_flag) 119 fnotice (stderr, "%s\n", string); 120 121 if (m_can_restore) 122 { 123 char *equals = strchr (const_cast <char *> (string), '='); 124 gcc_assert (equals); 125 126 struct kv kv; 127 kv.m_key = xstrndup (string, equals - string); 128 const char *cur_value = ::getenv (kv.m_key); 129 if (m_debug) 130 fprintf (stderr, "saving old value: %s\n",cur_value); 131 kv.m_value = cur_value ? xstrdup (cur_value) : NULL; 132 m_keys.safe_push (kv); 133 } 134 135 ::putenv (CONST_CAST (char *, string)); 136 } 137 138 /* Undo any xputenv changes made since last restore. 139 Can only be called if the env_manager was initialized with 140 CAN_RESTORE enabled. */ 141 142 void 143 env_manager::restore () 144 { 145 unsigned int i; 146 struct kv *item; 147 148 gcc_assert (m_can_restore); 149 150 FOR_EACH_VEC_ELT_REVERSE (m_keys, i, item) 151 { 152 if (m_debug) 153 printf ("restoring saved key: %s value: %s\n", item->m_key, item->m_value); 154 if (item->m_value) 155 ::setenv (item->m_key, item->m_value, 1); 156 else 157 ::unsetenv (item->m_key); 158 free (item->m_key); 159 free (item->m_value); 160 } 161 162 m_keys.truncate (0); 163 } 164 165 /* Forbid other uses of getenv and putenv. */ 166 #if (GCC_VERSION >= 3000) 167 #pragma GCC poison getenv putenv 168 #endif 169 170 171 172 /* By default there is no special suffix for target executables. */ 173 #ifdef TARGET_EXECUTABLE_SUFFIX 174 #define HAVE_TARGET_EXECUTABLE_SUFFIX 175 #else 176 #define TARGET_EXECUTABLE_SUFFIX "" 177 #endif 178 179 /* By default there is no special suffix for host executables. */ 180 #ifdef HOST_EXECUTABLE_SUFFIX 181 #define HAVE_HOST_EXECUTABLE_SUFFIX 182 #else 183 #define HOST_EXECUTABLE_SUFFIX "" 184 #endif 185 186 /* By default, the suffix for target object files is ".o". */ 187 #ifdef TARGET_OBJECT_SUFFIX 188 #define HAVE_TARGET_OBJECT_SUFFIX 189 #else 190 #define TARGET_OBJECT_SUFFIX ".o" 191 #endif 192 193 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 }; 194 195 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */ 196 #ifndef LIBRARY_PATH_ENV 197 #define LIBRARY_PATH_ENV "LIBRARY_PATH" 198 #endif 199 200 /* If a stage of compilation returns an exit status >= 1, 201 compilation of that file ceases. */ 202 203 #define MIN_FATAL_STATUS 1 204 205 /* Flag set by cppspec.c to 1. */ 206 int is_cpp_driver; 207 208 /* Flag set to nonzero if an @file argument has been supplied to gcc. */ 209 static bool at_file_supplied; 210 211 /* Definition of string containing the arguments given to configure. */ 212 #include "configargs.h" 213 214 /* Flag saying to print the command line options understood by gcc and its 215 sub-processes. */ 216 217 static int print_help_list; 218 219 /* Flag saying to print the version of gcc and its sub-processes. */ 220 221 static int print_version; 222 223 /* Flag indicating whether we should ONLY print the command and 224 arguments (like verbose_flag) without executing the command. 225 Displayed arguments are quoted so that the generated command 226 line is suitable for execution. This is intended for use in 227 shell scripts to capture the driver-generated command line. */ 228 static int verbose_only_flag; 229 230 /* Flag indicating how to print command line options of sub-processes. */ 231 232 static int print_subprocess_help; 233 234 /* Linker suffix passed to -fuse-ld=... */ 235 static const char *use_ld; 236 237 /* Whether we should report subprocess execution times to a file. */ 238 239 FILE *report_times_to_file = NULL; 240 241 /* Nonzero means place this string before uses of /, so that include 242 and library files can be found in an alternate location. */ 243 244 #ifdef TARGET_SYSTEM_ROOT 245 #define DEFAULT_TARGET_SYSTEM_ROOT (TARGET_SYSTEM_ROOT) 246 #else 247 #define DEFAULT_TARGET_SYSTEM_ROOT (0) 248 #endif 249 static const char *target_system_root = DEFAULT_TARGET_SYSTEM_ROOT; 250 251 /* Nonzero means pass the updated target_system_root to the compiler. */ 252 253 static int target_system_root_changed; 254 255 /* Nonzero means append this string to target_system_root. */ 256 257 static const char *target_sysroot_suffix = 0; 258 259 /* Nonzero means append this string to target_system_root for headers. */ 260 261 static const char *target_sysroot_hdrs_suffix = 0; 262 263 /* Nonzero means write "temp" files in source directory 264 and use the source file's name in them, and don't delete them. */ 265 266 static enum save_temps { 267 SAVE_TEMPS_NONE, /* no -save-temps */ 268 SAVE_TEMPS_CWD, /* -save-temps in current directory */ 269 SAVE_TEMPS_OBJ /* -save-temps in object directory */ 270 } save_temps_flag; 271 272 /* Output file to use to get the object directory for -save-temps=obj */ 273 static char *save_temps_prefix = 0; 274 static size_t save_temps_length = 0; 275 276 /* The compiler version. */ 277 278 static const char *compiler_version; 279 280 /* The target version. */ 281 282 static const char *const spec_version = DEFAULT_TARGET_VERSION; 283 284 /* The target machine. */ 285 286 static const char *spec_machine = DEFAULT_TARGET_MACHINE; 287 static const char *spec_host_machine = DEFAULT_REAL_TARGET_MACHINE; 288 289 /* List of offload targets. Separated by colon. Empty string for 290 -foffload=disable. */ 291 292 static char *offload_targets = NULL; 293 294 /* Nonzero if cross-compiling. 295 When -b is used, the value comes from the `specs' file. */ 296 297 #ifdef CROSS_DIRECTORY_STRUCTURE 298 static const char *cross_compile = "1"; 299 #else 300 static const char *cross_compile = "0"; 301 #endif 302 303 /* Greatest exit code of sub-processes that has been encountered up to 304 now. */ 305 static int greatest_status = 1; 306 307 /* This is the obstack which we use to allocate many strings. */ 308 309 static struct obstack obstack; 310 311 /* This is the obstack to build an environment variable to pass to 312 collect2 that describes all of the relevant switches of what to 313 pass the compiler in building the list of pointers to constructors 314 and destructors. */ 315 316 static struct obstack collect_obstack; 317 318 /* Forward declaration for prototypes. */ 319 struct path_prefix; 320 struct prefix_list; 321 322 static void init_spec (void); 323 static void store_arg (const char *, int, int); 324 static void insert_wrapper (const char *); 325 static char *load_specs (const char *); 326 static void read_specs (const char *, bool, bool); 327 static void set_spec (const char *, const char *, bool); 328 static struct compiler *lookup_compiler (const char *, size_t, const char *); 329 static char *build_search_list (const struct path_prefix *, const char *, 330 bool, bool); 331 static void xputenv (const char *); 332 static void putenv_from_prefixes (const struct path_prefix *, const char *, 333 bool); 334 static int access_check (const char *, int); 335 static char *find_a_file (const struct path_prefix *, const char *, int, bool); 336 static void add_prefix (struct path_prefix *, const char *, const char *, 337 int, int, int); 338 static void add_sysrooted_prefix (struct path_prefix *, const char *, 339 const char *, int, int, int); 340 static char *skip_whitespace (char *); 341 static void delete_if_ordinary (const char *); 342 static void delete_temp_files (void); 343 static void delete_failure_queue (void); 344 static void clear_failure_queue (void); 345 static int check_live_switch (int, int); 346 static const char *handle_braces (const char *); 347 static inline bool input_suffix_matches (const char *, const char *); 348 static inline bool switch_matches (const char *, const char *, int); 349 static inline void mark_matching_switches (const char *, const char *, int); 350 static inline void process_marked_switches (void); 351 static const char *process_brace_body (const char *, const char *, const char *, int, int); 352 static const struct spec_function *lookup_spec_function (const char *); 353 static const char *eval_spec_function (const char *, const char *); 354 static const char *handle_spec_function (const char *, bool *); 355 static char *save_string (const char *, int); 356 static void set_collect_gcc_options (void); 357 static int do_spec_1 (const char *, int, const char *); 358 static int do_spec_2 (const char *); 359 static void do_option_spec (const char *, const char *); 360 static void do_self_spec (const char *); 361 static const char *find_file (const char *); 362 static int is_directory (const char *, bool); 363 static const char *validate_switches (const char *, bool); 364 static void validate_all_switches (void); 365 static inline void validate_switches_from_spec (const char *, bool); 366 static void give_switch (int, int); 367 static int default_arg (const char *, int); 368 static void set_multilib_dir (void); 369 static void print_multilib_info (void); 370 static void perror_with_name (const char *); 371 static void display_help (void); 372 static void add_preprocessor_option (const char *, int); 373 static void add_assembler_option (const char *, int); 374 static void add_linker_option (const char *, int); 375 static void process_command (unsigned int, struct cl_decoded_option *); 376 static int execute (void); 377 static void alloc_args (void); 378 static void clear_args (void); 379 static void fatal_signal (int); 380 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC) 381 static void init_gcc_specs (struct obstack *, const char *, const char *, 382 const char *); 383 #endif 384 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 385 static const char *convert_filename (const char *, int, int); 386 #endif 387 388 static void try_generate_repro (const char **argv); 389 static const char *getenv_spec_function (int, const char **); 390 static const char *if_exists_spec_function (int, const char **); 391 static const char *if_exists_else_spec_function (int, const char **); 392 static const char *sanitize_spec_function (int, const char **); 393 static const char *replace_outfile_spec_function (int, const char **); 394 static const char *remove_outfile_spec_function (int, const char **); 395 static const char *version_compare_spec_function (int, const char **); 396 static const char *include_spec_function (int, const char **); 397 static const char *find_file_spec_function (int, const char **); 398 static const char *find_plugindir_spec_function (int, const char **); 399 static const char *print_asm_header_spec_function (int, const char **); 400 static const char *compare_debug_dump_opt_spec_function (int, const char **); 401 static const char *compare_debug_self_opt_spec_function (int, const char **); 402 static const char *compare_debug_auxbase_opt_spec_function (int, const char **); 403 static const char *pass_through_libs_spec_func (int, const char **); 404 static const char *replace_extension_spec_func (int, const char **); 405 static const char *greater_than_spec_func (int, const char **); 406 static const char *debug_level_greater_than_spec_func (int, const char **); 407 static char *convert_white_space (char *); 408 409 /* The Specs Language 410 411 Specs are strings containing lines, each of which (if not blank) 412 is made up of a program name, and arguments separated by spaces. 413 The program name must be exact and start from root, since no path 414 is searched and it is unreliable to depend on the current working directory. 415 Redirection of input or output is not supported; the subprograms must 416 accept filenames saying what files to read and write. 417 418 In addition, the specs can contain %-sequences to substitute variable text 419 or for conditional text. Here is a table of all defined %-sequences. 420 Note that spaces are not generated automatically around the results of 421 expanding these sequences; therefore, you can concatenate them together 422 or with constant text in a single argument. 423 424 %% substitute one % into the program name or argument. 425 %i substitute the name of the input file being processed. 426 %b substitute the basename of the input file being processed. 427 This is the substring up to (and not including) the last period 428 and not including the directory unless -save-temps was specified 429 to put temporaries in a different location. 430 %B same as %b, but include the file suffix (text after the last period). 431 %gSUFFIX 432 substitute a file name that has suffix SUFFIX and is chosen 433 once per compilation, and mark the argument a la %d. To reduce 434 exposure to denial-of-service attacks, the file name is now 435 chosen in a way that is hard to predict even when previously 436 chosen file names are known. For example, `%g.s ... %g.o ... %g.s' 437 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches 438 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it 439 had been pre-processed. Previously, %g was simply substituted 440 with a file name chosen once per compilation, without regard 441 to any appended suffix (which was therefore treated just like 442 ordinary text), making such attacks more likely to succeed. 443 %|SUFFIX 444 like %g, but if -pipe is in effect, expands simply to "-". 445 %mSUFFIX 446 like %g, but if -pipe is in effect, expands to nothing. (We have both 447 %| and %m to accommodate differences between system assemblers; see 448 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.) 449 %uSUFFIX 450 like %g, but generates a new temporary file name even if %uSUFFIX 451 was already seen. 452 %USUFFIX 453 substitutes the last file name generated with %uSUFFIX, generating a 454 new one if there is no such last file name. In the absence of any 455 %uSUFFIX, this is just like %gSUFFIX, except they don't share 456 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s' 457 would involve the generation of two distinct file names, one 458 for each `%g.s' and another for each `%U.s'. Previously, %U was 459 simply substituted with a file name chosen for the previous %u, 460 without regard to any appended suffix. 461 %jSUFFIX 462 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is 463 writable, and if save-temps is off; otherwise, substitute the name 464 of a temporary file, just like %u. This temporary file is not 465 meant for communication between processes, but rather as a junk 466 disposal mechanism. 467 %.SUFFIX 468 substitutes .SUFFIX for the suffixes of a matched switch's args when 469 it is subsequently output with %*. SUFFIX is terminated by the next 470 space or %. 471 %d marks the argument containing or following the %d as a 472 temporary file name, so that file will be deleted if GCC exits 473 successfully. Unlike %g, this contributes no text to the argument. 474 %w marks the argument containing or following the %w as the 475 "output file" of this compilation. This puts the argument 476 into the sequence of arguments that %o will substitute later. 477 %V indicates that this compilation produces no "output file". 478 %W{...} 479 like %{...} but mark last argument supplied within 480 as a file to be deleted on failure. 481 %o substitutes the names of all the output files, with spaces 482 automatically placed around them. You should write spaces 483 around the %o as well or the results are undefined. 484 %o is for use in the specs for running the linker. 485 Input files whose names have no recognized suffix are not compiled 486 at all, but they are included among the output files, so they will 487 be linked. 488 %O substitutes the suffix for object files. Note that this is 489 handled specially when it immediately follows %g, %u, or %U 490 (with or without a suffix argument) because of the need for 491 those to form complete file names. The handling is such that 492 %O is treated exactly as if it had already been substituted, 493 except that %g, %u, and %U do not currently support additional 494 SUFFIX characters following %O as they would following, for 495 example, `.o'. 496 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot 497 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH 498 and -B options) and -imultilib as necessary. 499 %s current argument is the name of a library or startup file of some sort. 500 Search for that file in a standard list of directories 501 and substitute the full name found. 502 %eSTR Print STR as an error message. STR is terminated by a newline. 503 Use this when inconsistent options are detected. 504 %nSTR Print STR as a notice. STR is terminated by a newline. 505 %x{OPTION} Accumulate an option for %X. 506 %X Output the accumulated linker options specified by compilations. 507 %Y Output the accumulated assembler options specified by compilations. 508 %Z Output the accumulated preprocessor options specified by compilations. 509 %a process ASM_SPEC as a spec. 510 This allows config.h to specify part of the spec for running as. 511 %A process ASM_FINAL_SPEC as a spec. A capital A is actually 512 used here. This can be used to run a post-processor after the 513 assembler has done its job. 514 %D Dump out a -L option for each directory in startfile_prefixes. 515 If multilib_dir is set, extra entries are generated with it affixed. 516 %l process LINK_SPEC as a spec. 517 %L process LIB_SPEC as a spec. 518 %M Output multilib_os_dir. 519 %G process LIBGCC_SPEC as a spec. 520 %R Output the concatenation of target_system_root and 521 target_sysroot_suffix. 522 %S process STARTFILE_SPEC as a spec. A capital S is actually used here. 523 %E process ENDFILE_SPEC as a spec. A capital E is actually used here. 524 %C process CPP_SPEC as a spec. 525 %1 process CC1_SPEC as a spec. 526 %2 process CC1PLUS_SPEC as a spec. 527 %* substitute the variable part of a matched option. (See below.) 528 Note that each comma in the substituted string is replaced by 529 a single space. A space is appended after the last substition 530 unless there is more text in current sequence. 531 %<S remove all occurrences of -S from the command line. 532 Note - this command is position dependent. % commands in the 533 spec string before this one will see -S, % commands in the 534 spec string after this one will not. 535 %>S Similar to "%<S", but keep it in the GCC command line. 536 %<S* remove all occurrences of all switches beginning with -S from the 537 command line. 538 %:function(args) 539 Call the named function FUNCTION, passing it ARGS. ARGS is 540 first processed as a nested spec string, then split into an 541 argument vector in the usual fashion. The function returns 542 a string which is processed as if it had appeared literally 543 as part of the current spec. 544 %{S} substitutes the -S switch, if that switch was given to GCC. 545 If that switch was not specified, this substitutes nothing. 546 Here S is a metasyntactic variable. 547 %{S*} substitutes all the switches specified to GCC whose names start 548 with -S. This is used for -o, -I, etc; switches that take 549 arguments. GCC considers `-o foo' as being one switch whose 550 name starts with `o'. %{o*} would substitute this text, 551 including the space; thus, two arguments would be generated. 552 %{S*&T*} likewise, but preserve order of S and T options (the order 553 of S and T in the spec is not significant). Can be any number 554 of ampersand-separated variables; for each the wild card is 555 optional. Useful for CPP as %{D*&U*&A*}. 556 557 %{S:X} substitutes X, if the -S switch was given to GCC. 558 %{!S:X} substitutes X, if the -S switch was NOT given to GCC. 559 %{S*:X} substitutes X if one or more switches whose names start 560 with -S was given to GCC. Normally X is substituted only 561 once, no matter how many such switches appeared. However, 562 if %* appears somewhere in X, then X will be substituted 563 once for each matching switch, with the %* replaced by the 564 part of that switch that matched the '*'. A space will be 565 appended after the last substition unless there is more 566 text in current sequence. 567 %{.S:X} substitutes X, if processing a file with suffix S. 568 %{!.S:X} substitutes X, if NOT processing a file with suffix S. 569 %{,S:X} substitutes X, if processing a file which will use spec S. 570 %{!,S:X} substitutes X, if NOT processing a file which will use spec S. 571 572 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be 573 combined with '!', '.', ',', and '*' as above binding stronger 574 than the OR. 575 If %* appears in X, all of the alternatives must be starred, and 576 only the first matching alternative is substituted. 577 %{%:function(args):X} 578 Call function named FUNCTION with args ARGS. If the function 579 returns non-NULL, then X is substituted, if it returns 580 NULL, it isn't substituted. 581 %{S:X; if S was given to GCC, substitutes X; 582 T:Y; else if T was given to GCC, substitutes Y; 583 :D} else substitutes D. There can be as many clauses as you need. 584 This may be combined with '.', '!', ',', '|', and '*' as above. 585 586 %(Spec) processes a specification defined in a specs file as *Spec: 587 588 The switch matching text S in a %{S}, %{S:X}, or similar construct can use 589 a backslash to ignore the special meaning of the character following it, 590 thus allowing literal matching of a character that is otherwise specially 591 treated. For example, %{std=iso9899\:1999:X} substitutes X if the 592 -std=iso9899:1999 option is given. 593 594 The conditional text X in a %{S:X} or similar construct may contain 595 other nested % constructs or spaces, or even newlines. They are 596 processed as usual, as described above. Trailing white space in X is 597 ignored. White space may also appear anywhere on the left side of the 598 colon in these constructs, except between . or * and the corresponding 599 word. 600 601 The -O, -f, -g, -m, and -W switches are handled specifically in these 602 constructs. If another value of -O or the negated form of a -f, -m, or 603 -W switch is found later in the command line, the earlier switch 604 value is ignored, except with {S*} where S is just one letter; this 605 passes all matching options. 606 607 The character | at the beginning of the predicate text is used to indicate 608 that a command should be piped to the following command, but only if -pipe 609 is specified. 610 611 Note that it is built into GCC which switches take arguments and which 612 do not. You might think it would be useful to generalize this to 613 allow each compiler's spec to say which switches take arguments. But 614 this cannot be done in a consistent fashion. GCC cannot even decide 615 which input files have been specified without knowing which switches 616 take arguments, and it must know which input files to compile in order 617 to tell which compilers to run. 618 619 GCC also knows implicitly that arguments starting in `-l' are to be 620 treated as compiler output files, and passed to the linker in their 621 proper position among the other output files. */ 622 623 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */ 624 625 /* config.h can define ASM_SPEC to provide extra args to the assembler 626 or extra switch-translations. */ 627 #ifndef ASM_SPEC 628 #define ASM_SPEC "" 629 #endif 630 631 /* config.h can define ASM_FINAL_SPEC to run a post processor after 632 the assembler has run. */ 633 #ifndef ASM_FINAL_SPEC 634 #define ASM_FINAL_SPEC \ 635 "%{gsplit-dwarf: \n\ 636 objcopy --extract-dwo \ 637 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \ 638 %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\ 639 objcopy --strip-dwo \ 640 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \ 641 }" 642 #endif 643 644 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor 645 or extra switch-translations. */ 646 #ifndef CPP_SPEC 647 #define CPP_SPEC "" 648 #endif 649 650 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus 651 or extra switch-translations. */ 652 #ifndef CC1_SPEC 653 #define CC1_SPEC "" 654 #endif 655 656 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus 657 or extra switch-translations. */ 658 #ifndef CC1PLUS_SPEC 659 #define CC1PLUS_SPEC "" 660 #endif 661 662 /* config.h can define LINK_SPEC to provide extra args to the linker 663 or extra switch-translations. */ 664 #ifndef LINK_SPEC 665 #define LINK_SPEC "" 666 #endif 667 668 /* config.h can define LIB_SPEC to override the default libraries. */ 669 #ifndef LIB_SPEC 670 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}" 671 #endif 672 673 /* When using -fsplit-stack we need to wrap pthread_create, in order 674 to initialize the stack guard. We always use wrapping, rather than 675 shared library ordering, and we keep the wrapper function in 676 libgcc. This is not yet a real spec, though it could become one; 677 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping 678 only works with GNU ld and gold. */ 679 #ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK 680 #define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}" 681 #else 682 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}" 683 #endif 684 685 #ifndef LIBASAN_SPEC 686 #define STATIC_LIBASAN_LIBS \ 687 " %{static-libasan|static:%:include(libsanitizer.spec)%(link_libasan)}" 688 #ifdef LIBASAN_EARLY_SPEC 689 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS 690 #elif defined(HAVE_LD_STATIC_DYNAMIC) 691 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \ 692 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \ 693 STATIC_LIBASAN_LIBS 694 #else 695 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS 696 #endif 697 #endif 698 699 #ifndef LIBASAN_EARLY_SPEC 700 #define LIBASAN_EARLY_SPEC "" 701 #endif 702 703 #ifndef LIBTSAN_SPEC 704 #define STATIC_LIBTSAN_LIBS \ 705 " %{static-libtsan|static:%:include(libsanitizer.spec)%(link_libtsan)}" 706 #ifdef LIBTSAN_EARLY_SPEC 707 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS 708 #elif defined(HAVE_LD_STATIC_DYNAMIC) 709 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \ 710 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \ 711 STATIC_LIBTSAN_LIBS 712 #else 713 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS 714 #endif 715 #endif 716 717 #ifndef LIBTSAN_EARLY_SPEC 718 #define LIBTSAN_EARLY_SPEC "" 719 #endif 720 721 #ifndef LIBLSAN_SPEC 722 #define STATIC_LIBLSAN_LIBS \ 723 " %{static-liblsan|static:%:include(libsanitizer.spec)%(link_liblsan)}" 724 #ifdef LIBLSAN_EARLY_SPEC 725 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS 726 #elif defined(HAVE_LD_STATIC_DYNAMIC) 727 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \ 728 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \ 729 STATIC_LIBLSAN_LIBS 730 #else 731 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS 732 #endif 733 #endif 734 735 #ifndef LIBLSAN_EARLY_SPEC 736 #define LIBLSAN_EARLY_SPEC "" 737 #endif 738 739 #ifndef LIBUBSAN_SPEC 740 #define STATIC_LIBUBSAN_LIBS \ 741 " %{static-libubsan|static:%:include(libsanitizer.spec)%(link_libubsan)}" 742 #ifdef HAVE_LD_STATIC_DYNAMIC 743 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \ 744 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \ 745 STATIC_LIBUBSAN_LIBS 746 #else 747 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS 748 #endif 749 #endif 750 751 /* Linker options for compressed debug sections. */ 752 #if HAVE_LD_COMPRESS_DEBUG == 0 753 /* No linker support. */ 754 #define LINK_COMPRESS_DEBUG_SPEC \ 755 " %{gz*:%e-gz is not supported in this configuration} " 756 #elif HAVE_LD_COMPRESS_DEBUG == 1 757 /* GNU style on input, GNU ld options. Reject, not useful. */ 758 #define LINK_COMPRESS_DEBUG_SPEC \ 759 " %{gz*:%e-gz is not supported in this configuration} " 760 #elif HAVE_LD_COMPRESS_DEBUG == 2 761 /* GNU style, GNU gold options. */ 762 #define LINK_COMPRESS_DEBUG_SPEC \ 763 " %{gz|gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \ 764 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \ 765 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} " 766 #elif HAVE_LD_COMPRESS_DEBUG == 3 767 /* ELF gABI style. */ 768 #define LINK_COMPRESS_DEBUG_SPEC \ 769 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \ 770 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \ 771 " %{gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib-gnu} " 772 #else 773 #error Unknown value for HAVE_LD_COMPRESS_DEBUG. 774 #endif 775 776 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is 777 included. */ 778 #ifndef LIBGCC_SPEC 779 #if defined(REAL_LIBGCC_SPEC) 780 #define LIBGCC_SPEC REAL_LIBGCC_SPEC 781 #elif defined(LINK_LIBGCC_SPECIAL_1) 782 /* Have gcc do the search for libgcc.a. */ 783 #define LIBGCC_SPEC "libgcc.a%s" 784 #else 785 #define LIBGCC_SPEC "-lgcc" 786 #endif 787 #endif 788 789 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */ 790 #ifndef STARTFILE_SPEC 791 #define STARTFILE_SPEC \ 792 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}" 793 #endif 794 795 /* config.h can define ENDFILE_SPEC to override the default crtn files. */ 796 #ifndef ENDFILE_SPEC 797 #define ENDFILE_SPEC "" 798 #endif 799 800 #ifndef LINKER_NAME 801 #define LINKER_NAME "collect2" 802 #endif 803 804 #ifdef HAVE_AS_DEBUG_PREFIX_MAP 805 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}" 806 #else 807 #define ASM_MAP "" 808 #endif 809 810 /* Assembler options for compressed debug sections. */ 811 #if HAVE_LD_COMPRESS_DEBUG < 2 812 /* Reject if the linker cannot write compressed debug sections. */ 813 #define ASM_COMPRESS_DEBUG_SPEC \ 814 " %{gz*:%e-gz is not supported in this configuration} " 815 #else /* HAVE_LD_COMPRESS_DEBUG >= 2 */ 816 #if HAVE_AS_COMPRESS_DEBUG == 0 817 /* No assembler support. Ignore silently. */ 818 #define ASM_COMPRESS_DEBUG_SPEC \ 819 " %{gz*:} " 820 #elif HAVE_AS_COMPRESS_DEBUG == 1 821 /* GNU style, GNU as options. */ 822 #define ASM_COMPRESS_DEBUG_SPEC \ 823 " %{gz|gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "}" \ 824 " %{gz=none:" AS_NO_COMPRESS_DEBUG_OPTION "}" \ 825 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} " 826 #elif HAVE_AS_COMPRESS_DEBUG == 2 827 /* ELF gABI style. */ 828 #define ASM_COMPRESS_DEBUG_SPEC \ 829 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \ 830 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \ 831 " %{gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "=zlib-gnu} " 832 #else 833 #error Unknown value for HAVE_AS_COMPRESS_DEBUG. 834 #endif 835 #endif /* HAVE_LD_COMPRESS_DEBUG >= 2 */ 836 837 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g' 838 to the assembler. */ 839 #ifndef ASM_DEBUG_SPEC 840 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \ 841 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG) 842 # define ASM_DEBUG_SPEC \ 843 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \ 844 ? "%{%:debug-level-gt(0):" \ 845 "%{gdwarf*:--gdwarf2}%{!gdwarf*:%{g*:--gstabs}}}" ASM_MAP \ 846 : "%{%:debug-level-gt(0):" \ 847 "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP) 848 # else 849 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG) 850 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):--gstabs}}" ASM_MAP 851 # endif 852 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) 853 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):--gdwarf2}}" ASM_MAP 854 # endif 855 # endif 856 #endif 857 #ifndef ASM_DEBUG_SPEC 858 # define ASM_DEBUG_SPEC "" 859 #endif 860 861 /* Here is the spec for running the linker, after compiling all files. */ 862 863 /* This is overridable by the target in case they need to specify the 864 -lgcc and -lc order specially, yet not require them to override all 865 of LINK_COMMAND_SPEC. */ 866 #ifndef LINK_GCC_C_SEQUENCE_SPEC 867 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G" 868 #endif 869 870 #ifndef LINK_SSP_SPEC 871 #ifdef TARGET_LIBC_PROVIDES_SSP 872 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \ 873 "|fstack-protector-strong|fstack-protector-explicit:}" 874 #else 875 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \ 876 "|fstack-protector-strong|fstack-protector-explicit" \ 877 ":-lssp_nonshared -lssp}" 878 #endif 879 #endif 880 881 #ifdef ENABLE_DEFAULT_PIE 882 #define PIE_SPEC "!no-pie" 883 #define NO_FPIE1_SPEC "fno-pie" 884 #define FPIE1_SPEC NO_FPIE1_SPEC ":;" 885 #define NO_FPIE2_SPEC "fno-PIE" 886 #define FPIE2_SPEC NO_FPIE2_SPEC ":;" 887 #define NO_FPIE_SPEC NO_FPIE1_SPEC "|" NO_FPIE2_SPEC 888 #define FPIE_SPEC NO_FPIE_SPEC ":;" 889 #define NO_FPIC1_SPEC "fno-pic" 890 #define FPIC1_SPEC NO_FPIC1_SPEC ":;" 891 #define NO_FPIC2_SPEC "fno-PIC" 892 #define FPIC2_SPEC NO_FPIC2_SPEC ":;" 893 #define NO_FPIC_SPEC NO_FPIC1_SPEC "|" NO_FPIC2_SPEC 894 #define FPIC_SPEC NO_FPIC_SPEC ":;" 895 #define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC 896 #define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;" 897 #define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC 898 #define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;" 899 #define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "|" NO_FPIC_SPEC 900 #define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;" 901 #else 902 #define PIE_SPEC "pie" 903 #define FPIE1_SPEC "fpie" 904 #define NO_FPIE1_SPEC FPIE1_SPEC ":;" 905 #define FPIE2_SPEC "fPIE" 906 #define NO_FPIE2_SPEC FPIE2_SPEC ":;" 907 #define FPIE_SPEC FPIE1_SPEC "|" FPIE2_SPEC 908 #define NO_FPIE_SPEC FPIE_SPEC ":;" 909 #define FPIC1_SPEC "fpic" 910 #define NO_FPIC1_SPEC FPIC1_SPEC ":;" 911 #define FPIC2_SPEC "fPIC" 912 #define NO_FPIC2_SPEC FPIC2_SPEC ":;" 913 #define FPIC_SPEC FPIC1_SPEC "|" FPIC2_SPEC 914 #define NO_FPIC_SPEC FPIC_SPEC ":;" 915 #define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "|" FPIC1_SPEC 916 #define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;" 917 #define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "|" FPIC2_SPEC 918 #define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;" 919 #define FPIE_OR_FPIC_SPEC FPIE_SPEC "|" FPIC_SPEC 920 #define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;" 921 #endif 922 923 #ifndef LINK_PIE_SPEC 924 #ifdef HAVE_LD_PIE 925 #ifndef LD_PIE_SPEC 926 #define LD_PIE_SPEC "-pie" 927 #endif 928 #else 929 #define LD_PIE_SPEC "" 930 #endif 931 #define LINK_PIE_SPEC "%{static|shared|r:;" PIE_SPEC ":" LD_PIE_SPEC "} " 932 #endif 933 934 #ifndef LINK_BUILDID_SPEC 935 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID) 936 # define LINK_BUILDID_SPEC "%{!r:--build-id} " 937 # endif 938 #endif 939 940 /* Conditional to test whether the LTO plugin is used or not. 941 FIXME: For slim LTO we will need to enable plugin unconditionally. This 942 still cause problems with PLUGIN_LD != LD and when plugin is built but 943 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable 944 plugin only when LTO is enabled. We still honor explicit 945 -fuse-linker-plugin if the linker used understands -plugin. */ 946 947 /* The linker has some plugin support. */ 948 #if HAVE_LTO_PLUGIN > 0 949 /* The linker used has full plugin support, use LTO plugin by default. */ 950 #if HAVE_LTO_PLUGIN == 2 951 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto" 952 #define PLUGIN_COND_CLOSE "}" 953 #else 954 /* The linker used has limited plugin support, use LTO plugin with explicit 955 -fuse-linker-plugin. */ 956 #define PLUGIN_COND "fuse-linker-plugin" 957 #define PLUGIN_COND_CLOSE "" 958 #endif 959 #define LINK_PLUGIN_SPEC \ 960 "%{" PLUGIN_COND": \ 961 -plugin %(linker_plugin_file) \ 962 -plugin-opt=%(lto_wrapper) \ 963 -plugin-opt=-fresolution=%u.res \ 964 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \ 965 }" PLUGIN_COND_CLOSE 966 #else 967 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */ 968 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\ 969 %e-fuse-linker-plugin is not supported in this configuration}" 970 #endif 971 972 /* Linker command line options for -fsanitize= early on the command line. */ 973 #ifndef SANITIZER_EARLY_SPEC 974 #define SANITIZER_EARLY_SPEC "\ 975 %{!shared:%{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \ 976 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \ 977 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}}" 978 #endif 979 980 /* Linker command line options for -fsanitize= late on the command line. */ 981 #ifndef SANITIZER_SPEC 982 #define SANITIZER_SPEC "\ 983 %{!shared:%{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\ 984 %{static:%ecannot specify -static with -fsanitize=address}}\ 985 %{%:sanitize(thread):" LIBTSAN_SPEC "\ 986 %{static:%ecannot specify -static with -fsanitize=thread}}\ 987 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\ 988 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}}" 989 #endif 990 991 #ifndef POST_LINK_SPEC 992 #define POST_LINK_SPEC "" 993 #endif 994 995 /* This is the spec to use, once the code for creating the vtable 996 verification runtime library, libvtv.so, has been created. Currently 997 the vtable verification runtime functions are in libstdc++, so we use 998 the spec just below this one. */ 999 #ifndef VTABLE_VERIFICATION_SPEC 1000 #if ENABLE_VTABLE_VERIFY 1001 #define VTABLE_VERIFICATION_SPEC "\ 1002 %{!nostdlib:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\ 1003 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}" 1004 #else 1005 #define VTABLE_VERIFICATION_SPEC "\ 1006 %{fvtable-verify=none:} \ 1007 %{fvtable-verify=std: \ 1008 %e-fvtable-verify=std is not supported in this configuration} \ 1009 %{fvtable-verify=preinit: \ 1010 %e-fvtable-verify=preinit is not supported in this configuration}" 1011 #endif 1012 #endif 1013 1014 #ifndef CHKP_SPEC 1015 #define CHKP_SPEC "" 1016 #endif 1017 1018 /* -u* was put back because both BSD and SysV seem to support it. */ 1019 /* %{static|no-pie|static-pie:} simply prevents an error message: 1020 1. If the target machine doesn't handle -static. 1021 2. If PIE isn't enabled by default. 1022 3. If the target machine doesn't handle -static-pie. 1023 */ 1024 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker 1025 scripts which exist in user specified directories, or in standard 1026 directories. */ 1027 /* We pass any -flto flags on to the linker, which is expected 1028 to understand them. In practice, this means it had better be collect2. */ 1029 /* %{e*} includes -export-dynamic; see comment in common.opt. */ 1030 #ifndef LINK_COMMAND_SPEC 1031 #define LINK_COMMAND_SPEC "\ 1032 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\ 1033 %(linker) " \ 1034 LINK_PLUGIN_SPEC \ 1035 "%{flto|flto=*:%<fcompare-debug*} \ 1036 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \ 1037 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \ 1038 "%X %{o*} %{e*} %{N} %{n} %{r}\ 1039 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}} \ 1040 %{static|no-pie|static-pie:} %{L*} %(mfwrap) %(link_libgcc) " \ 1041 VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o " CHKP_SPEC " \ 1042 %{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1):\ 1043 %:include(libgomp.spec)%(link_gomp)}\ 1044 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\ 1045 %(mflib) " STACK_SPLIT_SPEC "\ 1046 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \ 1047 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\ 1048 %{!nostdlib:%{!nostartfiles:%E}} %{T*} \n%(post_link) }}}}}}" 1049 #endif 1050 1051 #ifndef LINK_LIBGCC_SPEC 1052 /* Generate -L options for startfile prefix list. */ 1053 # define LINK_LIBGCC_SPEC "%D" 1054 #endif 1055 1056 #ifndef STARTFILE_PREFIX_SPEC 1057 # define STARTFILE_PREFIX_SPEC "" 1058 #endif 1059 1060 #ifndef SYSROOT_SPEC 1061 # define SYSROOT_SPEC "--sysroot=%R" 1062 #endif 1063 1064 #ifndef SYSROOT_SUFFIX_SPEC 1065 # define SYSROOT_SUFFIX_SPEC "" 1066 #endif 1067 1068 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC 1069 # define SYSROOT_HEADERS_SUFFIX_SPEC "" 1070 #endif 1071 1072 static const char *asm_debug = ASM_DEBUG_SPEC; 1073 static const char *cpp_spec = CPP_SPEC; 1074 static const char *cc1_spec = CC1_SPEC; 1075 static const char *cc1plus_spec = CC1PLUS_SPEC; 1076 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC; 1077 static const char *link_ssp_spec = LINK_SSP_SPEC; 1078 static const char *asm_spec = ASM_SPEC; 1079 static const char *asm_final_spec = ASM_FINAL_SPEC; 1080 static const char *link_spec = LINK_SPEC; 1081 static const char *lib_spec = LIB_SPEC; 1082 static const char *link_gomp_spec = ""; 1083 static const char *libgcc_spec = LIBGCC_SPEC; 1084 static const char *endfile_spec = ENDFILE_SPEC; 1085 static const char *startfile_spec = STARTFILE_SPEC; 1086 static const char *linker_name_spec = LINKER_NAME; 1087 static const char *linker_plugin_file_spec = ""; 1088 static const char *lto_wrapper_spec = ""; 1089 static const char *lto_gcc_spec = ""; 1090 static const char *post_link_spec = POST_LINK_SPEC; 1091 static const char *link_command_spec = LINK_COMMAND_SPEC; 1092 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC; 1093 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC; 1094 static const char *sysroot_spec = SYSROOT_SPEC; 1095 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC; 1096 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC; 1097 static const char *self_spec = ""; 1098 1099 /* Standard options to cpp, cc1, and as, to reduce duplication in specs. 1100 There should be no need to override these in target dependent files, 1101 but we need to copy them to the specs file so that newer versions 1102 of the GCC driver can correctly drive older tool chains with the 1103 appropriate -B options. */ 1104 1105 /* When cpplib handles traditional preprocessing, get rid of this, and 1106 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so 1107 that we default the front end language better. */ 1108 static const char *trad_capable_cpp = 1109 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}"; 1110 1111 /* We don't wrap .d files in %W{} since a missing .d file, and 1112 therefore no dependency entry, confuses make into thinking a .o 1113 file that happens to exist is up-to-date. */ 1114 static const char *cpp_unique_options = 1115 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\ 1116 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\ 1117 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\ 1118 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\ 1119 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\ 1120 %{remap} %{g3|ggdb3|gstabs3|gxcoff3|gvms3:-dD}\ 1121 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\ 1122 %{H} %C %{D*&U*&A*} %{i*} %Z %i\ 1123 %{E|M|MM:%W{o*}}"; 1124 1125 /* This contains cpp options which are common with cc1_options and are passed 1126 only when preprocessing only to avoid duplication. We pass the cc1 spec 1127 options to the preprocessor so that it the cc1 spec may manipulate 1128 options used to set target flags. Those special target flags settings may 1129 in turn cause preprocessor symbols to be defined specially. */ 1130 static const char *cpp_options = 1131 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\ 1132 %{f*} %{g*:%{%:debug-level-gt(0):%{g*}\ 1133 %{!fno-working-directory:-fworking-directory}}} %{O*}\ 1134 %{undef} %{save-temps*:-fpch-preprocess}"; 1135 1136 /* This contains cpp options which are not passed when the preprocessor 1137 output will be used by another program. */ 1138 static const char *cpp_debug_options = "%{d*}"; 1139 1140 /* NB: This is shared amongst all front-ends, except for Ada. */ 1141 static const char *cc1_options = 1142 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\ 1143 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\ 1144 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\ 1145 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \ 1146 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \ 1147 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\ 1148 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\ 1149 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\ 1150 %{-target-help:--target-help}\ 1151 %{-version:--version}\ 1152 %{-help=*:--help=%*}\ 1153 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\ 1154 %{fsyntax-only:-o %j} %{-param*}\ 1155 %{coverage:-fprofile-arcs -ftest-coverage}\ 1156 %{fprofile-arcs|fprofile-generate*|coverage:\ 1157 %{!fprofile-update=single:\ 1158 %{pthread:-fprofile-update=prefer-atomic}}}"; 1159 1160 static const char *asm_options = 1161 "%{-target-help:%:print-asm-header()} " 1162 #if HAVE_GNU_AS 1163 /* If GNU AS is used, then convert -w (no warnings), -I, and -v 1164 to the assembler equivalents. */ 1165 "%{v} %{w:-W} %{I*} " 1166 #endif 1167 ASM_COMPRESS_DEBUG_SPEC 1168 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}"; 1169 1170 static const char *invoke_as = 1171 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT 1172 "%{!fwpa*:\ 1173 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\ 1174 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\ 1175 }"; 1176 #else 1177 "%{!fwpa*:\ 1178 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\ 1179 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\ 1180 }"; 1181 #endif 1182 1183 /* Some compilers have limits on line lengths, and the multilib_select 1184 and/or multilib_matches strings can be very long, so we build them at 1185 run time. */ 1186 static struct obstack multilib_obstack; 1187 static const char *multilib_select; 1188 static const char *multilib_matches; 1189 static const char *multilib_defaults; 1190 static const char *multilib_exclusions; 1191 static const char *multilib_reuse; 1192 1193 /* Check whether a particular argument is a default argument. */ 1194 1195 #ifndef MULTILIB_DEFAULTS 1196 #define MULTILIB_DEFAULTS { "" } 1197 #endif 1198 1199 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS; 1200 1201 #ifndef DRIVER_SELF_SPECS 1202 #define DRIVER_SELF_SPECS "" 1203 #endif 1204 1205 /* Linking to libgomp implies pthreads. This is particularly important 1206 for targets that use different start files and suchlike. */ 1207 #ifndef GOMP_SELF_SPECS 1208 #define GOMP_SELF_SPECS \ 1209 "%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1): " \ 1210 "-pthread}" 1211 #endif 1212 1213 /* Likewise for -fgnu-tm. */ 1214 #ifndef GTM_SELF_SPECS 1215 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}" 1216 #endif 1217 1218 static const char *const driver_self_specs[] = { 1219 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns", 1220 DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS, GTM_SELF_SPECS 1221 }; 1222 1223 #ifndef OPTION_DEFAULT_SPECS 1224 #define OPTION_DEFAULT_SPECS { "", "" } 1225 #endif 1226 1227 struct default_spec 1228 { 1229 const char *name; 1230 const char *spec; 1231 }; 1232 1233 static const struct default_spec 1234 option_default_specs[] = { OPTION_DEFAULT_SPECS }; 1235 1236 struct user_specs 1237 { 1238 struct user_specs *next; 1239 const char *filename; 1240 }; 1241 1242 static struct user_specs *user_specs_head, *user_specs_tail; 1243 1244 1245 /* Record the mapping from file suffixes for compilation specs. */ 1246 1247 struct compiler 1248 { 1249 const char *suffix; /* Use this compiler for input files 1250 whose names end in this suffix. */ 1251 1252 const char *spec; /* To use this compiler, run this spec. */ 1253 1254 const char *cpp_spec; /* If non-NULL, substitute this spec 1255 for `%C', rather than the usual 1256 cpp_spec. */ 1257 int combinable; /* If nonzero, compiler can deal with 1258 multiple source files at once (IMA). */ 1259 int needs_preprocessing; /* If nonzero, source files need to 1260 be run through a preprocessor. */ 1261 }; 1262 1263 /* Pointer to a vector of `struct compiler' that gives the spec for 1264 compiling a file, based on its suffix. 1265 A file that does not end in any of these suffixes will be passed 1266 unchanged to the loader and nothing else will be done to it. 1267 1268 An entry containing two 0s is used to terminate the vector. 1269 1270 If multiple entries match a file, the last matching one is used. */ 1271 1272 static struct compiler *compilers; 1273 1274 /* Number of entries in `compilers', not counting the null terminator. */ 1275 1276 static int n_compilers; 1277 1278 /* The default list of file name suffixes and their compilation specs. */ 1279 1280 static const struct compiler default_compilers[] = 1281 { 1282 /* Add lists of suffixes of known languages here. If those languages 1283 were not present when we built the driver, we will hit these copies 1284 and be given a more meaningful error than "file not used since 1285 linking is not done". */ 1286 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0}, 1287 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0}, 1288 {".mii", "#Objective-C++", 0, 0, 0}, 1289 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0}, 1290 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0}, 1291 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0}, 1292 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0}, 1293 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0}, 1294 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0}, 1295 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0}, 1296 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0}, 1297 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0}, 1298 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0}, 1299 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0}, 1300 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0}, 1301 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0}, 1302 {".r", "#Ratfor", 0, 0, 0}, 1303 {".go", "#Go", 0, 1, 0}, 1304 /* Next come the entries for C. */ 1305 {".c", "@c", 0, 0, 1}, 1306 {"@c", 1307 /* cc1 has an integrated ISO C preprocessor. We should invoke the 1308 external preprocessor if -save-temps is given. */ 1309 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\ 1310 %{!E:%{!M:%{!MM:\ 1311 %{traditional:\ 1312 %eGNU C no longer supports -traditional without -E}\ 1313 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \ 1314 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\ 1315 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \ 1316 %(cc1_options)}\ 1317 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\ 1318 cc1 %(cpp_unique_options) %(cc1_options)}}}\ 1319 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1}, 1320 {"-", 1321 "%{!E:%e-E or -x required when input is from standard input}\ 1322 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0}, 1323 {".h", "@c-header", 0, 0, 0}, 1324 {"@c-header", 1325 /* cc1 has an integrated ISO C preprocessor. We should invoke the 1326 external preprocessor if -save-temps is given. */ 1327 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\ 1328 %{!E:%{!M:%{!MM:\ 1329 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \ 1330 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\ 1331 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \ 1332 %(cc1_options)\ 1333 %{!fsyntax-only:%{!S:-o %g.s} \ 1334 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\ 1335 %W{o*:--output-pch=%*}}%V}}\ 1336 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\ 1337 cc1 %(cpp_unique_options) %(cc1_options)\ 1338 %{!fsyntax-only:%{!S:-o %g.s} \ 1339 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\ 1340 %W{o*:--output-pch=%*}}%V}}}}}}}", 0, 0, 0}, 1341 {".i", "@cpp-output", 0, 0, 0}, 1342 {"@cpp-output", 1343 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0}, 1344 {".s", "@assembler", 0, 0, 0}, 1345 {"@assembler", 1346 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0}, 1347 {".sx", "@assembler-with-cpp", 0, 0, 0}, 1348 {".S", "@assembler-with-cpp", 0, 0, 0}, 1349 {"@assembler-with-cpp", 1350 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT 1351 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\ 1352 %{E|M|MM:%(cpp_debug_options)}\ 1353 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\ 1354 as %(asm_debug) %(asm_options) %|.s %A }}}}" 1355 #else 1356 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\ 1357 %{E|M|MM:%(cpp_debug_options)}\ 1358 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\ 1359 as %(asm_debug) %(asm_options) %m.s %A }}}}" 1360 #endif 1361 , 0, 0, 0}, 1362 1363 #include "specs.h" 1364 /* Mark end of table. */ 1365 {0, 0, 0, 0, 0} 1366 }; 1367 1368 /* Number of elements in default_compilers, not counting the terminator. */ 1369 1370 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1; 1371 1372 typedef char *char_p; /* For DEF_VEC_P. */ 1373 1374 /* A vector of options to give to the linker. 1375 These options are accumulated by %x, 1376 and substituted into the linker command with %X. */ 1377 static vec<char_p> linker_options; 1378 1379 /* A vector of options to give to the assembler. 1380 These options are accumulated by -Wa, 1381 and substituted into the assembler command with %Y. */ 1382 static vec<char_p> assembler_options; 1383 1384 /* A vector of options to give to the preprocessor. 1385 These options are accumulated by -Wp, 1386 and substituted into the preprocessor command with %Z. */ 1387 static vec<char_p> preprocessor_options; 1388 1389 static char * 1390 skip_whitespace (char *p) 1391 { 1392 while (1) 1393 { 1394 /* A fully-blank line is a delimiter in the SPEC file and shouldn't 1395 be considered whitespace. */ 1396 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n') 1397 return p + 1; 1398 else if (*p == '\n' || *p == ' ' || *p == '\t') 1399 p++; 1400 else if (*p == '#') 1401 { 1402 while (*p != '\n') 1403 p++; 1404 p++; 1405 } 1406 else 1407 break; 1408 } 1409 1410 return p; 1411 } 1412 /* Structures to keep track of prefixes to try when looking for files. */ 1413 1414 struct prefix_list 1415 { 1416 const char *prefix; /* String to prepend to the path. */ 1417 struct prefix_list *next; /* Next in linked list. */ 1418 int require_machine_suffix; /* Don't use without machine_suffix. */ 1419 /* 2 means try both machine_suffix and just_machine_suffix. */ 1420 int priority; /* Sort key - priority within list. */ 1421 int os_multilib; /* 1 if OS multilib scheme should be used, 1422 0 for GCC multilib scheme. */ 1423 }; 1424 1425 struct path_prefix 1426 { 1427 struct prefix_list *plist; /* List of prefixes to try */ 1428 int max_len; /* Max length of a prefix in PLIST */ 1429 const char *name; /* Name of this list (used in config stuff) */ 1430 }; 1431 1432 /* List of prefixes to try when looking for executables. */ 1433 1434 static struct path_prefix exec_prefixes = { 0, 0, "exec" }; 1435 1436 /* List of prefixes to try when looking for startup (crt0) files. */ 1437 1438 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" }; 1439 1440 /* List of prefixes to try when looking for include files. */ 1441 1442 static struct path_prefix include_prefixes = { 0, 0, "include" }; 1443 1444 /* Suffix to attach to directories searched for commands. 1445 This looks like `MACHINE/VERSION/'. */ 1446 1447 static const char *machine_suffix = 0; 1448 1449 /* Suffix to attach to directories searched for commands. 1450 This is just `MACHINE/'. */ 1451 1452 static const char *just_machine_suffix = 0; 1453 1454 /* Adjusted value of GCC_EXEC_PREFIX envvar. */ 1455 1456 static const char *gcc_exec_prefix; 1457 1458 /* Adjusted value of standard_libexec_prefix. */ 1459 1460 static const char *gcc_libexec_prefix; 1461 1462 /* Default prefixes to attach to command names. */ 1463 1464 #ifndef STANDARD_STARTFILE_PREFIX_1 1465 #define STANDARD_STARTFILE_PREFIX_1 "/lib/" 1466 #endif 1467 #ifndef STANDARD_STARTFILE_PREFIX_2 1468 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/" 1469 #endif 1470 1471 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */ 1472 #undef MD_EXEC_PREFIX 1473 #undef MD_STARTFILE_PREFIX 1474 #undef MD_STARTFILE_PREFIX_1 1475 #endif 1476 1477 /* If no prefixes defined, use the null string, which will disable them. */ 1478 #ifndef MD_EXEC_PREFIX 1479 #define MD_EXEC_PREFIX "" 1480 #endif 1481 #ifndef MD_STARTFILE_PREFIX 1482 #define MD_STARTFILE_PREFIX "" 1483 #endif 1484 #ifndef MD_STARTFILE_PREFIX_1 1485 #define MD_STARTFILE_PREFIX_1 "" 1486 #endif 1487 1488 /* These directories are locations set at configure-time based on the 1489 --prefix option provided to configure. Their initializers are 1490 defined in Makefile.in. These paths are not *directly* used when 1491 gcc_exec_prefix is set because, in that case, we know where the 1492 compiler has been installed, and use paths relative to that 1493 location instead. */ 1494 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX; 1495 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX; 1496 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX; 1497 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX; 1498 1499 /* For native compilers, these are well-known paths containing 1500 components that may be provided by the system. For cross 1501 compilers, these paths are not used. */ 1502 static const char *md_exec_prefix = MD_EXEC_PREFIX; 1503 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX; 1504 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1; 1505 static const char *const standard_startfile_prefix_1 1506 = STANDARD_STARTFILE_PREFIX_1; 1507 static const char *const standard_startfile_prefix_2 1508 = STANDARD_STARTFILE_PREFIX_2; 1509 1510 /* A relative path to be used in finding the location of tools 1511 relative to the driver. */ 1512 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX; 1513 1514 /* A prefix to be used when this is an accelerator compiler. */ 1515 static const char *const accel_dir_suffix = ACCEL_DIR_SUFFIX; 1516 1517 /* Subdirectory to use for locating libraries. Set by 1518 set_multilib_dir based on the compilation options. */ 1519 1520 static const char *multilib_dir; 1521 1522 /* Subdirectory to use for locating libraries in OS conventions. Set by 1523 set_multilib_dir based on the compilation options. */ 1524 1525 static const char *multilib_os_dir; 1526 1527 /* Subdirectory to use for locating libraries in multiarch conventions. Set by 1528 set_multilib_dir based on the compilation options. */ 1529 1530 static const char *multiarch_dir; 1531 1532 /* Structure to keep track of the specs that have been defined so far. 1533 These are accessed using %(specname) in a compiler or link 1534 spec. */ 1535 1536 struct spec_list 1537 { 1538 /* The following 2 fields must be first */ 1539 /* to allow EXTRA_SPECS to be initialized */ 1540 const char *name; /* name of the spec. */ 1541 const char *ptr; /* available ptr if no static pointer */ 1542 1543 /* The following fields are not initialized */ 1544 /* by EXTRA_SPECS */ 1545 const char **ptr_spec; /* pointer to the spec itself. */ 1546 struct spec_list *next; /* Next spec in linked list. */ 1547 int name_len; /* length of the name */ 1548 bool user_p; /* whether string come from file spec. */ 1549 bool alloc_p; /* whether string was allocated */ 1550 const char *default_ptr; /* The default value of *ptr_spec. */ 1551 }; 1552 1553 #define INIT_STATIC_SPEC(NAME,PTR) \ 1554 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \ 1555 *PTR } 1556 1557 /* List of statically defined specs. */ 1558 static struct spec_list static_specs[] = 1559 { 1560 INIT_STATIC_SPEC ("asm", &asm_spec), 1561 INIT_STATIC_SPEC ("asm_debug", &asm_debug), 1562 INIT_STATIC_SPEC ("asm_final", &asm_final_spec), 1563 INIT_STATIC_SPEC ("asm_options", &asm_options), 1564 INIT_STATIC_SPEC ("invoke_as", &invoke_as), 1565 INIT_STATIC_SPEC ("cpp", &cpp_spec), 1566 INIT_STATIC_SPEC ("cpp_options", &cpp_options), 1567 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options), 1568 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options), 1569 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp), 1570 INIT_STATIC_SPEC ("cc1", &cc1_spec), 1571 INIT_STATIC_SPEC ("cc1_options", &cc1_options), 1572 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec), 1573 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec), 1574 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec), 1575 INIT_STATIC_SPEC ("endfile", &endfile_spec), 1576 INIT_STATIC_SPEC ("link", &link_spec), 1577 INIT_STATIC_SPEC ("lib", &lib_spec), 1578 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec), 1579 INIT_STATIC_SPEC ("libgcc", &libgcc_spec), 1580 INIT_STATIC_SPEC ("startfile", &startfile_spec), 1581 INIT_STATIC_SPEC ("cross_compile", &cross_compile), 1582 INIT_STATIC_SPEC ("version", &compiler_version), 1583 INIT_STATIC_SPEC ("multilib", &multilib_select), 1584 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults), 1585 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra), 1586 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches), 1587 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions), 1588 INIT_STATIC_SPEC ("multilib_options", &multilib_options), 1589 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse), 1590 INIT_STATIC_SPEC ("linker", &linker_name_spec), 1591 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec), 1592 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec), 1593 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec), 1594 INIT_STATIC_SPEC ("post_link", &post_link_spec), 1595 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec), 1596 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix), 1597 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix), 1598 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1), 1599 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec), 1600 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec), 1601 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec), 1602 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec), 1603 INIT_STATIC_SPEC ("self_spec", &self_spec), 1604 }; 1605 1606 #ifdef EXTRA_SPECS /* additional specs needed */ 1607 /* Structure to keep track of just the first two args of a spec_list. 1608 That is all that the EXTRA_SPECS macro gives us. */ 1609 struct spec_list_1 1610 { 1611 const char *const name; 1612 const char *const ptr; 1613 }; 1614 1615 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS }; 1616 static struct spec_list *extra_specs = (struct spec_list *) 0; 1617 #endif 1618 1619 /* List of dynamically allocates specs that have been defined so far. */ 1620 1621 static struct spec_list *specs = (struct spec_list *) 0; 1622 1623 /* List of static spec functions. */ 1624 1625 static const struct spec_function static_spec_functions[] = 1626 { 1627 { "getenv", getenv_spec_function }, 1628 { "if-exists", if_exists_spec_function }, 1629 { "if-exists-else", if_exists_else_spec_function }, 1630 { "sanitize", sanitize_spec_function }, 1631 { "replace-outfile", replace_outfile_spec_function }, 1632 { "remove-outfile", remove_outfile_spec_function }, 1633 { "version-compare", version_compare_spec_function }, 1634 { "include", include_spec_function }, 1635 { "find-file", find_file_spec_function }, 1636 { "find-plugindir", find_plugindir_spec_function }, 1637 { "print-asm-header", print_asm_header_spec_function }, 1638 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function }, 1639 { "compare-debug-self-opt", compare_debug_self_opt_spec_function }, 1640 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function }, 1641 { "pass-through-libs", pass_through_libs_spec_func }, 1642 { "replace-extension", replace_extension_spec_func }, 1643 { "gt", greater_than_spec_func }, 1644 { "debug-level-gt", debug_level_greater_than_spec_func }, 1645 #ifdef EXTRA_SPEC_FUNCTIONS 1646 EXTRA_SPEC_FUNCTIONS 1647 #endif 1648 { 0, 0 } 1649 }; 1650 1651 static int processing_spec_function; 1652 1653 /* Add appropriate libgcc specs to OBSTACK, taking into account 1654 various permutations of -shared-libgcc, -shared, and such. */ 1655 1656 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC) 1657 1658 #ifndef USE_LD_AS_NEEDED 1659 #define USE_LD_AS_NEEDED 0 1660 #endif 1661 1662 static void 1663 init_gcc_specs (struct obstack *obstack, const char *shared_name, 1664 const char *static_name, const char *eh_name) 1665 { 1666 char *buf; 1667 1668 #if USE_LD_AS_NEEDED 1669 buf = concat ("%{static|static-libgcc|static-pie:", static_name, " ", eh_name, "}" 1670 "%{!static:%{!static-libgcc:%{!static-pie:" 1671 "%{!shared-libgcc:", 1672 static_name, " " LD_AS_NEEDED_OPTION " ", 1673 shared_name, " " LD_NO_AS_NEEDED_OPTION 1674 "}" 1675 "%{shared-libgcc:", 1676 shared_name, "%{!shared: ", static_name, "}" 1677 "}}" 1678 #else 1679 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}" 1680 "%{!static:%{!static-libgcc:" 1681 "%{!shared:" 1682 "%{!shared-libgcc:", static_name, " ", eh_name, "}" 1683 "%{shared-libgcc:", shared_name, " ", static_name, "}" 1684 "}" 1685 #ifdef LINK_EH_SPEC 1686 "%{shared:" 1687 "%{shared-libgcc:", shared_name, "}" 1688 "%{!shared-libgcc:", static_name, "}" 1689 "}" 1690 #else 1691 "%{shared:", shared_name, "}" 1692 #endif 1693 #endif 1694 "}}", NULL); 1695 1696 obstack_grow (obstack, buf, strlen (buf)); 1697 free (buf); 1698 } 1699 #endif /* ENABLE_SHARED_LIBGCC */ 1700 1701 /* Initialize the specs lookup routines. */ 1702 1703 static void 1704 init_spec (void) 1705 { 1706 struct spec_list *next = (struct spec_list *) 0; 1707 struct spec_list *sl = (struct spec_list *) 0; 1708 int i; 1709 1710 if (specs) 1711 return; /* Already initialized. */ 1712 1713 if (verbose_flag) 1714 fnotice (stderr, "Using built-in specs.\n"); 1715 1716 #ifdef EXTRA_SPECS 1717 extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1)); 1718 1719 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--) 1720 { 1721 sl = &extra_specs[i]; 1722 sl->name = extra_specs_1[i].name; 1723 sl->ptr = extra_specs_1[i].ptr; 1724 sl->next = next; 1725 sl->name_len = strlen (sl->name); 1726 sl->ptr_spec = &sl->ptr; 1727 gcc_assert (sl->ptr_spec != NULL); 1728 sl->default_ptr = sl->ptr; 1729 next = sl; 1730 } 1731 #endif 1732 1733 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--) 1734 { 1735 sl = &static_specs[i]; 1736 sl->next = next; 1737 next = sl; 1738 } 1739 1740 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC) 1741 /* ??? If neither -shared-libgcc nor --static-libgcc was 1742 seen, then we should be making an educated guess. Some proposed 1743 heuristics for ELF include: 1744 1745 (1) If "-Wl,--export-dynamic", then it's a fair bet that the 1746 program will be doing dynamic loading, which will likely 1747 need the shared libgcc. 1748 1749 (2) If "-ldl", then it's also a fair bet that we're doing 1750 dynamic loading. 1751 1752 (3) For each ET_DYN we're linking against (either through -lfoo 1753 or /some/path/foo.so), check to see whether it or one of 1754 its dependencies depends on a shared libgcc. 1755 1756 (4) If "-shared" 1757 1758 If the runtime is fixed to look for program headers instead 1759 of calling __register_frame_info at all, for each object, 1760 use the shared libgcc if any EH symbol referenced. 1761 1762 If crtstuff is fixed to not invoke __register_frame_info 1763 automatically, for each object, use the shared libgcc if 1764 any non-empty unwind section found. 1765 1766 Doing any of this probably requires invoking an external program to 1767 do the actual object file scanning. */ 1768 { 1769 const char *p = libgcc_spec; 1770 int in_sep = 1; 1771 1772 /* Transform the extant libgcc_spec into one that uses the shared libgcc 1773 when given the proper command line arguments. */ 1774 while (*p) 1775 { 1776 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0) 1777 { 1778 init_gcc_specs (&obstack, 1779 "-lgcc_s" 1780 #ifdef USE_LIBUNWIND_EXCEPTIONS 1781 " -lunwind" 1782 #endif 1783 , 1784 "-lgcc", 1785 "-lgcc_eh" 1786 #ifdef USE_LIBUNWIND_EXCEPTIONS 1787 # ifdef HAVE_LD_STATIC_DYNAMIC 1788 " %{!static:%{!static-pie:" LD_STATIC_OPTION "}} -lunwind" 1789 " %{!static:%{!static-pie:" LD_DYNAMIC_OPTION "}}" 1790 # else 1791 " -lunwind" 1792 # endif 1793 #endif 1794 ); 1795 1796 p += 5; 1797 in_sep = 0; 1798 } 1799 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0) 1800 { 1801 /* Ug. We don't know shared library extensions. Hope that 1802 systems that use this form don't do shared libraries. */ 1803 init_gcc_specs (&obstack, 1804 "-lgcc_s", 1805 "libgcc.a%s", 1806 "libgcc_eh.a%s" 1807 #ifdef USE_LIBUNWIND_EXCEPTIONS 1808 " -lunwind" 1809 #endif 1810 ); 1811 p += 10; 1812 in_sep = 0; 1813 } 1814 else 1815 { 1816 obstack_1grow (&obstack, *p); 1817 in_sep = (*p == ' '); 1818 p += 1; 1819 } 1820 } 1821 1822 obstack_1grow (&obstack, '\0'); 1823 libgcc_spec = XOBFINISH (&obstack, const char *); 1824 } 1825 #endif 1826 #ifdef USE_AS_TRADITIONAL_FORMAT 1827 /* Prepend "--traditional-format" to whatever asm_spec we had before. */ 1828 { 1829 static const char tf[] = "--traditional-format "; 1830 obstack_grow (&obstack, tf, sizeof (tf) - 1); 1831 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec)); 1832 asm_spec = XOBFINISH (&obstack, const char *); 1833 } 1834 #endif 1835 1836 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \ 1837 defined LINKER_HASH_STYLE 1838 # ifdef LINK_BUILDID_SPEC 1839 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */ 1840 obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof (LINK_BUILDID_SPEC) - 1); 1841 # endif 1842 # ifdef LINK_EH_SPEC 1843 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */ 1844 obstack_grow (&obstack, LINK_EH_SPEC, sizeof (LINK_EH_SPEC) - 1); 1845 # endif 1846 # ifdef LINKER_HASH_STYLE 1847 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had 1848 before. */ 1849 { 1850 static const char hash_style[] = "--hash-style="; 1851 obstack_grow (&obstack, hash_style, sizeof (hash_style) - 1); 1852 obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof (LINKER_HASH_STYLE) - 1); 1853 obstack_1grow (&obstack, ' '); 1854 } 1855 # endif 1856 obstack_grow0 (&obstack, link_spec, strlen (link_spec)); 1857 link_spec = XOBFINISH (&obstack, const char *); 1858 #endif 1859 1860 specs = sl; 1861 } 1862 1863 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is 1864 removed; If the spec starts with a + then SPEC is added to the end of the 1865 current spec. */ 1866 1867 static void 1868 set_spec (const char *name, const char *spec, bool user_p) 1869 { 1870 struct spec_list *sl; 1871 const char *old_spec; 1872 int name_len = strlen (name); 1873 int i; 1874 1875 /* If this is the first call, initialize the statically allocated specs. */ 1876 if (!specs) 1877 { 1878 struct spec_list *next = (struct spec_list *) 0; 1879 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--) 1880 { 1881 sl = &static_specs[i]; 1882 sl->next = next; 1883 next = sl; 1884 } 1885 specs = sl; 1886 } 1887 1888 /* See if the spec already exists. */ 1889 for (sl = specs; sl; sl = sl->next) 1890 if (name_len == sl->name_len && !strcmp (sl->name, name)) 1891 break; 1892 1893 if (!sl) 1894 { 1895 /* Not found - make it. */ 1896 sl = XNEW (struct spec_list); 1897 sl->name = xstrdup (name); 1898 sl->name_len = name_len; 1899 sl->ptr_spec = &sl->ptr; 1900 sl->alloc_p = 0; 1901 *(sl->ptr_spec) = ""; 1902 sl->next = specs; 1903 sl->default_ptr = NULL; 1904 specs = sl; 1905 } 1906 1907 old_spec = *(sl->ptr_spec); 1908 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1])) 1909 ? concat (old_spec, spec + 1, NULL) 1910 : xstrdup (spec)); 1911 1912 #ifdef DEBUG_SPECS 1913 if (verbose_flag) 1914 fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec)); 1915 #endif 1916 1917 /* Free the old spec. */ 1918 if (old_spec && sl->alloc_p) 1919 free (CONST_CAST (char *, old_spec)); 1920 1921 sl->user_p = user_p; 1922 sl->alloc_p = true; 1923 } 1924 1925 /* Accumulate a command (program name and args), and run it. */ 1926 1927 typedef const char *const_char_p; /* For DEF_VEC_P. */ 1928 1929 /* Vector of pointers to arguments in the current line of specifications. */ 1930 1931 static vec<const_char_p> argbuf; 1932 1933 /* Were the options -c, -S or -E passed. */ 1934 static int have_c = 0; 1935 1936 /* Was the option -o passed. */ 1937 static int have_o = 0; 1938 1939 /* Was the option -E passed. */ 1940 static int have_E = 0; 1941 1942 /* Pointer to output file name passed in with -o. */ 1943 static const char *output_file = 0; 1944 1945 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated 1946 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for 1947 it here. */ 1948 1949 static struct temp_name { 1950 const char *suffix; /* suffix associated with the code. */ 1951 int length; /* strlen (suffix). */ 1952 int unique; /* Indicates whether %g or %u/%U was used. */ 1953 const char *filename; /* associated filename. */ 1954 int filename_length; /* strlen (filename). */ 1955 struct temp_name *next; 1956 } *temp_names; 1957 1958 /* Number of commands executed so far. */ 1959 1960 static int execution_count; 1961 1962 /* Number of commands that exited with a signal. */ 1963 1964 static int signal_count; 1965 1966 /* Allocate the argument vector. */ 1967 1968 static void 1969 alloc_args (void) 1970 { 1971 argbuf.create (10); 1972 } 1973 1974 /* Clear out the vector of arguments (after a command is executed). */ 1975 1976 static void 1977 clear_args (void) 1978 { 1979 argbuf.truncate (0); 1980 } 1981 1982 /* Add one argument to the vector at the end. 1983 This is done when a space is seen or at the end of the line. 1984 If DELETE_ALWAYS is nonzero, the arg is a filename 1985 and the file should be deleted eventually. 1986 If DELETE_FAILURE is nonzero, the arg is a filename 1987 and the file should be deleted if this compilation fails. */ 1988 1989 static void 1990 store_arg (const char *arg, int delete_always, int delete_failure) 1991 { 1992 argbuf.safe_push (arg); 1993 1994 if (delete_always || delete_failure) 1995 { 1996 const char *p; 1997 /* If the temporary file we should delete is specified as 1998 part of a joined argument extract the filename. */ 1999 if (arg[0] == '-' 2000 && (p = strrchr (arg, '='))) 2001 arg = p + 1; 2002 record_temp_file (arg, delete_always, delete_failure); 2003 } 2004 } 2005 2006 /* Load specs from a file name named FILENAME, replacing occurrences of 2007 various different types of line-endings, \r\n, \n\r and just \r, with 2008 a single \n. */ 2009 2010 static char * 2011 load_specs (const char *filename) 2012 { 2013 int desc; 2014 int readlen; 2015 struct stat statbuf; 2016 char *buffer; 2017 char *buffer_p; 2018 char *specs; 2019 char *specs_p; 2020 2021 if (verbose_flag) 2022 fnotice (stderr, "Reading specs from %s\n", filename); 2023 2024 /* Open and stat the file. */ 2025 desc = open (filename, O_RDONLY, 0); 2026 if (desc < 0) 2027 pfatal_with_name (filename); 2028 if (stat (filename, &statbuf) < 0) 2029 pfatal_with_name (filename); 2030 2031 /* Read contents of file into BUFFER. */ 2032 buffer = XNEWVEC (char, statbuf.st_size + 1); 2033 readlen = read (desc, buffer, (unsigned) statbuf.st_size); 2034 if (readlen < 0) 2035 pfatal_with_name (filename); 2036 buffer[readlen] = 0; 2037 close (desc); 2038 2039 specs = XNEWVEC (char, readlen + 1); 2040 specs_p = specs; 2041 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++) 2042 { 2043 int skip = 0; 2044 char c = *buffer_p; 2045 if (c == '\r') 2046 { 2047 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */ 2048 skip = 1; 2049 else if (*(buffer_p + 1) == '\n') /* \r\n */ 2050 skip = 1; 2051 else /* \r */ 2052 c = '\n'; 2053 } 2054 if (! skip) 2055 *specs_p++ = c; 2056 } 2057 *specs_p = '\0'; 2058 2059 free (buffer); 2060 return (specs); 2061 } 2062 2063 /* Read compilation specs from a file named FILENAME, 2064 replacing the default ones. 2065 2066 A suffix which starts with `*' is a definition for 2067 one of the machine-specific sub-specs. The "suffix" should be 2068 *asm, *cc1, *cpp, *link, *startfile, etc. 2069 The corresponding spec is stored in asm_spec, etc., 2070 rather than in the `compilers' vector. 2071 2072 Anything invalid in the file is a fatal error. */ 2073 2074 static void 2075 read_specs (const char *filename, bool main_p, bool user_p) 2076 { 2077 char *buffer; 2078 char *p; 2079 2080 buffer = load_specs (filename); 2081 2082 /* Scan BUFFER for specs, putting them in the vector. */ 2083 p = buffer; 2084 while (1) 2085 { 2086 char *suffix; 2087 char *spec; 2088 char *in, *out, *p1, *p2, *p3; 2089 2090 /* Advance P in BUFFER to the next nonblank nocomment line. */ 2091 p = skip_whitespace (p); 2092 if (*p == 0) 2093 break; 2094 2095 /* Is this a special command that starts with '%'? */ 2096 /* Don't allow this for the main specs file, since it would 2097 encourage people to overwrite it. */ 2098 if (*p == '%' && !main_p) 2099 { 2100 p1 = p; 2101 while (*p && *p != '\n') 2102 p++; 2103 2104 /* Skip '\n'. */ 2105 p++; 2106 2107 if (!strncmp (p1, "%include", sizeof ("%include") - 1) 2108 && (p1[sizeof "%include" - 1] == ' ' 2109 || p1[sizeof "%include" - 1] == '\t')) 2110 { 2111 char *new_filename; 2112 2113 p1 += sizeof ("%include"); 2114 while (*p1 == ' ' || *p1 == '\t') 2115 p1++; 2116 2117 if (*p1++ != '<' || p[-2] != '>') 2118 fatal_error (input_location, 2119 "specs %%include syntax malformed after " 2120 "%ld characters", 2121 (long) (p1 - buffer + 1)); 2122 2123 p[-2] = '\0'; 2124 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true); 2125 read_specs (new_filename ? new_filename : p1, false, user_p); 2126 continue; 2127 } 2128 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1) 2129 && (p1[sizeof "%include_noerr" - 1] == ' ' 2130 || p1[sizeof "%include_noerr" - 1] == '\t')) 2131 { 2132 char *new_filename; 2133 2134 p1 += sizeof "%include_noerr"; 2135 while (*p1 == ' ' || *p1 == '\t') 2136 p1++; 2137 2138 if (*p1++ != '<' || p[-2] != '>') 2139 fatal_error (input_location, 2140 "specs %%include syntax malformed after " 2141 "%ld characters", 2142 (long) (p1 - buffer + 1)); 2143 2144 p[-2] = '\0'; 2145 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true); 2146 if (new_filename) 2147 read_specs (new_filename, false, user_p); 2148 else if (verbose_flag) 2149 fnotice (stderr, "could not find specs file %s\n", p1); 2150 continue; 2151 } 2152 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1) 2153 && (p1[sizeof "%rename" - 1] == ' ' 2154 || p1[sizeof "%rename" - 1] == '\t')) 2155 { 2156 int name_len; 2157 struct spec_list *sl; 2158 struct spec_list *newsl; 2159 2160 /* Get original name. */ 2161 p1 += sizeof "%rename"; 2162 while (*p1 == ' ' || *p1 == '\t') 2163 p1++; 2164 2165 if (! ISALPHA ((unsigned char) *p1)) 2166 fatal_error (input_location, 2167 "specs %%rename syntax malformed after " 2168 "%ld characters", 2169 (long) (p1 - buffer)); 2170 2171 p2 = p1; 2172 while (*p2 && !ISSPACE ((unsigned char) *p2)) 2173 p2++; 2174 2175 if (*p2 != ' ' && *p2 != '\t') 2176 fatal_error (input_location, 2177 "specs %%rename syntax malformed after " 2178 "%ld characters", 2179 (long) (p2 - buffer)); 2180 2181 name_len = p2 - p1; 2182 *p2++ = '\0'; 2183 while (*p2 == ' ' || *p2 == '\t') 2184 p2++; 2185 2186 if (! ISALPHA ((unsigned char) *p2)) 2187 fatal_error (input_location, 2188 "specs %%rename syntax malformed after " 2189 "%ld characters", 2190 (long) (p2 - buffer)); 2191 2192 /* Get new spec name. */ 2193 p3 = p2; 2194 while (*p3 && !ISSPACE ((unsigned char) *p3)) 2195 p3++; 2196 2197 if (p3 != p - 1) 2198 fatal_error (input_location, 2199 "specs %%rename syntax malformed after " 2200 "%ld characters", 2201 (long) (p3 - buffer)); 2202 *p3 = '\0'; 2203 2204 for (sl = specs; sl; sl = sl->next) 2205 if (name_len == sl->name_len && !strcmp (sl->name, p1)) 2206 break; 2207 2208 if (!sl) 2209 fatal_error (input_location, 2210 "specs %s spec was not found to be renamed", p1); 2211 2212 if (strcmp (p1, p2) == 0) 2213 continue; 2214 2215 for (newsl = specs; newsl; newsl = newsl->next) 2216 if (strcmp (newsl->name, p2) == 0) 2217 fatal_error (input_location, 2218 "%s: attempt to rename spec %qs to " 2219 "already defined spec %qs", 2220 filename, p1, p2); 2221 2222 if (verbose_flag) 2223 { 2224 fnotice (stderr, "rename spec %s to %s\n", p1, p2); 2225 #ifdef DEBUG_SPECS 2226 fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec)); 2227 #endif 2228 } 2229 2230 set_spec (p2, *(sl->ptr_spec), user_p); 2231 if (sl->alloc_p) 2232 free (CONST_CAST (char *, *(sl->ptr_spec))); 2233 2234 *(sl->ptr_spec) = ""; 2235 sl->alloc_p = 0; 2236 continue; 2237 } 2238 else 2239 fatal_error (input_location, 2240 "specs unknown %% command after %ld characters", 2241 (long) (p1 - buffer)); 2242 } 2243 2244 /* Find the colon that should end the suffix. */ 2245 p1 = p; 2246 while (*p1 && *p1 != ':' && *p1 != '\n') 2247 p1++; 2248 2249 /* The colon shouldn't be missing. */ 2250 if (*p1 != ':') 2251 fatal_error (input_location, 2252 "specs file malformed after %ld characters", 2253 (long) (p1 - buffer)); 2254 2255 /* Skip back over trailing whitespace. */ 2256 p2 = p1; 2257 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t')) 2258 p2--; 2259 2260 /* Copy the suffix to a string. */ 2261 suffix = save_string (p, p2 - p); 2262 /* Find the next line. */ 2263 p = skip_whitespace (p1 + 1); 2264 if (p[1] == 0) 2265 fatal_error (input_location, 2266 "specs file malformed after %ld characters", 2267 (long) (p - buffer)); 2268 2269 p1 = p; 2270 /* Find next blank line or end of string. */ 2271 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0'))) 2272 p1++; 2273 2274 /* Specs end at the blank line and do not include the newline. */ 2275 spec = save_string (p, p1 - p); 2276 p = p1; 2277 2278 /* Delete backslash-newline sequences from the spec. */ 2279 in = spec; 2280 out = spec; 2281 while (*in != 0) 2282 { 2283 if (in[0] == '\\' && in[1] == '\n') 2284 in += 2; 2285 else if (in[0] == '#') 2286 while (*in && *in != '\n') 2287 in++; 2288 2289 else 2290 *out++ = *in++; 2291 } 2292 *out = 0; 2293 2294 if (suffix[0] == '*') 2295 { 2296 if (! strcmp (suffix, "*link_command")) 2297 link_command_spec = spec; 2298 else 2299 { 2300 set_spec (suffix + 1, spec, user_p); 2301 free (spec); 2302 } 2303 } 2304 else 2305 { 2306 /* Add this pair to the vector. */ 2307 compilers 2308 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2); 2309 2310 compilers[n_compilers].suffix = suffix; 2311 compilers[n_compilers].spec = spec; 2312 n_compilers++; 2313 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]); 2314 } 2315 2316 if (*suffix == 0) 2317 link_command_spec = spec; 2318 } 2319 2320 if (link_command_spec == 0) 2321 fatal_error (input_location, "spec file has no spec for linking"); 2322 2323 XDELETEVEC (buffer); 2324 } 2325 2326 /* Record the names of temporary files we tell compilers to write, 2327 and delete them at the end of the run. */ 2328 2329 /* This is the common prefix we use to make temp file names. 2330 It is chosen once for each run of this program. 2331 It is substituted into a spec by %g or %j. 2332 Thus, all temp file names contain this prefix. 2333 In practice, all temp file names start with this prefix. 2334 2335 This prefix comes from the envvar TMPDIR if it is defined; 2336 otherwise, from the P_tmpdir macro if that is defined; 2337 otherwise, in /usr/tmp or /tmp; 2338 or finally the current directory if all else fails. */ 2339 2340 static const char *temp_filename; 2341 2342 /* Length of the prefix. */ 2343 2344 static int temp_filename_length; 2345 2346 /* Define the list of temporary files to delete. */ 2347 2348 struct temp_file 2349 { 2350 const char *name; 2351 struct temp_file *next; 2352 }; 2353 2354 /* Queue of files to delete on success or failure of compilation. */ 2355 static struct temp_file *always_delete_queue; 2356 /* Queue of files to delete on failure of compilation. */ 2357 static struct temp_file *failure_delete_queue; 2358 2359 /* Record FILENAME as a file to be deleted automatically. 2360 ALWAYS_DELETE nonzero means delete it if all compilation succeeds; 2361 otherwise delete it in any case. 2362 FAIL_DELETE nonzero means delete it if a compilation step fails; 2363 otherwise delete it in any case. */ 2364 2365 void 2366 record_temp_file (const char *filename, int always_delete, int fail_delete) 2367 { 2368 char *const name = xstrdup (filename); 2369 2370 if (always_delete) 2371 { 2372 struct temp_file *temp; 2373 for (temp = always_delete_queue; temp; temp = temp->next) 2374 if (! filename_cmp (name, temp->name)) 2375 { 2376 free (name); 2377 goto already1; 2378 } 2379 2380 temp = XNEW (struct temp_file); 2381 temp->next = always_delete_queue; 2382 temp->name = name; 2383 always_delete_queue = temp; 2384 2385 already1:; 2386 } 2387 2388 if (fail_delete) 2389 { 2390 struct temp_file *temp; 2391 for (temp = failure_delete_queue; temp; temp = temp->next) 2392 if (! filename_cmp (name, temp->name)) 2393 { 2394 free (name); 2395 goto already2; 2396 } 2397 2398 temp = XNEW (struct temp_file); 2399 temp->next = failure_delete_queue; 2400 temp->name = name; 2401 failure_delete_queue = temp; 2402 2403 already2:; 2404 } 2405 } 2406 2407 /* Delete all the temporary files whose names we previously recorded. */ 2408 2409 #ifndef DELETE_IF_ORDINARY 2410 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \ 2411 do \ 2412 { \ 2413 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \ 2414 if (unlink (NAME) < 0) \ 2415 if (VERBOSE_FLAG) \ 2416 perror_with_name (NAME); \ 2417 } while (0) 2418 #endif 2419 2420 static void 2421 delete_if_ordinary (const char *name) 2422 { 2423 struct stat st; 2424 #ifdef DEBUG 2425 int i, c; 2426 2427 printf ("Delete %s? (y or n) ", name); 2428 fflush (stdout); 2429 i = getchar (); 2430 if (i != '\n') 2431 while ((c = getchar ()) != '\n' && c != EOF) 2432 ; 2433 2434 if (i == 'y' || i == 'Y') 2435 #endif /* DEBUG */ 2436 DELETE_IF_ORDINARY (name, st, verbose_flag); 2437 } 2438 2439 static void 2440 delete_temp_files (void) 2441 { 2442 struct temp_file *temp; 2443 2444 for (temp = always_delete_queue; temp; temp = temp->next) 2445 delete_if_ordinary (temp->name); 2446 always_delete_queue = 0; 2447 } 2448 2449 /* Delete all the files to be deleted on error. */ 2450 2451 static void 2452 delete_failure_queue (void) 2453 { 2454 struct temp_file *temp; 2455 2456 for (temp = failure_delete_queue; temp; temp = temp->next) 2457 delete_if_ordinary (temp->name); 2458 } 2459 2460 static void 2461 clear_failure_queue (void) 2462 { 2463 failure_delete_queue = 0; 2464 } 2465 2466 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK 2467 returns non-NULL. 2468 If DO_MULTI is true iterate over the paths twice, first with multilib 2469 suffix then without, otherwise iterate over the paths once without 2470 adding a multilib suffix. When DO_MULTI is true, some attempt is made 2471 to avoid visiting the same path twice, but we could do better. For 2472 instance, /usr/lib/../lib is considered different from /usr/lib. 2473 At least EXTRA_SPACE chars past the end of the path passed to 2474 CALLBACK are available for use by the callback. 2475 CALLBACK_INFO allows extra parameters to be passed to CALLBACK. 2476 2477 Returns the value returned by CALLBACK. */ 2478 2479 static void * 2480 for_each_path (const struct path_prefix *paths, 2481 bool do_multi, 2482 size_t extra_space, 2483 void *(*callback) (char *, void *), 2484 void *callback_info) 2485 { 2486 struct prefix_list *pl; 2487 const char *multi_dir = NULL; 2488 const char *multi_os_dir = NULL; 2489 const char *multiarch_suffix = NULL; 2490 const char *multi_suffix; 2491 const char *just_multi_suffix; 2492 char *path = NULL; 2493 void *ret = NULL; 2494 bool skip_multi_dir = false; 2495 bool skip_multi_os_dir = false; 2496 2497 multi_suffix = machine_suffix; 2498 just_multi_suffix = just_machine_suffix; 2499 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0) 2500 { 2501 multi_dir = concat (multilib_dir, dir_separator_str, NULL); 2502 multi_suffix = concat (multi_suffix, multi_dir, NULL); 2503 just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL); 2504 } 2505 if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0) 2506 multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL); 2507 if (multiarch_dir) 2508 multiarch_suffix = concat (multiarch_dir, dir_separator_str, NULL); 2509 2510 while (1) 2511 { 2512 size_t multi_dir_len = 0; 2513 size_t multi_os_dir_len = 0; 2514 size_t multiarch_len = 0; 2515 size_t suffix_len; 2516 size_t just_suffix_len; 2517 size_t len; 2518 2519 if (multi_dir) 2520 multi_dir_len = strlen (multi_dir); 2521 if (multi_os_dir) 2522 multi_os_dir_len = strlen (multi_os_dir); 2523 if (multiarch_suffix) 2524 multiarch_len = strlen (multiarch_suffix); 2525 suffix_len = strlen (multi_suffix); 2526 just_suffix_len = strlen (just_multi_suffix); 2527 2528 if (path == NULL) 2529 { 2530 len = paths->max_len + extra_space + 1; 2531 len += MAX (MAX (suffix_len, multi_os_dir_len), multiarch_len); 2532 path = XNEWVEC (char, len); 2533 } 2534 2535 for (pl = paths->plist; pl != 0; pl = pl->next) 2536 { 2537 len = strlen (pl->prefix); 2538 memcpy (path, pl->prefix, len); 2539 2540 /* Look first in MACHINE/VERSION subdirectory. */ 2541 if (!skip_multi_dir) 2542 { 2543 memcpy (path + len, multi_suffix, suffix_len + 1); 2544 ret = callback (path, callback_info); 2545 if (ret) 2546 break; 2547 } 2548 2549 /* Some paths are tried with just the machine (ie. target) 2550 subdir. This is used for finding as, ld, etc. */ 2551 if (!skip_multi_dir 2552 && pl->require_machine_suffix == 2) 2553 { 2554 memcpy (path + len, just_multi_suffix, just_suffix_len + 1); 2555 ret = callback (path, callback_info); 2556 if (ret) 2557 break; 2558 } 2559 2560 /* Now try the multiarch path. */ 2561 if (!skip_multi_dir 2562 && !pl->require_machine_suffix && multiarch_dir) 2563 { 2564 memcpy (path + len, multiarch_suffix, multiarch_len + 1); 2565 ret = callback (path, callback_info); 2566 if (ret) 2567 break; 2568 } 2569 2570 /* Now try the base path. */ 2571 if (!pl->require_machine_suffix 2572 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir)) 2573 { 2574 const char *this_multi; 2575 size_t this_multi_len; 2576 2577 if (pl->os_multilib) 2578 { 2579 this_multi = multi_os_dir; 2580 this_multi_len = multi_os_dir_len; 2581 } 2582 else 2583 { 2584 this_multi = multi_dir; 2585 this_multi_len = multi_dir_len; 2586 } 2587 2588 if (this_multi_len) 2589 memcpy (path + len, this_multi, this_multi_len + 1); 2590 else 2591 path[len] = '\0'; 2592 2593 ret = callback (path, callback_info); 2594 if (ret) 2595 break; 2596 } 2597 } 2598 if (pl) 2599 break; 2600 2601 if (multi_dir == NULL && multi_os_dir == NULL) 2602 break; 2603 2604 /* Run through the paths again, this time without multilibs. 2605 Don't repeat any we have already seen. */ 2606 if (multi_dir) 2607 { 2608 free (CONST_CAST (char *, multi_dir)); 2609 multi_dir = NULL; 2610 free (CONST_CAST (char *, multi_suffix)); 2611 multi_suffix = machine_suffix; 2612 free (CONST_CAST (char *, just_multi_suffix)); 2613 just_multi_suffix = just_machine_suffix; 2614 } 2615 else 2616 skip_multi_dir = true; 2617 if (multi_os_dir) 2618 { 2619 free (CONST_CAST (char *, multi_os_dir)); 2620 multi_os_dir = NULL; 2621 } 2622 else 2623 skip_multi_os_dir = true; 2624 } 2625 2626 if (multi_dir) 2627 { 2628 free (CONST_CAST (char *, multi_dir)); 2629 free (CONST_CAST (char *, multi_suffix)); 2630 free (CONST_CAST (char *, just_multi_suffix)); 2631 } 2632 if (multi_os_dir) 2633 free (CONST_CAST (char *, multi_os_dir)); 2634 if (ret != path) 2635 free (path); 2636 return ret; 2637 } 2638 2639 /* Callback for build_search_list. Adds path to obstack being built. */ 2640 2641 struct add_to_obstack_info { 2642 struct obstack *ob; 2643 bool check_dir; 2644 bool first_time; 2645 }; 2646 2647 static void * 2648 add_to_obstack (char *path, void *data) 2649 { 2650 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data; 2651 2652 if (info->check_dir && !is_directory (path, false)) 2653 return NULL; 2654 2655 if (!info->first_time) 2656 obstack_1grow (info->ob, PATH_SEPARATOR); 2657 2658 obstack_grow (info->ob, path, strlen (path)); 2659 2660 info->first_time = false; 2661 return NULL; 2662 } 2663 2664 /* Add or change the value of an environment variable, outputting the 2665 change to standard error if in verbose mode. */ 2666 static void 2667 xputenv (const char *string) 2668 { 2669 env.xput (string); 2670 } 2671 2672 /* Build a list of search directories from PATHS. 2673 PREFIX is a string to prepend to the list. 2674 If CHECK_DIR_P is true we ensure the directory exists. 2675 If DO_MULTI is true, multilib paths are output first, then 2676 non-multilib paths. 2677 This is used mostly by putenv_from_prefixes so we use `collect_obstack'. 2678 It is also used by the --print-search-dirs flag. */ 2679 2680 static char * 2681 build_search_list (const struct path_prefix *paths, const char *prefix, 2682 bool check_dir, bool do_multi) 2683 { 2684 struct add_to_obstack_info info; 2685 2686 info.ob = &collect_obstack; 2687 info.check_dir = check_dir; 2688 info.first_time = true; 2689 2690 obstack_grow (&collect_obstack, prefix, strlen (prefix)); 2691 obstack_1grow (&collect_obstack, '='); 2692 2693 for_each_path (paths, do_multi, 0, add_to_obstack, &info); 2694 2695 obstack_1grow (&collect_obstack, '\0'); 2696 return XOBFINISH (&collect_obstack, char *); 2697 } 2698 2699 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables 2700 for collect. */ 2701 2702 static void 2703 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var, 2704 bool do_multi) 2705 { 2706 xputenv (build_search_list (paths, env_var, true, do_multi)); 2707 } 2708 2709 /* Check whether NAME can be accessed in MODE. This is like access, 2710 except that it never considers directories to be executable. */ 2711 2712 static int 2713 access_check (const char *name, int mode) 2714 { 2715 if (mode == X_OK) 2716 { 2717 struct stat st; 2718 2719 if (stat (name, &st) < 0 2720 || S_ISDIR (st.st_mode)) 2721 return -1; 2722 } 2723 2724 return access (name, mode); 2725 } 2726 2727 /* Callback for find_a_file. Appends the file name to the directory 2728 path. If the resulting file exists in the right mode, return the 2729 full pathname to the file. */ 2730 2731 struct file_at_path_info { 2732 const char *name; 2733 const char *suffix; 2734 int name_len; 2735 int suffix_len; 2736 int mode; 2737 }; 2738 2739 static void * 2740 file_at_path (char *path, void *data) 2741 { 2742 struct file_at_path_info *info = (struct file_at_path_info *) data; 2743 size_t len = strlen (path); 2744 2745 memcpy (path + len, info->name, info->name_len); 2746 len += info->name_len; 2747 2748 /* Some systems have a suffix for executable files. 2749 So try appending that first. */ 2750 if (info->suffix_len) 2751 { 2752 memcpy (path + len, info->suffix, info->suffix_len + 1); 2753 if (access_check (path, info->mode) == 0) 2754 return path; 2755 } 2756 2757 path[len] = '\0'; 2758 if (access_check (path, info->mode) == 0) 2759 return path; 2760 2761 return NULL; 2762 } 2763 2764 /* Search for NAME using the prefix list PREFIXES. MODE is passed to 2765 access to check permissions. If DO_MULTI is true, search multilib 2766 paths then non-multilib paths, otherwise do not search multilib paths. 2767 Return 0 if not found, otherwise return its name, allocated with malloc. */ 2768 2769 static char * 2770 find_a_file (const struct path_prefix *pprefix, const char *name, int mode, 2771 bool do_multi) 2772 { 2773 struct file_at_path_info info; 2774 2775 #ifdef DEFAULT_ASSEMBLER 2776 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0) 2777 return xstrdup (DEFAULT_ASSEMBLER); 2778 #endif 2779 2780 #ifdef DEFAULT_LINKER 2781 if (! strcmp (name, "ld") && access (DEFAULT_LINKER, mode) == 0) 2782 return xstrdup (DEFAULT_LINKER); 2783 #endif 2784 2785 /* Determine the filename to execute (special case for absolute paths). */ 2786 2787 if (IS_ABSOLUTE_PATH (name)) 2788 { 2789 if (access (name, mode) == 0) 2790 return xstrdup (name); 2791 2792 return NULL; 2793 } 2794 2795 info.name = name; 2796 info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : ""; 2797 info.name_len = strlen (info.name); 2798 info.suffix_len = strlen (info.suffix); 2799 info.mode = mode; 2800 2801 return (char*) for_each_path (pprefix, do_multi, 2802 info.name_len + info.suffix_len, 2803 file_at_path, &info); 2804 } 2805 2806 /* Ranking of prefixes in the sort list. -B prefixes are put before 2807 all others. */ 2808 2809 enum path_prefix_priority 2810 { 2811 PREFIX_PRIORITY_B_OPT, 2812 PREFIX_PRIORITY_LAST 2813 }; 2814 2815 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending 2816 order according to PRIORITY. Within each PRIORITY, new entries are 2817 appended. 2818 2819 If WARN is nonzero, we will warn if no file is found 2820 through this prefix. WARN should point to an int 2821 which will be set to 1 if this entry is used. 2822 2823 COMPONENT is the value to be passed to update_path. 2824 2825 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without 2826 the complete value of machine_suffix. 2827 2 means try both machine_suffix and just_machine_suffix. */ 2828 2829 static void 2830 add_prefix (struct path_prefix *pprefix, const char *prefix, 2831 const char *component, /* enum prefix_priority */ int priority, 2832 int require_machine_suffix, int os_multilib) 2833 { 2834 struct prefix_list *pl, **prev; 2835 int len; 2836 2837 for (prev = &pprefix->plist; 2838 (*prev) != NULL && (*prev)->priority <= priority; 2839 prev = &(*prev)->next) 2840 ; 2841 2842 /* Keep track of the longest prefix. */ 2843 2844 prefix = update_path (prefix, component); 2845 len = strlen (prefix); 2846 if (len > pprefix->max_len) 2847 pprefix->max_len = len; 2848 2849 pl = XNEW (struct prefix_list); 2850 pl->prefix = prefix; 2851 pl->require_machine_suffix = require_machine_suffix; 2852 pl->priority = priority; 2853 pl->os_multilib = os_multilib; 2854 2855 /* Insert after PREV. */ 2856 pl->next = (*prev); 2857 (*prev) = pl; 2858 } 2859 2860 /* Same as add_prefix, but prepending target_system_root to prefix. */ 2861 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */ 2862 static void 2863 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix, 2864 const char *component, 2865 /* enum prefix_priority */ int priority, 2866 int require_machine_suffix, int os_multilib) 2867 { 2868 if (!IS_ABSOLUTE_PATH (prefix)) 2869 fatal_error (input_location, "system path %qs is not absolute", prefix); 2870 2871 if (target_system_root) 2872 { 2873 char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root); 2874 size_t sysroot_len = strlen (target_system_root); 2875 2876 if (sysroot_len > 0 2877 && target_system_root[sysroot_len - 1] == DIR_SEPARATOR) 2878 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0'; 2879 2880 if (target_sysroot_suffix) 2881 prefix = concat (sysroot_no_trailing_dir_separator, 2882 target_sysroot_suffix, prefix, NULL); 2883 else 2884 prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL); 2885 2886 free (sysroot_no_trailing_dir_separator); 2887 2888 /* We have to override this because GCC's notion of sysroot 2889 moves along with GCC. */ 2890 component = "GCC"; 2891 } 2892 2893 add_prefix (pprefix, prefix, component, priority, 2894 require_machine_suffix, os_multilib); 2895 } 2896 2897 /* Execute the command specified by the arguments on the current line of spec. 2898 When using pipes, this includes several piped-together commands 2899 with `|' between them. 2900 2901 Return 0 if successful, -1 if failed. */ 2902 2903 static int 2904 execute (void) 2905 { 2906 int i; 2907 int n_commands; /* # of command. */ 2908 char *string; 2909 struct pex_obj *pex; 2910 struct command 2911 { 2912 const char *prog; /* program name. */ 2913 const char **argv; /* vector of args. */ 2914 }; 2915 const char *arg; 2916 2917 struct command *commands; /* each command buffer with above info. */ 2918 2919 gcc_assert (!processing_spec_function); 2920 2921 if (wrapper_string) 2922 { 2923 string = find_a_file (&exec_prefixes, 2924 argbuf[0], X_OK, false); 2925 if (string) 2926 argbuf[0] = string; 2927 insert_wrapper (wrapper_string); 2928 } 2929 2930 /* Count # of piped commands. */ 2931 for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++) 2932 if (strcmp (arg, "|") == 0) 2933 n_commands++; 2934 2935 /* Get storage for each command. */ 2936 commands = (struct command *) alloca (n_commands * sizeof (struct command)); 2937 2938 /* Split argbuf into its separate piped processes, 2939 and record info about each one. 2940 Also search for the programs that are to be run. */ 2941 2942 argbuf.safe_push (0); 2943 2944 commands[0].prog = argbuf[0]; /* first command. */ 2945 commands[0].argv = argbuf.address (); 2946 2947 if (!wrapper_string) 2948 { 2949 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false); 2950 commands[0].argv[0] = (string) ? string : commands[0].argv[0]; 2951 } 2952 2953 for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++) 2954 if (arg && strcmp (arg, "|") == 0) 2955 { /* each command. */ 2956 #if defined (__MSDOS__) || defined (OS2) || defined (VMS) 2957 fatal_error (input_location, "-pipe not supported"); 2958 #endif 2959 argbuf[i] = 0; /* Termination of 2960 command args. */ 2961 commands[n_commands].prog = argbuf[i + 1]; 2962 commands[n_commands].argv 2963 = &(argbuf.address ())[i + 1]; 2964 string = find_a_file (&exec_prefixes, commands[n_commands].prog, 2965 X_OK, false); 2966 if (string) 2967 commands[n_commands].argv[0] = string; 2968 n_commands++; 2969 } 2970 2971 /* If -v, print what we are about to do, and maybe query. */ 2972 2973 if (verbose_flag) 2974 { 2975 /* For help listings, put a blank line between sub-processes. */ 2976 if (print_help_list) 2977 fputc ('\n', stderr); 2978 2979 /* Print each piped command as a separate line. */ 2980 for (i = 0; i < n_commands; i++) 2981 { 2982 const char *const *j; 2983 2984 if (verbose_only_flag) 2985 { 2986 for (j = commands[i].argv; *j; j++) 2987 { 2988 const char *p; 2989 for (p = *j; *p; ++p) 2990 if (!ISALNUM ((unsigned char) *p) 2991 && *p != '_' && *p != '/' && *p != '-' && *p != '.') 2992 break; 2993 if (*p || !*j) 2994 { 2995 fprintf (stderr, " \""); 2996 for (p = *j; *p; ++p) 2997 { 2998 if (*p == '"' || *p == '\\' || *p == '$') 2999 fputc ('\\', stderr); 3000 fputc (*p, stderr); 3001 } 3002 fputc ('"', stderr); 3003 } 3004 /* If it's empty, print "". */ 3005 else if (!**j) 3006 fprintf (stderr, " \"\""); 3007 else 3008 fprintf (stderr, " %s", *j); 3009 } 3010 } 3011 else 3012 for (j = commands[i].argv; *j; j++) 3013 /* If it's empty, print "". */ 3014 if (!**j) 3015 fprintf (stderr, " \"\""); 3016 else 3017 fprintf (stderr, " %s", *j); 3018 3019 /* Print a pipe symbol after all but the last command. */ 3020 if (i + 1 != n_commands) 3021 fprintf (stderr, " |"); 3022 fprintf (stderr, "\n"); 3023 } 3024 fflush (stderr); 3025 if (verbose_only_flag != 0) 3026 { 3027 /* verbose_only_flag should act as if the spec was 3028 executed, so increment execution_count before 3029 returning. This prevents spurious warnings about 3030 unused linker input files, etc. */ 3031 execution_count++; 3032 return 0; 3033 } 3034 #ifdef DEBUG 3035 fnotice (stderr, "\nGo ahead? (y or n) "); 3036 fflush (stderr); 3037 i = getchar (); 3038 if (i != '\n') 3039 while (getchar () != '\n') 3040 ; 3041 3042 if (i != 'y' && i != 'Y') 3043 return 0; 3044 #endif /* DEBUG */ 3045 } 3046 3047 #ifdef ENABLE_VALGRIND_CHECKING 3048 /* Run the each command through valgrind. To simplify prepending the 3049 path to valgrind and the option "-q" (for quiet operation unless 3050 something triggers), we allocate a separate argv array. */ 3051 3052 for (i = 0; i < n_commands; i++) 3053 { 3054 const char **argv; 3055 int argc; 3056 int j; 3057 3058 for (argc = 0; commands[i].argv[argc] != NULL; argc++) 3059 ; 3060 3061 argv = XALLOCAVEC (const char *, argc + 3); 3062 3063 argv[0] = VALGRIND_PATH; 3064 argv[1] = "-q"; 3065 for (j = 2; j < argc + 2; j++) 3066 argv[j] = commands[i].argv[j - 2]; 3067 argv[j] = NULL; 3068 3069 commands[i].argv = argv; 3070 commands[i].prog = argv[0]; 3071 } 3072 #endif 3073 3074 /* Run each piped subprocess. */ 3075 3076 pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file) 3077 ? PEX_RECORD_TIMES : 0), 3078 progname, temp_filename); 3079 if (pex == NULL) 3080 fatal_error (input_location, "pex_init failed: %m"); 3081 3082 for (i = 0; i < n_commands; i++) 3083 { 3084 const char *errmsg; 3085 int err; 3086 const char *string = commands[i].argv[0]; 3087 3088 errmsg = pex_run (pex, 3089 ((i + 1 == n_commands ? PEX_LAST : 0) 3090 | (string == commands[i].prog ? PEX_SEARCH : 0)), 3091 string, CONST_CAST (char **, commands[i].argv), 3092 NULL, NULL, &err); 3093 if (errmsg != NULL) 3094 { 3095 if (err == 0) 3096 fatal_error (input_location, errmsg); 3097 else 3098 { 3099 errno = err; 3100 pfatal_with_name (errmsg); 3101 } 3102 } 3103 3104 if (i && string != commands[i].prog) 3105 free (CONST_CAST (char *, string)); 3106 } 3107 3108 execution_count++; 3109 3110 /* Wait for all the subprocesses to finish. */ 3111 3112 { 3113 int *statuses; 3114 struct pex_time *times = NULL; 3115 int ret_code = 0; 3116 3117 statuses = (int *) alloca (n_commands * sizeof (int)); 3118 if (!pex_get_status (pex, n_commands, statuses)) 3119 fatal_error (input_location, "failed to get exit status: %m"); 3120 3121 if (report_times || report_times_to_file) 3122 { 3123 times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time)); 3124 if (!pex_get_times (pex, n_commands, times)) 3125 fatal_error (input_location, "failed to get process times: %m"); 3126 } 3127 3128 pex_free (pex); 3129 3130 for (i = 0; i < n_commands; ++i) 3131 { 3132 int status = statuses[i]; 3133 3134 if (WIFSIGNALED (status)) 3135 switch (WTERMSIG (status)) 3136 { 3137 case SIGINT: 3138 case SIGTERM: 3139 /* SIGQUIT and SIGKILL are not available on MinGW. */ 3140 #ifdef SIGQUIT 3141 case SIGQUIT: 3142 #endif 3143 #ifdef SIGKILL 3144 case SIGKILL: 3145 #endif 3146 /* The user (or environment) did something to the 3147 inferior. Making this an ICE confuses the user into 3148 thinking there's a compiler bug. Much more likely is 3149 the user or OOM killer nuked it. */ 3150 fatal_error (input_location, 3151 "%s signal terminated program %s", 3152 strsignal (WTERMSIG (status)), 3153 commands[i].prog); 3154 break; 3155 3156 #ifdef SIGPIPE 3157 case SIGPIPE: 3158 /* SIGPIPE is a special case. It happens in -pipe mode 3159 when the compiler dies before the preprocessor is 3160 done, or the assembler dies before the compiler is 3161 done. There's generally been an error already, and 3162 this is just fallout. So don't generate another 3163 error unless we would otherwise have succeeded. */ 3164 if (signal_count || greatest_status >= MIN_FATAL_STATUS) 3165 { 3166 signal_count++; 3167 ret_code = -1; 3168 break; 3169 } 3170 #endif 3171 /* FALLTHROUGH */ 3172 3173 default: 3174 /* The inferior failed to catch the signal. */ 3175 internal_error_no_backtrace ("%s signal terminated program %s", 3176 strsignal (WTERMSIG (status)), 3177 commands[i].prog); 3178 } 3179 else if (WIFEXITED (status) 3180 && WEXITSTATUS (status) >= MIN_FATAL_STATUS) 3181 { 3182 /* For ICEs in cc1, cc1obj, cc1plus see if it is 3183 reproducible or not. */ 3184 const char *p; 3185 if (flag_report_bug 3186 && WEXITSTATUS (status) == ICE_EXIT_CODE 3187 && i == 0 3188 && (p = strrchr (commands[0].argv[0], DIR_SEPARATOR)) 3189 && ! strncmp (p + 1, "cc1", 3)) 3190 try_generate_repro (commands[0].argv); 3191 if (WEXITSTATUS (status) > greatest_status) 3192 greatest_status = WEXITSTATUS (status); 3193 ret_code = -1; 3194 } 3195 3196 if (report_times || report_times_to_file) 3197 { 3198 struct pex_time *pt = ×[i]; 3199 double ut, st; 3200 3201 ut = ((double) pt->user_seconds 3202 + (double) pt->user_microseconds / 1.0e6); 3203 st = ((double) pt->system_seconds 3204 + (double) pt->system_microseconds / 1.0e6); 3205 3206 if (ut + st != 0) 3207 { 3208 if (report_times) 3209 fnotice (stderr, "# %s %.2f %.2f\n", 3210 commands[i].prog, ut, st); 3211 3212 if (report_times_to_file) 3213 { 3214 int c = 0; 3215 const char *const *j; 3216 3217 fprintf (report_times_to_file, "%g %g", ut, st); 3218 3219 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c]) 3220 { 3221 const char *p; 3222 for (p = *j; *p; ++p) 3223 if (*p == '"' || *p == '\\' || *p == '$' 3224 || ISSPACE (*p)) 3225 break; 3226 3227 if (*p) 3228 { 3229 fprintf (report_times_to_file, " \""); 3230 for (p = *j; *p; ++p) 3231 { 3232 if (*p == '"' || *p == '\\' || *p == '$') 3233 fputc ('\\', report_times_to_file); 3234 fputc (*p, report_times_to_file); 3235 } 3236 fputc ('"', report_times_to_file); 3237 } 3238 else 3239 fprintf (report_times_to_file, " %s", *j); 3240 } 3241 3242 fputc ('\n', report_times_to_file); 3243 } 3244 } 3245 } 3246 } 3247 3248 if (commands[0].argv[0] != commands[0].prog) 3249 free (CONST_CAST (char *, commands[0].argv[0])); 3250 3251 return ret_code; 3252 } 3253 } 3254 3255 /* Find all the switches given to us 3256 and make a vector describing them. 3257 The elements of the vector are strings, one per switch given. 3258 If a switch uses following arguments, then the `part1' field 3259 is the switch itself and the `args' field 3260 is a null-terminated vector containing the following arguments. 3261 Bits in the `live_cond' field are: 3262 SWITCH_LIVE to indicate this switch is true in a conditional spec. 3263 SWITCH_FALSE to indicate this switch is overridden by a later switch. 3264 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S). 3265 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored. 3266 SWITCH_KEEP_FOR_GCC to indicate that this switch, otherwise ignored, 3267 should be included in COLLECT_GCC_OPTIONS. 3268 in all do_spec calls afterwards. Used for %<S from self specs. 3269 The `known' field describes whether this is an internal switch. 3270 The `validated' field describes whether any spec has looked at this switch; 3271 if it remains false at the end of the run, the switch must be meaningless. 3272 The `ordering' field is used to temporarily mark switches that have to be 3273 kept in a specific order. */ 3274 3275 #define SWITCH_LIVE (1 << 0) 3276 #define SWITCH_FALSE (1 << 1) 3277 #define SWITCH_IGNORE (1 << 2) 3278 #define SWITCH_IGNORE_PERMANENTLY (1 << 3) 3279 #define SWITCH_KEEP_FOR_GCC (1 << 4) 3280 3281 struct switchstr 3282 { 3283 const char *part1; 3284 const char **args; 3285 unsigned int live_cond; 3286 bool known; 3287 bool validated; 3288 bool ordering; 3289 }; 3290 3291 static struct switchstr *switches; 3292 3293 static int n_switches; 3294 3295 static int n_switches_alloc; 3296 3297 /* Set to zero if -fcompare-debug is disabled, positive if it's 3298 enabled and we're running the first compilation, negative if it's 3299 enabled and we're running the second compilation. For most of the 3300 time, it's in the range -1..1, but it can be temporarily set to 2 3301 or 3 to indicate that the -fcompare-debug flags didn't come from 3302 the command-line, but rather from the GCC_COMPARE_DEBUG environment 3303 variable, until a synthesized -fcompare-debug flag is added to the 3304 command line. */ 3305 int compare_debug; 3306 3307 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */ 3308 int compare_debug_second; 3309 3310 /* Set to the flags that should be passed to the second compilation in 3311 a -fcompare-debug compilation. */ 3312 const char *compare_debug_opt; 3313 3314 static struct switchstr *switches_debug_check[2]; 3315 3316 static int n_switches_debug_check[2]; 3317 3318 static int n_switches_alloc_debug_check[2]; 3319 3320 static char *debug_check_temp_file[2]; 3321 3322 /* Language is one of three things: 3323 3324 1) The name of a real programming language. 3325 2) NULL, indicating that no one has figured out 3326 what it is yet. 3327 3) '*', indicating that the file should be passed 3328 to the linker. */ 3329 struct infile 3330 { 3331 const char *name; 3332 const char *language; 3333 struct compiler *incompiler; 3334 bool compiled; 3335 bool preprocessed; 3336 }; 3337 3338 /* Also a vector of input files specified. */ 3339 3340 static struct infile *infiles; 3341 3342 int n_infiles; 3343 3344 static int n_infiles_alloc; 3345 3346 /* True if undefined environment variables encountered during spec processing 3347 are ok to ignore, typically when we're running for --help or --version. */ 3348 3349 static bool spec_undefvar_allowed; 3350 3351 /* True if multiple input files are being compiled to a single 3352 assembly file. */ 3353 3354 static bool combine_inputs; 3355 3356 /* This counts the number of libraries added by lang_specific_driver, so that 3357 we can tell if there were any user supplied any files or libraries. */ 3358 3359 static int added_libraries; 3360 3361 /* And a vector of corresponding output files is made up later. */ 3362 3363 const char **outfiles; 3364 3365 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 3366 3367 /* Convert NAME to a new name if it is the standard suffix. DO_EXE 3368 is true if we should look for an executable suffix. DO_OBJ 3369 is true if we should look for an object suffix. */ 3370 3371 static const char * 3372 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED, 3373 int do_obj ATTRIBUTE_UNUSED) 3374 { 3375 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 3376 int i; 3377 #endif 3378 int len; 3379 3380 if (name == NULL) 3381 return NULL; 3382 3383 len = strlen (name); 3384 3385 #ifdef HAVE_TARGET_OBJECT_SUFFIX 3386 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */ 3387 if (do_obj && len > 2 3388 && name[len - 2] == '.' 3389 && name[len - 1] == 'o') 3390 { 3391 obstack_grow (&obstack, name, len - 2); 3392 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX)); 3393 name = XOBFINISH (&obstack, const char *); 3394 } 3395 #endif 3396 3397 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 3398 /* If there is no filetype, make it the executable suffix (which includes 3399 the "."). But don't get confused if we have just "-o". */ 3400 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-')) 3401 return name; 3402 3403 for (i = len - 1; i >= 0; i--) 3404 if (IS_DIR_SEPARATOR (name[i])) 3405 break; 3406 3407 for (i++; i < len; i++) 3408 if (name[i] == '.') 3409 return name; 3410 3411 obstack_grow (&obstack, name, len); 3412 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX, 3413 strlen (TARGET_EXECUTABLE_SUFFIX)); 3414 name = XOBFINISH (&obstack, const char *); 3415 #endif 3416 3417 return name; 3418 } 3419 #endif 3420 3421 /* Display the command line switches accepted by gcc. */ 3422 static void 3423 display_help (void) 3424 { 3425 printf (_("Usage: %s [options] file...\n"), progname); 3426 fputs (_("Options:\n"), stdout); 3427 3428 fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout); 3429 fputs (_(" --help Display this information.\n"), stdout); 3430 fputs (_(" --target-help Display target specific command line options.\n"), stdout); 3431 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout); 3432 fputs (_(" Display specific types of command line options.\n"), stdout); 3433 if (! verbose_flag) 3434 fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout); 3435 fputs (_(" --version Display compiler version information.\n"), stdout); 3436 fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout); 3437 fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout); 3438 fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout); 3439 fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout); 3440 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout); 3441 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout); 3442 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout); 3443 fputs (_("\ 3444 -print-multiarch Display the target's normalized GNU triplet, used as\n\ 3445 a component in the library path.\n"), stdout); 3446 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout); 3447 fputs (_("\ 3448 -print-multi-lib Display the mapping between command line options and\n\ 3449 multiple library search directories.\n"), stdout); 3450 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout); 3451 fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout); 3452 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout); 3453 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout); 3454 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout); 3455 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout); 3456 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout); 3457 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout); 3458 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout); 3459 fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout); 3460 fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout); 3461 fputs (_("\ 3462 -no-canonical-prefixes Do not canonicalize paths when building relative\n\ 3463 prefixes to other gcc components.\n"), stdout); 3464 fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout); 3465 fputs (_(" -time Time the execution of each subprocess.\n"), stdout); 3466 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout); 3467 fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout); 3468 fputs (_("\ 3469 --sysroot=<directory> Use <directory> as the root directory for headers\n\ 3470 and libraries.\n"), stdout); 3471 fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout); 3472 fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout); 3473 fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout); 3474 fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout); 3475 fputs (_(" -S Compile only; do not assemble or link.\n"), stdout); 3476 fputs (_(" -c Compile and assemble, but do not link.\n"), stdout); 3477 fputs (_(" -o <file> Place the output into <file>.\n"), stdout); 3478 fputs (_(" -pie Create a dynamically linked position independent\n\ 3479 executable.\n"), stdout); 3480 fputs (_(" -shared Create a shared library.\n"), stdout); 3481 fputs (_("\ 3482 -x <language> Specify the language of the following input files.\n\ 3483 Permissible languages include: c c++ assembler none\n\ 3484 'none' means revert to the default behavior of\n\ 3485 guessing the language based on the file's extension.\n\ 3486 "), stdout); 3487 3488 printf (_("\ 3489 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\ 3490 passed on to the various sub-processes invoked by %s. In order to pass\n\ 3491 other options on to these processes the -W<letter> options must be used.\n\ 3492 "), progname); 3493 3494 /* The rest of the options are displayed by invocations of the various 3495 sub-processes. */ 3496 } 3497 3498 static void 3499 add_preprocessor_option (const char *option, int len) 3500 { 3501 preprocessor_options.safe_push (save_string (option, len)); 3502 } 3503 3504 static void 3505 add_assembler_option (const char *option, int len) 3506 { 3507 assembler_options.safe_push (save_string (option, len)); 3508 } 3509 3510 static void 3511 add_linker_option (const char *option, int len) 3512 { 3513 linker_options.safe_push (save_string (option, len)); 3514 } 3515 3516 /* Allocate space for an input file in infiles. */ 3517 3518 static void 3519 alloc_infile (void) 3520 { 3521 if (n_infiles_alloc == 0) 3522 { 3523 n_infiles_alloc = 16; 3524 infiles = XNEWVEC (struct infile, n_infiles_alloc); 3525 } 3526 else if (n_infiles_alloc == n_infiles) 3527 { 3528 n_infiles_alloc *= 2; 3529 infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc); 3530 } 3531 } 3532 3533 /* Store an input file with the given NAME and LANGUAGE in 3534 infiles. */ 3535 3536 static void 3537 add_infile (const char *name, const char *language) 3538 { 3539 alloc_infile (); 3540 infiles[n_infiles].name = name; 3541 infiles[n_infiles++].language = language; 3542 } 3543 3544 /* Allocate space for a switch in switches. */ 3545 3546 static void 3547 alloc_switch (void) 3548 { 3549 if (n_switches_alloc == 0) 3550 { 3551 n_switches_alloc = 16; 3552 switches = XNEWVEC (struct switchstr, n_switches_alloc); 3553 } 3554 else if (n_switches_alloc == n_switches) 3555 { 3556 n_switches_alloc *= 2; 3557 switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc); 3558 } 3559 } 3560 3561 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it 3562 as validated if VALIDATED and KNOWN if it is an internal switch. */ 3563 3564 static void 3565 save_switch (const char *opt, size_t n_args, const char *const *args, 3566 bool validated, bool known) 3567 { 3568 alloc_switch (); 3569 switches[n_switches].part1 = opt + 1; 3570 if (n_args == 0) 3571 switches[n_switches].args = 0; 3572 else 3573 { 3574 switches[n_switches].args = XNEWVEC (const char *, n_args + 1); 3575 memcpy (switches[n_switches].args, args, n_args * sizeof (const char *)); 3576 switches[n_switches].args[n_args] = NULL; 3577 } 3578 3579 switches[n_switches].live_cond = 0; 3580 switches[n_switches].validated = validated; 3581 switches[n_switches].known = known; 3582 switches[n_switches].ordering = 0; 3583 n_switches++; 3584 } 3585 3586 /* Set the SOURCE_DATE_EPOCH environment variable to the current time if it is 3587 not set already. */ 3588 3589 static void 3590 set_source_date_epoch_envvar () 3591 { 3592 /* Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations 3593 of 64 bit integers. */ 3594 char source_date_epoch[21]; 3595 time_t tt; 3596 3597 errno = 0; 3598 tt = time (NULL); 3599 if (tt < (time_t) 0 || errno != 0) 3600 tt = (time_t) 0; 3601 3602 snprintf (source_date_epoch, 21, "%llu", (unsigned long long) tt); 3603 /* Using setenv instead of xputenv because we want the variable to remain 3604 after finalizing so that it's still set in the second run when using 3605 -fcompare-debug. */ 3606 setenv ("SOURCE_DATE_EPOCH", source_date_epoch, 0); 3607 } 3608 3609 /* Handle an option DECODED that is unknown to the option-processing 3610 machinery. */ 3611 3612 static bool 3613 driver_unknown_option_callback (const struct cl_decoded_option *decoded) 3614 { 3615 const char *opt = decoded->arg; 3616 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-' 3617 && !(decoded->errors & CL_ERR_NEGATIVE)) 3618 { 3619 /* Leave unknown -Wno-* options for the compiler proper, to be 3620 diagnosed only if there are warnings. */ 3621 save_switch (decoded->canonical_option[0], 3622 decoded->canonical_option_num_elements - 1, 3623 &decoded->canonical_option[1], false, true); 3624 return false; 3625 } 3626 if (decoded->opt_index == OPT_SPECIAL_unknown) 3627 { 3628 /* Give it a chance to define it a spec file. */ 3629 save_switch (decoded->canonical_option[0], 3630 decoded->canonical_option_num_elements - 1, 3631 &decoded->canonical_option[1], false, false); 3632 return false; 3633 } 3634 else 3635 return true; 3636 } 3637 3638 /* Handle an option DECODED that is not marked as CL_DRIVER. 3639 LANG_MASK will always be CL_DRIVER. */ 3640 3641 static void 3642 driver_wrong_lang_callback (const struct cl_decoded_option *decoded, 3643 unsigned int lang_mask ATTRIBUTE_UNUSED) 3644 { 3645 /* At this point, non-driver options are accepted (and expected to 3646 be passed down by specs) unless marked to be rejected by the 3647 driver. Options to be rejected by the driver but accepted by the 3648 compilers proper are treated just like completely unknown 3649 options. */ 3650 const struct cl_option *option = &cl_options[decoded->opt_index]; 3651 3652 if (option->cl_reject_driver) 3653 error ("unrecognized command line option %qs", 3654 decoded->orig_option_with_args_text); 3655 else 3656 save_switch (decoded->canonical_option[0], 3657 decoded->canonical_option_num_elements - 1, 3658 &decoded->canonical_option[1], false, true); 3659 } 3660 3661 static const char *spec_lang = 0; 3662 static int last_language_n_infiles; 3663 3664 /* Parse -foffload option argument. */ 3665 3666 static void 3667 handle_foffload_option (const char *arg) 3668 { 3669 const char *c, *cur, *n, *next, *end; 3670 char *target; 3671 3672 /* If option argument starts with '-' then no target is specified and we 3673 do not need to parse it. */ 3674 if (arg[0] == '-') 3675 return; 3676 3677 end = strchr (arg, '='); 3678 if (end == NULL) 3679 end = strchr (arg, '\0'); 3680 cur = arg; 3681 3682 while (cur < end) 3683 { 3684 next = strchr (cur, ','); 3685 if (next == NULL) 3686 next = end; 3687 next = (next > end) ? end : next; 3688 3689 target = XNEWVEC (char, next - cur + 1); 3690 memcpy (target, cur, next - cur); 3691 target[next - cur] = '\0'; 3692 3693 /* If 'disable' is passed to the option, stop parsing the option and clean 3694 the list of offload targets. */ 3695 if (strcmp (target, "disable") == 0) 3696 { 3697 free (offload_targets); 3698 offload_targets = xstrdup (""); 3699 break; 3700 } 3701 3702 /* Check that GCC is configured to support the offload target. */ 3703 c = OFFLOAD_TARGETS; 3704 while (c) 3705 { 3706 n = strchr (c, ','); 3707 if (n == NULL) 3708 n = strchr (c, '\0'); 3709 3710 if (next - cur == n - c && strncmp (target, c, n - c) == 0) 3711 break; 3712 3713 c = *n ? n + 1 : NULL; 3714 } 3715 3716 if (!c) 3717 fatal_error (input_location, 3718 "GCC is not configured to support %s as offload target", 3719 target); 3720 3721 if (!offload_targets) 3722 { 3723 offload_targets = target; 3724 target = NULL; 3725 } 3726 else 3727 { 3728 /* Check that the target hasn't already presented in the list. */ 3729 c = offload_targets; 3730 do 3731 { 3732 n = strchr (c, ':'); 3733 if (n == NULL) 3734 n = strchr (c, '\0'); 3735 3736 if (next - cur == n - c && strncmp (c, target, n - c) == 0) 3737 break; 3738 3739 c = n + 1; 3740 } 3741 while (*n); 3742 3743 /* If duplicate is not found, append the target to the list. */ 3744 if (c > n) 3745 { 3746 size_t offload_targets_len = strlen (offload_targets); 3747 offload_targets 3748 = XRESIZEVEC (char, offload_targets, 3749 offload_targets_len + 1 + next - cur + 1); 3750 offload_targets[offload_targets_len++] = ':'; 3751 memcpy (offload_targets + offload_targets_len, target, next - cur + 1); 3752 } 3753 } 3754 3755 cur = next + 1; 3756 XDELETEVEC (target); 3757 } 3758 } 3759 3760 /* Handle a driver option; arguments and return value as for 3761 handle_option. */ 3762 3763 static bool 3764 driver_handle_option (struct gcc_options *opts, 3765 struct gcc_options *opts_set, 3766 const struct cl_decoded_option *decoded, 3767 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind, 3768 location_t loc, 3769 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED, 3770 diagnostic_context *dc, 3771 void (*) (void)) 3772 { 3773 size_t opt_index = decoded->opt_index; 3774 const char *arg = decoded->arg; 3775 const char *compare_debug_replacement_opt; 3776 int value = decoded->value; 3777 bool validated = false; 3778 bool do_save = true; 3779 3780 gcc_assert (opts == &global_options); 3781 gcc_assert (opts_set == &global_options_set); 3782 gcc_assert (kind == DK_UNSPECIFIED); 3783 gcc_assert (loc == UNKNOWN_LOCATION); 3784 gcc_assert (dc == global_dc); 3785 3786 switch (opt_index) 3787 { 3788 case OPT_dumpspecs: 3789 { 3790 struct spec_list *sl; 3791 init_spec (); 3792 for (sl = specs; sl; sl = sl->next) 3793 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec)); 3794 if (link_command_spec) 3795 printf ("*link_command:\n%s\n\n", link_command_spec); 3796 exit (0); 3797 } 3798 3799 case OPT_dumpversion: 3800 printf ("%s\n", spec_version); 3801 exit (0); 3802 3803 case OPT_dumpmachine: 3804 printf ("%s\n", spec_machine); 3805 exit (0); 3806 3807 case OPT_dumpfullversion: 3808 printf ("%s\n", BASEVER); 3809 exit (0); 3810 3811 case OPT__version: 3812 print_version = 1; 3813 3814 /* CPP driver cannot obtain switch from cc1_options. */ 3815 if (is_cpp_driver) 3816 add_preprocessor_option ("--version", strlen ("--version")); 3817 add_assembler_option ("--version", strlen ("--version")); 3818 add_linker_option ("--version", strlen ("--version")); 3819 break; 3820 3821 case OPT__help: 3822 print_help_list = 1; 3823 3824 /* CPP driver cannot obtain switch from cc1_options. */ 3825 if (is_cpp_driver) 3826 add_preprocessor_option ("--help", 6); 3827 add_assembler_option ("--help", 6); 3828 add_linker_option ("--help", 6); 3829 break; 3830 3831 case OPT__help_: 3832 print_subprocess_help = 2; 3833 break; 3834 3835 case OPT__target_help: 3836 print_subprocess_help = 1; 3837 3838 /* CPP driver cannot obtain switch from cc1_options. */ 3839 if (is_cpp_driver) 3840 add_preprocessor_option ("--target-help", 13); 3841 add_assembler_option ("--target-help", 13); 3842 add_linker_option ("--target-help", 13); 3843 break; 3844 3845 case OPT__no_sysroot_suffix: 3846 case OPT_pass_exit_codes: 3847 case OPT_print_search_dirs: 3848 case OPT_print_file_name_: 3849 case OPT_print_prog_name_: 3850 case OPT_print_multi_lib: 3851 case OPT_print_multi_directory: 3852 case OPT_print_sysroot: 3853 case OPT_print_multi_os_directory: 3854 case OPT_print_multiarch: 3855 case OPT_print_sysroot_headers_suffix: 3856 case OPT_time: 3857 case OPT_wrapper: 3858 /* These options set the variables specified in common.opt 3859 automatically, and do not need to be saved for spec 3860 processing. */ 3861 do_save = false; 3862 break; 3863 3864 case OPT_print_libgcc_file_name: 3865 print_file_name = "libgcc.a"; 3866 do_save = false; 3867 break; 3868 3869 case OPT_fuse_ld_bfd: 3870 use_ld = ".bfd"; 3871 break; 3872 3873 case OPT_fuse_ld_gold: 3874 use_ld = ".gold"; 3875 break; 3876 3877 case OPT_fcompare_debug_second: 3878 compare_debug_second = 1; 3879 break; 3880 3881 case OPT_fcompare_debug: 3882 switch (value) 3883 { 3884 case 0: 3885 compare_debug_replacement_opt = "-fcompare-debug="; 3886 arg = ""; 3887 goto compare_debug_with_arg; 3888 3889 case 1: 3890 compare_debug_replacement_opt = "-fcompare-debug=-gtoggle"; 3891 arg = "-gtoggle"; 3892 goto compare_debug_with_arg; 3893 3894 default: 3895 gcc_unreachable (); 3896 } 3897 break; 3898 3899 case OPT_fcompare_debug_: 3900 compare_debug_replacement_opt = decoded->canonical_option[0]; 3901 compare_debug_with_arg: 3902 gcc_assert (decoded->canonical_option_num_elements == 1); 3903 gcc_assert (arg != NULL); 3904 if (*arg) 3905 compare_debug = 1; 3906 else 3907 compare_debug = -1; 3908 if (compare_debug < 0) 3909 compare_debug_opt = NULL; 3910 else 3911 compare_debug_opt = arg; 3912 save_switch (compare_debug_replacement_opt, 0, NULL, validated, true); 3913 set_source_date_epoch_envvar (); 3914 return true; 3915 3916 case OPT_fdiagnostics_color_: 3917 diagnostic_color_init (dc, value); 3918 break; 3919 3920 case OPT_Wa_: 3921 { 3922 int prev, j; 3923 /* Pass the rest of this option to the assembler. */ 3924 3925 /* Split the argument at commas. */ 3926 prev = 0; 3927 for (j = 0; arg[j]; j++) 3928 if (arg[j] == ',') 3929 { 3930 add_assembler_option (arg + prev, j - prev); 3931 prev = j + 1; 3932 } 3933 3934 /* Record the part after the last comma. */ 3935 add_assembler_option (arg + prev, j - prev); 3936 } 3937 do_save = false; 3938 break; 3939 3940 case OPT_Wp_: 3941 { 3942 int prev, j; 3943 /* Pass the rest of this option to the preprocessor. */ 3944 3945 /* Split the argument at commas. */ 3946 prev = 0; 3947 for (j = 0; arg[j]; j++) 3948 if (arg[j] == ',') 3949 { 3950 add_preprocessor_option (arg + prev, j - prev); 3951 prev = j + 1; 3952 } 3953 3954 /* Record the part after the last comma. */ 3955 add_preprocessor_option (arg + prev, j - prev); 3956 } 3957 do_save = false; 3958 break; 3959 3960 case OPT_Wl_: 3961 { 3962 int prev, j; 3963 /* Split the argument at commas. */ 3964 prev = 0; 3965 for (j = 0; arg[j]; j++) 3966 if (arg[j] == ',') 3967 { 3968 add_infile (save_string (arg + prev, j - prev), "*"); 3969 prev = j + 1; 3970 } 3971 /* Record the part after the last comma. */ 3972 add_infile (arg + prev, "*"); 3973 } 3974 do_save = false; 3975 break; 3976 3977 case OPT_Xlinker: 3978 add_infile (arg, "*"); 3979 do_save = false; 3980 break; 3981 3982 case OPT_Xpreprocessor: 3983 add_preprocessor_option (arg, strlen (arg)); 3984 do_save = false; 3985 break; 3986 3987 case OPT_Xassembler: 3988 add_assembler_option (arg, strlen (arg)); 3989 do_save = false; 3990 break; 3991 3992 case OPT_l: 3993 /* POSIX allows separation of -l and the lib arg; canonicalize 3994 by concatenating -l with its arg */ 3995 add_infile (concat ("-l", arg, NULL), "*"); 3996 do_save = false; 3997 break; 3998 3999 case OPT_L: 4000 /* Similarly, canonicalize -L for linkers that may not accept 4001 separate arguments. */ 4002 save_switch (concat ("-L", arg, NULL), 0, NULL, validated, true); 4003 return true; 4004 4005 case OPT_F: 4006 /* Likewise -F. */ 4007 save_switch (concat ("-F", arg, NULL), 0, NULL, validated, true); 4008 return true; 4009 4010 case OPT_save_temps: 4011 save_temps_flag = SAVE_TEMPS_CWD; 4012 validated = true; 4013 break; 4014 4015 case OPT_save_temps_: 4016 if (strcmp (arg, "cwd") == 0) 4017 save_temps_flag = SAVE_TEMPS_CWD; 4018 else if (strcmp (arg, "obj") == 0 4019 || strcmp (arg, "object") == 0) 4020 save_temps_flag = SAVE_TEMPS_OBJ; 4021 else 4022 fatal_error (input_location, "%qs is an unknown -save-temps option", 4023 decoded->orig_option_with_args_text); 4024 break; 4025 4026 case OPT_no_canonical_prefixes: 4027 /* Already handled as a special case, so ignored here. */ 4028 do_save = false; 4029 break; 4030 4031 case OPT_pipe: 4032 validated = true; 4033 /* These options set the variables specified in common.opt 4034 automatically, but do need to be saved for spec 4035 processing. */ 4036 break; 4037 4038 case OPT_specs_: 4039 { 4040 struct user_specs *user = XNEW (struct user_specs); 4041 4042 user->next = (struct user_specs *) 0; 4043 user->filename = arg; 4044 if (user_specs_tail) 4045 user_specs_tail->next = user; 4046 else 4047 user_specs_head = user; 4048 user_specs_tail = user; 4049 } 4050 validated = true; 4051 break; 4052 4053 case OPT__sysroot_: 4054 target_system_root = arg; 4055 target_system_root_changed = 1; 4056 do_save = false; 4057 break; 4058 4059 case OPT_time_: 4060 if (report_times_to_file) 4061 fclose (report_times_to_file); 4062 report_times_to_file = fopen (arg, "a"); 4063 do_save = false; 4064 break; 4065 4066 case OPT____: 4067 /* "-###" 4068 This is similar to -v except that there is no execution 4069 of the commands and the echoed arguments are quoted. It 4070 is intended for use in shell scripts to capture the 4071 driver-generated command line. */ 4072 verbose_only_flag++; 4073 verbose_flag = 1; 4074 do_save = false; 4075 break; 4076 4077 case OPT_B: 4078 { 4079 size_t len = strlen (arg); 4080 4081 /* Catch the case where the user has forgotten to append a 4082 directory separator to the path. Note, they may be using 4083 -B to add an executable name prefix, eg "i386-elf-", in 4084 order to distinguish between multiple installations of 4085 GCC in the same directory. Hence we must check to see 4086 if appending a directory separator actually makes a 4087 valid directory name. */ 4088 if (!IS_DIR_SEPARATOR (arg[len - 1]) 4089 && is_directory (arg, false)) 4090 { 4091 char *tmp = XNEWVEC (char, len + 2); 4092 strcpy (tmp, arg); 4093 tmp[len] = DIR_SEPARATOR; 4094 tmp[++len] = 0; 4095 arg = tmp; 4096 } 4097 4098 add_prefix (&exec_prefixes, arg, NULL, 4099 PREFIX_PRIORITY_B_OPT, 0, 0); 4100 add_prefix (&startfile_prefixes, arg, NULL, 4101 PREFIX_PRIORITY_B_OPT, 0, 0); 4102 add_prefix (&include_prefixes, arg, NULL, 4103 PREFIX_PRIORITY_B_OPT, 0, 0); 4104 } 4105 validated = true; 4106 break; 4107 4108 case OPT_E: 4109 have_E = true; 4110 break; 4111 4112 case OPT_x: 4113 spec_lang = arg; 4114 if (!strcmp (spec_lang, "none")) 4115 /* Suppress the warning if -xnone comes after the last input 4116 file, because alternate command interfaces like g++ might 4117 find it useful to place -xnone after each input file. */ 4118 spec_lang = 0; 4119 else 4120 last_language_n_infiles = n_infiles; 4121 do_save = false; 4122 break; 4123 4124 case OPT_o: 4125 have_o = 1; 4126 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX) 4127 arg = convert_filename (arg, ! have_c, 0); 4128 #endif 4129 output_file = arg; 4130 /* Save the output name in case -save-temps=obj was used. */ 4131 save_temps_prefix = xstrdup (arg); 4132 /* On some systems, ld cannot handle "-o" without a space. So 4133 split the option from its argument. */ 4134 save_switch ("-o", 1, &arg, validated, true); 4135 return true; 4136 4137 #ifdef ENABLE_DEFAULT_PIE 4138 case OPT_pie: 4139 /* -pie is turned on by default. */ 4140 #endif 4141 4142 case OPT_static_libgcc: 4143 case OPT_shared_libgcc: 4144 case OPT_static_libgfortran: 4145 case OPT_static_libstdc__: 4146 /* These are always valid, since gcc.c itself understands the 4147 first two, gfortranspec.c understands -static-libgfortran and 4148 g++spec.c understands -static-libstdc++ */ 4149 validated = true; 4150 break; 4151 4152 case OPT_fwpa: 4153 flag_wpa = ""; 4154 break; 4155 4156 case OPT_foffload_: 4157 handle_foffload_option (arg); 4158 break; 4159 4160 default: 4161 /* Various driver options need no special processing at this 4162 point, having been handled in a prescan above or being 4163 handled by specs. */ 4164 break; 4165 } 4166 4167 if (do_save) 4168 save_switch (decoded->canonical_option[0], 4169 decoded->canonical_option_num_elements - 1, 4170 &decoded->canonical_option[1], validated, true); 4171 return true; 4172 } 4173 4174 /* Put the driver's standard set of option handlers in *HANDLERS. */ 4175 4176 static void 4177 set_option_handlers (struct cl_option_handlers *handlers) 4178 { 4179 handlers->unknown_option_callback = driver_unknown_option_callback; 4180 handlers->wrong_lang_callback = driver_wrong_lang_callback; 4181 handlers->num_handlers = 3; 4182 handlers->handlers[0].handler = driver_handle_option; 4183 handlers->handlers[0].mask = CL_DRIVER; 4184 handlers->handlers[1].handler = common_handle_option; 4185 handlers->handlers[1].mask = CL_COMMON; 4186 handlers->handlers[2].handler = target_handle_option; 4187 handlers->handlers[2].mask = CL_TARGET; 4188 } 4189 4190 /* Create the vector `switches' and its contents. 4191 Store its length in `n_switches'. */ 4192 4193 static void 4194 process_command (unsigned int decoded_options_count, 4195 struct cl_decoded_option *decoded_options) 4196 { 4197 const char *temp; 4198 char *temp1; 4199 char *tooldir_prefix, *tooldir_prefix2; 4200 char *(*get_relative_prefix) (const char *, const char *, 4201 const char *) = NULL; 4202 struct cl_option_handlers handlers; 4203 unsigned int j; 4204 4205 gcc_exec_prefix = env.get ("GCC_EXEC_PREFIX"); 4206 4207 n_switches = 0; 4208 n_infiles = 0; 4209 added_libraries = 0; 4210 4211 /* Figure compiler version from version string. */ 4212 4213 compiler_version = temp1 = xstrdup (version_string); 4214 4215 for (; *temp1; ++temp1) 4216 { 4217 if (*temp1 == ' ') 4218 { 4219 *temp1 = '\0'; 4220 break; 4221 } 4222 } 4223 4224 /* Handle any -no-canonical-prefixes flag early, to assign the function 4225 that builds relative prefixes. This function creates default search 4226 paths that are needed later in normal option handling. */ 4227 4228 for (j = 1; j < decoded_options_count; j++) 4229 { 4230 if (decoded_options[j].opt_index == OPT_no_canonical_prefixes) 4231 { 4232 get_relative_prefix = make_relative_prefix_ignore_links; 4233 break; 4234 } 4235 } 4236 if (! get_relative_prefix) 4237 get_relative_prefix = make_relative_prefix; 4238 4239 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX, 4240 see if we can create it from the pathname specified in 4241 decoded_options[0].arg. */ 4242 4243 gcc_libexec_prefix = standard_libexec_prefix; 4244 #ifndef VMS 4245 /* FIXME: make_relative_prefix doesn't yet work for VMS. */ 4246 if (!gcc_exec_prefix) 4247 { 4248 #ifdef NETBSD_NATIVE 4249 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC", 4250 PREFIX_PRIORITY_LAST, 0, 0); 4251 #else 4252 gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg, 4253 standard_bindir_prefix, 4254 standard_exec_prefix); 4255 gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg, 4256 standard_bindir_prefix, 4257 standard_libexec_prefix); 4258 if (gcc_exec_prefix) 4259 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL)); 4260 #endif 4261 } 4262 else 4263 { 4264 /* make_relative_prefix requires a program name, but 4265 GCC_EXEC_PREFIX is typically a directory name with a trailing 4266 / (which is ignored by make_relative_prefix), so append a 4267 program name. */ 4268 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL); 4269 gcc_libexec_prefix = get_relative_prefix (tmp_prefix, 4270 standard_exec_prefix, 4271 standard_libexec_prefix); 4272 4273 /* The path is unrelocated, so fallback to the original setting. */ 4274 if (!gcc_libexec_prefix) 4275 gcc_libexec_prefix = standard_libexec_prefix; 4276 4277 free (tmp_prefix); 4278 } 4279 #else 4280 #endif 4281 /* From this point onward, gcc_exec_prefix is non-null if the toolchain 4282 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX 4283 or an automatically created GCC_EXEC_PREFIX from 4284 decoded_options[0].arg. */ 4285 4286 /* Do language-specific adjustment/addition of flags. */ 4287 lang_specific_driver (&decoded_options, &decoded_options_count, 4288 &added_libraries); 4289 4290 if (gcc_exec_prefix) 4291 { 4292 int len = strlen (gcc_exec_prefix); 4293 4294 if (len > (int) sizeof ("/lib/gcc/") - 1 4295 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1]))) 4296 { 4297 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1; 4298 if (IS_DIR_SEPARATOR (*temp) 4299 && filename_ncmp (temp + 1, "lib", 3) == 0 4300 && IS_DIR_SEPARATOR (temp[4]) 4301 && filename_ncmp (temp + 5, "gcc", 3) == 0) 4302 len -= sizeof ("/lib/gcc/") - 1; 4303 } 4304 4305 set_std_prefix (gcc_exec_prefix, len); 4306 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC", 4307 PREFIX_PRIORITY_LAST, 0, 0); 4308 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC", 4309 PREFIX_PRIORITY_LAST, 0, 0); 4310 } 4311 4312 /* COMPILER_PATH and LIBRARY_PATH have values 4313 that are lists of directory names with colons. */ 4314 4315 temp = env.get ("COMPILER_PATH"); 4316 if (temp) 4317 { 4318 const char *startp, *endp; 4319 char *nstore = (char *) alloca (strlen (temp) + 3); 4320 4321 startp = endp = temp; 4322 while (1) 4323 { 4324 if (*endp == PATH_SEPARATOR || *endp == 0) 4325 { 4326 strncpy (nstore, startp, endp - startp); 4327 if (endp == startp) 4328 strcpy (nstore, concat (".", dir_separator_str, NULL)); 4329 else if (!IS_DIR_SEPARATOR (endp[-1])) 4330 { 4331 nstore[endp - startp] = DIR_SEPARATOR; 4332 nstore[endp - startp + 1] = 0; 4333 } 4334 else 4335 nstore[endp - startp] = 0; 4336 add_prefix (&exec_prefixes, nstore, 0, 4337 PREFIX_PRIORITY_LAST, 0, 0); 4338 add_prefix (&include_prefixes, nstore, 0, 4339 PREFIX_PRIORITY_LAST, 0, 0); 4340 if (*endp == 0) 4341 break; 4342 endp = startp = endp + 1; 4343 } 4344 else 4345 endp++; 4346 } 4347 } 4348 4349 temp = env.get (LIBRARY_PATH_ENV); 4350 if (temp && *cross_compile == '0') 4351 { 4352 const char *startp, *endp; 4353 char *nstore = (char *) alloca (strlen (temp) + 3); 4354 4355 startp = endp = temp; 4356 while (1) 4357 { 4358 if (*endp == PATH_SEPARATOR || *endp == 0) 4359 { 4360 strncpy (nstore, startp, endp - startp); 4361 if (endp == startp) 4362 strcpy (nstore, concat (".", dir_separator_str, NULL)); 4363 else if (!IS_DIR_SEPARATOR (endp[-1])) 4364 { 4365 nstore[endp - startp] = DIR_SEPARATOR; 4366 nstore[endp - startp + 1] = 0; 4367 } 4368 else 4369 nstore[endp - startp] = 0; 4370 add_prefix (&startfile_prefixes, nstore, NULL, 4371 PREFIX_PRIORITY_LAST, 0, 1); 4372 if (*endp == 0) 4373 break; 4374 endp = startp = endp + 1; 4375 } 4376 else 4377 endp++; 4378 } 4379 } 4380 4381 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */ 4382 temp = env.get ("LPATH"); 4383 if (temp && *cross_compile == '0') 4384 { 4385 const char *startp, *endp; 4386 char *nstore = (char *) alloca (strlen (temp) + 3); 4387 4388 startp = endp = temp; 4389 while (1) 4390 { 4391 if (*endp == PATH_SEPARATOR || *endp == 0) 4392 { 4393 strncpy (nstore, startp, endp - startp); 4394 if (endp == startp) 4395 strcpy (nstore, concat (".", dir_separator_str, NULL)); 4396 else if (!IS_DIR_SEPARATOR (endp[-1])) 4397 { 4398 nstore[endp - startp] = DIR_SEPARATOR; 4399 nstore[endp - startp + 1] = 0; 4400 } 4401 else 4402 nstore[endp - startp] = 0; 4403 add_prefix (&startfile_prefixes, nstore, NULL, 4404 PREFIX_PRIORITY_LAST, 0, 1); 4405 if (*endp == 0) 4406 break; 4407 endp = startp = endp + 1; 4408 } 4409 else 4410 endp++; 4411 } 4412 } 4413 4414 /* Process the options and store input files and switches in their 4415 vectors. */ 4416 4417 last_language_n_infiles = -1; 4418 4419 set_option_handlers (&handlers); 4420 4421 for (j = 1; j < decoded_options_count; j++) 4422 { 4423 switch (decoded_options[j].opt_index) 4424 { 4425 case OPT_S: 4426 case OPT_c: 4427 case OPT_E: 4428 have_c = 1; 4429 break; 4430 } 4431 if (have_c) 4432 break; 4433 } 4434 4435 for (j = 1; j < decoded_options_count; j++) 4436 { 4437 if (decoded_options[j].opt_index == OPT_SPECIAL_input_file) 4438 { 4439 const char *arg = decoded_options[j].arg; 4440 const char *p = strrchr (arg, '@'); 4441 char *fname; 4442 long offset; 4443 int consumed; 4444 #ifdef HAVE_TARGET_OBJECT_SUFFIX 4445 arg = convert_filename (arg, 0, access (arg, F_OK)); 4446 #endif 4447 /* For LTO static archive support we handle input file 4448 specifications that are composed of a filename and 4449 an offset like FNAME@OFFSET. */ 4450 if (p 4451 && p != arg 4452 && sscanf (p, "@%li%n", &offset, &consumed) >= 1 4453 && strlen (p) == (unsigned int)consumed) 4454 { 4455 fname = (char *)xmalloc (p - arg + 1); 4456 memcpy (fname, arg, p - arg); 4457 fname[p - arg] = '\0'; 4458 /* Only accept non-stdin and existing FNAME parts, otherwise 4459 try with the full name. */ 4460 if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0) 4461 { 4462 free (fname); 4463 fname = xstrdup (arg); 4464 } 4465 } 4466 else 4467 fname = xstrdup (arg); 4468 4469 if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0) 4470 { 4471 if (fname[0] == '@' && access (fname + 1, F_OK) < 0) 4472 perror_with_name (fname + 1); 4473 else 4474 perror_with_name (fname); 4475 } 4476 else 4477 add_infile (arg, spec_lang); 4478 4479 free (fname); 4480 continue; 4481 } 4482 4483 read_cmdline_option (&global_options, &global_options_set, 4484 decoded_options + j, UNKNOWN_LOCATION, 4485 CL_DRIVER, &handlers, global_dc); 4486 } 4487 4488 /* If the user didn't specify any, default to all configured offload 4489 targets. */ 4490 if (ENABLE_OFFLOADING && offload_targets == NULL) 4491 handle_foffload_option (OFFLOAD_TARGETS); 4492 4493 if (output_file 4494 && strcmp (output_file, "-") != 0 4495 && strcmp (output_file, HOST_BIT_BUCKET) != 0) 4496 { 4497 int i; 4498 for (i = 0; i < n_infiles; i++) 4499 if ((!infiles[i].language || infiles[i].language[0] != '*') 4500 && canonical_filename_eq (infiles[i].name, output_file)) 4501 fatal_error (input_location, 4502 "input file %qs is the same as output file", 4503 output_file); 4504 } 4505 4506 if (output_file != NULL && output_file[0] == '\0') 4507 fatal_error (input_location, "output filename may not be empty"); 4508 4509 /* If -save-temps=obj and -o name, create the prefix to use for %b. 4510 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */ 4511 if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL) 4512 { 4513 save_temps_length = strlen (save_temps_prefix); 4514 temp = strrchr (lbasename (save_temps_prefix), '.'); 4515 if (temp) 4516 { 4517 save_temps_length -= strlen (temp); 4518 save_temps_prefix[save_temps_length] = '\0'; 4519 } 4520 4521 } 4522 else if (save_temps_prefix != NULL) 4523 { 4524 free (save_temps_prefix); 4525 save_temps_prefix = NULL; 4526 } 4527 4528 if (save_temps_flag && use_pipes) 4529 { 4530 /* -save-temps overrides -pipe, so that temp files are produced */ 4531 if (save_temps_flag) 4532 warning (0, "-pipe ignored because -save-temps specified"); 4533 use_pipes = 0; 4534 } 4535 4536 if (!compare_debug) 4537 { 4538 const char *gcd = env.get ("GCC_COMPARE_DEBUG"); 4539 4540 if (gcd && gcd[0] == '-') 4541 { 4542 compare_debug = 2; 4543 compare_debug_opt = gcd; 4544 } 4545 else if (gcd && *gcd && strcmp (gcd, "0")) 4546 { 4547 compare_debug = 3; 4548 compare_debug_opt = "-gtoggle"; 4549 } 4550 } 4551 else if (compare_debug < 0) 4552 { 4553 compare_debug = 0; 4554 gcc_assert (!compare_debug_opt); 4555 } 4556 4557 /* Set up the search paths. We add directories that we expect to 4558 contain GNU Toolchain components before directories specified by 4559 the machine description so that we will find GNU components (like 4560 the GNU assembler) before those of the host system. */ 4561 4562 /* If we don't know where the toolchain has been installed, use the 4563 configured-in locations. */ 4564 if (!gcc_exec_prefix) 4565 { 4566 #ifndef OS2 4567 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC", 4568 PREFIX_PRIORITY_LAST, 1, 0); 4569 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS", 4570 PREFIX_PRIORITY_LAST, 2, 0); 4571 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS", 4572 PREFIX_PRIORITY_LAST, 2, 0); 4573 #endif 4574 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS", 4575 PREFIX_PRIORITY_LAST, 1, 0); 4576 } 4577 4578 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix)); 4579 tooldir_prefix2 = concat (tooldir_base_prefix, spec_machine, 4580 dir_separator_str, NULL); 4581 4582 /* Look for tools relative to the location from which the driver is 4583 running, or, if that is not available, the configured prefix. */ 4584 tooldir_prefix 4585 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix, 4586 spec_host_machine, dir_separator_str, spec_version, 4587 accel_dir_suffix, dir_separator_str, tooldir_prefix2, NULL); 4588 free (tooldir_prefix2); 4589 4590 add_prefix (&exec_prefixes, 4591 concat (tooldir_prefix, "bin", dir_separator_str, NULL), 4592 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0); 4593 add_prefix (&startfile_prefixes, 4594 concat (tooldir_prefix, "lib", dir_separator_str, NULL), 4595 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1); 4596 free (tooldir_prefix); 4597 4598 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS) 4599 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix, 4600 then consider it to relocate with the rest of the GCC installation 4601 if GCC_EXEC_PREFIX is set. 4602 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */ 4603 if (target_system_root && !target_system_root_changed && gcc_exec_prefix) 4604 { 4605 char *tmp_prefix = get_relative_prefix (decoded_options[0].arg, 4606 standard_bindir_prefix, 4607 target_system_root); 4608 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0) 4609 { 4610 target_system_root = tmp_prefix; 4611 target_system_root_changed = 1; 4612 } 4613 } 4614 #endif 4615 4616 /* More prefixes are enabled in main, after we read the specs file 4617 and determine whether this is cross-compilation or not. */ 4618 4619 if (n_infiles == last_language_n_infiles && spec_lang != 0) 4620 warning (0, "%<-x %s%> after last input file has no effect", spec_lang); 4621 4622 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG 4623 environment variable. */ 4624 if (compare_debug == 2 || compare_debug == 3) 4625 { 4626 const char *opt = concat ("-fcompare-debug=", compare_debug_opt, NULL); 4627 save_switch (opt, 0, NULL, false, true); 4628 compare_debug = 1; 4629 } 4630 4631 /* Ensure we only invoke each subprocess once. */ 4632 if (print_subprocess_help || print_help_list || print_version) 4633 { 4634 n_infiles = 0; 4635 4636 /* Create a dummy input file, so that we can pass 4637 the help option on to the various sub-processes. */ 4638 add_infile ("help-dummy", "c"); 4639 } 4640 4641 /* Decide if undefined variable references are allowed in specs. */ 4642 4643 /* -v alone is safe. --version and --help alone or together are safe. Note 4644 that -v would make them unsafe, as they'd then be run for subprocesses as 4645 well, the location of which might depend on variables possibly coming 4646 from self-specs. Note also that the command name is counted in 4647 decoded_options_count. */ 4648 4649 unsigned help_version_count = 0; 4650 4651 if (print_version) 4652 help_version_count++; 4653 4654 if (print_help_list) 4655 help_version_count++; 4656 4657 spec_undefvar_allowed = 4658 ((verbose_flag && decoded_options_count == 2) 4659 || help_version_count == decoded_options_count - 1); 4660 4661 alloc_switch (); 4662 switches[n_switches].part1 = 0; 4663 alloc_infile (); 4664 infiles[n_infiles].name = 0; 4665 } 4666 4667 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS 4668 and place that in the environment. */ 4669 4670 static void 4671 set_collect_gcc_options (void) 4672 { 4673 int i; 4674 int first_time; 4675 4676 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to 4677 the compiler. */ 4678 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=", 4679 sizeof ("COLLECT_GCC_OPTIONS=") - 1); 4680 4681 first_time = TRUE; 4682 for (i = 0; (int) i < n_switches; i++) 4683 { 4684 const char *const *args; 4685 const char *p, *q; 4686 if (!first_time) 4687 obstack_grow (&collect_obstack, " ", 1); 4688 4689 first_time = FALSE; 4690 4691 /* Ignore elided switches. */ 4692 if ((switches[i].live_cond 4693 & (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC)) 4694 == SWITCH_IGNORE) 4695 continue; 4696 4697 obstack_grow (&collect_obstack, "'-", 2); 4698 q = switches[i].part1; 4699 while ((p = strchr (q, '\''))) 4700 { 4701 obstack_grow (&collect_obstack, q, p - q); 4702 obstack_grow (&collect_obstack, "'\\''", 4); 4703 q = ++p; 4704 } 4705 obstack_grow (&collect_obstack, q, strlen (q)); 4706 obstack_grow (&collect_obstack, "'", 1); 4707 4708 for (args = switches[i].args; args && *args; args++) 4709 { 4710 obstack_grow (&collect_obstack, " '", 2); 4711 q = *args; 4712 while ((p = strchr (q, '\''))) 4713 { 4714 obstack_grow (&collect_obstack, q, p - q); 4715 obstack_grow (&collect_obstack, "'\\''", 4); 4716 q = ++p; 4717 } 4718 obstack_grow (&collect_obstack, q, strlen (q)); 4719 obstack_grow (&collect_obstack, "'", 1); 4720 } 4721 } 4722 obstack_grow (&collect_obstack, "\0", 1); 4723 xputenv (XOBFINISH (&collect_obstack, char *)); 4724 } 4725 4726 /* Process a spec string, accumulating and running commands. */ 4727 4728 /* These variables describe the input file name. 4729 input_file_number is the index on outfiles of this file, 4730 so that the output file name can be stored for later use by %o. 4731 input_basename is the start of the part of the input file 4732 sans all directory names, and basename_length is the number 4733 of characters starting there excluding the suffix .c or whatever. */ 4734 4735 static const char *gcc_input_filename; 4736 static int input_file_number; 4737 size_t input_filename_length; 4738 static int basename_length; 4739 static int suffixed_basename_length; 4740 static const char *input_basename; 4741 static const char *input_suffix; 4742 #ifndef HOST_LACKS_INODE_NUMBERS 4743 static struct stat input_stat; 4744 #endif 4745 static int input_stat_set; 4746 4747 /* The compiler used to process the current input file. */ 4748 static struct compiler *input_file_compiler; 4749 4750 /* These are variables used within do_spec and do_spec_1. */ 4751 4752 /* Nonzero if an arg has been started and not yet terminated 4753 (with space, tab or newline). */ 4754 static int arg_going; 4755 4756 /* Nonzero means %d or %g has been seen; the next arg to be terminated 4757 is a temporary file name. */ 4758 static int delete_this_arg; 4759 4760 /* Nonzero means %w has been seen; the next arg to be terminated 4761 is the output file name of this compilation. */ 4762 static int this_is_output_file; 4763 4764 /* Nonzero means %s has been seen; the next arg to be terminated 4765 is the name of a library file and we should try the standard 4766 search dirs for it. */ 4767 static int this_is_library_file; 4768 4769 /* Nonzero means %T has been seen; the next arg to be terminated 4770 is the name of a linker script and we should try all of the 4771 standard search dirs for it. If it is found insert a --script 4772 command line switch and then substitute the full path in place, 4773 otherwise generate an error message. */ 4774 static int this_is_linker_script; 4775 4776 /* Nonzero means that the input of this command is coming from a pipe. */ 4777 static int input_from_pipe; 4778 4779 /* Nonnull means substitute this for any suffix when outputting a switches 4780 arguments. */ 4781 static const char *suffix_subst; 4782 4783 /* If there is an argument being accumulated, terminate it and store it. */ 4784 4785 static void 4786 end_going_arg (void) 4787 { 4788 if (arg_going) 4789 { 4790 const char *string; 4791 4792 obstack_1grow (&obstack, 0); 4793 string = XOBFINISH (&obstack, const char *); 4794 if (this_is_library_file) 4795 string = find_file (string); 4796 if (this_is_linker_script) 4797 { 4798 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true); 4799 4800 if (full_script_path == NULL) 4801 { 4802 error ("unable to locate default linker script %qs in the library search paths", string); 4803 /* Script was not found on search path. */ 4804 return; 4805 } 4806 store_arg ("--script", false, false); 4807 string = full_script_path; 4808 } 4809 store_arg (string, delete_this_arg, this_is_output_file); 4810 if (this_is_output_file) 4811 outfiles[input_file_number] = string; 4812 arg_going = 0; 4813 } 4814 } 4815 4816 4817 /* Parse the WRAPPER string which is a comma separated list of the command line 4818 and insert them into the beginning of argbuf. */ 4819 4820 static void 4821 insert_wrapper (const char *wrapper) 4822 { 4823 int n = 0; 4824 int i; 4825 char *buf = xstrdup (wrapper); 4826 char *p = buf; 4827 unsigned int old_length = argbuf.length (); 4828 4829 do 4830 { 4831 n++; 4832 while (*p == ',') 4833 p++; 4834 } 4835 while ((p = strchr (p, ',')) != NULL); 4836 4837 argbuf.safe_grow (old_length + n); 4838 memmove (argbuf.address () + n, 4839 argbuf.address (), 4840 old_length * sizeof (const_char_p)); 4841 4842 i = 0; 4843 p = buf; 4844 do 4845 { 4846 while (*p == ',') 4847 { 4848 *p = 0; 4849 p++; 4850 } 4851 argbuf[i] = p; 4852 i++; 4853 } 4854 while ((p = strchr (p, ',')) != NULL); 4855 gcc_assert (i == n); 4856 } 4857 4858 /* Process the spec SPEC and run the commands specified therein. 4859 Returns 0 if the spec is successfully processed; -1 if failed. */ 4860 4861 int 4862 do_spec (const char *spec) 4863 { 4864 int value; 4865 4866 value = do_spec_2 (spec); 4867 4868 /* Force out any unfinished command. 4869 If -pipe, this forces out the last command if it ended in `|'. */ 4870 if (value == 0) 4871 { 4872 if (argbuf.length () > 0 4873 && !strcmp (argbuf.last (), "|")) 4874 argbuf.pop (); 4875 4876 set_collect_gcc_options (); 4877 4878 if (argbuf.length () > 0) 4879 value = execute (); 4880 } 4881 4882 return value; 4883 } 4884 4885 static int 4886 do_spec_2 (const char *spec) 4887 { 4888 int result; 4889 4890 clear_args (); 4891 arg_going = 0; 4892 delete_this_arg = 0; 4893 this_is_output_file = 0; 4894 this_is_library_file = 0; 4895 this_is_linker_script = 0; 4896 input_from_pipe = 0; 4897 suffix_subst = NULL; 4898 4899 result = do_spec_1 (spec, 0, NULL); 4900 4901 end_going_arg (); 4902 4903 return result; 4904 } 4905 4906 4907 /* Process the given spec string and add any new options to the end 4908 of the switches/n_switches array. */ 4909 4910 static void 4911 do_option_spec (const char *name, const char *spec) 4912 { 4913 unsigned int i, value_count, value_len; 4914 const char *p, *q, *value; 4915 char *tmp_spec, *tmp_spec_p; 4916 4917 if (configure_default_options[0].name == NULL) 4918 return; 4919 4920 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++) 4921 if (strcmp (configure_default_options[i].name, name) == 0) 4922 break; 4923 if (i == ARRAY_SIZE (configure_default_options)) 4924 return; 4925 4926 value = configure_default_options[i].value; 4927 value_len = strlen (value); 4928 4929 /* Compute the size of the final spec. */ 4930 value_count = 0; 4931 p = spec; 4932 while ((p = strstr (p, "%(VALUE)")) != NULL) 4933 { 4934 p ++; 4935 value_count ++; 4936 } 4937 4938 /* Replace each %(VALUE) by the specified value. */ 4939 tmp_spec = (char *) alloca (strlen (spec) + 1 4940 + value_count * (value_len - strlen ("%(VALUE)"))); 4941 tmp_spec_p = tmp_spec; 4942 q = spec; 4943 while ((p = strstr (q, "%(VALUE)")) != NULL) 4944 { 4945 memcpy (tmp_spec_p, q, p - q); 4946 tmp_spec_p = tmp_spec_p + (p - q); 4947 memcpy (tmp_spec_p, value, value_len); 4948 tmp_spec_p += value_len; 4949 q = p + strlen ("%(VALUE)"); 4950 } 4951 strcpy (tmp_spec_p, q); 4952 4953 do_self_spec (tmp_spec); 4954 } 4955 4956 /* Process the given spec string and add any new options to the end 4957 of the switches/n_switches array. */ 4958 4959 static void 4960 do_self_spec (const char *spec) 4961 { 4962 int i; 4963 4964 do_spec_2 (spec); 4965 do_spec_1 (" ", 0, NULL); 4966 4967 /* Mark %<S switches processed by do_self_spec to be ignored permanently. 4968 do_self_specs adds the replacements to switches array, so it shouldn't 4969 be processed afterwards. */ 4970 for (i = 0; i < n_switches; i++) 4971 if ((switches[i].live_cond & SWITCH_IGNORE)) 4972 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY; 4973 4974 if (argbuf.length () > 0) 4975 { 4976 const char **argbuf_copy; 4977 struct cl_decoded_option *decoded_options; 4978 struct cl_option_handlers handlers; 4979 unsigned int decoded_options_count; 4980 unsigned int j; 4981 4982 /* Create a copy of argbuf with a dummy argv[0] entry for 4983 decode_cmdline_options_to_array. */ 4984 argbuf_copy = XNEWVEC (const char *, 4985 argbuf.length () + 1); 4986 argbuf_copy[0] = ""; 4987 memcpy (argbuf_copy + 1, argbuf.address (), 4988 argbuf.length () * sizeof (const char *)); 4989 4990 decode_cmdline_options_to_array (argbuf.length () + 1, 4991 argbuf_copy, 4992 CL_DRIVER, &decoded_options, 4993 &decoded_options_count); 4994 free (argbuf_copy); 4995 4996 set_option_handlers (&handlers); 4997 4998 for (j = 1; j < decoded_options_count; j++) 4999 { 5000 switch (decoded_options[j].opt_index) 5001 { 5002 case OPT_SPECIAL_input_file: 5003 /* Specs should only generate options, not input 5004 files. */ 5005 if (strcmp (decoded_options[j].arg, "-") != 0) 5006 fatal_error (input_location, 5007 "switch %qs does not start with %<-%>", 5008 decoded_options[j].arg); 5009 else 5010 fatal_error (input_location, 5011 "spec-generated switch is just %<-%>"); 5012 break; 5013 5014 case OPT_fcompare_debug_second: 5015 case OPT_fcompare_debug: 5016 case OPT_fcompare_debug_: 5017 case OPT_o: 5018 /* Avoid duplicate processing of some options from 5019 compare-debug specs; just save them here. */ 5020 save_switch (decoded_options[j].canonical_option[0], 5021 (decoded_options[j].canonical_option_num_elements 5022 - 1), 5023 &decoded_options[j].canonical_option[1], false, true); 5024 break; 5025 5026 default: 5027 read_cmdline_option (&global_options, &global_options_set, 5028 decoded_options + j, UNKNOWN_LOCATION, 5029 CL_DRIVER, &handlers, global_dc); 5030 break; 5031 } 5032 } 5033 5034 free (decoded_options); 5035 5036 alloc_switch (); 5037 switches[n_switches].part1 = 0; 5038 } 5039 } 5040 5041 /* Callback for processing %D and %I specs. */ 5042 5043 struct spec_path_info { 5044 const char *option; 5045 const char *append; 5046 size_t append_len; 5047 bool omit_relative; 5048 bool separate_options; 5049 }; 5050 5051 static void * 5052 spec_path (char *path, void *data) 5053 { 5054 struct spec_path_info *info = (struct spec_path_info *) data; 5055 size_t len = 0; 5056 char save = 0; 5057 5058 if (info->omit_relative && !IS_ABSOLUTE_PATH (path)) 5059 return NULL; 5060 5061 if (info->append_len != 0) 5062 { 5063 len = strlen (path); 5064 memcpy (path + len, info->append, info->append_len + 1); 5065 } 5066 5067 if (!is_directory (path, true)) 5068 return NULL; 5069 5070 do_spec_1 (info->option, 1, NULL); 5071 if (info->separate_options) 5072 do_spec_1 (" ", 0, NULL); 5073 5074 if (info->append_len == 0) 5075 { 5076 len = strlen (path); 5077 save = path[len - 1]; 5078 if (IS_DIR_SEPARATOR (path[len - 1])) 5079 path[len - 1] = '\0'; 5080 } 5081 5082 do_spec_1 (path, 1, NULL); 5083 do_spec_1 (" ", 0, NULL); 5084 5085 /* Must not damage the original path. */ 5086 if (info->append_len == 0) 5087 path[len - 1] = save; 5088 5089 return NULL; 5090 } 5091 5092 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the 5093 argument list. */ 5094 5095 static void 5096 create_at_file (char **argv) 5097 { 5098 char *temp_file = make_temp_file (""); 5099 char *at_argument = concat ("@", temp_file, NULL); 5100 FILE *f = fopen (temp_file, "w"); 5101 int status; 5102 5103 if (f == NULL) 5104 fatal_error (input_location, "could not open temporary response file %s", 5105 temp_file); 5106 5107 status = writeargv (argv, f); 5108 5109 if (status) 5110 fatal_error (input_location, 5111 "could not write to temporary response file %s", 5112 temp_file); 5113 5114 status = fclose (f); 5115 5116 if (EOF == status) 5117 fatal_error (input_location, "could not close temporary response file %s", 5118 temp_file); 5119 5120 store_arg (at_argument, 0, 0); 5121 5122 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag); 5123 } 5124 5125 /* True if we should compile INFILE. */ 5126 5127 static bool 5128 compile_input_file_p (struct infile *infile) 5129 { 5130 if ((!infile->language) || (infile->language[0] != '*')) 5131 if (infile->incompiler == input_file_compiler) 5132 return true; 5133 return false; 5134 } 5135 5136 /* Process each member of VEC as a spec. */ 5137 5138 static void 5139 do_specs_vec (vec<char_p> vec) 5140 { 5141 unsigned ix; 5142 char *opt; 5143 5144 FOR_EACH_VEC_ELT (vec, ix, opt) 5145 { 5146 do_spec_1 (opt, 1, NULL); 5147 /* Make each accumulated option a separate argument. */ 5148 do_spec_1 (" ", 0, NULL); 5149 } 5150 } 5151 5152 /* Process the sub-spec SPEC as a portion of a larger spec. 5153 This is like processing a whole spec except that we do 5154 not initialize at the beginning and we do not supply a 5155 newline by default at the end. 5156 INSWITCH nonzero means don't process %-sequences in SPEC; 5157 in this case, % is treated as an ordinary character. 5158 This is used while substituting switches. 5159 INSWITCH nonzero also causes SPC not to terminate an argument. 5160 5161 Value is zero unless a line was finished 5162 and the command on that line reported an error. */ 5163 5164 static int 5165 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part) 5166 { 5167 const char *p = spec; 5168 int c; 5169 int i; 5170 int value; 5171 5172 /* If it's an empty string argument to a switch, keep it as is. */ 5173 if (inswitch && !*p) 5174 arg_going = 1; 5175 5176 while ((c = *p++)) 5177 /* If substituting a switch, treat all chars like letters. 5178 Otherwise, NL, SPC, TAB and % are special. */ 5179 switch (inswitch ? 'a' : c) 5180 { 5181 case '\n': 5182 end_going_arg (); 5183 5184 if (argbuf.length () > 0 5185 && !strcmp (argbuf.last (), "|")) 5186 { 5187 /* A `|' before the newline means use a pipe here, 5188 but only if -pipe was specified. 5189 Otherwise, execute now and don't pass the `|' as an arg. */ 5190 if (use_pipes) 5191 { 5192 input_from_pipe = 1; 5193 break; 5194 } 5195 else 5196 argbuf.pop (); 5197 } 5198 5199 set_collect_gcc_options (); 5200 5201 if (argbuf.length () > 0) 5202 { 5203 value = execute (); 5204 if (value) 5205 return value; 5206 } 5207 /* Reinitialize for a new command, and for a new argument. */ 5208 clear_args (); 5209 arg_going = 0; 5210 delete_this_arg = 0; 5211 this_is_output_file = 0; 5212 this_is_library_file = 0; 5213 this_is_linker_script = 0; 5214 input_from_pipe = 0; 5215 break; 5216 5217 case '|': 5218 end_going_arg (); 5219 5220 /* Use pipe */ 5221 obstack_1grow (&obstack, c); 5222 arg_going = 1; 5223 break; 5224 5225 case '\t': 5226 case ' ': 5227 end_going_arg (); 5228 5229 /* Reinitialize for a new argument. */ 5230 delete_this_arg = 0; 5231 this_is_output_file = 0; 5232 this_is_library_file = 0; 5233 this_is_linker_script = 0; 5234 break; 5235 5236 case '%': 5237 switch (c = *p++) 5238 { 5239 case 0: 5240 fatal_error (input_location, "spec %qs invalid", spec); 5241 5242 case 'b': 5243 if (save_temps_length) 5244 obstack_grow (&obstack, save_temps_prefix, save_temps_length); 5245 else 5246 obstack_grow (&obstack, input_basename, basename_length); 5247 if (compare_debug < 0) 5248 obstack_grow (&obstack, ".gk", 3); 5249 arg_going = 1; 5250 break; 5251 5252 case 'B': 5253 if (save_temps_length) 5254 obstack_grow (&obstack, save_temps_prefix, save_temps_length); 5255 else 5256 obstack_grow (&obstack, input_basename, suffixed_basename_length); 5257 if (compare_debug < 0) 5258 obstack_grow (&obstack, ".gk", 3); 5259 arg_going = 1; 5260 break; 5261 5262 case 'd': 5263 delete_this_arg = 2; 5264 break; 5265 5266 /* Dump out the directories specified with LIBRARY_PATH, 5267 followed by the absolute directories 5268 that we search for startfiles. */ 5269 case 'D': 5270 { 5271 struct spec_path_info info; 5272 5273 info.option = "-L"; 5274 info.append_len = 0; 5275 #ifdef RELATIVE_PREFIX_NOT_LINKDIR 5276 /* Used on systems which record the specified -L dirs 5277 and use them to search for dynamic linking. 5278 Relative directories always come from -B, 5279 and it is better not to use them for searching 5280 at run time. In particular, stage1 loses. */ 5281 info.omit_relative = true; 5282 #else 5283 info.omit_relative = false; 5284 #endif 5285 info.separate_options = false; 5286 5287 for_each_path (&startfile_prefixes, true, 0, spec_path, &info); 5288 } 5289 break; 5290 5291 case 'e': 5292 /* %efoo means report an error with `foo' as error message 5293 and don't execute any more commands for this file. */ 5294 { 5295 const char *q = p; 5296 char *buf; 5297 while (*p != 0 && *p != '\n') 5298 p++; 5299 buf = (char *) alloca (p - q + 1); 5300 strncpy (buf, q, p - q); 5301 buf[p - q] = 0; 5302 error ("%s", _(buf)); 5303 return -1; 5304 } 5305 break; 5306 case 'n': 5307 /* %nfoo means report a notice with `foo' on stderr. */ 5308 { 5309 const char *q = p; 5310 char *buf; 5311 while (*p != 0 && *p != '\n') 5312 p++; 5313 buf = (char *) alloca (p - q + 1); 5314 strncpy (buf, q, p - q); 5315 buf[p - q] = 0; 5316 inform (UNKNOWN_LOCATION, "%s", _(buf)); 5317 if (*p) 5318 p++; 5319 } 5320 break; 5321 5322 case 'j': 5323 { 5324 struct stat st; 5325 5326 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is 5327 defined, and it is not a directory, and it is 5328 writable, use it. Otherwise, treat this like any 5329 other temporary file. */ 5330 5331 if ((!save_temps_flag) 5332 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode)) 5333 && (access (HOST_BIT_BUCKET, W_OK) == 0)) 5334 { 5335 obstack_grow (&obstack, HOST_BIT_BUCKET, 5336 strlen (HOST_BIT_BUCKET)); 5337 delete_this_arg = 0; 5338 arg_going = 1; 5339 break; 5340 } 5341 } 5342 goto create_temp_file; 5343 case '|': 5344 if (use_pipes) 5345 { 5346 obstack_1grow (&obstack, '-'); 5347 delete_this_arg = 0; 5348 arg_going = 1; 5349 5350 /* consume suffix */ 5351 while (*p == '.' || ISALNUM ((unsigned char) *p)) 5352 p++; 5353 if (p[0] == '%' && p[1] == 'O') 5354 p += 2; 5355 5356 break; 5357 } 5358 goto create_temp_file; 5359 case 'm': 5360 if (use_pipes) 5361 { 5362 /* consume suffix */ 5363 while (*p == '.' || ISALNUM ((unsigned char) *p)) 5364 p++; 5365 if (p[0] == '%' && p[1] == 'O') 5366 p += 2; 5367 5368 break; 5369 } 5370 goto create_temp_file; 5371 case 'g': 5372 case 'u': 5373 case 'U': 5374 create_temp_file: 5375 { 5376 struct temp_name *t; 5377 int suffix_length; 5378 const char *suffix = p; 5379 char *saved_suffix = NULL; 5380 5381 while (*p == '.' || ISALNUM ((unsigned char) *p)) 5382 p++; 5383 suffix_length = p - suffix; 5384 if (p[0] == '%' && p[1] == 'O') 5385 { 5386 p += 2; 5387 /* We don't support extra suffix characters after %O. */ 5388 if (*p == '.' || ISALNUM ((unsigned char) *p)) 5389 fatal_error (input_location, 5390 "spec %qs has invalid %<%%0%c%>", spec, *p); 5391 if (suffix_length == 0) 5392 suffix = TARGET_OBJECT_SUFFIX; 5393 else 5394 { 5395 saved_suffix 5396 = XNEWVEC (char, suffix_length 5397 + strlen (TARGET_OBJECT_SUFFIX) + 1); 5398 strncpy (saved_suffix, suffix, suffix_length); 5399 strcpy (saved_suffix + suffix_length, 5400 TARGET_OBJECT_SUFFIX); 5401 } 5402 suffix_length += strlen (TARGET_OBJECT_SUFFIX); 5403 } 5404 5405 if (compare_debug < 0) 5406 { 5407 suffix = concat (".gk", suffix, NULL); 5408 suffix_length += 3; 5409 } 5410 5411 /* If -save-temps=obj and -o were specified, use that for the 5412 temp file. */ 5413 if (save_temps_length) 5414 { 5415 char *tmp; 5416 temp_filename_length 5417 = save_temps_length + suffix_length + 1; 5418 tmp = (char *) alloca (temp_filename_length); 5419 memcpy (tmp, save_temps_prefix, save_temps_length); 5420 memcpy (tmp + save_temps_length, suffix, suffix_length); 5421 tmp[save_temps_length + suffix_length] = '\0'; 5422 temp_filename = save_string (tmp, save_temps_length 5423 + suffix_length); 5424 obstack_grow (&obstack, temp_filename, 5425 temp_filename_length); 5426 arg_going = 1; 5427 delete_this_arg = 0; 5428 break; 5429 } 5430 5431 /* If the gcc_input_filename has the same suffix specified 5432 for the %g, %u, or %U, and -save-temps is specified, 5433 we could end up using that file as an intermediate 5434 thus clobbering the user's source file (.e.g., 5435 gcc -save-temps foo.s would clobber foo.s with the 5436 output of cpp0). So check for this condition and 5437 generate a temp file as the intermediate. */ 5438 5439 if (save_temps_flag) 5440 { 5441 char *tmp; 5442 temp_filename_length = basename_length + suffix_length + 1; 5443 tmp = (char *) alloca (temp_filename_length); 5444 memcpy (tmp, input_basename, basename_length); 5445 memcpy (tmp + basename_length, suffix, suffix_length); 5446 tmp[basename_length + suffix_length] = '\0'; 5447 temp_filename = tmp; 5448 5449 if (filename_cmp (temp_filename, gcc_input_filename) != 0) 5450 { 5451 #ifndef HOST_LACKS_INODE_NUMBERS 5452 struct stat st_temp; 5453 5454 /* Note, set_input() resets input_stat_set to 0. */ 5455 if (input_stat_set == 0) 5456 { 5457 input_stat_set = stat (gcc_input_filename, 5458 &input_stat); 5459 if (input_stat_set >= 0) 5460 input_stat_set = 1; 5461 } 5462 5463 /* If we have the stat for the gcc_input_filename 5464 and we can do the stat for the temp_filename 5465 then the they could still refer to the same 5466 file if st_dev/st_ino's are the same. */ 5467 if (input_stat_set != 1 5468 || stat (temp_filename, &st_temp) < 0 5469 || input_stat.st_dev != st_temp.st_dev 5470 || input_stat.st_ino != st_temp.st_ino) 5471 #else 5472 /* Just compare canonical pathnames. */ 5473 char* input_realname = lrealpath (gcc_input_filename); 5474 char* temp_realname = lrealpath (temp_filename); 5475 bool files_differ = filename_cmp (input_realname, temp_realname); 5476 free (input_realname); 5477 free (temp_realname); 5478 if (files_differ) 5479 #endif 5480 { 5481 temp_filename 5482 = save_string (temp_filename, 5483 temp_filename_length - 1); 5484 obstack_grow (&obstack, temp_filename, 5485 temp_filename_length); 5486 arg_going = 1; 5487 delete_this_arg = 0; 5488 break; 5489 } 5490 } 5491 } 5492 5493 /* See if we already have an association of %g/%u/%U and 5494 suffix. */ 5495 for (t = temp_names; t; t = t->next) 5496 if (t->length == suffix_length 5497 && strncmp (t->suffix, suffix, suffix_length) == 0 5498 && t->unique == (c == 'u' || c == 'U' || c == 'j')) 5499 break; 5500 5501 /* Make a new association if needed. %u and %j 5502 require one. */ 5503 if (t == 0 || c == 'u' || c == 'j') 5504 { 5505 if (t == 0) 5506 { 5507 t = XNEW (struct temp_name); 5508 t->next = temp_names; 5509 temp_names = t; 5510 } 5511 t->length = suffix_length; 5512 if (saved_suffix) 5513 { 5514 t->suffix = saved_suffix; 5515 saved_suffix = NULL; 5516 } 5517 else 5518 t->suffix = save_string (suffix, suffix_length); 5519 t->unique = (c == 'u' || c == 'U' || c == 'j'); 5520 temp_filename = make_temp_file (t->suffix); 5521 temp_filename_length = strlen (temp_filename); 5522 t->filename = temp_filename; 5523 t->filename_length = temp_filename_length; 5524 } 5525 5526 free (saved_suffix); 5527 5528 obstack_grow (&obstack, t->filename, t->filename_length); 5529 delete_this_arg = 1; 5530 } 5531 arg_going = 1; 5532 break; 5533 5534 case 'i': 5535 if (combine_inputs) 5536 { 5537 if (at_file_supplied) 5538 { 5539 /* We are going to expand `%i' to `@FILE', where FILE 5540 is a newly-created temporary filename. The filenames 5541 that would usually be expanded in place of %o will be 5542 written to the temporary file. */ 5543 char **argv; 5544 int n_files = 0; 5545 int j; 5546 5547 for (i = 0; i < n_infiles; i++) 5548 if (compile_input_file_p (&infiles[i])) 5549 n_files++; 5550 5551 argv = (char **) alloca (sizeof (char *) * (n_files + 1)); 5552 5553 /* Copy the strings over. */ 5554 for (i = 0, j = 0; i < n_infiles; i++) 5555 if (compile_input_file_p (&infiles[i])) 5556 { 5557 argv[j] = CONST_CAST (char *, infiles[i].name); 5558 infiles[i].compiled = true; 5559 j++; 5560 } 5561 argv[j] = NULL; 5562 5563 create_at_file (argv); 5564 } 5565 else 5566 for (i = 0; (int) i < n_infiles; i++) 5567 if (compile_input_file_p (&infiles[i])) 5568 { 5569 store_arg (infiles[i].name, 0, 0); 5570 infiles[i].compiled = true; 5571 } 5572 } 5573 else 5574 { 5575 obstack_grow (&obstack, gcc_input_filename, 5576 input_filename_length); 5577 arg_going = 1; 5578 } 5579 break; 5580 5581 case 'I': 5582 { 5583 struct spec_path_info info; 5584 5585 if (multilib_dir) 5586 { 5587 do_spec_1 ("-imultilib", 1, NULL); 5588 /* Make this a separate argument. */ 5589 do_spec_1 (" ", 0, NULL); 5590 do_spec_1 (multilib_dir, 1, NULL); 5591 do_spec_1 (" ", 0, NULL); 5592 } 5593 5594 if (multiarch_dir) 5595 { 5596 do_spec_1 ("-imultiarch", 1, NULL); 5597 /* Make this a separate argument. */ 5598 do_spec_1 (" ", 0, NULL); 5599 do_spec_1 (multiarch_dir, 1, NULL); 5600 do_spec_1 (" ", 0, NULL); 5601 } 5602 5603 if (gcc_exec_prefix) 5604 { 5605 do_spec_1 ("-iprefix", 1, NULL); 5606 /* Make this a separate argument. */ 5607 do_spec_1 (" ", 0, NULL); 5608 do_spec_1 (gcc_exec_prefix, 1, NULL); 5609 do_spec_1 (" ", 0, NULL); 5610 } 5611 5612 if (target_system_root_changed || 5613 (target_system_root && target_sysroot_hdrs_suffix)) 5614 { 5615 do_spec_1 ("-isysroot", 1, NULL); 5616 /* Make this a separate argument. */ 5617 do_spec_1 (" ", 0, NULL); 5618 do_spec_1 (target_system_root, 1, NULL); 5619 if (target_sysroot_hdrs_suffix) 5620 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL); 5621 do_spec_1 (" ", 0, NULL); 5622 } 5623 5624 info.option = "-isystem"; 5625 info.append = "include"; 5626 info.append_len = strlen (info.append); 5627 info.omit_relative = false; 5628 info.separate_options = true; 5629 5630 for_each_path (&include_prefixes, false, info.append_len, 5631 spec_path, &info); 5632 5633 info.append = "include-fixed"; 5634 if (*sysroot_hdrs_suffix_spec) 5635 info.append = concat (info.append, dir_separator_str, 5636 multilib_dir, NULL); 5637 info.append_len = strlen (info.append); 5638 for_each_path (&include_prefixes, false, info.append_len, 5639 spec_path, &info); 5640 } 5641 break; 5642 5643 case 'o': 5644 { 5645 int max = n_infiles; 5646 max += lang_specific_extra_outfiles; 5647 5648 if (HAVE_GNU_LD && at_file_supplied) 5649 { 5650 /* We are going to expand `%o' to `@FILE', where FILE 5651 is a newly-created temporary filename. The filenames 5652 that would usually be expanded in place of %o will be 5653 written to the temporary file. */ 5654 5655 char **argv; 5656 int n_files, j; 5657 5658 /* Convert OUTFILES into a form suitable for writeargv. */ 5659 5660 /* Determine how many are non-NULL. */ 5661 for (n_files = 0, i = 0; i < max; i++) 5662 n_files += outfiles[i] != NULL; 5663 5664 argv = (char **) alloca (sizeof (char *) * (n_files + 1)); 5665 5666 /* Copy the strings over. */ 5667 for (i = 0, j = 0; i < max; i++) 5668 if (outfiles[i]) 5669 { 5670 argv[j] = CONST_CAST (char *, outfiles[i]); 5671 j++; 5672 } 5673 argv[j] = NULL; 5674 5675 create_at_file (argv); 5676 } 5677 else 5678 for (i = 0; i < max; i++) 5679 if (outfiles[i]) 5680 store_arg (outfiles[i], 0, 0); 5681 break; 5682 } 5683 5684 case 'O': 5685 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX)); 5686 arg_going = 1; 5687 break; 5688 5689 case 's': 5690 this_is_library_file = 1; 5691 break; 5692 5693 case 'T': 5694 this_is_linker_script = 1; 5695 break; 5696 5697 case 'V': 5698 outfiles[input_file_number] = NULL; 5699 break; 5700 5701 case 'w': 5702 this_is_output_file = 1; 5703 break; 5704 5705 case 'W': 5706 { 5707 unsigned int cur_index = argbuf.length (); 5708 /* Handle the {...} following the %W. */ 5709 if (*p != '{') 5710 fatal_error (input_location, 5711 "spec %qs has invalid %<%%W%c%>", spec, *p); 5712 p = handle_braces (p + 1); 5713 if (p == 0) 5714 return -1; 5715 end_going_arg (); 5716 /* If any args were output, mark the last one for deletion 5717 on failure. */ 5718 if (argbuf.length () != cur_index) 5719 record_temp_file (argbuf.last (), 0, 1); 5720 break; 5721 } 5722 5723 /* %x{OPTION} records OPTION for %X to output. */ 5724 case 'x': 5725 { 5726 const char *p1 = p; 5727 char *string; 5728 char *opt; 5729 unsigned ix; 5730 5731 /* Skip past the option value and make a copy. */ 5732 if (*p != '{') 5733 fatal_error (input_location, 5734 "spec %qs has invalid %<%%x%c%>", spec, *p); 5735 while (*p++ != '}') 5736 ; 5737 string = save_string (p1 + 1, p - p1 - 2); 5738 5739 /* See if we already recorded this option. */ 5740 FOR_EACH_VEC_ELT (linker_options, ix, opt) 5741 if (! strcmp (string, opt)) 5742 { 5743 free (string); 5744 return 0; 5745 } 5746 5747 /* This option is new; add it. */ 5748 add_linker_option (string, strlen (string)); 5749 free (string); 5750 } 5751 break; 5752 5753 /* Dump out the options accumulated previously using %x. */ 5754 case 'X': 5755 do_specs_vec (linker_options); 5756 break; 5757 5758 /* Dump out the options accumulated previously using -Wa,. */ 5759 case 'Y': 5760 do_specs_vec (assembler_options); 5761 break; 5762 5763 /* Dump out the options accumulated previously using -Wp,. */ 5764 case 'Z': 5765 do_specs_vec (preprocessor_options); 5766 break; 5767 5768 /* Here are digits and numbers that just process 5769 a certain constant string as a spec. */ 5770 5771 case '1': 5772 value = do_spec_1 (cc1_spec, 0, NULL); 5773 if (value != 0) 5774 return value; 5775 break; 5776 5777 case '2': 5778 value = do_spec_1 (cc1plus_spec, 0, NULL); 5779 if (value != 0) 5780 return value; 5781 break; 5782 5783 case 'a': 5784 value = do_spec_1 (asm_spec, 0, NULL); 5785 if (value != 0) 5786 return value; 5787 break; 5788 5789 case 'A': 5790 value = do_spec_1 (asm_final_spec, 0, NULL); 5791 if (value != 0) 5792 return value; 5793 break; 5794 5795 case 'C': 5796 { 5797 const char *const spec 5798 = (input_file_compiler->cpp_spec 5799 ? input_file_compiler->cpp_spec 5800 : cpp_spec); 5801 value = do_spec_1 (spec, 0, NULL); 5802 if (value != 0) 5803 return value; 5804 } 5805 break; 5806 5807 case 'E': 5808 value = do_spec_1 (endfile_spec, 0, NULL); 5809 if (value != 0) 5810 return value; 5811 break; 5812 5813 case 'l': 5814 value = do_spec_1 (link_spec, 0, NULL); 5815 if (value != 0) 5816 return value; 5817 break; 5818 5819 case 'L': 5820 value = do_spec_1 (lib_spec, 0, NULL); 5821 if (value != 0) 5822 return value; 5823 break; 5824 5825 case 'M': 5826 if (multilib_os_dir == NULL) 5827 obstack_1grow (&obstack, '.'); 5828 else 5829 obstack_grow (&obstack, multilib_os_dir, 5830 strlen (multilib_os_dir)); 5831 break; 5832 5833 case 'G': 5834 value = do_spec_1 (libgcc_spec, 0, NULL); 5835 if (value != 0) 5836 return value; 5837 break; 5838 5839 case 'R': 5840 /* We assume there is a directory 5841 separator at the end of this string. */ 5842 if (target_system_root) 5843 { 5844 obstack_grow (&obstack, target_system_root, 5845 strlen (target_system_root)); 5846 if (target_sysroot_suffix) 5847 obstack_grow (&obstack, target_sysroot_suffix, 5848 strlen (target_sysroot_suffix)); 5849 } 5850 break; 5851 5852 case 'S': 5853 value = do_spec_1 (startfile_spec, 0, NULL); 5854 if (value != 0) 5855 return value; 5856 break; 5857 5858 /* Here we define characters other than letters and digits. */ 5859 5860 case '{': 5861 p = handle_braces (p); 5862 if (p == 0) 5863 return -1; 5864 break; 5865 5866 case ':': 5867 p = handle_spec_function (p, NULL); 5868 if (p == 0) 5869 return -1; 5870 break; 5871 5872 case '%': 5873 obstack_1grow (&obstack, '%'); 5874 break; 5875 5876 case '.': 5877 { 5878 unsigned len = 0; 5879 5880 while (p[len] && p[len] != ' ' && p[len] != '%') 5881 len++; 5882 suffix_subst = save_string (p - 1, len + 1); 5883 p += len; 5884 } 5885 break; 5886 5887 /* Henceforth ignore the option(s) matching the pattern 5888 after the %<. */ 5889 case '<': 5890 case '>': 5891 { 5892 unsigned len = 0; 5893 int have_wildcard = 0; 5894 int i; 5895 int switch_option; 5896 5897 if (c == '>') 5898 switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC; 5899 else 5900 switch_option = SWITCH_IGNORE; 5901 5902 while (p[len] && p[len] != ' ' && p[len] != '\t') 5903 len++; 5904 5905 if (p[len-1] == '*') 5906 have_wildcard = 1; 5907 5908 for (i = 0; i < n_switches; i++) 5909 if (!strncmp (switches[i].part1, p, len - have_wildcard) 5910 && (have_wildcard || switches[i].part1[len] == '\0')) 5911 { 5912 switches[i].live_cond |= switch_option; 5913 /* User switch be validated from validate_all_switches. 5914 when the definition is seen from the spec file. 5915 If not defined anywhere, will be rejected. */ 5916 if (switches[i].known) 5917 switches[i].validated = true; 5918 } 5919 5920 p += len; 5921 } 5922 break; 5923 5924 case '*': 5925 if (soft_matched_part) 5926 { 5927 if (soft_matched_part[0]) 5928 do_spec_1 (soft_matched_part, 1, NULL); 5929 /* Only insert a space after the substitution if it is at the 5930 end of the current sequence. So if: 5931 5932 "%{foo=*:bar%*}%{foo=*:one%*two}" 5933 5934 matches -foo=hello then it will produce: 5935 5936 barhello onehellotwo 5937 */ 5938 if (*p == 0 || *p == '}') 5939 do_spec_1 (" ", 0, NULL); 5940 } 5941 else 5942 /* Catch the case where a spec string contains something like 5943 '%{foo:%*}'. i.e. there is no * in the pattern on the left 5944 hand side of the :. */ 5945 error ("spec failure: %<%%*%> has not been initialized by pattern match"); 5946 break; 5947 5948 /* Process a string found as the value of a spec given by name. 5949 This feature allows individual machine descriptions 5950 to add and use their own specs. */ 5951 case '(': 5952 { 5953 const char *name = p; 5954 struct spec_list *sl; 5955 int len; 5956 5957 /* The string after the S/P is the name of a spec that is to be 5958 processed. */ 5959 while (*p && *p != ')') 5960 p++; 5961 5962 /* See if it's in the list. */ 5963 for (len = p - name, sl = specs; sl; sl = sl->next) 5964 if (sl->name_len == len && !strncmp (sl->name, name, len)) 5965 { 5966 name = *(sl->ptr_spec); 5967 #ifdef DEBUG_SPECS 5968 fnotice (stderr, "Processing spec (%s), which is '%s'\n", 5969 sl->name, name); 5970 #endif 5971 break; 5972 } 5973 5974 if (sl) 5975 { 5976 value = do_spec_1 (name, 0, NULL); 5977 if (value != 0) 5978 return value; 5979 } 5980 5981 /* Discard the closing paren. */ 5982 if (*p) 5983 p++; 5984 } 5985 break; 5986 5987 default: 5988 error ("spec failure: unrecognized spec option %qc", c); 5989 break; 5990 } 5991 break; 5992 5993 case '\\': 5994 /* Backslash: treat next character as ordinary. */ 5995 c = *p++; 5996 5997 /* Fall through. */ 5998 default: 5999 /* Ordinary character: put it into the current argument. */ 6000 obstack_1grow (&obstack, c); 6001 arg_going = 1; 6002 } 6003 6004 /* End of string. If we are processing a spec function, we need to 6005 end any pending argument. */ 6006 if (processing_spec_function) 6007 end_going_arg (); 6008 6009 return 0; 6010 } 6011 6012 /* Look up a spec function. */ 6013 6014 static const struct spec_function * 6015 lookup_spec_function (const char *name) 6016 { 6017 const struct spec_function *sf; 6018 6019 for (sf = static_spec_functions; sf->name != NULL; sf++) 6020 if (strcmp (sf->name, name) == 0) 6021 return sf; 6022 6023 return NULL; 6024 } 6025 6026 /* Evaluate a spec function. */ 6027 6028 static const char * 6029 eval_spec_function (const char *func, const char *args) 6030 { 6031 const struct spec_function *sf; 6032 const char *funcval; 6033 6034 /* Saved spec processing context. */ 6035 vec<const_char_p> save_argbuf; 6036 6037 int save_arg_going; 6038 int save_delete_this_arg; 6039 int save_this_is_output_file; 6040 int save_this_is_library_file; 6041 int save_input_from_pipe; 6042 int save_this_is_linker_script; 6043 const char *save_suffix_subst; 6044 6045 int save_growing_size; 6046 void *save_growing_value = NULL; 6047 6048 sf = lookup_spec_function (func); 6049 if (sf == NULL) 6050 fatal_error (input_location, "unknown spec function %qs", func); 6051 6052 /* Push the spec processing context. */ 6053 save_argbuf = argbuf; 6054 6055 save_arg_going = arg_going; 6056 save_delete_this_arg = delete_this_arg; 6057 save_this_is_output_file = this_is_output_file; 6058 save_this_is_library_file = this_is_library_file; 6059 save_this_is_linker_script = this_is_linker_script; 6060 save_input_from_pipe = input_from_pipe; 6061 save_suffix_subst = suffix_subst; 6062 6063 /* If we have some object growing now, finalize it so the args and function 6064 eval proceed from a cleared context. This is needed to prevent the first 6065 constructed arg from mistakenly including the growing value. We'll push 6066 this value back on the obstack once the function evaluation is done, to 6067 restore a consistent processing context for our caller. This is fine as 6068 the address of growing objects isn't guaranteed to remain stable until 6069 they are finalized, and we expect this situation to be rare enough for 6070 the extra copy not to be an issue. */ 6071 save_growing_size = obstack_object_size (&obstack); 6072 if (save_growing_size > 0) 6073 save_growing_value = obstack_finish (&obstack); 6074 6075 /* Create a new spec processing context, and build the function 6076 arguments. */ 6077 6078 alloc_args (); 6079 if (do_spec_2 (args) < 0) 6080 fatal_error (input_location, "error in args to spec function %qs", func); 6081 6082 /* argbuf_index is an index for the next argument to be inserted, and 6083 so contains the count of the args already inserted. */ 6084 6085 funcval = (*sf->func) (argbuf.length (), 6086 argbuf.address ()); 6087 6088 /* Pop the spec processing context. */ 6089 argbuf.release (); 6090 argbuf = save_argbuf; 6091 6092 arg_going = save_arg_going; 6093 delete_this_arg = save_delete_this_arg; 6094 this_is_output_file = save_this_is_output_file; 6095 this_is_library_file = save_this_is_library_file; 6096 this_is_linker_script = save_this_is_linker_script; 6097 input_from_pipe = save_input_from_pipe; 6098 suffix_subst = save_suffix_subst; 6099 6100 if (save_growing_size > 0) 6101 obstack_grow (&obstack, save_growing_value, save_growing_size); 6102 6103 return funcval; 6104 } 6105 6106 /* Handle a spec function call of the form: 6107 6108 %:function(args) 6109 6110 ARGS is processed as a spec in a separate context and split into an 6111 argument vector in the normal fashion. The function returns a string 6112 containing a spec which we then process in the caller's context, or 6113 NULL if no processing is required. 6114 6115 If RETVAL_NONNULL is not NULL, then store a bool whether function 6116 returned non-NULL. */ 6117 6118 static const char * 6119 handle_spec_function (const char *p, bool *retval_nonnull) 6120 { 6121 char *func, *args; 6122 const char *endp, *funcval; 6123 int count; 6124 6125 processing_spec_function++; 6126 6127 /* Get the function name. */ 6128 for (endp = p; *endp != '\0'; endp++) 6129 { 6130 if (*endp == '(') /* ) */ 6131 break; 6132 /* Only allow [A-Za-z0-9], -, and _ in function names. */ 6133 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_')) 6134 fatal_error (input_location, "malformed spec function name"); 6135 } 6136 if (*endp != '(') /* ) */ 6137 fatal_error (input_location, "no arguments for spec function"); 6138 func = save_string (p, endp - p); 6139 p = ++endp; 6140 6141 /* Get the arguments. */ 6142 for (count = 0; *endp != '\0'; endp++) 6143 { 6144 /* ( */ 6145 if (*endp == ')') 6146 { 6147 if (count == 0) 6148 break; 6149 count--; 6150 } 6151 else if (*endp == '(') /* ) */ 6152 count++; 6153 } 6154 /* ( */ 6155 if (*endp != ')') 6156 fatal_error (input_location, "malformed spec function arguments"); 6157 args = save_string (p, endp - p); 6158 p = ++endp; 6159 6160 /* p now points to just past the end of the spec function expression. */ 6161 6162 funcval = eval_spec_function (func, args); 6163 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0) 6164 p = NULL; 6165 if (retval_nonnull) 6166 *retval_nonnull = funcval != NULL; 6167 6168 free (func); 6169 free (args); 6170 6171 processing_spec_function--; 6172 6173 return p; 6174 } 6175 6176 /* Inline subroutine of handle_braces. Returns true if the current 6177 input suffix matches the atom bracketed by ATOM and END_ATOM. */ 6178 static inline bool 6179 input_suffix_matches (const char *atom, const char *end_atom) 6180 { 6181 return (input_suffix 6182 && !strncmp (input_suffix, atom, end_atom - atom) 6183 && input_suffix[end_atom - atom] == '\0'); 6184 } 6185 6186 /* Subroutine of handle_braces. Returns true if the current 6187 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */ 6188 static bool 6189 input_spec_matches (const char *atom, const char *end_atom) 6190 { 6191 return (input_file_compiler 6192 && input_file_compiler->suffix 6193 && input_file_compiler->suffix[0] != '\0' 6194 && !strncmp (input_file_compiler->suffix + 1, atom, 6195 end_atom - atom) 6196 && input_file_compiler->suffix[end_atom - atom + 1] == '\0'); 6197 } 6198 6199 /* Subroutine of handle_braces. Returns true if a switch 6200 matching the atom bracketed by ATOM and END_ATOM appeared on the 6201 command line. */ 6202 static bool 6203 switch_matches (const char *atom, const char *end_atom, int starred) 6204 { 6205 int i; 6206 int len = end_atom - atom; 6207 int plen = starred ? len : -1; 6208 6209 for (i = 0; i < n_switches; i++) 6210 if (!strncmp (switches[i].part1, atom, len) 6211 && (starred || switches[i].part1[len] == '\0') 6212 && check_live_switch (i, plen)) 6213 return true; 6214 6215 /* Check if a switch with separated form matching the atom. 6216 We check -D and -U switches. */ 6217 else if (switches[i].args != 0) 6218 { 6219 if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U') 6220 && *switches[i].part1 == atom[0]) 6221 { 6222 if (!strncmp (switches[i].args[0], &atom[1], len - 1) 6223 && (starred || (switches[i].part1[1] == '\0' 6224 && switches[i].args[0][len - 1] == '\0')) 6225 && check_live_switch (i, (starred ? 1 : -1))) 6226 return true; 6227 } 6228 } 6229 6230 return false; 6231 } 6232 6233 /* Inline subroutine of handle_braces. Mark all of the switches which 6234 match ATOM (extends to END_ATOM; STARRED indicates whether there 6235 was a star after the atom) for later processing. */ 6236 static inline void 6237 mark_matching_switches (const char *atom, const char *end_atom, int starred) 6238 { 6239 int i; 6240 int len = end_atom - atom; 6241 int plen = starred ? len : -1; 6242 6243 for (i = 0; i < n_switches; i++) 6244 if (!strncmp (switches[i].part1, atom, len) 6245 && (starred || switches[i].part1[len] == '\0') 6246 && check_live_switch (i, plen)) 6247 switches[i].ordering = 1; 6248 } 6249 6250 /* Inline subroutine of handle_braces. Process all the currently 6251 marked switches through give_switch, and clear the marks. */ 6252 static inline void 6253 process_marked_switches (void) 6254 { 6255 int i; 6256 6257 for (i = 0; i < n_switches; i++) 6258 if (switches[i].ordering == 1) 6259 { 6260 switches[i].ordering = 0; 6261 give_switch (i, 0); 6262 } 6263 } 6264 6265 /* Handle a %{ ... } construct. P points just inside the leading {. 6266 Returns a pointer one past the end of the brace block, or 0 6267 if we call do_spec_1 and that returns -1. */ 6268 6269 static const char * 6270 handle_braces (const char *p) 6271 { 6272 const char *atom, *end_atom; 6273 const char *d_atom = NULL, *d_end_atom = NULL; 6274 char *esc_buf = NULL, *d_esc_buf = NULL; 6275 int esc; 6276 const char *orig = p; 6277 6278 bool a_is_suffix; 6279 bool a_is_spectype; 6280 bool a_is_starred; 6281 bool a_is_negated; 6282 bool a_matched; 6283 6284 bool a_must_be_last = false; 6285 bool ordered_set = false; 6286 bool disjunct_set = false; 6287 bool disj_matched = false; 6288 bool disj_starred = true; 6289 bool n_way_choice = false; 6290 bool n_way_matched = false; 6291 6292 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0) 6293 6294 do 6295 { 6296 if (a_must_be_last) 6297 goto invalid; 6298 6299 /* Scan one "atom" (S in the description above of %{}, possibly 6300 with '!', '.', '@', ',', or '*' modifiers). */ 6301 a_matched = false; 6302 a_is_suffix = false; 6303 a_is_starred = false; 6304 a_is_negated = false; 6305 a_is_spectype = false; 6306 6307 SKIP_WHITE (); 6308 if (*p == '!') 6309 p++, a_is_negated = true; 6310 6311 SKIP_WHITE (); 6312 if (*p == '%' && p[1] == ':') 6313 { 6314 atom = NULL; 6315 end_atom = NULL; 6316 p = handle_spec_function (p + 2, &a_matched); 6317 } 6318 else 6319 { 6320 if (*p == '.') 6321 p++, a_is_suffix = true; 6322 else if (*p == ',') 6323 p++, a_is_spectype = true; 6324 6325 atom = p; 6326 esc = 0; 6327 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '=' 6328 || *p == ',' || *p == '.' || *p == '@' || *p == '\\') 6329 { 6330 if (*p == '\\') 6331 { 6332 p++; 6333 if (!*p) 6334 fatal_error (input_location, 6335 "braced spec %qs ends in escape", orig); 6336 esc++; 6337 } 6338 p++; 6339 } 6340 end_atom = p; 6341 6342 if (esc) 6343 { 6344 const char *ap; 6345 char *ep; 6346 6347 if (esc_buf && esc_buf != d_esc_buf) 6348 free (esc_buf); 6349 esc_buf = NULL; 6350 ep = esc_buf = (char *) xmalloc (end_atom - atom - esc + 1); 6351 for (ap = atom; ap != end_atom; ap++, ep++) 6352 { 6353 if (*ap == '\\') 6354 ap++; 6355 *ep = *ap; 6356 } 6357 *ep = '\0'; 6358 atom = esc_buf; 6359 end_atom = ep; 6360 } 6361 6362 if (*p == '*') 6363 p++, a_is_starred = 1; 6364 } 6365 6366 SKIP_WHITE (); 6367 switch (*p) 6368 { 6369 case '&': case '}': 6370 /* Substitute the switch(es) indicated by the current atom. */ 6371 ordered_set = true; 6372 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix 6373 || a_is_spectype || atom == end_atom) 6374 goto invalid; 6375 6376 mark_matching_switches (atom, end_atom, a_is_starred); 6377 6378 if (*p == '}') 6379 process_marked_switches (); 6380 break; 6381 6382 case '|': case ':': 6383 /* Substitute some text if the current atom appears as a switch 6384 or suffix. */ 6385 disjunct_set = true; 6386 if (ordered_set) 6387 goto invalid; 6388 6389 if (atom && atom == end_atom) 6390 { 6391 if (!n_way_choice || disj_matched || *p == '|' 6392 || a_is_negated || a_is_suffix || a_is_spectype 6393 || a_is_starred) 6394 goto invalid; 6395 6396 /* An empty term may appear as the last choice of an 6397 N-way choice set; it means "otherwise". */ 6398 a_must_be_last = true; 6399 disj_matched = !n_way_matched; 6400 disj_starred = false; 6401 } 6402 else 6403 { 6404 if ((a_is_suffix || a_is_spectype) && a_is_starred) 6405 goto invalid; 6406 6407 if (!a_is_starred) 6408 disj_starred = false; 6409 6410 /* Don't bother testing this atom if we already have a 6411 match. */ 6412 if (!disj_matched && !n_way_matched) 6413 { 6414 if (atom == NULL) 6415 /* a_matched is already set by handle_spec_function. */; 6416 else if (a_is_suffix) 6417 a_matched = input_suffix_matches (atom, end_atom); 6418 else if (a_is_spectype) 6419 a_matched = input_spec_matches (atom, end_atom); 6420 else 6421 a_matched = switch_matches (atom, end_atom, a_is_starred); 6422 6423 if (a_matched != a_is_negated) 6424 { 6425 disj_matched = true; 6426 d_atom = atom; 6427 d_end_atom = end_atom; 6428 d_esc_buf = esc_buf; 6429 } 6430 } 6431 } 6432 6433 if (*p == ':') 6434 { 6435 /* Found the body, that is, the text to substitute if the 6436 current disjunction matches. */ 6437 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred, 6438 disj_matched && !n_way_matched); 6439 if (p == 0) 6440 goto done; 6441 6442 /* If we have an N-way choice, reset state for the next 6443 disjunction. */ 6444 if (*p == ';') 6445 { 6446 n_way_choice = true; 6447 n_way_matched |= disj_matched; 6448 disj_matched = false; 6449 disj_starred = true; 6450 d_atom = d_end_atom = NULL; 6451 } 6452 } 6453 break; 6454 6455 default: 6456 goto invalid; 6457 } 6458 } 6459 while (*p++ != '}'); 6460 6461 done: 6462 if (d_esc_buf && d_esc_buf != esc_buf) 6463 free (d_esc_buf); 6464 if (esc_buf) 6465 free (esc_buf); 6466 6467 return p; 6468 6469 invalid: 6470 fatal_error (input_location, "braced spec %qs is invalid at %qc", orig, *p); 6471 6472 #undef SKIP_WHITE 6473 } 6474 6475 /* Subroutine of handle_braces. Scan and process a brace substitution body 6476 (X in the description of %{} syntax). P points one past the colon; 6477 ATOM and END_ATOM bracket the first atom which was found to be true 6478 (present) in the current disjunction; STARRED indicates whether all 6479 the atoms in the current disjunction were starred (for syntax validation); 6480 MATCHED indicates whether the disjunction matched or not, and therefore 6481 whether or not the body is to be processed through do_spec_1 or just 6482 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1 6483 returns -1. */ 6484 6485 static const char * 6486 process_brace_body (const char *p, const char *atom, const char *end_atom, 6487 int starred, int matched) 6488 { 6489 const char *body, *end_body; 6490 unsigned int nesting_level; 6491 bool have_subst = false; 6492 6493 /* Locate the closing } or ;, honoring nested braces. 6494 Trim trailing whitespace. */ 6495 body = p; 6496 nesting_level = 1; 6497 for (;;) 6498 { 6499 if (*p == '{') 6500 nesting_level++; 6501 else if (*p == '}') 6502 { 6503 if (!--nesting_level) 6504 break; 6505 } 6506 else if (*p == ';' && nesting_level == 1) 6507 break; 6508 else if (*p == '%' && p[1] == '*' && nesting_level == 1) 6509 have_subst = true; 6510 else if (*p == '\0') 6511 goto invalid; 6512 p++; 6513 } 6514 6515 end_body = p; 6516 while (end_body[-1] == ' ' || end_body[-1] == '\t') 6517 end_body--; 6518 6519 if (have_subst && !starred) 6520 goto invalid; 6521 6522 if (matched) 6523 { 6524 /* Copy the substitution body to permanent storage and execute it. 6525 If have_subst is false, this is a simple matter of running the 6526 body through do_spec_1... */ 6527 char *string = save_string (body, end_body - body); 6528 if (!have_subst) 6529 { 6530 if (do_spec_1 (string, 0, NULL) < 0) 6531 { 6532 free (string); 6533 return 0; 6534 } 6535 } 6536 else 6537 { 6538 /* ... but if have_subst is true, we have to process the 6539 body once for each matching switch, with %* set to the 6540 variant part of the switch. */ 6541 unsigned int hard_match_len = end_atom - atom; 6542 int i; 6543 6544 for (i = 0; i < n_switches; i++) 6545 if (!strncmp (switches[i].part1, atom, hard_match_len) 6546 && check_live_switch (i, hard_match_len)) 6547 { 6548 if (do_spec_1 (string, 0, 6549 &switches[i].part1[hard_match_len]) < 0) 6550 { 6551 free (string); 6552 return 0; 6553 } 6554 /* Pass any arguments this switch has. */ 6555 give_switch (i, 1); 6556 suffix_subst = NULL; 6557 } 6558 } 6559 free (string); 6560 } 6561 6562 return p; 6563 6564 invalid: 6565 fatal_error (input_location, "braced spec body %qs is invalid", body); 6566 } 6567 6568 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch 6569 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*} 6570 spec, or -1 if either exact match or %* is used. 6571 6572 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch 6573 whose value does not begin with "no-" is obsoleted by the same value 6574 with the "no-", similarly for a switch with the "no-" prefix. */ 6575 6576 static int 6577 check_live_switch (int switchnum, int prefix_length) 6578 { 6579 const char *name = switches[switchnum].part1; 6580 int i; 6581 6582 /* If we already processed this switch and determined if it was 6583 live or not, return our past determination. */ 6584 if (switches[switchnum].live_cond != 0) 6585 return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0 6586 && (switches[switchnum].live_cond & SWITCH_FALSE) == 0 6587 && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY) 6588 == 0); 6589 6590 /* In the common case of {<at-most-one-letter>*}, a negating 6591 switch would always match, so ignore that case. We will just 6592 send the conflicting switches to the compiler phase. */ 6593 if (prefix_length >= 0 && prefix_length <= 1) 6594 return 1; 6595 6596 /* Now search for duplicate in a manner that depends on the name. */ 6597 switch (*name) 6598 { 6599 case 'O': 6600 for (i = switchnum + 1; i < n_switches; i++) 6601 if (switches[i].part1[0] == 'O') 6602 { 6603 switches[switchnum].validated = true; 6604 switches[switchnum].live_cond = SWITCH_FALSE; 6605 return 0; 6606 } 6607 break; 6608 6609 case 'W': case 'f': case 'm': case 'g': 6610 if (! strncmp (name + 1, "no-", 3)) 6611 { 6612 /* We have Xno-YYY, search for XYYY. */ 6613 for (i = switchnum + 1; i < n_switches; i++) 6614 if (switches[i].part1[0] == name[0] 6615 && ! strcmp (&switches[i].part1[1], &name[4])) 6616 { 6617 /* --specs are validated with the validate_switches mechanism. */ 6618 if (switches[switchnum].known) 6619 switches[switchnum].validated = true; 6620 switches[switchnum].live_cond = SWITCH_FALSE; 6621 return 0; 6622 } 6623 } 6624 else 6625 { 6626 /* We have XYYY, search for Xno-YYY. */ 6627 for (i = switchnum + 1; i < n_switches; i++) 6628 if (switches[i].part1[0] == name[0] 6629 && switches[i].part1[1] == 'n' 6630 && switches[i].part1[2] == 'o' 6631 && switches[i].part1[3] == '-' 6632 && !strcmp (&switches[i].part1[4], &name[1])) 6633 { 6634 /* --specs are validated with the validate_switches mechanism. */ 6635 if (switches[switchnum].known) 6636 switches[switchnum].validated = true; 6637 switches[switchnum].live_cond = SWITCH_FALSE; 6638 return 0; 6639 } 6640 } 6641 break; 6642 } 6643 6644 /* Otherwise the switch is live. */ 6645 switches[switchnum].live_cond |= SWITCH_LIVE; 6646 return 1; 6647 } 6648 6649 /* Pass a switch to the current accumulating command 6650 in the same form that we received it. 6651 SWITCHNUM identifies the switch; it is an index into 6652 the vector of switches gcc received, which is `switches'. 6653 This cannot fail since it never finishes a command line. 6654 6655 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */ 6656 6657 static void 6658 give_switch (int switchnum, int omit_first_word) 6659 { 6660 if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0) 6661 return; 6662 6663 if (!omit_first_word) 6664 { 6665 do_spec_1 ("-", 0, NULL); 6666 do_spec_1 (switches[switchnum].part1, 1, NULL); 6667 } 6668 6669 if (switches[switchnum].args != 0) 6670 { 6671 const char **p; 6672 for (p = switches[switchnum].args; *p; p++) 6673 { 6674 const char *arg = *p; 6675 6676 do_spec_1 (" ", 0, NULL); 6677 if (suffix_subst) 6678 { 6679 unsigned length = strlen (arg); 6680 int dot = 0; 6681 6682 while (length-- && !IS_DIR_SEPARATOR (arg[length])) 6683 if (arg[length] == '.') 6684 { 6685 (CONST_CAST (char *, arg))[length] = 0; 6686 dot = 1; 6687 break; 6688 } 6689 do_spec_1 (arg, 1, NULL); 6690 if (dot) 6691 (CONST_CAST (char *, arg))[length] = '.'; 6692 do_spec_1 (suffix_subst, 1, NULL); 6693 } 6694 else 6695 do_spec_1 (arg, 1, NULL); 6696 } 6697 } 6698 6699 do_spec_1 (" ", 0, NULL); 6700 switches[switchnum].validated = true; 6701 } 6702 6703 /* Print GCC configuration (e.g. version, thread model, target, 6704 configuration_arguments) to a given FILE. */ 6705 6706 static void 6707 print_configuration (FILE *file) 6708 { 6709 int n; 6710 const char *thrmod; 6711 6712 fnotice (file, "Target: %s\n", spec_machine); 6713 fnotice (file, "Configured with: %s\n", configuration_arguments); 6714 6715 #ifdef THREAD_MODEL_SPEC 6716 /* We could have defined THREAD_MODEL_SPEC to "%*" by default, 6717 but there's no point in doing all this processing just to get 6718 thread_model back. */ 6719 obstack_init (&obstack); 6720 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model); 6721 obstack_1grow (&obstack, '\0'); 6722 thrmod = XOBFINISH (&obstack, const char *); 6723 #else 6724 thrmod = thread_model; 6725 #endif 6726 6727 fnotice (file, "Thread model: %s\n", thrmod); 6728 6729 /* compiler_version is truncated at the first space when initialized 6730 from version string, so truncate version_string at the first space 6731 before comparing. */ 6732 for (n = 0; version_string[n]; n++) 6733 if (version_string[n] == ' ') 6734 break; 6735 6736 if (! strncmp (version_string, compiler_version, n) 6737 && compiler_version[n] == 0) 6738 fnotice (file, "gcc version %s %s\n", version_string, 6739 pkgversion_string); 6740 else 6741 fnotice (file, "gcc driver version %s %sexecuting gcc version %s\n", 6742 version_string, pkgversion_string, compiler_version); 6743 6744 } 6745 6746 #define RETRY_ICE_ATTEMPTS 3 6747 6748 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */ 6749 6750 static bool 6751 files_equal_p (char *file1, char *file2) 6752 { 6753 struct stat st1, st2; 6754 off_t n, len; 6755 int fd1, fd2; 6756 const int bufsize = 8192; 6757 char *buf = XNEWVEC (char, bufsize); 6758 6759 fd1 = open (file1, O_RDONLY); 6760 fd2 = open (file2, O_RDONLY); 6761 6762 if (fd1 < 0 || fd2 < 0) 6763 goto error; 6764 6765 if (fstat (fd1, &st1) < 0 || fstat (fd2, &st2) < 0) 6766 goto error; 6767 6768 if (st1.st_size != st2.st_size) 6769 goto error; 6770 6771 for (n = st1.st_size; n; n -= len) 6772 { 6773 len = n; 6774 if ((int) len > bufsize / 2) 6775 len = bufsize / 2; 6776 6777 if (read (fd1, buf, len) != (int) len 6778 || read (fd2, buf + bufsize / 2, len) != (int) len) 6779 { 6780 goto error; 6781 } 6782 6783 if (memcmp (buf, buf + bufsize / 2, len) != 0) 6784 goto error; 6785 } 6786 6787 free (buf); 6788 close (fd1); 6789 close (fd2); 6790 6791 return 1; 6792 6793 error: 6794 free (buf); 6795 close (fd1); 6796 close (fd2); 6797 return 0; 6798 } 6799 6800 /* Check that compiler's output doesn't differ across runs. 6801 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing 6802 stdout and stderr for each compiler run. Return true if all of 6803 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */ 6804 6805 static bool 6806 check_repro (char **temp_stdout_files, char **temp_stderr_files) 6807 { 6808 int i; 6809 for (i = 0; i < RETRY_ICE_ATTEMPTS - 2; ++i) 6810 { 6811 if (!files_equal_p (temp_stdout_files[i], temp_stdout_files[i + 1]) 6812 || !files_equal_p (temp_stderr_files[i], temp_stderr_files[i + 1])) 6813 { 6814 fnotice (stderr, "The bug is not reproducible, so it is" 6815 " likely a hardware or OS problem.\n"); 6816 break; 6817 } 6818 } 6819 return i == RETRY_ICE_ATTEMPTS - 2; 6820 } 6821 6822 enum attempt_status { 6823 ATTEMPT_STATUS_FAIL_TO_RUN, 6824 ATTEMPT_STATUS_SUCCESS, 6825 ATTEMPT_STATUS_ICE 6826 }; 6827 6828 6829 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout 6830 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP 6831 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write 6832 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if 6833 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and 6834 ATTEMPT_STATUS_SUCCESS otherwise. */ 6835 6836 static enum attempt_status 6837 run_attempt (const char **new_argv, const char *out_temp, 6838 const char *err_temp, int emit_system_info, int append) 6839 { 6840 6841 if (emit_system_info) 6842 { 6843 FILE *file_out = fopen (err_temp, "a"); 6844 print_configuration (file_out); 6845 fputs ("\n", file_out); 6846 fclose (file_out); 6847 } 6848 6849 int exit_status; 6850 const char *errmsg; 6851 struct pex_obj *pex; 6852 int err; 6853 int pex_flags = PEX_USE_PIPES | PEX_LAST; 6854 enum attempt_status status = ATTEMPT_STATUS_FAIL_TO_RUN; 6855 6856 if (append) 6857 pex_flags |= PEX_STDOUT_APPEND | PEX_STDERR_APPEND; 6858 6859 pex = pex_init (PEX_USE_PIPES, new_argv[0], NULL); 6860 if (!pex) 6861 fatal_error (input_location, "pex_init failed: %m"); 6862 6863 errmsg = pex_run (pex, pex_flags, new_argv[0], 6864 CONST_CAST2 (char *const *, const char **, &new_argv[1]), out_temp, 6865 err_temp, &err); 6866 if (errmsg != NULL) 6867 { 6868 if (err == 0) 6869 fatal_error (input_location, errmsg); 6870 else 6871 { 6872 errno = err; 6873 pfatal_with_name (errmsg); 6874 } 6875 } 6876 6877 if (!pex_get_status (pex, 1, &exit_status)) 6878 goto out; 6879 6880 switch (WEXITSTATUS (exit_status)) 6881 { 6882 case ICE_EXIT_CODE: 6883 status = ATTEMPT_STATUS_ICE; 6884 break; 6885 6886 case SUCCESS_EXIT_CODE: 6887 status = ATTEMPT_STATUS_SUCCESS; 6888 break; 6889 6890 default: 6891 ; 6892 } 6893 6894 out: 6895 pex_free (pex); 6896 return status; 6897 } 6898 6899 /* This routine reads lines from IN file, adds C++ style comments 6900 at the begining of each line and writes result into OUT. */ 6901 6902 static void 6903 insert_comments (const char *file_in, const char *file_out) 6904 { 6905 FILE *in = fopen (file_in, "rb"); 6906 FILE *out = fopen (file_out, "wb"); 6907 char line[256]; 6908 6909 bool add_comment = true; 6910 while (fgets (line, sizeof (line), in)) 6911 { 6912 if (add_comment) 6913 fputs ("// ", out); 6914 fputs (line, out); 6915 add_comment = strchr (line, '\n') != NULL; 6916 } 6917 6918 fclose (in); 6919 fclose (out); 6920 } 6921 6922 /* This routine adds preprocessed source code into the given ERR_FILE. 6923 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to 6924 add information in report file. RUN_ATTEMPT should return 6925 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */ 6926 6927 static void 6928 do_report_bug (const char **new_argv, const int nargs, 6929 char **out_file, char **err_file) 6930 { 6931 int i, status; 6932 int fd = open (*out_file, O_RDWR | O_APPEND); 6933 if (fd < 0) 6934 return; 6935 write (fd, "\n//", 3); 6936 for (i = 0; i < nargs; i++) 6937 { 6938 write (fd, " ", 1); 6939 write (fd, new_argv[i], strlen (new_argv[i])); 6940 } 6941 write (fd, "\n\n", 2); 6942 close (fd); 6943 new_argv[nargs] = "-E"; 6944 new_argv[nargs + 1] = NULL; 6945 6946 status = run_attempt (new_argv, *out_file, *err_file, 0, 1); 6947 6948 if (status == ATTEMPT_STATUS_SUCCESS) 6949 { 6950 fnotice (stderr, "Preprocessed source stored into %s file," 6951 " please attach this to your bugreport.\n", *out_file); 6952 /* Make sure it is not deleted. */ 6953 free (*out_file); 6954 *out_file = NULL; 6955 } 6956 } 6957 6958 /* Try to reproduce ICE. If bug is reproducible, generate report .err file 6959 containing GCC configuration, backtrace, compiler's command line options 6960 and preprocessed source code. */ 6961 6962 static void 6963 try_generate_repro (const char **argv) 6964 { 6965 int i, nargs, out_arg = -1, quiet = 0, attempt; 6966 const char **new_argv; 6967 char *temp_files[RETRY_ICE_ATTEMPTS * 2]; 6968 char **temp_stdout_files = &temp_files[0]; 6969 char **temp_stderr_files = &temp_files[RETRY_ICE_ATTEMPTS]; 6970 6971 if (gcc_input_filename == NULL || ! strcmp (gcc_input_filename, "-")) 6972 return; 6973 6974 for (nargs = 0; argv[nargs] != NULL; ++nargs) 6975 /* Only retry compiler ICEs, not preprocessor ones. */ 6976 if (! strcmp (argv[nargs], "-E")) 6977 return; 6978 else if (argv[nargs][0] == '-' && argv[nargs][1] == 'o') 6979 { 6980 if (out_arg == -1) 6981 out_arg = nargs; 6982 else 6983 return; 6984 } 6985 /* If the compiler is going to output any time information, 6986 it might varry between invocations. */ 6987 else if (! strcmp (argv[nargs], "-quiet")) 6988 quiet = 1; 6989 else if (! strcmp (argv[nargs], "-ftime-report")) 6990 return; 6991 6992 if (out_arg == -1 || !quiet) 6993 return; 6994 6995 memset (temp_files, '\0', sizeof (temp_files)); 6996 new_argv = XALLOCAVEC (const char *, nargs + 4); 6997 memcpy (new_argv, argv, (nargs + 1) * sizeof (const char *)); 6998 new_argv[nargs++] = "-frandom-seed=0"; 6999 new_argv[nargs++] = "-fdump-noaddr"; 7000 new_argv[nargs] = NULL; 7001 if (new_argv[out_arg][2] == '\0') 7002 new_argv[out_arg + 1] = "-"; 7003 else 7004 new_argv[out_arg] = "-o-"; 7005 7006 int status; 7007 for (attempt = 0; attempt < RETRY_ICE_ATTEMPTS; ++attempt) 7008 { 7009 int emit_system_info = 0; 7010 int append = 0; 7011 temp_stdout_files[attempt] = make_temp_file (".out"); 7012 temp_stderr_files[attempt] = make_temp_file (".err"); 7013 7014 if (attempt == RETRY_ICE_ATTEMPTS - 1) 7015 { 7016 append = 1; 7017 emit_system_info = 1; 7018 } 7019 7020 status = run_attempt (new_argv, temp_stdout_files[attempt], 7021 temp_stderr_files[attempt], emit_system_info, 7022 append); 7023 7024 if (status != ATTEMPT_STATUS_ICE) 7025 { 7026 fnotice (stderr, "The bug is not reproducible, so it is" 7027 " likely a hardware or OS problem.\n"); 7028 goto out; 7029 } 7030 } 7031 7032 if (!check_repro (temp_stdout_files, temp_stderr_files)) 7033 goto out; 7034 7035 { 7036 /* Insert commented out backtrace into report file. */ 7037 char **stderr_commented = &temp_stdout_files[RETRY_ICE_ATTEMPTS - 1]; 7038 insert_comments (temp_stderr_files[RETRY_ICE_ATTEMPTS - 1], 7039 *stderr_commented); 7040 7041 /* In final attempt we append compiler options and preprocesssed code to last 7042 generated .out file with configuration and backtrace. */ 7043 char **err = &temp_stderr_files[RETRY_ICE_ATTEMPTS - 1]; 7044 do_report_bug (new_argv, nargs, stderr_commented, err); 7045 } 7046 7047 out: 7048 for (i = 0; i < RETRY_ICE_ATTEMPTS * 2; i++) 7049 if (temp_files[i]) 7050 { 7051 unlink (temp_stdout_files[i]); 7052 free (temp_stdout_files[i]); 7053 } 7054 } 7055 7056 /* Search for a file named NAME trying various prefixes including the 7057 user's -B prefix and some standard ones. 7058 Return the absolute file name found. If nothing is found, return NAME. */ 7059 7060 static const char * 7061 find_file (const char *name) 7062 { 7063 char *newname = find_a_file (&startfile_prefixes, name, R_OK, true); 7064 return newname ? newname : name; 7065 } 7066 7067 /* Determine whether a directory exists. If LINKER, return 0 for 7068 certain fixed names not needed by the linker. */ 7069 7070 static int 7071 is_directory (const char *path1, bool linker) 7072 { 7073 int len1; 7074 char *path; 7075 char *cp; 7076 struct stat st; 7077 7078 /* Ensure the string ends with "/.". The resulting path will be a 7079 directory even if the given path is a symbolic link. */ 7080 len1 = strlen (path1); 7081 path = (char *) alloca (3 + len1); 7082 memcpy (path, path1, len1); 7083 cp = path + len1; 7084 if (!IS_DIR_SEPARATOR (cp[-1])) 7085 *cp++ = DIR_SEPARATOR; 7086 *cp++ = '.'; 7087 *cp = '\0'; 7088 7089 /* Exclude directories that the linker is known to search. */ 7090 if (linker 7091 && IS_DIR_SEPARATOR (path[0]) 7092 && ((cp - path == 6 7093 && filename_ncmp (path + 1, "lib", 3) == 0) 7094 || (cp - path == 10 7095 && filename_ncmp (path + 1, "usr", 3) == 0 7096 && IS_DIR_SEPARATOR (path[4]) 7097 && filename_ncmp (path + 5, "lib", 3) == 0))) 7098 return 0; 7099 7100 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode)); 7101 } 7102 7103 /* Set up the various global variables to indicate that we're processing 7104 the input file named FILENAME. */ 7105 7106 void 7107 set_input (const char *filename) 7108 { 7109 const char *p; 7110 7111 gcc_input_filename = filename; 7112 input_filename_length = strlen (gcc_input_filename); 7113 input_basename = lbasename (gcc_input_filename); 7114 7115 /* Find a suffix starting with the last period, 7116 and set basename_length to exclude that suffix. */ 7117 basename_length = strlen (input_basename); 7118 suffixed_basename_length = basename_length; 7119 p = input_basename + basename_length; 7120 while (p != input_basename && *p != '.') 7121 --p; 7122 if (*p == '.' && p != input_basename) 7123 { 7124 basename_length = p - input_basename; 7125 input_suffix = p + 1; 7126 } 7127 else 7128 input_suffix = ""; 7129 7130 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then 7131 we will need to do a stat on the gcc_input_filename. The 7132 INPUT_STAT_SET signals that the stat is needed. */ 7133 input_stat_set = 0; 7134 } 7135 7136 /* On fatal signals, delete all the temporary files. */ 7137 7138 static void 7139 fatal_signal (int signum) 7140 { 7141 signal (signum, SIG_DFL); 7142 delete_failure_queue (); 7143 delete_temp_files (); 7144 /* Get the same signal again, this time not handled, 7145 so its normal effect occurs. */ 7146 kill (getpid (), signum); 7147 } 7148 7149 /* Compare the contents of the two files named CMPFILE[0] and 7150 CMPFILE[1]. Return zero if they're identical, nonzero 7151 otherwise. */ 7152 7153 static int 7154 compare_files (char *cmpfile[]) 7155 { 7156 int ret = 0; 7157 FILE *temp[2] = { NULL, NULL }; 7158 int i; 7159 7160 #if HAVE_MMAP_FILE 7161 { 7162 size_t length[2]; 7163 void *map[2] = { NULL, NULL }; 7164 7165 for (i = 0; i < 2; i++) 7166 { 7167 struct stat st; 7168 7169 if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode)) 7170 { 7171 error ("%s: could not determine length of compare-debug file %s", 7172 gcc_input_filename, cmpfile[i]); 7173 ret = 1; 7174 break; 7175 } 7176 7177 length[i] = st.st_size; 7178 } 7179 7180 if (!ret && length[0] != length[1]) 7181 { 7182 error ("%s: -fcompare-debug failure (length)", gcc_input_filename); 7183 ret = 1; 7184 } 7185 7186 if (!ret) 7187 for (i = 0; i < 2; i++) 7188 { 7189 int fd = open (cmpfile[i], O_RDONLY); 7190 if (fd < 0) 7191 { 7192 error ("%s: could not open compare-debug file %s", 7193 gcc_input_filename, cmpfile[i]); 7194 ret = 1; 7195 break; 7196 } 7197 7198 map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0); 7199 close (fd); 7200 7201 if (map[i] == (void *) MAP_FAILED) 7202 { 7203 ret = -1; 7204 break; 7205 } 7206 } 7207 7208 if (!ret) 7209 { 7210 if (memcmp (map[0], map[1], length[0]) != 0) 7211 { 7212 error ("%s: -fcompare-debug failure", gcc_input_filename); 7213 ret = 1; 7214 } 7215 } 7216 7217 for (i = 0; i < 2; i++) 7218 if (map[i]) 7219 munmap ((caddr_t) map[i], length[i]); 7220 7221 if (ret >= 0) 7222 return ret; 7223 7224 ret = 0; 7225 } 7226 #endif 7227 7228 for (i = 0; i < 2; i++) 7229 { 7230 temp[i] = fopen (cmpfile[i], "r"); 7231 if (!temp[i]) 7232 { 7233 error ("%s: could not open compare-debug file %s", 7234 gcc_input_filename, cmpfile[i]); 7235 ret = 1; 7236 break; 7237 } 7238 } 7239 7240 if (!ret && temp[0] && temp[1]) 7241 for (;;) 7242 { 7243 int c0, c1; 7244 c0 = fgetc (temp[0]); 7245 c1 = fgetc (temp[1]); 7246 7247 if (c0 != c1) 7248 { 7249 error ("%s: -fcompare-debug failure", 7250 gcc_input_filename); 7251 ret = 1; 7252 break; 7253 } 7254 7255 if (c0 == EOF) 7256 break; 7257 } 7258 7259 for (i = 1; i >= 0; i--) 7260 { 7261 if (temp[i]) 7262 fclose (temp[i]); 7263 } 7264 7265 return ret; 7266 } 7267 7268 driver::driver (bool can_finalize, bool debug) : 7269 explicit_link_files (NULL), 7270 decoded_options (NULL), 7271 m_option_suggestions (NULL) 7272 { 7273 env.init (can_finalize, debug); 7274 } 7275 7276 driver::~driver () 7277 { 7278 XDELETEVEC (explicit_link_files); 7279 XDELETEVEC (decoded_options); 7280 if (m_option_suggestions) 7281 { 7282 int i; 7283 char *str; 7284 FOR_EACH_VEC_ELT (*m_option_suggestions, i, str) 7285 free (str); 7286 delete m_option_suggestions; 7287 } 7288 } 7289 7290 /* driver::main is implemented as a series of driver:: method calls. */ 7291 7292 int 7293 driver::main (int argc, char **argv) 7294 { 7295 bool early_exit; 7296 7297 set_progname (argv[0]); 7298 expand_at_files (&argc, &argv); 7299 decode_argv (argc, const_cast <const char **> (argv)); 7300 global_initializations (); 7301 build_multilib_strings (); 7302 set_up_specs (); 7303 putenv_COLLECT_GCC (argv[0]); 7304 maybe_putenv_COLLECT_LTO_WRAPPER (); 7305 maybe_putenv_OFFLOAD_TARGETS (); 7306 handle_unrecognized_options (); 7307 7308 if (!maybe_print_and_exit ()) 7309 return 0; 7310 7311 early_exit = prepare_infiles (); 7312 if (early_exit) 7313 return get_exit_code (); 7314 7315 do_spec_on_infiles (); 7316 maybe_run_linker (argv[0]); 7317 final_actions (); 7318 return get_exit_code (); 7319 } 7320 7321 /* Locate the final component of argv[0] after any leading path, and set 7322 the program name accordingly. */ 7323 7324 void 7325 driver::set_progname (const char *argv0) const 7326 { 7327 const char *p = argv0 + strlen (argv0); 7328 while (p != argv0 && !IS_DIR_SEPARATOR (p[-1])) 7329 --p; 7330 progname = p; 7331 7332 xmalloc_set_program_name (progname); 7333 } 7334 7335 /* Expand any @ files within the command-line args, 7336 setting at_file_supplied if any were expanded. */ 7337 7338 void 7339 driver::expand_at_files (int *argc, char ***argv) const 7340 { 7341 char **old_argv = *argv; 7342 7343 expandargv (argc, argv); 7344 7345 /* Determine if any expansions were made. */ 7346 if (*argv != old_argv) 7347 at_file_supplied = true; 7348 } 7349 7350 /* Decode the command-line arguments from argc/argv into the 7351 decoded_options array. */ 7352 7353 void 7354 driver::decode_argv (int argc, const char **argv) 7355 { 7356 /* Register the language-independent parameters. */ 7357 global_init_params (); 7358 finish_params (); 7359 7360 init_opts_obstack (); 7361 init_options_struct (&global_options, &global_options_set); 7362 7363 decode_cmdline_options_to_array (argc, argv, 7364 CL_DRIVER, 7365 &decoded_options, &decoded_options_count); 7366 } 7367 7368 /* Perform various initializations and setup. */ 7369 7370 void 7371 driver::global_initializations () 7372 { 7373 /* Unlock the stdio streams. */ 7374 unlock_std_streams (); 7375 7376 gcc_init_libintl (); 7377 7378 diagnostic_initialize (global_dc, 0); 7379 diagnostic_color_init (global_dc); 7380 7381 #ifdef GCC_DRIVER_HOST_INITIALIZATION 7382 /* Perform host dependent initialization when needed. */ 7383 GCC_DRIVER_HOST_INITIALIZATION; 7384 #endif 7385 7386 if (atexit (delete_temp_files) != 0) 7387 fatal_error (input_location, "atexit failed"); 7388 7389 if (signal (SIGINT, SIG_IGN) != SIG_IGN) 7390 signal (SIGINT, fatal_signal); 7391 #ifdef SIGHUP 7392 if (signal (SIGHUP, SIG_IGN) != SIG_IGN) 7393 signal (SIGHUP, fatal_signal); 7394 #endif 7395 if (signal (SIGTERM, SIG_IGN) != SIG_IGN) 7396 signal (SIGTERM, fatal_signal); 7397 #ifdef SIGPIPE 7398 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN) 7399 signal (SIGPIPE, fatal_signal); 7400 #endif 7401 #ifdef SIGCHLD 7402 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will 7403 receive the signal. A different setting is inheritable */ 7404 signal (SIGCHLD, SIG_DFL); 7405 #endif 7406 7407 /* Parsing and gimplification sometimes need quite large stack. 7408 Increase stack size limits if possible. */ 7409 stack_limit_increase (64 * 1024 * 1024); 7410 7411 /* Allocate the argument vector. */ 7412 alloc_args (); 7413 7414 obstack_init (&obstack); 7415 } 7416 7417 /* Build multilib_select, et. al from the separate lines that make up each 7418 multilib selection. */ 7419 7420 void 7421 driver::build_multilib_strings () const 7422 { 7423 { 7424 const char *p; 7425 const char *const *q = multilib_raw; 7426 int need_space; 7427 7428 obstack_init (&multilib_obstack); 7429 while ((p = *q++) != (char *) 0) 7430 obstack_grow (&multilib_obstack, p, strlen (p)); 7431 7432 obstack_1grow (&multilib_obstack, 0); 7433 multilib_select = XOBFINISH (&multilib_obstack, const char *); 7434 7435 q = multilib_matches_raw; 7436 while ((p = *q++) != (char *) 0) 7437 obstack_grow (&multilib_obstack, p, strlen (p)); 7438 7439 obstack_1grow (&multilib_obstack, 0); 7440 multilib_matches = XOBFINISH (&multilib_obstack, const char *); 7441 7442 q = multilib_exclusions_raw; 7443 while ((p = *q++) != (char *) 0) 7444 obstack_grow (&multilib_obstack, p, strlen (p)); 7445 7446 obstack_1grow (&multilib_obstack, 0); 7447 multilib_exclusions = XOBFINISH (&multilib_obstack, const char *); 7448 7449 q = multilib_reuse_raw; 7450 while ((p = *q++) != (char *) 0) 7451 obstack_grow (&multilib_obstack, p, strlen (p)); 7452 7453 obstack_1grow (&multilib_obstack, 0); 7454 multilib_reuse = XOBFINISH (&multilib_obstack, const char *); 7455 7456 need_space = FALSE; 7457 for (size_t i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++) 7458 { 7459 if (need_space) 7460 obstack_1grow (&multilib_obstack, ' '); 7461 obstack_grow (&multilib_obstack, 7462 multilib_defaults_raw[i], 7463 strlen (multilib_defaults_raw[i])); 7464 need_space = TRUE; 7465 } 7466 7467 obstack_1grow (&multilib_obstack, 0); 7468 multilib_defaults = XOBFINISH (&multilib_obstack, const char *); 7469 } 7470 } 7471 7472 /* Set up the spec-handling machinery. */ 7473 7474 void 7475 driver::set_up_specs () const 7476 { 7477 const char *spec_machine_suffix; 7478 char *specs_file; 7479 size_t i; 7480 7481 #ifdef INIT_ENVIRONMENT 7482 /* Set up any other necessary machine specific environment variables. */ 7483 xputenv (INIT_ENVIRONMENT); 7484 #endif 7485 7486 /* Make a table of what switches there are (switches, n_switches). 7487 Make a table of specified input files (infiles, n_infiles). 7488 Decode switches that are handled locally. */ 7489 7490 process_command (decoded_options_count, decoded_options); 7491 7492 /* Initialize the vector of specs to just the default. 7493 This means one element containing 0s, as a terminator. */ 7494 7495 compilers = XNEWVAR (struct compiler, sizeof default_compilers); 7496 memcpy (compilers, default_compilers, sizeof default_compilers); 7497 n_compilers = n_default_compilers; 7498 7499 /* Read specs from a file if there is one. */ 7500 7501 machine_suffix = concat (spec_host_machine, dir_separator_str, spec_version, 7502 accel_dir_suffix, dir_separator_str, NULL); 7503 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL); 7504 7505 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true); 7506 /* Read the specs file unless it is a default one. */ 7507 if (specs_file != 0 && strcmp (specs_file, "specs")) 7508 read_specs (specs_file, true, false); 7509 else 7510 init_spec (); 7511 7512 #ifdef ACCEL_COMPILER 7513 spec_machine_suffix = machine_suffix; 7514 #else 7515 spec_machine_suffix = just_machine_suffix; 7516 #endif 7517 7518 #ifndef NETBSD_NATIVE 7519 /* We need to check standard_exec_prefix/spec_machine_suffix/specs 7520 for any override of as, ld and libraries. */ 7521 specs_file = (char *) alloca (strlen (standard_exec_prefix) 7522 + strlen (spec_machine_suffix) + sizeof ("specs")); 7523 strcpy (specs_file, standard_exec_prefix); 7524 strcat (specs_file, spec_machine_suffix); 7525 strcat (specs_file, "specs"); 7526 if (access (specs_file, R_OK) == 0) 7527 read_specs (specs_file, true, false); 7528 #endif 7529 7530 /* Process any configure-time defaults specified for the command line 7531 options, via OPTION_DEFAULT_SPECS. */ 7532 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++) 7533 do_option_spec (option_default_specs[i].name, 7534 option_default_specs[i].spec); 7535 7536 /* Process DRIVER_SELF_SPECS, adding any new options to the end 7537 of the command line. */ 7538 7539 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++) 7540 do_self_spec (driver_self_specs[i]); 7541 7542 /* If not cross-compiling, look for executables in the standard 7543 places. */ 7544 if (*cross_compile == '0') 7545 { 7546 if (*md_exec_prefix) 7547 { 7548 add_prefix (&exec_prefixes, md_exec_prefix, "GCC", 7549 PREFIX_PRIORITY_LAST, 0, 0); 7550 } 7551 } 7552 7553 /* Process sysroot_suffix_spec. */ 7554 if (*sysroot_suffix_spec != 0 7555 && !no_sysroot_suffix 7556 && do_spec_2 (sysroot_suffix_spec) == 0) 7557 { 7558 if (argbuf.length () > 1) 7559 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC"); 7560 else if (argbuf.length () == 1) 7561 target_sysroot_suffix = xstrdup (argbuf.last ()); 7562 } 7563 7564 #ifdef HAVE_LD_SYSROOT 7565 /* Pass the --sysroot option to the linker, if it supports that. If 7566 there is a sysroot_suffix_spec, it has already been processed by 7567 this point, so target_system_root really is the system root we 7568 should be using. */ 7569 if (target_system_root) 7570 { 7571 obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) ")); 7572 obstack_grow0 (&obstack, link_spec, strlen (link_spec)); 7573 set_spec ("link", XOBFINISH (&obstack, const char *), false); 7574 } 7575 #endif 7576 7577 /* Process sysroot_hdrs_suffix_spec. */ 7578 if (*sysroot_hdrs_suffix_spec != 0 7579 && !no_sysroot_suffix 7580 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0) 7581 { 7582 if (argbuf.length () > 1) 7583 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC"); 7584 else if (argbuf.length () == 1) 7585 target_sysroot_hdrs_suffix = xstrdup (argbuf.last ()); 7586 } 7587 7588 /* Look for startfiles in the standard places. */ 7589 if (*startfile_prefix_spec != 0 7590 && do_spec_2 (startfile_prefix_spec) == 0 7591 && do_spec_1 (" ", 0, NULL) == 0) 7592 { 7593 const char *arg; 7594 int ndx; 7595 FOR_EACH_VEC_ELT (argbuf, ndx, arg) 7596 add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS", 7597 PREFIX_PRIORITY_LAST, 0, 1); 7598 } 7599 /* We should eventually get rid of all these and stick to 7600 startfile_prefix_spec exclusively. */ 7601 else if (*cross_compile == '0' || target_system_root) 7602 { 7603 if (*md_startfile_prefix) 7604 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix, 7605 "GCC", PREFIX_PRIORITY_LAST, 0, 1); 7606 7607 if (*md_startfile_prefix_1) 7608 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1, 7609 "GCC", PREFIX_PRIORITY_LAST, 0, 1); 7610 7611 /* If standard_startfile_prefix is relative, base it on 7612 standard_exec_prefix. This lets us move the installed tree 7613 as a unit. If GCC_EXEC_PREFIX is defined, base 7614 standard_startfile_prefix on that as well. 7615 7616 If the prefix is relative, only search it for native compilers; 7617 otherwise we will search a directory containing host libraries. */ 7618 if (IS_ABSOLUTE_PATH (standard_startfile_prefix)) 7619 add_sysrooted_prefix (&startfile_prefixes, 7620 standard_startfile_prefix, "BINUTILS", 7621 PREFIX_PRIORITY_LAST, 0, 1); 7622 else if (*cross_compile == '0') 7623 { 7624 #if !defined(NETBSD_NATIVE) && !defined(NETBSD_TOOLS) 7625 add_prefix (&startfile_prefixes, 7626 concat (gcc_exec_prefix 7627 ? gcc_exec_prefix : standard_exec_prefix, 7628 machine_suffix, 7629 standard_startfile_prefix, NULL), 7630 NULL, PREFIX_PRIORITY_LAST, 0, 1); 7631 #endif /* NETBSD_NATIVE */ 7632 } 7633 7634 #if !defined(NETBSD_NATIVE) && !defined(NETBSD_TOOLS) 7635 /* Sysrooted prefixes are relocated because target_system_root is 7636 also relocated by gcc_exec_prefix. */ 7637 if (*standard_startfile_prefix_1) 7638 add_sysrooted_prefix (&startfile_prefixes, 7639 standard_startfile_prefix_1, "BINUTILS", 7640 PREFIX_PRIORITY_LAST, 0, 1); 7641 if (*standard_startfile_prefix_2) 7642 add_sysrooted_prefix (&startfile_prefixes, 7643 standard_startfile_prefix_2, "BINUTILS", 7644 PREFIX_PRIORITY_LAST, 0, 1); 7645 #endif /* NETBSD_NATIVE */ 7646 } 7647 7648 /* Process any user specified specs in the order given on the command 7649 line. */ 7650 for (struct user_specs *uptr = user_specs_head; uptr; uptr = uptr->next) 7651 { 7652 char *filename = find_a_file (&startfile_prefixes, uptr->filename, 7653 R_OK, true); 7654 read_specs (filename ? filename : uptr->filename, false, true); 7655 } 7656 7657 /* Process any user self specs. */ 7658 { 7659 struct spec_list *sl; 7660 for (sl = specs; sl; sl = sl->next) 7661 if (sl->name_len == sizeof "self_spec" - 1 7662 && !strcmp (sl->name, "self_spec")) 7663 do_self_spec (*sl->ptr_spec); 7664 } 7665 7666 if (compare_debug) 7667 { 7668 enum save_temps save; 7669 7670 if (!compare_debug_second) 7671 { 7672 n_switches_debug_check[1] = n_switches; 7673 n_switches_alloc_debug_check[1] = n_switches_alloc; 7674 switches_debug_check[1] = XDUPVEC (struct switchstr, switches, 7675 n_switches_alloc); 7676 7677 do_self_spec ("%:compare-debug-self-opt()"); 7678 n_switches_debug_check[0] = n_switches; 7679 n_switches_alloc_debug_check[0] = n_switches_alloc; 7680 switches_debug_check[0] = switches; 7681 7682 n_switches = n_switches_debug_check[1]; 7683 n_switches_alloc = n_switches_alloc_debug_check[1]; 7684 switches = switches_debug_check[1]; 7685 } 7686 7687 /* Avoid crash when computing %j in this early. */ 7688 save = save_temps_flag; 7689 save_temps_flag = SAVE_TEMPS_NONE; 7690 7691 compare_debug = -compare_debug; 7692 do_self_spec ("%:compare-debug-self-opt()"); 7693 7694 save_temps_flag = save; 7695 7696 if (!compare_debug_second) 7697 { 7698 n_switches_debug_check[1] = n_switches; 7699 n_switches_alloc_debug_check[1] = n_switches_alloc; 7700 switches_debug_check[1] = switches; 7701 compare_debug = -compare_debug; 7702 n_switches = n_switches_debug_check[0]; 7703 n_switches_alloc = n_switches_debug_check[0]; 7704 switches = switches_debug_check[0]; 7705 } 7706 } 7707 7708 7709 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */ 7710 if (gcc_exec_prefix) 7711 gcc_exec_prefix = concat (gcc_exec_prefix, spec_host_machine, 7712 dir_separator_str, spec_version, 7713 accel_dir_suffix, dir_separator_str, NULL); 7714 7715 /* Now we have the specs. 7716 Set the `valid' bits for switches that match anything in any spec. */ 7717 7718 validate_all_switches (); 7719 7720 /* Now that we have the switches and the specs, set 7721 the subdirectory based on the options. */ 7722 set_multilib_dir (); 7723 } 7724 7725 /* Set up to remember the pathname of gcc and any options 7726 needed for collect. We use argv[0] instead of progname because 7727 we need the complete pathname. */ 7728 7729 void 7730 driver::putenv_COLLECT_GCC (const char *argv0) const 7731 { 7732 obstack_init (&collect_obstack); 7733 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1); 7734 obstack_grow (&collect_obstack, argv0, strlen (argv0) + 1); 7735 xputenv (XOBFINISH (&collect_obstack, char *)); 7736 } 7737 7738 /* Set up to remember the pathname of the lto wrapper. */ 7739 7740 void 7741 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const 7742 { 7743 char *lto_wrapper_file; 7744 7745 if (have_c) 7746 lto_wrapper_file = NULL; 7747 else 7748 lto_wrapper_file = find_a_file (&exec_prefixes, "lto-wrapper", 7749 X_OK, false); 7750 if (lto_wrapper_file) 7751 { 7752 lto_wrapper_file = convert_white_space (lto_wrapper_file); 7753 lto_wrapper_spec = lto_wrapper_file; 7754 obstack_init (&collect_obstack); 7755 obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=", 7756 sizeof ("COLLECT_LTO_WRAPPER=") - 1); 7757 obstack_grow (&collect_obstack, lto_wrapper_spec, 7758 strlen (lto_wrapper_spec) + 1); 7759 xputenv (XOBFINISH (&collect_obstack, char *)); 7760 } 7761 7762 } 7763 7764 /* Set up to remember the names of offload targets. */ 7765 7766 void 7767 driver::maybe_putenv_OFFLOAD_TARGETS () const 7768 { 7769 if (offload_targets && offload_targets[0] != '\0') 7770 { 7771 obstack_grow (&collect_obstack, "OFFLOAD_TARGET_NAMES=", 7772 sizeof ("OFFLOAD_TARGET_NAMES=") - 1); 7773 obstack_grow (&collect_obstack, offload_targets, 7774 strlen (offload_targets) + 1); 7775 xputenv (XOBFINISH (&collect_obstack, char *)); 7776 } 7777 7778 free (offload_targets); 7779 offload_targets = NULL; 7780 } 7781 7782 /* Helper function for driver::suggest_option. Populate 7783 m_option_suggestions with candidate strings for misspelled options. 7784 The strings will be freed by the driver's dtor. */ 7785 7786 void 7787 driver::build_option_suggestions (void) 7788 { 7789 gcc_assert (m_option_suggestions == NULL); 7790 m_option_suggestions = new auto_vec <char *> (); 7791 7792 /* We build a vec of m_option_suggestions, using add_misspelling_candidates 7793 to add copies of strings, without a leading dash. */ 7794 7795 for (unsigned int i = 0; i < cl_options_count; i++) 7796 { 7797 const struct cl_option *option = &cl_options[i]; 7798 const char *opt_text = option->opt_text; 7799 switch (i) 7800 { 7801 default: 7802 if (option->var_type == CLVC_ENUM) 7803 { 7804 const struct cl_enum *e = &cl_enums[option->var_enum]; 7805 for (unsigned j = 0; e->values[j].arg != NULL; j++) 7806 { 7807 char *with_arg = concat (opt_text, e->values[j].arg, NULL); 7808 add_misspelling_candidates (m_option_suggestions, option, 7809 with_arg); 7810 free (with_arg); 7811 } 7812 } 7813 else 7814 add_misspelling_candidates (m_option_suggestions, option, 7815 opt_text); 7816 break; 7817 7818 case OPT_fsanitize_: 7819 case OPT_fsanitize_recover_: 7820 /* -fsanitize= and -fsanitize-recover= can take 7821 a comma-separated list of arguments. Given that combinations 7822 are supported, we can't add all potential candidates to the 7823 vec, but if we at least add them individually without commas, 7824 we should do a better job e.g. correcting 7825 "-sanitize=address" 7826 to 7827 "-fsanitize=address" 7828 rather than to "-Wframe-address" (PR driver/69265). */ 7829 { 7830 for (int j = 0; sanitizer_opts[j].name != NULL; ++j) 7831 { 7832 struct cl_option optb; 7833 /* -fsanitize=all is not valid, only -fno-sanitize=all. 7834 So don't register the positive misspelling candidates 7835 for it. */ 7836 if (sanitizer_opts[j].flag == ~0U && i == OPT_fsanitize_) 7837 { 7838 optb = *option; 7839 optb.opt_text = opt_text = "-fno-sanitize="; 7840 optb.cl_reject_negative = true; 7841 option = &optb; 7842 } 7843 /* Get one arg at a time e.g. "-fsanitize=address". */ 7844 char *with_arg = concat (opt_text, 7845 sanitizer_opts[j].name, 7846 NULL); 7847 /* Add with_arg and all of its variant spellings e.g. 7848 "-fno-sanitize=address" to candidates (albeit without 7849 leading dashes). */ 7850 add_misspelling_candidates (m_option_suggestions, option, 7851 with_arg); 7852 free (with_arg); 7853 } 7854 } 7855 break; 7856 } 7857 } 7858 } 7859 7860 /* Helper function for driver::handle_unrecognized_options. 7861 7862 Given an unrecognized option BAD_OPT (without the leading dash), 7863 locate the closest reasonable matching option (again, without the 7864 leading dash), or NULL. 7865 7866 The returned string is owned by the driver instance. */ 7867 7868 const char * 7869 driver::suggest_option (const char *bad_opt) 7870 { 7871 /* Lazily populate m_option_suggestions. */ 7872 if (!m_option_suggestions) 7873 build_option_suggestions (); 7874 gcc_assert (m_option_suggestions); 7875 7876 /* "m_option_suggestions" is now populated. Use it. */ 7877 return find_closest_string 7878 (bad_opt, 7879 (auto_vec <const char *> *) m_option_suggestions); 7880 } 7881 7882 /* Reject switches that no pass was interested in. */ 7883 7884 void 7885 driver::handle_unrecognized_options () 7886 { 7887 for (size_t i = 0; (int) i < n_switches; i++) 7888 if (! switches[i].validated) 7889 { 7890 const char *hint = suggest_option (switches[i].part1); 7891 if (hint) 7892 error ("unrecognized command line option %<-%s%>;" 7893 " did you mean %<-%s%>?", 7894 switches[i].part1, hint); 7895 else 7896 error ("unrecognized command line option %<-%s%>", 7897 switches[i].part1); 7898 } 7899 } 7900 7901 /* Handle the various -print-* options, returning 0 if the driver 7902 should exit, or nonzero if the driver should continue. */ 7903 7904 int 7905 driver::maybe_print_and_exit () const 7906 { 7907 if (print_search_dirs) 7908 { 7909 printf (_("install: %s%s\n"), 7910 gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix, 7911 gcc_exec_prefix ? "" : machine_suffix); 7912 printf (_("programs: %s\n"), 7913 build_search_list (&exec_prefixes, "", false, false)); 7914 printf (_("libraries: %s\n"), 7915 build_search_list (&startfile_prefixes, "", false, true)); 7916 return (0); 7917 } 7918 7919 if (print_file_name) 7920 { 7921 printf ("%s\n", find_file (print_file_name)); 7922 return (0); 7923 } 7924 7925 if (print_prog_name) 7926 { 7927 if (use_ld != NULL && ! strcmp (print_prog_name, "ld")) 7928 { 7929 /* Append USE_LD to the default linker. */ 7930 #ifdef DEFAULT_LINKER 7931 char *ld; 7932 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX 7933 int len = (sizeof (DEFAULT_LINKER) 7934 - sizeof (HOST_EXECUTABLE_SUFFIX)); 7935 ld = NULL; 7936 if (len > 0) 7937 { 7938 char *default_linker = xstrdup (DEFAULT_LINKER); 7939 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains 7940 HOST_EXECUTABLE_SUFFIX. */ 7941 if (! strcmp (&default_linker[len], HOST_EXECUTABLE_SUFFIX)) 7942 { 7943 default_linker[len] = '\0'; 7944 ld = concat (default_linker, use_ld, 7945 HOST_EXECUTABLE_SUFFIX, NULL); 7946 } 7947 } 7948 if (ld == NULL) 7949 # endif 7950 ld = concat (DEFAULT_LINKER, use_ld, NULL); 7951 if (access (ld, X_OK) == 0) 7952 { 7953 printf ("%s\n", ld); 7954 return (0); 7955 } 7956 #endif 7957 print_prog_name = concat (print_prog_name, use_ld, NULL); 7958 } 7959 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0); 7960 printf ("%s\n", (newname ? newname : print_prog_name)); 7961 return (0); 7962 } 7963 7964 if (print_multi_lib) 7965 { 7966 print_multilib_info (); 7967 return (0); 7968 } 7969 7970 if (print_multi_directory) 7971 { 7972 if (multilib_dir == NULL) 7973 printf (".\n"); 7974 else 7975 printf ("%s\n", multilib_dir); 7976 return (0); 7977 } 7978 7979 if (print_multiarch) 7980 { 7981 if (multiarch_dir == NULL) 7982 printf ("\n"); 7983 else 7984 printf ("%s\n", multiarch_dir); 7985 return (0); 7986 } 7987 7988 if (print_sysroot) 7989 { 7990 if (target_system_root) 7991 { 7992 if (target_sysroot_suffix) 7993 printf ("%s%s\n", target_system_root, target_sysroot_suffix); 7994 else 7995 printf ("%s\n", target_system_root); 7996 } 7997 return (0); 7998 } 7999 8000 if (print_multi_os_directory) 8001 { 8002 if (multilib_os_dir == NULL) 8003 printf (".\n"); 8004 else 8005 printf ("%s\n", multilib_os_dir); 8006 return (0); 8007 } 8008 8009 if (print_sysroot_headers_suffix) 8010 { 8011 if (*sysroot_hdrs_suffix_spec) 8012 { 8013 printf("%s\n", (target_sysroot_hdrs_suffix 8014 ? target_sysroot_hdrs_suffix 8015 : "")); 8016 return (0); 8017 } 8018 else 8019 /* The error status indicates that only one set of fixed 8020 headers should be built. */ 8021 fatal_error (input_location, 8022 "not configured with sysroot headers suffix"); 8023 } 8024 8025 if (print_help_list) 8026 { 8027 display_help (); 8028 8029 if (! verbose_flag) 8030 { 8031 printf (_("\nFor bug reporting instructions, please see:\n")); 8032 printf ("%s.\n", bug_report_url); 8033 8034 return (0); 8035 } 8036 8037 /* We do not exit here. Instead we have created a fake input file 8038 called 'help-dummy' which needs to be compiled, and we pass this 8039 on the various sub-processes, along with the --help switch. 8040 Ensure their output appears after ours. */ 8041 fputc ('\n', stdout); 8042 fflush (stdout); 8043 } 8044 8045 if (print_version) 8046 { 8047 printf (_("%s %s%s\n"), progname, pkgversion_string, 8048 version_string); 8049 printf ("Copyright %s 2018 Free Software Foundation, Inc.\n", 8050 _("(C)")); 8051 fputs (_("This is free software; see the source for copying conditions. There is NO\n\ 8052 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"), 8053 stdout); 8054 if (! verbose_flag) 8055 return 0; 8056 8057 /* We do not exit here. We use the same mechanism of --help to print 8058 the version of the sub-processes. */ 8059 fputc ('\n', stdout); 8060 fflush (stdout); 8061 } 8062 8063 if (verbose_flag) 8064 { 8065 print_configuration (stderr); 8066 if (n_infiles == 0) 8067 return (0); 8068 } 8069 8070 return 1; 8071 } 8072 8073 /* Figure out what to do with each input file. 8074 Return true if we need to exit early from "main", false otherwise. */ 8075 8076 bool 8077 driver::prepare_infiles () 8078 { 8079 size_t i; 8080 int lang_n_infiles = 0; 8081 8082 if (n_infiles == added_libraries) 8083 fatal_error (input_location, "no input files"); 8084 8085 if (seen_error ()) 8086 /* Early exit needed from main. */ 8087 return true; 8088 8089 /* Make a place to record the compiler output file names 8090 that correspond to the input files. */ 8091 8092 i = n_infiles; 8093 i += lang_specific_extra_outfiles; 8094 outfiles = XCNEWVEC (const char *, i); 8095 8096 /* Record which files were specified explicitly as link input. */ 8097 8098 explicit_link_files = XCNEWVEC (char, n_infiles); 8099 8100 combine_inputs = have_o || flag_wpa; 8101 8102 for (i = 0; (int) i < n_infiles; i++) 8103 { 8104 const char *name = infiles[i].name; 8105 struct compiler *compiler = lookup_compiler (name, 8106 strlen (name), 8107 infiles[i].language); 8108 8109 if (compiler && !(compiler->combinable)) 8110 combine_inputs = false; 8111 8112 if (lang_n_infiles > 0 && compiler != input_file_compiler 8113 && infiles[i].language && infiles[i].language[0] != '*') 8114 infiles[i].incompiler = compiler; 8115 else if (compiler) 8116 { 8117 lang_n_infiles++; 8118 input_file_compiler = compiler; 8119 infiles[i].incompiler = compiler; 8120 } 8121 else 8122 { 8123 /* Since there is no compiler for this input file, assume it is a 8124 linker file. */ 8125 explicit_link_files[i] = 1; 8126 infiles[i].incompiler = NULL; 8127 } 8128 infiles[i].compiled = false; 8129 infiles[i].preprocessed = false; 8130 } 8131 8132 if (!combine_inputs && have_c && have_o && lang_n_infiles > 1) 8133 fatal_error (input_location, 8134 "cannot specify -o with -c, -S or -E with multiple files"); 8135 8136 /* No early exit needed from main; we can continue. */ 8137 return false; 8138 } 8139 8140 /* Run the spec machinery on each input file. */ 8141 8142 void 8143 driver::do_spec_on_infiles () const 8144 { 8145 size_t i; 8146 8147 for (i = 0; (int) i < n_infiles; i++) 8148 { 8149 int this_file_error = 0; 8150 8151 /* Tell do_spec what to substitute for %i. */ 8152 8153 input_file_number = i; 8154 set_input (infiles[i].name); 8155 8156 if (infiles[i].compiled) 8157 continue; 8158 8159 /* Use the same thing in %o, unless cp->spec says otherwise. */ 8160 8161 outfiles[i] = gcc_input_filename; 8162 8163 /* Figure out which compiler from the file's suffix. */ 8164 8165 input_file_compiler 8166 = lookup_compiler (infiles[i].name, input_filename_length, 8167 infiles[i].language); 8168 8169 if (input_file_compiler) 8170 { 8171 /* Ok, we found an applicable compiler. Run its spec. */ 8172 8173 if (input_file_compiler->spec[0] == '#') 8174 { 8175 error ("%s: %s compiler not installed on this system", 8176 gcc_input_filename, &input_file_compiler->spec[1]); 8177 this_file_error = 1; 8178 } 8179 else 8180 { 8181 int value; 8182 8183 if (compare_debug) 8184 { 8185 free (debug_check_temp_file[0]); 8186 debug_check_temp_file[0] = NULL; 8187 8188 free (debug_check_temp_file[1]); 8189 debug_check_temp_file[1] = NULL; 8190 } 8191 8192 value = do_spec (input_file_compiler->spec); 8193 infiles[i].compiled = true; 8194 if (value < 0) 8195 this_file_error = 1; 8196 else if (compare_debug && debug_check_temp_file[0]) 8197 { 8198 if (verbose_flag) 8199 inform (UNKNOWN_LOCATION, 8200 "recompiling with -fcompare-debug"); 8201 8202 compare_debug = -compare_debug; 8203 n_switches = n_switches_debug_check[1]; 8204 n_switches_alloc = n_switches_alloc_debug_check[1]; 8205 switches = switches_debug_check[1]; 8206 8207 value = do_spec (input_file_compiler->spec); 8208 8209 compare_debug = -compare_debug; 8210 n_switches = n_switches_debug_check[0]; 8211 n_switches_alloc = n_switches_alloc_debug_check[0]; 8212 switches = switches_debug_check[0]; 8213 8214 if (value < 0) 8215 { 8216 error ("during -fcompare-debug recompilation"); 8217 this_file_error = 1; 8218 } 8219 8220 gcc_assert (debug_check_temp_file[1] 8221 && filename_cmp (debug_check_temp_file[0], 8222 debug_check_temp_file[1])); 8223 8224 if (verbose_flag) 8225 inform (UNKNOWN_LOCATION, "comparing final insns dumps"); 8226 8227 if (compare_files (debug_check_temp_file)) 8228 this_file_error = 1; 8229 } 8230 8231 if (compare_debug) 8232 { 8233 free (debug_check_temp_file[0]); 8234 debug_check_temp_file[0] = NULL; 8235 8236 free (debug_check_temp_file[1]); 8237 debug_check_temp_file[1] = NULL; 8238 } 8239 } 8240 } 8241 8242 /* If this file's name does not contain a recognized suffix, 8243 record it as explicit linker input. */ 8244 8245 else 8246 explicit_link_files[i] = 1; 8247 8248 /* Clear the delete-on-failure queue, deleting the files in it 8249 if this compilation failed. */ 8250 8251 if (this_file_error) 8252 { 8253 delete_failure_queue (); 8254 errorcount++; 8255 } 8256 /* If this compilation succeeded, don't delete those files later. */ 8257 clear_failure_queue (); 8258 } 8259 8260 /* Reset the input file name to the first compile/object file name, for use 8261 with %b in LINK_SPEC. We use the first input file that we can find 8262 a compiler to compile it instead of using infiles.language since for 8263 languages other than C we use aliases that we then lookup later. */ 8264 if (n_infiles > 0) 8265 { 8266 int i; 8267 8268 for (i = 0; i < n_infiles ; i++) 8269 if (infiles[i].incompiler 8270 || (infiles[i].language && infiles[i].language[0] != '*')) 8271 { 8272 set_input (infiles[i].name); 8273 break; 8274 } 8275 } 8276 8277 if (!seen_error ()) 8278 { 8279 /* Make sure INPUT_FILE_NUMBER points to first available open 8280 slot. */ 8281 input_file_number = n_infiles; 8282 if (lang_specific_pre_link ()) 8283 errorcount++; 8284 } 8285 } 8286 8287 /* If we have to run the linker, do it now. */ 8288 8289 void 8290 driver::maybe_run_linker (const char *argv0) const 8291 { 8292 size_t i; 8293 int linker_was_run = 0; 8294 int num_linker_inputs; 8295 8296 /* Determine if there are any linker input files. */ 8297 num_linker_inputs = 0; 8298 for (i = 0; (int) i < n_infiles; i++) 8299 if (explicit_link_files[i] || outfiles[i] != NULL) 8300 num_linker_inputs++; 8301 8302 /* Run ld to link all the compiler output files. */ 8303 8304 if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2) 8305 { 8306 int tmp = execution_count; 8307 8308 if (! have_c) 8309 { 8310 #if HAVE_LTO_PLUGIN > 0 8311 #if HAVE_LTO_PLUGIN == 2 8312 const char *fno_use_linker_plugin = "fno-use-linker-plugin"; 8313 #else 8314 const char *fuse_linker_plugin = "fuse-linker-plugin"; 8315 #endif 8316 #endif 8317 8318 /* We'll use ld if we can't find collect2. */ 8319 if (! strcmp (linker_name_spec, "collect2")) 8320 { 8321 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false); 8322 if (s == NULL) 8323 linker_name_spec = "ld"; 8324 } 8325 8326 #if HAVE_LTO_PLUGIN > 0 8327 #if HAVE_LTO_PLUGIN == 2 8328 if (!switch_matches (fno_use_linker_plugin, 8329 fno_use_linker_plugin 8330 + strlen (fno_use_linker_plugin), 0)) 8331 #else 8332 if (switch_matches (fuse_linker_plugin, 8333 fuse_linker_plugin 8334 + strlen (fuse_linker_plugin), 0)) 8335 #endif 8336 { 8337 char *temp_spec = find_a_file (&exec_prefixes, 8338 LTOPLUGINSONAME, R_OK, 8339 false); 8340 if (!temp_spec) 8341 fatal_error (input_location, 8342 "-fuse-linker-plugin, but %s not found", 8343 LTOPLUGINSONAME); 8344 linker_plugin_file_spec = convert_white_space (temp_spec); 8345 } 8346 #endif 8347 lto_gcc_spec = argv0; 8348 } 8349 8350 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables 8351 for collect. */ 8352 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false); 8353 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true); 8354 8355 if (print_subprocess_help == 1) 8356 { 8357 printf (_("\nLinker options\n==============\n\n")); 8358 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\"" 8359 " to the linker.\n\n")); 8360 fflush (stdout); 8361 } 8362 int value = do_spec (link_command_spec); 8363 if (value < 0) 8364 errorcount = 1; 8365 linker_was_run = (tmp != execution_count); 8366 } 8367 8368 /* If options said don't run linker, 8369 complain about input files to be given to the linker. */ 8370 8371 if (! linker_was_run && !seen_error ()) 8372 for (i = 0; (int) i < n_infiles; i++) 8373 if (explicit_link_files[i] 8374 && !(infiles[i].language && infiles[i].language[0] == '*')) 8375 warning (0, "%s: linker input file unused because linking not done", 8376 outfiles[i]); 8377 } 8378 8379 /* The end of "main". */ 8380 8381 void 8382 driver::final_actions () const 8383 { 8384 /* Delete some or all of the temporary files we made. */ 8385 8386 if (seen_error ()) 8387 delete_failure_queue (); 8388 delete_temp_files (); 8389 8390 if (print_help_list) 8391 { 8392 printf (("\nFor bug reporting instructions, please see:\n")); 8393 printf ("%s\n", bug_report_url); 8394 } 8395 } 8396 8397 /* Determine what the exit code of the driver should be. */ 8398 8399 int 8400 driver::get_exit_code () const 8401 { 8402 return (signal_count != 0 ? 2 8403 : seen_error () ? (pass_exit_codes ? greatest_status : 1) 8404 : 0); 8405 } 8406 8407 /* Find the proper compilation spec for the file name NAME, 8408 whose length is LENGTH. LANGUAGE is the specified language, 8409 or 0 if this file is to be passed to the linker. */ 8410 8411 static struct compiler * 8412 lookup_compiler (const char *name, size_t length, const char *language) 8413 { 8414 struct compiler *cp; 8415 8416 /* If this was specified by the user to be a linker input, indicate that. */ 8417 if (language != 0 && language[0] == '*') 8418 return 0; 8419 8420 /* Otherwise, look for the language, if one is spec'd. */ 8421 if (language != 0) 8422 { 8423 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 8424 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language)) 8425 { 8426 if (name != NULL && strcmp (name, "-") == 0 8427 && (strcmp (cp->suffix, "@c-header") == 0 8428 || strcmp (cp->suffix, "@c++-header") == 0) 8429 && !have_E) 8430 fatal_error (input_location, 8431 "cannot use %<-%> as input filename for a " 8432 "precompiled header"); 8433 8434 return cp; 8435 } 8436 8437 error ("language %s not recognized", language); 8438 return 0; 8439 } 8440 8441 /* Look for a suffix. */ 8442 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 8443 { 8444 if (/* The suffix `-' matches only the file name `-'. */ 8445 (!strcmp (cp->suffix, "-") && !strcmp (name, "-")) 8446 || (strlen (cp->suffix) < length 8447 /* See if the suffix matches the end of NAME. */ 8448 && !strcmp (cp->suffix, 8449 name + length - strlen (cp->suffix)) 8450 )) 8451 break; 8452 } 8453 8454 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM) 8455 /* Look again, but case-insensitively this time. */ 8456 if (cp < compilers) 8457 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 8458 { 8459 if (/* The suffix `-' matches only the file name `-'. */ 8460 (!strcmp (cp->suffix, "-") && !strcmp (name, "-")) 8461 || (strlen (cp->suffix) < length 8462 /* See if the suffix matches the end of NAME. */ 8463 && ((!strcmp (cp->suffix, 8464 name + length - strlen (cp->suffix)) 8465 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ")) 8466 && !strcasecmp (cp->suffix, 8467 name + length - strlen (cp->suffix))) 8468 )) 8469 break; 8470 } 8471 #endif 8472 8473 if (cp >= compilers) 8474 { 8475 if (cp->spec[0] != '@') 8476 /* A non-alias entry: return it. */ 8477 return cp; 8478 8479 /* An alias entry maps a suffix to a language. 8480 Search for the language; pass 0 for NAME and LENGTH 8481 to avoid infinite recursion if language not found. */ 8482 return lookup_compiler (NULL, 0, cp->spec + 1); 8483 } 8484 return 0; 8485 } 8486 8487 static char * 8488 save_string (const char *s, int len) 8489 { 8490 char *result = XNEWVEC (char, len + 1); 8491 8492 gcc_checking_assert (strlen (s) >= (unsigned int) len); 8493 memcpy (result, s, len); 8494 result[len] = 0; 8495 return result; 8496 } 8497 8498 void 8499 pfatal_with_name (const char *name) 8500 { 8501 perror_with_name (name); 8502 delete_temp_files (); 8503 exit (1); 8504 } 8505 8506 static void 8507 perror_with_name (const char *name) 8508 { 8509 error ("%s: %m", name); 8510 } 8511 8512 static inline void 8513 validate_switches_from_spec (const char *spec, bool user) 8514 { 8515 const char *p = spec; 8516 char c; 8517 while ((c = *p++)) 8518 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{'))) 8519 /* We have a switch spec. */ 8520 p = validate_switches (p + 1, user); 8521 } 8522 8523 static void 8524 validate_all_switches (void) 8525 { 8526 struct compiler *comp; 8527 struct spec_list *spec; 8528 8529 for (comp = compilers; comp->spec; comp++) 8530 validate_switches_from_spec (comp->spec, false); 8531 8532 /* Look through the linked list of specs read from the specs file. */ 8533 for (spec = specs; spec; spec = spec->next) 8534 validate_switches_from_spec (*spec->ptr_spec, spec->user_p); 8535 8536 validate_switches_from_spec (link_command_spec, false); 8537 } 8538 8539 /* Look at the switch-name that comes after START 8540 and mark as valid all supplied switches that match it. */ 8541 8542 static const char * 8543 validate_switches (const char *start, bool user_spec) 8544 { 8545 const char *p = start; 8546 const char *atom; 8547 size_t len; 8548 int i; 8549 bool suffix = false; 8550 bool starred = false; 8551 8552 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0) 8553 8554 next_member: 8555 SKIP_WHITE (); 8556 8557 if (*p == '!') 8558 p++; 8559 8560 SKIP_WHITE (); 8561 if (*p == '.' || *p == ',') 8562 suffix = true, p++; 8563 8564 atom = p; 8565 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '=' 8566 || *p == ',' || *p == '.' || *p == '@') 8567 p++; 8568 len = p - atom; 8569 8570 if (*p == '*') 8571 starred = true, p++; 8572 8573 SKIP_WHITE (); 8574 8575 if (!suffix) 8576 { 8577 /* Mark all matching switches as valid. */ 8578 for (i = 0; i < n_switches; i++) 8579 if (!strncmp (switches[i].part1, atom, len) 8580 && (starred || switches[i].part1[len] == '\0') 8581 && (switches[i].known || user_spec)) 8582 switches[i].validated = true; 8583 } 8584 8585 if (*p) p++; 8586 if (*p && (p[-1] == '|' || p[-1] == '&')) 8587 goto next_member; 8588 8589 if (*p && p[-1] == ':') 8590 { 8591 while (*p && *p != ';' && *p != '}') 8592 { 8593 if (*p == '%') 8594 { 8595 p++; 8596 if (*p == '{' || *p == '<') 8597 p = validate_switches (p+1, user_spec); 8598 else if (p[0] == 'W' && p[1] == '{') 8599 p = validate_switches (p+2, user_spec); 8600 } 8601 else 8602 p++; 8603 } 8604 8605 if (*p) p++; 8606 if (*p && p[-1] == ';') 8607 goto next_member; 8608 } 8609 8610 return p; 8611 #undef SKIP_WHITE 8612 } 8613 8614 struct mdswitchstr 8615 { 8616 const char *str; 8617 int len; 8618 }; 8619 8620 static struct mdswitchstr *mdswitches; 8621 static int n_mdswitches; 8622 8623 /* Check whether a particular argument was used. The first time we 8624 canonicalize the switches to keep only the ones we care about. */ 8625 8626 class used_arg_t 8627 { 8628 public: 8629 int operator () (const char *p, int len); 8630 void finalize (); 8631 8632 private: 8633 struct mswitchstr 8634 { 8635 const char *str; 8636 const char *replace; 8637 int len; 8638 int rep_len; 8639 }; 8640 8641 mswitchstr *mswitches; 8642 int n_mswitches; 8643 8644 }; 8645 8646 used_arg_t used_arg; 8647 8648 int 8649 used_arg_t::operator () (const char *p, int len) 8650 { 8651 int i, j; 8652 8653 if (!mswitches) 8654 { 8655 struct mswitchstr *matches; 8656 const char *q; 8657 int cnt = 0; 8658 8659 /* Break multilib_matches into the component strings of string 8660 and replacement string. */ 8661 for (q = multilib_matches; *q != '\0'; q++) 8662 if (*q == ';') 8663 cnt++; 8664 8665 matches 8666 = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt); 8667 i = 0; 8668 q = multilib_matches; 8669 while (*q != '\0') 8670 { 8671 matches[i].str = q; 8672 while (*q != ' ') 8673 { 8674 if (*q == '\0') 8675 { 8676 invalid_matches: 8677 fatal_error (input_location, "multilib spec %qs is invalid", 8678 multilib_matches); 8679 } 8680 q++; 8681 } 8682 matches[i].len = q - matches[i].str; 8683 8684 matches[i].replace = ++q; 8685 while (*q != ';' && *q != '\0') 8686 { 8687 if (*q == ' ') 8688 goto invalid_matches; 8689 q++; 8690 } 8691 matches[i].rep_len = q - matches[i].replace; 8692 i++; 8693 if (*q == ';') 8694 q++; 8695 } 8696 8697 /* Now build a list of the replacement string for switches that we care 8698 about. Make sure we allocate at least one entry. This prevents 8699 xmalloc from calling fatal, and prevents us from re-executing this 8700 block of code. */ 8701 mswitches 8702 = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1)); 8703 for (i = 0; i < n_switches; i++) 8704 if ((switches[i].live_cond & SWITCH_IGNORE) == 0) 8705 { 8706 int xlen = strlen (switches[i].part1); 8707 for (j = 0; j < cnt; j++) 8708 if (xlen == matches[j].len 8709 && ! strncmp (switches[i].part1, matches[j].str, xlen)) 8710 { 8711 mswitches[n_mswitches].str = matches[j].replace; 8712 mswitches[n_mswitches].len = matches[j].rep_len; 8713 mswitches[n_mswitches].replace = (char *) 0; 8714 mswitches[n_mswitches].rep_len = 0; 8715 n_mswitches++; 8716 break; 8717 } 8718 } 8719 8720 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present 8721 on the command line nor any options mutually incompatible with 8722 them. */ 8723 for (i = 0; i < n_mdswitches; i++) 8724 { 8725 const char *r; 8726 8727 for (q = multilib_options; *q != '\0'; *q && q++) 8728 { 8729 while (*q == ' ') 8730 q++; 8731 8732 r = q; 8733 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0 8734 || strchr (" /", q[mdswitches[i].len]) == NULL) 8735 { 8736 while (*q != ' ' && *q != '/' && *q != '\0') 8737 q++; 8738 if (*q != '/') 8739 break; 8740 q++; 8741 } 8742 8743 if (*q != ' ' && *q != '\0') 8744 { 8745 while (*r != ' ' && *r != '\0') 8746 { 8747 q = r; 8748 while (*q != ' ' && *q != '/' && *q != '\0') 8749 q++; 8750 8751 if (used_arg (r, q - r)) 8752 break; 8753 8754 if (*q != '/') 8755 { 8756 mswitches[n_mswitches].str = mdswitches[i].str; 8757 mswitches[n_mswitches].len = mdswitches[i].len; 8758 mswitches[n_mswitches].replace = (char *) 0; 8759 mswitches[n_mswitches].rep_len = 0; 8760 n_mswitches++; 8761 break; 8762 } 8763 8764 r = q + 1; 8765 } 8766 break; 8767 } 8768 } 8769 } 8770 } 8771 8772 for (i = 0; i < n_mswitches; i++) 8773 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len)) 8774 return 1; 8775 8776 return 0; 8777 } 8778 8779 void used_arg_t::finalize () 8780 { 8781 XDELETEVEC (mswitches); 8782 mswitches = NULL; 8783 n_mswitches = 0; 8784 } 8785 8786 8787 static int 8788 default_arg (const char *p, int len) 8789 { 8790 int i; 8791 8792 for (i = 0; i < n_mdswitches; i++) 8793 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len)) 8794 return 1; 8795 8796 return 0; 8797 } 8798 8799 /* Work out the subdirectory to use based on the options. The format of 8800 multilib_select is a list of elements. Each element is a subdirectory 8801 name followed by a list of options followed by a semicolon. The format 8802 of multilib_exclusions is the same, but without the preceding 8803 directory. First gcc will check the exclusions, if none of the options 8804 beginning with an exclamation point are present, and all of the other 8805 options are present, then we will ignore this completely. Passing 8806 that, gcc will consider each multilib_select in turn using the same 8807 rules for matching the options. If a match is found, that subdirectory 8808 will be used. 8809 A subdirectory name is optionally followed by a colon and the corresponding 8810 multiarch name. */ 8811 8812 static void 8813 set_multilib_dir (void) 8814 { 8815 const char *p; 8816 unsigned int this_path_len; 8817 const char *this_path, *this_arg; 8818 const char *start, *end; 8819 int not_arg; 8820 int ok, ndfltok, first; 8821 8822 n_mdswitches = 0; 8823 start = multilib_defaults; 8824 while (*start == ' ' || *start == '\t') 8825 start++; 8826 while (*start != '\0') 8827 { 8828 n_mdswitches++; 8829 while (*start != ' ' && *start != '\t' && *start != '\0') 8830 start++; 8831 while (*start == ' ' || *start == '\t') 8832 start++; 8833 } 8834 8835 if (n_mdswitches) 8836 { 8837 int i = 0; 8838 8839 mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches); 8840 for (start = multilib_defaults; *start != '\0'; start = end + 1) 8841 { 8842 while (*start == ' ' || *start == '\t') 8843 start++; 8844 8845 if (*start == '\0') 8846 break; 8847 8848 for (end = start + 1; 8849 *end != ' ' && *end != '\t' && *end != '\0'; end++) 8850 ; 8851 8852 obstack_grow (&multilib_obstack, start, end - start); 8853 obstack_1grow (&multilib_obstack, 0); 8854 mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *); 8855 mdswitches[i++].len = end - start; 8856 8857 if (*end == '\0') 8858 break; 8859 } 8860 } 8861 8862 p = multilib_exclusions; 8863 while (*p != '\0') 8864 { 8865 /* Ignore newlines. */ 8866 if (*p == '\n') 8867 { 8868 ++p; 8869 continue; 8870 } 8871 8872 /* Check the arguments. */ 8873 ok = 1; 8874 while (*p != ';') 8875 { 8876 if (*p == '\0') 8877 { 8878 invalid_exclusions: 8879 fatal_error (input_location, "multilib exclusions %qs is invalid", 8880 multilib_exclusions); 8881 } 8882 8883 if (! ok) 8884 { 8885 ++p; 8886 continue; 8887 } 8888 8889 this_arg = p; 8890 while (*p != ' ' && *p != ';') 8891 { 8892 if (*p == '\0') 8893 goto invalid_exclusions; 8894 ++p; 8895 } 8896 8897 if (*this_arg != '!') 8898 not_arg = 0; 8899 else 8900 { 8901 not_arg = 1; 8902 ++this_arg; 8903 } 8904 8905 ok = used_arg (this_arg, p - this_arg); 8906 if (not_arg) 8907 ok = ! ok; 8908 8909 if (*p == ' ') 8910 ++p; 8911 } 8912 8913 if (ok) 8914 return; 8915 8916 ++p; 8917 } 8918 8919 first = 1; 8920 p = multilib_select; 8921 8922 /* Append multilib reuse rules if any. With those rules, we can reuse 8923 one multilib for certain different options sets. */ 8924 if (strlen (multilib_reuse) > 0) 8925 p = concat (p, multilib_reuse, NULL); 8926 8927 while (*p != '\0') 8928 { 8929 /* Ignore newlines. */ 8930 if (*p == '\n') 8931 { 8932 ++p; 8933 continue; 8934 } 8935 8936 /* Get the initial path. */ 8937 this_path = p; 8938 while (*p != ' ') 8939 { 8940 if (*p == '\0') 8941 { 8942 invalid_select: 8943 fatal_error (input_location, "multilib select %qs %qs is invalid", 8944 multilib_select, multilib_reuse); 8945 } 8946 ++p; 8947 } 8948 this_path_len = p - this_path; 8949 8950 /* Check the arguments. */ 8951 ok = 1; 8952 ndfltok = 1; 8953 ++p; 8954 while (*p != ';') 8955 { 8956 if (*p == '\0') 8957 goto invalid_select; 8958 8959 if (! ok) 8960 { 8961 ++p; 8962 continue; 8963 } 8964 8965 this_arg = p; 8966 while (*p != ' ' && *p != ';') 8967 { 8968 if (*p == '\0') 8969 goto invalid_select; 8970 ++p; 8971 } 8972 8973 if (*this_arg != '!') 8974 not_arg = 0; 8975 else 8976 { 8977 not_arg = 1; 8978 ++this_arg; 8979 } 8980 8981 /* If this is a default argument, we can just ignore it. 8982 This is true even if this_arg begins with '!'. Beginning 8983 with '!' does not mean that this argument is necessarily 8984 inappropriate for this library: it merely means that 8985 there is a more specific library which uses this 8986 argument. If this argument is a default, we need not 8987 consider that more specific library. */ 8988 ok = used_arg (this_arg, p - this_arg); 8989 if (not_arg) 8990 ok = ! ok; 8991 8992 if (! ok) 8993 ndfltok = 0; 8994 8995 if (default_arg (this_arg, p - this_arg)) 8996 ok = 1; 8997 8998 if (*p == ' ') 8999 ++p; 9000 } 9001 9002 if (ok && first) 9003 { 9004 if (this_path_len != 1 9005 || this_path[0] != '.') 9006 { 9007 char *new_multilib_dir = XNEWVEC (char, this_path_len + 1); 9008 char *q; 9009 9010 strncpy (new_multilib_dir, this_path, this_path_len); 9011 new_multilib_dir[this_path_len] = '\0'; 9012 q = strchr (new_multilib_dir, ':'); 9013 if (q != NULL) 9014 *q = '\0'; 9015 multilib_dir = new_multilib_dir; 9016 } 9017 first = 0; 9018 } 9019 9020 if (ndfltok) 9021 { 9022 const char *q = this_path, *end = this_path + this_path_len; 9023 9024 while (q < end && *q != ':') 9025 q++; 9026 if (q < end) 9027 { 9028 const char *q2 = q + 1, *ml_end = end; 9029 char *new_multilib_os_dir; 9030 9031 while (q2 < end && *q2 != ':') 9032 q2++; 9033 if (*q2 == ':') 9034 ml_end = q2; 9035 if (ml_end - q == 1) 9036 multilib_os_dir = xstrdup ("."); 9037 else 9038 { 9039 new_multilib_os_dir = XNEWVEC (char, ml_end - q); 9040 memcpy (new_multilib_os_dir, q + 1, ml_end - q - 1); 9041 new_multilib_os_dir[ml_end - q - 1] = '\0'; 9042 multilib_os_dir = new_multilib_os_dir; 9043 } 9044 9045 if (q2 < end && *q2 == ':') 9046 { 9047 char *new_multiarch_dir = XNEWVEC (char, end - q2); 9048 memcpy (new_multiarch_dir, q2 + 1, end - q2 - 1); 9049 new_multiarch_dir[end - q2 - 1] = '\0'; 9050 multiarch_dir = new_multiarch_dir; 9051 } 9052 break; 9053 } 9054 } 9055 9056 ++p; 9057 } 9058 9059 if (multilib_dir == NULL && multilib_os_dir != NULL 9060 && strcmp (multilib_os_dir, ".") == 0) 9061 { 9062 free (CONST_CAST (char *, multilib_os_dir)); 9063 multilib_os_dir = NULL; 9064 } 9065 else if (multilib_dir != NULL && multilib_os_dir == NULL) 9066 multilib_os_dir = multilib_dir; 9067 } 9068 9069 /* Print out the multiple library subdirectory selection 9070 information. This prints out a series of lines. Each line looks 9071 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is 9072 required. Only the desired options are printed out, the negative 9073 matches. The options are print without a leading dash. There are 9074 no spaces to make it easy to use the information in the shell. 9075 Each subdirectory is printed only once. This assumes the ordering 9076 generated by the genmultilib script. Also, we leave out ones that match 9077 the exclusions. */ 9078 9079 static void 9080 print_multilib_info (void) 9081 { 9082 const char *p = multilib_select; 9083 const char *last_path = 0, *this_path; 9084 int skip; 9085 unsigned int last_path_len = 0; 9086 9087 while (*p != '\0') 9088 { 9089 skip = 0; 9090 /* Ignore newlines. */ 9091 if (*p == '\n') 9092 { 9093 ++p; 9094 continue; 9095 } 9096 9097 /* Get the initial path. */ 9098 this_path = p; 9099 while (*p != ' ') 9100 { 9101 if (*p == '\0') 9102 { 9103 invalid_select: 9104 fatal_error (input_location, 9105 "multilib select %qs is invalid", multilib_select); 9106 } 9107 9108 ++p; 9109 } 9110 9111 /* When --disable-multilib was used but target defines 9112 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting 9113 with .:: for multiarch configurations) are there just to find 9114 multilib_os_dir, so skip them from output. */ 9115 if (this_path[0] == '.' && this_path[1] == ':' && this_path[2] != ':') 9116 skip = 1; 9117 9118 /* Check for matches with the multilib_exclusions. We don't bother 9119 with the '!' in either list. If any of the exclusion rules match 9120 all of its options with the select rule, we skip it. */ 9121 { 9122 const char *e = multilib_exclusions; 9123 const char *this_arg; 9124 9125 while (*e != '\0') 9126 { 9127 int m = 1; 9128 /* Ignore newlines. */ 9129 if (*e == '\n') 9130 { 9131 ++e; 9132 continue; 9133 } 9134 9135 /* Check the arguments. */ 9136 while (*e != ';') 9137 { 9138 const char *q; 9139 int mp = 0; 9140 9141 if (*e == '\0') 9142 { 9143 invalid_exclusion: 9144 fatal_error (input_location, 9145 "multilib exclusion %qs is invalid", 9146 multilib_exclusions); 9147 } 9148 9149 if (! m) 9150 { 9151 ++e; 9152 continue; 9153 } 9154 9155 this_arg = e; 9156 9157 while (*e != ' ' && *e != ';') 9158 { 9159 if (*e == '\0') 9160 goto invalid_exclusion; 9161 ++e; 9162 } 9163 9164 q = p + 1; 9165 while (*q != ';') 9166 { 9167 const char *arg; 9168 int len = e - this_arg; 9169 9170 if (*q == '\0') 9171 goto invalid_select; 9172 9173 arg = q; 9174 9175 while (*q != ' ' && *q != ';') 9176 { 9177 if (*q == '\0') 9178 goto invalid_select; 9179 ++q; 9180 } 9181 9182 if (! strncmp (arg, this_arg, 9183 (len < q - arg) ? q - arg : len) 9184 || default_arg (this_arg, e - this_arg)) 9185 { 9186 mp = 1; 9187 break; 9188 } 9189 9190 if (*q == ' ') 9191 ++q; 9192 } 9193 9194 if (! mp) 9195 m = 0; 9196 9197 if (*e == ' ') 9198 ++e; 9199 } 9200 9201 if (m) 9202 { 9203 skip = 1; 9204 break; 9205 } 9206 9207 if (*e != '\0') 9208 ++e; 9209 } 9210 } 9211 9212 if (! skip) 9213 { 9214 /* If this is a duplicate, skip it. */ 9215 skip = (last_path != 0 9216 && (unsigned int) (p - this_path) == last_path_len 9217 && ! filename_ncmp (last_path, this_path, last_path_len)); 9218 9219 last_path = this_path; 9220 last_path_len = p - this_path; 9221 } 9222 9223 /* If this directory requires any default arguments, we can skip 9224 it. We will already have printed a directory identical to 9225 this one which does not require that default argument. */ 9226 if (! skip) 9227 { 9228 const char *q; 9229 9230 q = p + 1; 9231 while (*q != ';') 9232 { 9233 const char *arg; 9234 9235 if (*q == '\0') 9236 goto invalid_select; 9237 9238 if (*q == '!') 9239 arg = NULL; 9240 else 9241 arg = q; 9242 9243 while (*q != ' ' && *q != ';') 9244 { 9245 if (*q == '\0') 9246 goto invalid_select; 9247 ++q; 9248 } 9249 9250 if (arg != NULL 9251 && default_arg (arg, q - arg)) 9252 { 9253 skip = 1; 9254 break; 9255 } 9256 9257 if (*q == ' ') 9258 ++q; 9259 } 9260 } 9261 9262 if (! skip) 9263 { 9264 const char *p1; 9265 9266 for (p1 = last_path; p1 < p && *p1 != ':'; p1++) 9267 putchar (*p1); 9268 putchar (';'); 9269 } 9270 9271 ++p; 9272 while (*p != ';') 9273 { 9274 int use_arg; 9275 9276 if (*p == '\0') 9277 goto invalid_select; 9278 9279 if (skip) 9280 { 9281 ++p; 9282 continue; 9283 } 9284 9285 use_arg = *p != '!'; 9286 9287 if (use_arg) 9288 putchar ('@'); 9289 9290 while (*p != ' ' && *p != ';') 9291 { 9292 if (*p == '\0') 9293 goto invalid_select; 9294 if (use_arg) 9295 putchar (*p); 9296 ++p; 9297 } 9298 9299 if (*p == ' ') 9300 ++p; 9301 } 9302 9303 if (! skip) 9304 { 9305 /* If there are extra options, print them now. */ 9306 if (multilib_extra && *multilib_extra) 9307 { 9308 int print_at = TRUE; 9309 const char *q; 9310 9311 for (q = multilib_extra; *q != '\0'; q++) 9312 { 9313 if (*q == ' ') 9314 print_at = TRUE; 9315 else 9316 { 9317 if (print_at) 9318 putchar ('@'); 9319 putchar (*q); 9320 print_at = FALSE; 9321 } 9322 } 9323 } 9324 9325 putchar ('\n'); 9326 } 9327 9328 ++p; 9329 } 9330 } 9331 9332 /* getenv built-in spec function. 9333 9334 Returns the value of the environment variable given by its first argument, 9335 concatenated with the second argument. If the variable is not defined, a 9336 fatal error is issued unless such undefs are internally allowed, in which 9337 case the variable name is used as the variable value. */ 9338 9339 static const char * 9340 getenv_spec_function (int argc, const char **argv) 9341 { 9342 const char *value; 9343 const char *varname; 9344 9345 char *result; 9346 char *ptr; 9347 size_t len; 9348 9349 if (argc != 2) 9350 return NULL; 9351 9352 varname = argv[0]; 9353 value = env.get (varname); 9354 9355 if (!value && spec_undefvar_allowed) 9356 value = varname; 9357 9358 if (!value) 9359 fatal_error (input_location, 9360 "environment variable %qs not defined", varname); 9361 9362 /* We have to escape every character of the environment variable so 9363 they are not interpreted as active spec characters. A 9364 particularly painful case is when we are reading a variable 9365 holding a windows path complete with \ separators. */ 9366 len = strlen (value) * 2 + strlen (argv[1]) + 1; 9367 result = XNEWVAR (char, len); 9368 for (ptr = result; *value; ptr += 2) 9369 { 9370 ptr[0] = '\\'; 9371 ptr[1] = *value++; 9372 } 9373 9374 strcpy (ptr, argv[1]); 9375 9376 return result; 9377 } 9378 9379 /* if-exists built-in spec function. 9380 9381 Checks to see if the file specified by the absolute pathname in 9382 ARGS exists. Returns that pathname if found. 9383 9384 The usual use for this function is to check for a library file 9385 (whose name has been expanded with %s). */ 9386 9387 static const char * 9388 if_exists_spec_function (int argc, const char **argv) 9389 { 9390 /* Must have only one argument. */ 9391 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK)) 9392 return argv[0]; 9393 9394 return NULL; 9395 } 9396 9397 /* if-exists-else built-in spec function. 9398 9399 This is like if-exists, but takes an additional argument which 9400 is returned if the first argument does not exist. */ 9401 9402 static const char * 9403 if_exists_else_spec_function (int argc, const char **argv) 9404 { 9405 /* Must have exactly two arguments. */ 9406 if (argc != 2) 9407 return NULL; 9408 9409 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK)) 9410 return argv[0]; 9411 9412 return argv[1]; 9413 } 9414 9415 /* sanitize built-in spec function. 9416 9417 This returns non-NULL, if sanitizing address, thread or 9418 any of the undefined behavior sanitizers. */ 9419 9420 static const char * 9421 sanitize_spec_function (int argc, const char **argv) 9422 { 9423 if (argc != 1) 9424 return NULL; 9425 9426 if (strcmp (argv[0], "address") == 0) 9427 return (flag_sanitize & SANITIZE_USER_ADDRESS) ? "" : NULL; 9428 if (strcmp (argv[0], "kernel-address") == 0) 9429 return (flag_sanitize & SANITIZE_KERNEL_ADDRESS) ? "" : NULL; 9430 if (strcmp (argv[0], "thread") == 0) 9431 return (flag_sanitize & SANITIZE_THREAD) ? "" : NULL; 9432 if (strcmp (argv[0], "undefined") == 0) 9433 return ((flag_sanitize 9434 & (SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT)) 9435 && !flag_sanitize_undefined_trap_on_error) ? "" : NULL; 9436 if (strcmp (argv[0], "leak") == 0) 9437 return ((flag_sanitize 9438 & (SANITIZE_ADDRESS | SANITIZE_LEAK | SANITIZE_THREAD)) 9439 == SANITIZE_LEAK) ? "" : NULL; 9440 return NULL; 9441 } 9442 9443 /* replace-outfile built-in spec function. 9444 9445 This looks for the first argument in the outfiles array's name and 9446 replaces it with the second argument. */ 9447 9448 static const char * 9449 replace_outfile_spec_function (int argc, const char **argv) 9450 { 9451 int i; 9452 /* Must have exactly two arguments. */ 9453 if (argc != 2) 9454 abort (); 9455 9456 for (i = 0; i < n_infiles; i++) 9457 { 9458 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0])) 9459 outfiles[i] = xstrdup (argv[1]); 9460 } 9461 return NULL; 9462 } 9463 9464 /* remove-outfile built-in spec function. 9465 * 9466 * This looks for the first argument in the outfiles array's name and 9467 * removes it. */ 9468 9469 static const char * 9470 remove_outfile_spec_function (int argc, const char **argv) 9471 { 9472 int i; 9473 /* Must have exactly one argument. */ 9474 if (argc != 1) 9475 abort (); 9476 9477 for (i = 0; i < n_infiles; i++) 9478 { 9479 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0])) 9480 outfiles[i] = NULL; 9481 } 9482 return NULL; 9483 } 9484 9485 /* Given two version numbers, compares the two numbers. 9486 A version number must match the regular expression 9487 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))* 9488 */ 9489 static int 9490 compare_version_strings (const char *v1, const char *v2) 9491 { 9492 int rresult; 9493 regex_t r; 9494 9495 if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$", 9496 REG_EXTENDED | REG_NOSUB) != 0) 9497 abort (); 9498 rresult = regexec (&r, v1, 0, NULL, 0); 9499 if (rresult == REG_NOMATCH) 9500 fatal_error (input_location, "invalid version number %qs", v1); 9501 else if (rresult != 0) 9502 abort (); 9503 rresult = regexec (&r, v2, 0, NULL, 0); 9504 if (rresult == REG_NOMATCH) 9505 fatal_error (input_location, "invalid version number %qs", v2); 9506 else if (rresult != 0) 9507 abort (); 9508 9509 return strverscmp (v1, v2); 9510 } 9511 9512 9513 /* version_compare built-in spec function. 9514 9515 This takes an argument of the following form: 9516 9517 <comparison-op> <arg1> [<arg2>] <switch> <result> 9518 9519 and produces "result" if the comparison evaluates to true, 9520 and nothing if it doesn't. 9521 9522 The supported <comparison-op> values are: 9523 9524 >= true if switch is a later (or same) version than arg1 9525 !> opposite of >= 9526 < true if switch is an earlier version than arg1 9527 !< opposite of < 9528 >< true if switch is arg1 or later, and earlier than arg2 9529 <> true if switch is earlier than arg1 or is arg2 or later 9530 9531 If the switch is not present, the condition is false unless 9532 the first character of the <comparison-op> is '!'. 9533 9534 For example, 9535 %:version-compare(>= 10.3 mmacosx-version-min= -lmx) 9536 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */ 9537 9538 static const char * 9539 version_compare_spec_function (int argc, const char **argv) 9540 { 9541 int comp1, comp2; 9542 size_t switch_len; 9543 const char *switch_value = NULL; 9544 int nargs = 1, i; 9545 bool result; 9546 9547 if (argc < 3) 9548 fatal_error (input_location, "too few arguments to %%:version-compare"); 9549 if (argv[0][0] == '\0') 9550 abort (); 9551 if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!') 9552 nargs = 2; 9553 if (argc != nargs + 3) 9554 fatal_error (input_location, "too many arguments to %%:version-compare"); 9555 9556 switch_len = strlen (argv[nargs + 1]); 9557 for (i = 0; i < n_switches; i++) 9558 if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len) 9559 && check_live_switch (i, switch_len)) 9560 switch_value = switches[i].part1 + switch_len; 9561 9562 if (switch_value == NULL) 9563 comp1 = comp2 = -1; 9564 else 9565 { 9566 comp1 = compare_version_strings (switch_value, argv[1]); 9567 if (nargs == 2) 9568 comp2 = compare_version_strings (switch_value, argv[2]); 9569 else 9570 comp2 = -1; /* This value unused. */ 9571 } 9572 9573 switch (argv[0][0] << 8 | argv[0][1]) 9574 { 9575 case '>' << 8 | '=': 9576 result = comp1 >= 0; 9577 break; 9578 case '!' << 8 | '<': 9579 result = comp1 >= 0 || switch_value == NULL; 9580 break; 9581 case '<' << 8: 9582 result = comp1 < 0; 9583 break; 9584 case '!' << 8 | '>': 9585 result = comp1 < 0 || switch_value == NULL; 9586 break; 9587 case '>' << 8 | '<': 9588 result = comp1 >= 0 && comp2 < 0; 9589 break; 9590 case '<' << 8 | '>': 9591 result = comp1 < 0 || comp2 >= 0; 9592 break; 9593 9594 default: 9595 fatal_error (input_location, 9596 "unknown operator %qs in %%:version-compare", argv[0]); 9597 } 9598 if (! result) 9599 return NULL; 9600 9601 return argv[nargs + 2]; 9602 } 9603 9604 /* %:include builtin spec function. This differs from %include in that it 9605 can be nested inside a spec, and thus be conditionalized. It takes 9606 one argument, the filename, and looks for it in the startfile path. 9607 The result is always NULL, i.e. an empty expansion. */ 9608 9609 static const char * 9610 include_spec_function (int argc, const char **argv) 9611 { 9612 char *file; 9613 9614 if (argc != 1) 9615 abort (); 9616 9617 file = find_a_file (&startfile_prefixes, argv[0], R_OK, true); 9618 read_specs (file ? file : argv[0], false, false); 9619 9620 return NULL; 9621 } 9622 9623 /* %:find-file spec function. This function replaces its argument by 9624 the file found through find_file, that is the -print-file-name gcc 9625 program option. */ 9626 static const char * 9627 find_file_spec_function (int argc, const char **argv) 9628 { 9629 const char *file; 9630 9631 if (argc != 1) 9632 abort (); 9633 9634 file = find_file (argv[0]); 9635 return file; 9636 } 9637 9638 9639 /* %:find-plugindir spec function. This function replaces its argument 9640 by the -iplugindir=<dir> option. `dir' is found through find_file, that 9641 is the -print-file-name gcc program option. */ 9642 static const char * 9643 find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED) 9644 { 9645 const char *option; 9646 9647 if (argc != 0) 9648 abort (); 9649 9650 option = concat ("-iplugindir=", find_file ("plugin"), NULL); 9651 return option; 9652 } 9653 9654 9655 /* %:print-asm-header spec function. Print a banner to say that the 9656 following output is from the assembler. */ 9657 9658 static const char * 9659 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED, 9660 const char **argv ATTRIBUTE_UNUSED) 9661 { 9662 printf (_("Assembler options\n=================\n\n")); 9663 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n")); 9664 fflush (stdout); 9665 return NULL; 9666 } 9667 9668 /* Get a random number for -frandom-seed */ 9669 9670 static unsigned HOST_WIDE_INT 9671 get_random_number (void) 9672 { 9673 unsigned HOST_WIDE_INT ret = 0; 9674 int fd; 9675 9676 fd = open ("/dev/urandom", O_RDONLY); 9677 if (fd >= 0) 9678 { 9679 read (fd, &ret, sizeof (HOST_WIDE_INT)); 9680 close (fd); 9681 if (ret) 9682 return ret; 9683 } 9684 9685 /* Get some more or less random data. */ 9686 #ifdef HAVE_GETTIMEOFDAY 9687 { 9688 struct timeval tv; 9689 9690 gettimeofday (&tv, NULL); 9691 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000; 9692 } 9693 #else 9694 { 9695 time_t now = time (NULL); 9696 9697 if (now != (time_t)-1) 9698 ret = (unsigned) now; 9699 } 9700 #endif 9701 9702 return ret ^ getpid (); 9703 } 9704 9705 /* %:compare-debug-dump-opt spec function. Save the last argument, 9706 expected to be the last -fdump-final-insns option, or generate a 9707 temporary. */ 9708 9709 static const char * 9710 compare_debug_dump_opt_spec_function (int arg, 9711 const char **argv ATTRIBUTE_UNUSED) 9712 { 9713 char *ret; 9714 char *name; 9715 int which; 9716 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3]; 9717 9718 if (arg != 0) 9719 fatal_error (input_location, 9720 "too many arguments to %%:compare-debug-dump-opt"); 9721 9722 do_spec_2 ("%{fdump-final-insns=*:%*}"); 9723 do_spec_1 (" ", 0, NULL); 9724 9725 if (argbuf.length () > 0 9726 && strcmp (argv[argbuf.length () - 1], ".")) 9727 { 9728 if (!compare_debug) 9729 return NULL; 9730 9731 name = xstrdup (argv[argbuf.length () - 1]); 9732 ret = NULL; 9733 } 9734 else 9735 { 9736 const char *ext = NULL; 9737 9738 if (argbuf.length () > 0) 9739 { 9740 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}"); 9741 ext = ".gkd"; 9742 } 9743 else if (!compare_debug) 9744 return NULL; 9745 else 9746 do_spec_2 ("%g.gkd"); 9747 9748 do_spec_1 (" ", 0, NULL); 9749 9750 gcc_assert (argbuf.length () > 0); 9751 9752 name = concat (argbuf.last (), ext, NULL); 9753 9754 ret = concat ("-fdump-final-insns=", name, NULL); 9755 } 9756 9757 which = compare_debug < 0; 9758 debug_check_temp_file[which] = name; 9759 9760 if (!which) 9761 { 9762 unsigned HOST_WIDE_INT value = get_random_number (); 9763 9764 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value); 9765 } 9766 9767 if (*random_seed) 9768 { 9769 char *tmp = ret; 9770 ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ", 9771 ret, NULL); 9772 free (tmp); 9773 } 9774 9775 if (which) 9776 *random_seed = 0; 9777 9778 return ret; 9779 } 9780 9781 static const char *debug_auxbase_opt; 9782 9783 /* %:compare-debug-self-opt spec function. Expands to the options 9784 that are to be passed in the second compilation of 9785 compare-debug. */ 9786 9787 static const char * 9788 compare_debug_self_opt_spec_function (int arg, 9789 const char **argv ATTRIBUTE_UNUSED) 9790 { 9791 if (arg != 0) 9792 fatal_error (input_location, 9793 "too many arguments to %%:compare-debug-self-opt"); 9794 9795 if (compare_debug >= 0) 9796 return NULL; 9797 9798 do_spec_2 ("%{c|S:%{o*:%*}}"); 9799 do_spec_1 (" ", 0, NULL); 9800 9801 if (argbuf.length () > 0) 9802 debug_auxbase_opt = concat ("-auxbase-strip ", 9803 argbuf.last (), 9804 NULL); 9805 else 9806 debug_auxbase_opt = NULL; 9807 9808 return concat ("\ 9809 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \ 9810 %<fdump-final-insns=* -w -S -o %j \ 9811 %{!fcompare-debug-second:-fcompare-debug-second} \ 9812 ", compare_debug_opt, NULL); 9813 } 9814 9815 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase 9816 options that are to be passed in the second compilation of 9817 compare-debug. It expects, as an argument, the basename of the 9818 current input file name, with the .gk suffix appended to it. */ 9819 9820 static const char * 9821 compare_debug_auxbase_opt_spec_function (int arg, 9822 const char **argv) 9823 { 9824 char *name; 9825 int len; 9826 9827 if (arg == 0) 9828 fatal_error (input_location, 9829 "too few arguments to %%:compare-debug-auxbase-opt"); 9830 9831 if (arg != 1) 9832 fatal_error (input_location, 9833 "too many arguments to %%:compare-debug-auxbase-opt"); 9834 9835 if (compare_debug >= 0) 9836 return NULL; 9837 9838 len = strlen (argv[0]); 9839 if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0) 9840 fatal_error (input_location, "argument to %%:compare-debug-auxbase-opt " 9841 "does not end in .gk"); 9842 9843 if (debug_auxbase_opt) 9844 return debug_auxbase_opt; 9845 9846 #define OPT "-auxbase " 9847 9848 len -= 3; 9849 name = (char*) xmalloc (sizeof (OPT) + len); 9850 memcpy (name, OPT, sizeof (OPT) - 1); 9851 memcpy (name + sizeof (OPT) - 1, argv[0], len); 9852 name[sizeof (OPT) - 1 + len] = '\0'; 9853 9854 #undef OPT 9855 9856 return name; 9857 } 9858 9859 /* %:pass-through-libs spec function. Finds all -l options and input 9860 file names in the lib spec passed to it, and makes a list of them 9861 prepended with the plugin option to cause them to be passed through 9862 to the final link after all the new object files have been added. */ 9863 9864 const char * 9865 pass_through_libs_spec_func (int argc, const char **argv) 9866 { 9867 char *prepended = xstrdup (" "); 9868 int n; 9869 /* Shlemiel the painter's algorithm. Innately horrible, but at least 9870 we know that there will never be more than a handful of strings to 9871 concat, and it's only once per run, so it's not worth optimising. */ 9872 for (n = 0; n < argc; n++) 9873 { 9874 char *old = prepended; 9875 /* Anything that isn't an option is a full path to an output 9876 file; pass it through if it ends in '.a'. Among options, 9877 pass only -l. */ 9878 if (argv[n][0] == '-' && argv[n][1] == 'l') 9879 { 9880 const char *lopt = argv[n] + 2; 9881 /* Handle both joined and non-joined -l options. If for any 9882 reason there's a trailing -l with no joined or following 9883 arg just discard it. */ 9884 if (!*lopt && ++n >= argc) 9885 break; 9886 else if (!*lopt) 9887 lopt = argv[n]; 9888 prepended = concat (prepended, "-plugin-opt=-pass-through=-l", 9889 lopt, " ", NULL); 9890 } 9891 else if (!strcmp (".a", argv[n] + strlen (argv[n]) - 2)) 9892 { 9893 prepended = concat (prepended, "-plugin-opt=-pass-through=", 9894 argv[n], " ", NULL); 9895 } 9896 if (prepended != old) 9897 free (old); 9898 } 9899 return prepended; 9900 } 9901 9902 /* %:replace-extension spec function. Replaces the extension of the 9903 first argument with the second argument. */ 9904 9905 const char * 9906 replace_extension_spec_func (int argc, const char **argv) 9907 { 9908 char *name; 9909 char *p; 9910 char *result; 9911 int i; 9912 9913 if (argc != 2) 9914 fatal_error (input_location, "too few arguments to %%:replace-extension"); 9915 9916 name = xstrdup (argv[0]); 9917 9918 for (i = strlen (name) - 1; i >= 0; i--) 9919 if (IS_DIR_SEPARATOR (name[i])) 9920 break; 9921 9922 p = strrchr (name + i + 1, '.'); 9923 if (p != NULL) 9924 *p = '\0'; 9925 9926 result = concat (name, argv[1], NULL); 9927 9928 free (name); 9929 return result; 9930 } 9931 9932 /* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1]. 9933 Otherwise, return NULL. */ 9934 9935 static const char * 9936 greater_than_spec_func (int argc, const char **argv) 9937 { 9938 char *converted; 9939 9940 if (argc == 1) 9941 return NULL; 9942 9943 gcc_assert (argc >= 2); 9944 9945 long arg = strtol (argv[argc - 2], &converted, 10); 9946 gcc_assert (converted != argv[argc - 2]); 9947 9948 long lim = strtol (argv[argc - 1], &converted, 10); 9949 gcc_assert (converted != argv[argc - 1]); 9950 9951 if (arg > lim) 9952 return ""; 9953 9954 return NULL; 9955 } 9956 9957 /* Returns "" if debug_info_level is greater than ARGV[ARGC-1]. 9958 Otherwise, return NULL. */ 9959 9960 static const char * 9961 debug_level_greater_than_spec_func (int argc, const char **argv) 9962 { 9963 char *converted; 9964 9965 if (argc != 1) 9966 fatal_error (input_location, 9967 "wrong number of arguments to %%:debug-level-gt"); 9968 9969 long arg = strtol (argv[0], &converted, 10); 9970 gcc_assert (converted != argv[0]); 9971 9972 if (debug_info_level > arg) 9973 return ""; 9974 9975 return NULL; 9976 } 9977 9978 /* Insert backslash before spaces in ORIG (usually a file path), to 9979 avoid being broken by spec parser. 9980 9981 This function is needed as do_spec_1 treats white space (' ' and '\t') 9982 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so, 9983 the file name should be treated as a single argument rather than being 9984 broken into multiple. Solution is to insert '\\' before the space in a 9985 file name. 9986 9987 This function converts and only converts all occurrence of ' ' 9988 to '\\' + ' ' and '\t' to '\\' + '\t'. For example: 9989 "a b" -> "a\\ b" 9990 "a b" -> "a\\ \\ b" 9991 "a\tb" -> "a\\\tb" 9992 "a\\ b" -> "a\\\\ b" 9993 9994 orig: input null-terminating string that was allocated by xalloc. The 9995 memory it points to might be freed in this function. Behavior undefined 9996 if ORIG wasn't xalloced or was freed already at entry. 9997 9998 Return: ORIG if no conversion needed. Otherwise a newly allocated string 9999 that was converted from ORIG. */ 10000 10001 static char * 10002 convert_white_space (char *orig) 10003 { 10004 int len, number_of_space = 0; 10005 10006 for (len = 0; orig[len]; len++) 10007 if (orig[len] == ' ' || orig[len] == '\t') number_of_space++; 10008 10009 if (number_of_space) 10010 { 10011 char *new_spec = (char *) xmalloc (len + number_of_space + 1); 10012 int j, k; 10013 for (j = 0, k = 0; j <= len; j++, k++) 10014 { 10015 if (orig[j] == ' ' || orig[j] == '\t') 10016 new_spec[k++] = '\\'; 10017 new_spec[k] = orig[j]; 10018 } 10019 free (orig); 10020 return new_spec; 10021 } 10022 else 10023 return orig; 10024 } 10025 10026 static void 10027 path_prefix_reset (path_prefix *prefix) 10028 { 10029 struct prefix_list *iter, *next; 10030 iter = prefix->plist; 10031 while (iter) 10032 { 10033 next = iter->next; 10034 free (const_cast <char *> (iter->prefix)); 10035 XDELETE (iter); 10036 iter = next; 10037 } 10038 prefix->plist = 0; 10039 prefix->max_len = 0; 10040 } 10041 10042 /* Restore all state within gcc.c to the initial state, so that the driver 10043 code can be safely re-run in-process. 10044 10045 Many const char * variables are referenced by static specs (see 10046 INIT_STATIC_SPEC above). These variables are restored to their default 10047 values by a simple loop over the static specs. 10048 10049 For other variables, we directly restore them all to their initial 10050 values (often implicitly 0). 10051 10052 Free the various obstacks in this file, along with "opts_obstack" 10053 from opts.c. 10054 10055 This function also restores any environment variables that were changed. */ 10056 10057 void 10058 driver::finalize () 10059 { 10060 env.restore (); 10061 params_c_finalize (); 10062 diagnostic_finish (global_dc); 10063 10064 is_cpp_driver = 0; 10065 at_file_supplied = 0; 10066 print_help_list = 0; 10067 print_version = 0; 10068 verbose_only_flag = 0; 10069 print_subprocess_help = 0; 10070 use_ld = NULL; 10071 report_times_to_file = NULL; 10072 target_system_root = DEFAULT_TARGET_SYSTEM_ROOT; 10073 target_system_root_changed = 0; 10074 target_sysroot_suffix = 0; 10075 target_sysroot_hdrs_suffix = 0; 10076 save_temps_flag = SAVE_TEMPS_NONE; 10077 save_temps_prefix = 0; 10078 save_temps_length = 0; 10079 spec_machine = DEFAULT_TARGET_MACHINE; 10080 greatest_status = 1; 10081 10082 finalize_options_struct (&global_options); 10083 finalize_options_struct (&global_options_set); 10084 10085 obstack_free (&obstack, NULL); 10086 obstack_free (&opts_obstack, NULL); /* in opts.c */ 10087 obstack_free (&collect_obstack, NULL); 10088 10089 link_command_spec = LINK_COMMAND_SPEC; 10090 10091 obstack_free (&multilib_obstack, NULL); 10092 10093 user_specs_head = NULL; 10094 user_specs_tail = NULL; 10095 10096 /* Within the "compilers" vec, the fields "suffix" and "spec" were 10097 statically allocated for the default compilers, but dynamically 10098 allocated for additional compilers. Delete them for the latter. */ 10099 for (int i = n_default_compilers; i < n_compilers; i++) 10100 { 10101 free (const_cast <char *> (compilers[i].suffix)); 10102 free (const_cast <char *> (compilers[i].spec)); 10103 } 10104 XDELETEVEC (compilers); 10105 compilers = NULL; 10106 n_compilers = 0; 10107 10108 linker_options.truncate (0); 10109 assembler_options.truncate (0); 10110 preprocessor_options.truncate (0); 10111 10112 path_prefix_reset (&exec_prefixes); 10113 path_prefix_reset (&startfile_prefixes); 10114 path_prefix_reset (&include_prefixes); 10115 10116 machine_suffix = 0; 10117 just_machine_suffix = 0; 10118 gcc_exec_prefix = 0; 10119 gcc_libexec_prefix = 0; 10120 md_exec_prefix = MD_EXEC_PREFIX; 10121 md_startfile_prefix = MD_STARTFILE_PREFIX; 10122 md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1; 10123 multilib_dir = 0; 10124 multilib_os_dir = 0; 10125 multiarch_dir = 0; 10126 10127 /* Free any specs dynamically-allocated by set_spec. 10128 These will be at the head of the list, before the 10129 statically-allocated ones. */ 10130 if (specs) 10131 { 10132 while (specs != static_specs) 10133 { 10134 spec_list *next = specs->next; 10135 free (const_cast <char *> (specs->name)); 10136 XDELETE (specs); 10137 specs = next; 10138 } 10139 specs = 0; 10140 } 10141 for (unsigned i = 0; i < ARRAY_SIZE (static_specs); i++) 10142 { 10143 spec_list *sl = &static_specs[i]; 10144 if (sl->alloc_p) 10145 { 10146 if (0) 10147 free (const_cast <char *> (*(sl->ptr_spec))); 10148 sl->alloc_p = false; 10149 } 10150 *(sl->ptr_spec) = sl->default_ptr; 10151 } 10152 #ifdef EXTRA_SPECS 10153 extra_specs = NULL; 10154 #endif 10155 10156 processing_spec_function = 0; 10157 10158 argbuf.truncate (0); 10159 10160 have_c = 0; 10161 have_o = 0; 10162 10163 temp_names = NULL; 10164 execution_count = 0; 10165 signal_count = 0; 10166 10167 temp_filename = NULL; 10168 temp_filename_length = 0; 10169 always_delete_queue = NULL; 10170 failure_delete_queue = NULL; 10171 10172 XDELETEVEC (switches); 10173 switches = NULL; 10174 n_switches = 0; 10175 n_switches_alloc = 0; 10176 10177 compare_debug = 0; 10178 compare_debug_second = 0; 10179 compare_debug_opt = NULL; 10180 for (int i = 0; i < 2; i++) 10181 { 10182 switches_debug_check[i] = NULL; 10183 n_switches_debug_check[i] = 0; 10184 n_switches_alloc_debug_check[i] = 0; 10185 debug_check_temp_file[i] = NULL; 10186 } 10187 10188 XDELETEVEC (infiles); 10189 infiles = NULL; 10190 n_infiles = 0; 10191 n_infiles_alloc = 0; 10192 10193 combine_inputs = false; 10194 added_libraries = 0; 10195 XDELETEVEC (outfiles); 10196 outfiles = NULL; 10197 spec_lang = 0; 10198 last_language_n_infiles = 0; 10199 gcc_input_filename = NULL; 10200 input_file_number = 0; 10201 input_filename_length = 0; 10202 basename_length = 0; 10203 suffixed_basename_length = 0; 10204 input_basename = NULL; 10205 input_suffix = NULL; 10206 /* We don't need to purge "input_stat", just to unset "input_stat_set". */ 10207 input_stat_set = 0; 10208 input_file_compiler = NULL; 10209 arg_going = 0; 10210 delete_this_arg = 0; 10211 this_is_output_file = 0; 10212 this_is_library_file = 0; 10213 this_is_linker_script = 0; 10214 input_from_pipe = 0; 10215 suffix_subst = NULL; 10216 10217 mdswitches = NULL; 10218 n_mdswitches = 0; 10219 10220 debug_auxbase_opt = NULL; 10221 10222 used_arg.finalize (); 10223 } 10224 10225 /* PR jit/64810. 10226 Targets can provide configure-time default options in 10227 OPTION_DEFAULT_SPECS. The jit needs to access these, but 10228 they are expressed in the spec language. 10229 10230 Run just enough of the driver to be able to expand these 10231 specs, and then call the callback CB on each 10232 such option. The options strings are *without* a leading 10233 '-' character e.g. ("march=x86-64"). Finally, clean up. */ 10234 10235 void 10236 driver_get_configure_time_options (void (*cb) (const char *option, 10237 void *user_data), 10238 void *user_data) 10239 { 10240 size_t i; 10241 10242 obstack_init (&obstack); 10243 init_opts_obstack (); 10244 n_switches = 0; 10245 10246 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++) 10247 do_option_spec (option_default_specs[i].name, 10248 option_default_specs[i].spec); 10249 10250 for (i = 0; (int) i < n_switches; i++) 10251 { 10252 gcc_assert (switches[i].part1); 10253 (*cb) (switches[i].part1, user_data); 10254 } 10255 10256 obstack_free (&opts_obstack, NULL); 10257 obstack_free (&obstack, NULL); 10258 n_switches = 0; 10259 } 10260