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