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