/* FIXME: when autoconf is fixed, remove the host check - dj */
#if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
#define HAVE_TARGET_EXECUTABLE_SUFFIX
-#else
-#undef TARGET_EXECUTABLE_SUFFIX
-#define TARGET_EXECUTABLE_SUFFIX ""
#endif
/* By default there is no special suffix for host executables. */
static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
-#ifndef GET_ENV_PATH_LIST
-#define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
-#endif
-
/* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
#ifndef LIBRARY_PATH_ENV
#define LIBRARY_PATH_ENV "LIBRARY_PATH"
/* The target version specified with -V */
-static const char *spec_version = DEFAULT_TARGET_VERSION;
+static const char *const spec_version = DEFAULT_TARGET_VERSION;
/* The target machine specified with -b. */
}
modify_target[] = MODIFY_TARGET_NAME;
#endif
-
+
/* The number of errors that have occurred; the link phase will not be
run if this is non-zero. */
static int error_count = 0;
static char *save_string PARAMS ((const char *, int));
static void set_collect_gcc_options PARAMS ((void));
static int do_spec_1 PARAMS ((const char *, int, const char *));
+static int do_spec_2 PARAMS ((const char *));
static const char *find_file PARAMS ((const char *));
static int is_directory PARAMS ((const char *, const char *, int));
static void validate_switches PARAMS ((const char *));
#ifndef LIBGCC_SPEC
#if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
/* Have gcc do the search for libgcc.a. */
-#define LIBGCC_SPEC "libgcc.a%s %L libgcc.a%s"
+#define LIBGCC_SPEC "libgcc.a%s"
#else
-#define LIBGCC_SPEC "-lgcc %L -lgcc"
+#define LIBGCC_SPEC "-lgcc"
#endif
#endif
/* Here is the spec for running the linker, after compiling all files. */
+/* This is overridable by the target in case they need to specify the
+ -lgcc and -lc order specially, yet not require them to override all
+ of LINK_COMMAND_SPEC. */
+#ifndef LINK_GCC_C_SEQUENCE_SPEC
+#define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
+#endif
+
/* -u* was put back because both BSD and SysV seem to support it. */
/* %{static:} simply prevents an error message if the target machine
doesn't handle -static. */
%{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
%(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r} %{s} %{t}\
%{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
- %{static:} %{L*} %(link_libgcc) %o %{!nostdlib:%{!nodefaultlibs:%G}}\
+ %{static:} %{L*} %(link_libgcc) %o %{!nostdlib:%{!nodefaultlibs:%(link_gcc_c_sequence)}}\
%{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
#endif
# endif
#endif
-static const char *asm_debug = ASM_DEBUG_SPEC;
+#ifndef STARTFILE_PREFIX_SPEC
+# define STARTFILE_PREFIX_SPEC ""
+#endif
+
+static const char *asm_debug;
static const char *cpp_spec = CPP_SPEC;
static const char *cpp_predefines = CPP_PREDEFINES;
static const char *cc1_spec = CC1_SPEC;
static const char *cc1plus_spec = CC1PLUS_SPEC;
+static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
static const char *asm_spec = ASM_SPEC;
static const char *asm_final_spec = ASM_FINAL_SPEC;
static const char *link_spec = LINK_SPEC;
static const char *linker_name_spec = LINKER_NAME;
static const char *link_command_spec = LINK_COMMAND_SPEC;
static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
+static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
/* Standard options to cpp, cc1, and as, to reduce duplication in specs.
There should be no need to override these in target dependent files,
of the GCC driver can correctly drive older tool chains with the
appropriate -B options. */
+/* When cpplib handles traditional preprocessing, get rid of this, and
+ call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
+ that we default the front end language better. */
static const char *trad_capable_cpp =
-"%{traditional|ftraditional|traditional-cpp:tradcpp0}\
- %{!traditional:%{!ftraditional:%{!traditional-cpp:cc1 -E}}}";
+"cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
static const char *cpp_unique_options =
"%{C:%{!E:%eGNU C does not support -C without using -E}}\
- %{!Q:-quiet} %{nostdinc*} %{C} %{v} %{I*} %{P} %{$} %I\
+ %{CC:%{!E:%eGNU C does not support -CC without using -E}}\
+ %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*} %{P} %I\
%{MD:-MD %W{!o: %b.d}%W{o*:%.d%*}}\
%{MMD:-MMD %W{!o: %b.d}%W{o*:%.d%*}}\
%{M} %{MM} %W{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
%{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
%{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
%{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
- %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
- %{fno-inline|O0|!O*:-D__NO_INLINE__} %{ffast-math:-D__FAST_MATH__}\
- %{fshort-wchar:-U__WCHAR_TYPE__ -D__WCHAR_TYPE__=short\\ unsigned\\ int}\
- %{ffreestanding:-D__STDC_HOSTED__=0} %{fno-hosted:-D__STDC_HOSTED__=0}\
- %{!ffreestanding:%{!fno-hosted:-D__STDC_HOSTED__=1}} %{remap}\
- %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
+ %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
%{E|M|MM:%W{o*}}";
/* This contains cpp options which are common with cc1_options and are passed
- only when preprocessing only to avoid duplication. */
+ only when preprocessing only to avoid duplication. We pass the cc1 spec
+ options to the preprocessor so that it the cc1 spec may manipulate
+ options used to set target flags. Those special target flags settings may
+ in turn cause preprocessor symbols to be defined specially. */
static const char *cpp_options =
-"%(cpp_unique_options) %{std*} %{d*} %{W*&pedantic*} %{w}\
- %{fshow-column} %{fno-show-column}\
- %{fsigned-char&funsigned-char}\
- %{fleading-underscore} %{fno-leading-underscore}\
- %{fno-operator-names} %{ftabstop=*}";
+"%(cpp_unique_options) %1 %{std*} %{W*&pedantic*} %{w} %{m*} %{f*}\
+ %{O*} %{undef}";
+
+/* This contains cpp options which are not passed when the preprocessor
+ output will be used by another program. */
+static const char *cpp_debug_options = "%{d*}";
/* NB: This is shared amongst all front-ends. */
static const char *cc1_options =
"%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
%1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
+ -auxbase%{c|S:%{o*:-strip%*}%{!o*: %b}}%{!c:%{!S: %b}}\
%{g*} %{O*} %{W*&pedantic*} %{w} %{std*} %{ansi}\
- %{v:-version} %{pg:-p} %{p} %{f*}\
+ %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
%{Qn:-fno-ident} %{--help:--help}\
%{--target-help:--target-help}\
%{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
|| (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
|| (CHAR) == 'I' || (CHAR) == 'm' || (CHAR) == 'x' \
- || (CHAR) == 'L' || (CHAR) == 'A' || (CHAR) == 'V' \
- || (CHAR) == 'B' || (CHAR) == 'b')
+ || (CHAR) == 'L' || (CHAR) == 'A' || (CHAR) == 'B' || (CHAR) == 'b')
#ifndef SWITCH_TAKES_ARG
#define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
{".F", "#Fortran", 0}, {".FOR", "#Fortran", 0}, {".FPP", "#Fortran", 0},
{".r", "#Ratfor", 0},
{".p", "#Pascal", 0}, {".pas", "#Pascal", 0},
- {".ch", "#Chill", 0}, {".chi", "#Chill", 0},
{".java", "#Java", 0}, {".class", "#Java", 0},
{".zip", "#Java", 0}, {".jar", "#Java", 0},
/* Next come the entries for C. */
{"@c",
/* cc1 has an integrated ISO C preprocessor. We should invoke the
external preprocessor if -save-temps is given. */
- "%{E|M|MM:%(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)}\
+ "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
%{!E:%{!M:%{!MM:\
%{traditional|ftraditional:\
%eGNU C no longer supports -traditional without -E}\
%{save-temps|traditional-cpp:%(trad_capable_cpp) \
- -lang-c %{ansi:-std=c89} %(cpp_options) %b.i \n\
+ %(cpp_options) %b.i \n\
cc1 -fpreprocessed %b.i %(cc1_options)}\
%{!save-temps:%{!traditional-cpp:\
- cc1 -lang-c %{ansi:-std=c89} %(cpp_unique_options) %(cc1_options)}}\
+ cc1 %(cpp_unique_options) %(cc1_options)}}\
%{!fsyntax-only:%(invoke_as)}}}}", 0},
{"-",
"%{!E:%e-E required when input is from standard input}\
- %(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)", 0},
+ %(trad_capable_cpp) %(cpp_options)", 0},
{".h", "@c-header", 0},
{"@c-header",
"%{!E:%ecompilation of header file requested} \
- %(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)", 0},
+ %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)",
+ 0},
{".i", "@cpp-output", 0},
{"@cpp-output",
"%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0},
{".S", "@assembler-with-cpp", 0},
{"@assembler-with-cpp",
"%(trad_capable_cpp) -lang-asm %(cpp_options)\
+ %{E|M|MM:%(cpp_debug_options)}\
%{!M:%{!MM:%{!E:%{!S:-o %{|!pipe:%g.s} |\n\
as %(asm_debug) %(asm_options) %{!pipe:%g.s} %A }}}}", 0},
#include "specs.h"
{"--bootclasspath", "-fbootclasspath=", "aj"},
{"--CLASSPATH", "-fclasspath=", "aj"},
{"--comments", "-C", 0},
+ {"--comments-in-macros", "-CC", 0},
{"--compile", "-c", 0},
{"--debug", "-g", "oj"},
{"--define-macro", "-D", "aj"},
{"--profile", "-p", 0},
{"--profile-blocks", "-a", 0},
{"--quiet", "-q", 0},
+ {"--resource", "-fcompile-resource=", "aj"},
{"--save-temps", "-save-temps", 0},
{"--shared", "-shared", 0},
{"--silent", "-q", 0},
nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
else if (WORD_SWITCH_TAKES_ARG (p))
nskip += WORD_SWITCH_TAKES_ARG (p);
- else if ((c == 'B' || c == 'b' || c == 'V' || c == 'x')
+ else if ((c == 'B' || c == 'b' || c == 'x')
&& p[1] == 0)
nskip += 1;
else if (! strcmp (p, "Xlinker"))
INIT_STATIC_SPEC ("invoke_as", &invoke_as),
INIT_STATIC_SPEC ("cpp", &cpp_spec),
INIT_STATIC_SPEC ("cpp_options", &cpp_options),
+ INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
INIT_STATIC_SPEC ("cc1", &cc1_spec),
INIT_STATIC_SPEC ("cc1_options", &cc1_options),
INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
+ INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
INIT_STATIC_SPEC ("endfile", &endfile_spec),
INIT_STATIC_SPEC ("link", &link_spec),
INIT_STATIC_SPEC ("lib", &lib_spec),
INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
+ INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
};
#ifdef EXTRA_SPECS /* additional specs needed */
#else
shared_name,
#endif
- "}}} %L ",
- "%{static|static-libgcc:", static_name, " ", eh_name,
- "}%{!static:%{!static-libgcc:",
- "%{!shared:%{!shared-libgcc:", static_name, " ",
- eh_name, "}%{shared-libgcc:",
- static_name, "}}",
-#ifdef LINK_EH_SPEC
- "%{shared:%{!shared-libgcc:", static_name, "}}",
-#endif
- "}}", NULL);
+ "}}}", NULL);
obstack_grow (obstack, buf, strlen (buf));
free (buf);
}
#endif
+ /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
+ on ?: in file-scope variable initializations. */
+ asm_debug = ASM_DEBUG_SPEC;
+
for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
{
sl = &static_specs[i];
{
const char *p = libgcc_spec;
int in_sep = 1;
-
+
/* Transform the extant libgcc_spec into one that uses the shared libgcc
when given the proper command line arguments. */
while (*p)
{
- if (in_sep && *p == '-' && strncmp (p, "-lgcc %L -lgcc", 14) == 0)
+ if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
{
init_gcc_specs (&obstack,
#ifdef NO_SHARED_LIBGCC_MULTILIB
,
"-lgcc",
"-lgcc_eh");
- p += 14;
+ p += 5;
in_sep = 0;
}
- else if (in_sep && *p == 'l'
- && strncmp (p, "libgcc.a%s %L libgcc.a%s", 24) == 0)
+ else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
{
/* Ug. We don't know shared library extensions. Hope that
systems that use this form don't do shared libraries. */
,
"libgcc.a%s",
"libgcc_eh.a%s");
- p += 24;
+ p += 10;
in_sep = 0;
}
else
{
int name_len;
struct spec_list *sl;
+ struct spec_list *newsl;
- /* Get original name */
+ /* Get original name. */
p1 += sizeof "%rename";
while (*p1 == ' ' || *p1 == '\t')
p1++;
if (strcmp (p1, p2) == 0)
continue;
+ for (newsl = specs; newsl; newsl = newsl->next)
+ if (strcmp (newsl->name, p2) == 0)
+ fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
+ filename, p1, p2);
+
if (verbose_flag)
{
notice ("rename spec %s to %s\n", p1, p2);
{
char *temp;
- GET_ENV_PATH_LIST (temp, "PATH");
+ GET_ENVIRONMENT (temp, "PATH");
if (temp)
{
char *startp, *endp, *nstore;
{
const char *const *j;
- if (verbose_only_flag)
- {
+ if (verbose_only_flag)
+ {
for (j = commands[i].argv; *j; j++)
{
const char *p;
}
fputc ('"', stderr);
}
- }
- else
+ }
+ else
for (j = commands[i].argv; *j; j++)
fprintf (stderr, " %s", *j);
}
fflush (stderr);
if (verbose_only_flag != 0)
- return 0;
+ return 0;
#ifdef DEBUG
notice ("\nGo ahead? (y or n) ");
fflush (stderr);
/* Used to track if none of the -B paths are used. */
static int warn_B;
-/* Used to track if standard path isn't used and -b or -V is specified. */
-static int warn_std;
-
/* Gives value to pass as "warn" to add_prefix for standard prefixes. */
static int *warn_std_ptr = 0;
\f
int j;
#endif
- GET_ENV_PATH_LIST (gcc_exec_prefix, "GCC_EXEC_PREFIX");
+ GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
n_switches = 0;
n_infiles = 0;
}
}
+ /* If there is a -V or -b option (or both), process it now, before
+ trying to interpret the rest of the command line. */
+ if (argc > 1 && argv[1][0] == '-'
+ && (argv[1][1] == 'V' || argv[1][1] == 'b'))
+ {
+ const char *new_version = DEFAULT_TARGET_VERSION;
+ const char *new_machine = DEFAULT_TARGET_MACHINE;
+ const char *progname = argv[0];
+ char **new_argv;
+ char *new_argv0;
+ int baselen;
+
+ while (argc > 1 && argv[1][0] == '-'
+ && (argv[1][1] == 'V' || argv[1][1] == 'b'))
+ {
+ char opt = argv[1][1];
+ const char *arg;
+ if (argv[1][2] != '\0')
+ {
+ arg = argv[1] + 2;
+ argc -= 1;
+ argv += 1;
+ }
+ else if (argc > 2)
+ {
+ arg = argv[2];
+ argc -= 2;
+ argv += 2;
+ }
+ else
+ fatal ("`-%c' option must have argument", opt);
+ if (opt == 'V')
+ new_version = arg;
+ else
+ new_machine = arg;
+ }
+
+ for (baselen = strlen (progname); baselen > 0; baselen--)
+ if (IS_DIR_SEPARATOR (progname[baselen-1]))
+ break;
+ new_argv0 = xmemdup (progname, baselen,
+ baselen + concat_length (new_version, new_machine,
+ "-gcc-", NULL) + 1);
+ strcpy (new_argv0 + baselen, new_machine);
+ strcat (new_argv0, "-gcc-");
+ strcat (new_argv0, new_version);
+
+ new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
+ (argc + 1) * sizeof (argv[0]));
+ new_argv[0] = new_argv0;
+
+ execvp (new_argv0, new_argv);
+ fatal ("couldn't run `%s': %s", new_argv0, xstrerror (errno));
+ }
+
/* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
see if we can create it from the pathname specified in argv[0]. */
/* COMPILER_PATH and LIBRARY_PATH have values
that are lists of directory names with colons. */
- GET_ENV_PATH_LIST (temp, "COMPILER_PATH");
+ GET_ENVIRONMENT (temp, "COMPILER_PATH");
if (temp)
{
const char *startp, *endp;
}
}
- GET_ENV_PATH_LIST (temp, LIBRARY_PATH_ENV);
+ GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
if (temp && *cross_compile == '0')
{
const char *startp, *endp;
}
/* Use LPATH like LIBRARY_PATH (for the CMU build program). */
- GET_ENV_PATH_LIST (temp, "LPATH");
+ GET_ENVIRONMENT (temp, "LPATH");
if (temp && *cross_compile == '0')
{
const char *startp, *endp;
/* Scan argv twice. Here, the first time, just count how many switches
there will be in their vector, and how many input files in theirs.
- Also parse any switches that determine the configuration name, such as -b.
Here we also parse the switches that cc itself uses (e.g. -v). */
for (i = 1; i < argc; i++)
add_linker_option ("--help", 6);
}
else if (strcmp (argv[i], "-ftarget-help") == 0)
- {
- /* translate_options() has turned --target-help into -ftarget-help. */
- target_help_flag = 1;
+ {
+ /* translate_options() has turned --target-help into -ftarget-help. */
+ target_help_flag = 1;
- /* We will be passing a dummy file on to the sub-processes. */
- n_infiles++;
- n_switches++;
+ /* We will be passing a dummy file on to the sub-processes. */
+ n_infiles++;
+ n_switches++;
/* CPP driver cannot obtain switch from cc1_options. */
if (is_cpp_driver)
add_preprocessor_option ("--target-help", 13);
- add_assembler_option ("--target-help", 13);
- add_linker_option ("--target-help", 13);
- }
+ add_assembler_option ("--target-help", 13);
+ add_linker_option ("--target-help", 13);
+ }
else if (! strcmp (argv[i], "-pass-exit-codes"))
{
pass_exit_codes = 1;
switch (c)
{
case 'b':
- n_switches++;
- if (p[1] == 0 && i + 1 == argc)
- fatal ("argument to `-b' is missing");
- if (p[1] == 0)
- spec_machine = argv[++i];
- else
- spec_machine = p + 1;
-
- warn_std_ptr = &warn_std;
+ case 'V':
+ fatal ("`-%c' must come at the start of the command line", c);
break;
case 'B':
tmp[++ len] = 0;
value = tmp;
}
-
+
/* As a kludge, if the arg is "[foo/]stageN/", just
add "[foo/]include" to the include prefix. */
if ((len == 7
verbose_flag++;
break;
- case 'V':
- n_switches++;
- if (p[1] == 0 && i + 1 == argc)
- fatal ("argument to `-V' is missing");
- if (p[1] == 0)
- spec_version = argv[++i];
- else
- spec_version = p + 1;
- compiler_version = spec_version;
- warn_std_ptr = &warn_std;
-
- /* Validate the version number. Use the same checks
- done when inserting it into a spec.
-
- The format of the version string is
- ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
- {
- const char *v = compiler_version;
-
- /* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
- while (! ISDIGIT (*v))
- v++;
-
- if (v > compiler_version && v[-1] != '-')
- fatal ("invalid version number format");
-
- /* Set V after the first period. */
- while (ISDIGIT (*v))
- v++;
-
- if (*v != '.')
- fatal ("invalid version number format");
-
- v++;
- while (ISDIGIT (*v))
- v++;
-
- if (*v != 0 && *v != ' ' && *v != '.' && *v != '-')
- fatal ("invalid version number format");
- }
- break;
-
case 'S':
case 'c':
if (p[1] == 0)
if (is_modify_target_name)
break;
-#endif
+#endif
n_switches++;
/* -save-temps overrides -pipe, so that temp files are produced */
if (save_temps_flag)
error ("warning: -pipe ignored because -save-temps specified");
- /* -time overrides -pipe because we can't get correct stats when
+ /* -time overrides -pipe because we can't get correct stats when
multiple children are running at once. */
else if (report_times)
error ("warning: -pipe ignored because -time specified");
else
{
char ch = switches[n_switches].part1[0];
- if (ch == 'V' || ch == 'b' || ch == 'B')
+ if (ch == 'B')
switches[n_switches].validated = 1;
}
n_switches++;
{
int value;
- clear_args ();
- arg_going = 0;
- delete_this_arg = 0;
- this_is_output_file = 0;
- this_is_library_file = 0;
- input_from_pipe = 0;
- suffix_subst = NULL;
-
- value = do_spec_1 (spec, 0, NULL);
+ value = do_spec_2 (spec);
/* Force out any unfinished command.
If -pipe, this forces out the last command if it ended in `|'. */
return value;
}
+static int
+do_spec_2 (spec)
+ const char *spec;
+{
+ clear_args ();
+ arg_going = 0;
+ delete_this_arg = 0;
+ this_is_output_file = 0;
+ this_is_library_file = 0;
+ input_from_pipe = 0;
+ suffix_subst = NULL;
+
+ return do_spec_1 (spec, 0, NULL);
+}
+
/* Process the sub-spec SPEC as a portion of a larger spec.
This is like processing a whole spec except that we do
not initialize at the beginning and we do not supply a
}
suffix_length += strlen (TARGET_OBJECT_SUFFIX);
}
-
+
/* If the input_filename has the same suffix specified
for the %g, %u, or %U, and -save-temps is specified,
we could end up using that file as an intermediate
gcc -save-temps foo.s would clobber foo.s with the
output of cpp0). So check for this condition and
generate a temp file as the intermediate. */
-
+
if (save_temps_flag)
{
temp_filename_length = basename_length + suffix_length;
if (strcmp (temp_filename, input_filename) != 0)
{
struct stat st_temp;
-
+
/* Note, set_input() resets input_stat_set to 0. */
if (input_stat_set == 0)
{
if (input_stat_set >= 0)
input_stat_set = 1;
}
-
+
/* If we have the stat for the input_filename
and we can do the stat for the temp_filename
then the they could still refer to the same
file if st_dev/st_ino's are the same. */
-
+
if (input_stat_set != 1
|| stat (temp_filename, &st_temp) < 0
|| input_stat.st_dev != st_temp.st_dev
|| input_stat.st_ino != st_temp.st_ino)
- {
+ {
temp_filename = save_string (temp_filename,
temp_filename_length + 1);
obstack_grow (&obstack, temp_filename,
case 'C':
{
const char *const spec
- = (input_file_compiler->cpp_spec
- ? input_file_compiler->cpp_spec
+ = (input_file_compiler->cpp_spec
+ ? input_file_compiler->cpp_spec
: cpp_spec);
value = do_spec_1 (spec, 0, NULL);
if (value != 0)
obstack_1grow (&obstack, '%');
break;
- case '.':
- {
- unsigned len = 0;
+ case '.':
+ {
+ unsigned len = 0;
- while (p[len] && p[len] != ' ' && p[len] != '%')
- len++;
- suffix_subst = save_string (p - 1, len + 1);
- p += len;
- }
+ while (p[len] && p[len] != ' ' && p[len] != '%')
+ len++;
+ suffix_subst = save_string (p - 1, len + 1);
+ p += len;
+ }
break;
-
+
case '*':
if (soft_matched_part)
{
}
else
input_suffix = "";
-
+
/* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
we will need to do a stat on the input_filename. The
INPUT_STAT_SET signals that the stat is needed. */
if (access (specs_file, R_OK) == 0)
read_specs (specs_file, TRUE);
- /* If not cross-compiling, look for startfiles in the standard places. */
- if (*cross_compile == '0')
+ /* If not cross-compiling, look for startfiles in the standard places.
+ Similarly, don't add the standard prefixes if startfile handling
+ will be under control of startfile_prefix_spec. */
+ if (*cross_compile == '0' && *startfile_prefix_spec == 0)
{
if (*md_exec_prefix)
{
"BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
}
+ if (*startfile_prefix_spec != 0
+ && do_spec_2 (startfile_prefix_spec) == 0
+ && do_spec_1 (" ", 0, NULL) == 0)
+ {
+ int ndx;
+ for (ndx = 0; ndx < argbuf_index; ndx++)
+ add_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
+ PREFIX_PRIORITY_LAST, 0, NULL);
+ }
+
/* Process any user specified specs in the order given on the command
line. */
for (uptr = user_specs_head; uptr; uptr = uptr->next)
input_file_compiler
= lookup_compiler (infiles[i].name, input_filename_length,
infiles[i].language);
-
+
if (input_file_compiler)
{
/* Ok, we found an applicable compiler. Run its spec. */
&& !strcmp (cp->suffix,
name + length - strlen (cp->suffix))
))
- break;
+ break;
}
#if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
OSDN Git Service
