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