/* Compiler driver program that can handle many languages.
- Copyright (C) 1987, 89, 92-98, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+ 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU CC.
CC recognizes how to compile each input file by suffixes in the file names.
Once it knows which kind of compilation to perform, the procedure for
compilation is specified by a string called a "spec". */
-\f
+
+
#include "config.h"
#include "system.h"
#include <signal.h>
-
#include "obstack.h"
+#include "intl.h"
#include "prefix.h"
+#include "gcc.h"
#ifdef VMS
#define exit __posix_exit
#endif
+#ifdef HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif
+#if defined (HAVE_DECL_GETRUSAGE) && !HAVE_DECL_GETRUSAGE
+extern int getrusage PARAMS ((int, struct rusage *));
+#endif
+
/* By default there is no special suffix for executables. */
#ifdef EXECUTABLE_SUFFIX
#define HAVE_EXECUTABLE_SUFFIX
#define OBJECT_SUFFIX ".o"
#endif
-/* By default, colon separates directories in a path. */
-#ifndef PATH_SEPARATOR
-#define PATH_SEPARATOR ':'
-#endif
-
-#ifndef DIR_SEPARATOR
-#define DIR_SEPARATOR '/'
-#endif
+#ifndef VMS
+/* FIXME: the location independence code for VMS is hairier than this,
+ and hasn't been written. */
+#ifndef DIR_UP
+#define DIR_UP ".."
+#endif /* DIR_UP */
+#endif /* VMS */
static char dir_separator_str[] = {DIR_SEPARATOR, 0};
#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"
+#endif
+
#ifndef HAVE_KILL
#define kill(p,s) raise(s)
#endif
#define MIN_FATAL_STATUS 1
+/* Flag saying to pass the greatest exit code returned by a sub-process
+ to the calling program. */
+static int pass_exit_codes;
+
/* Flag saying to print the directories gcc will search through looking for
programs, libraries, etc. */
/* Flag saying to print the full filename of this file
as found through our usual search mechanism. */
-static char *print_file_name = NULL;
+static const char *print_file_name = NULL;
/* As print_file_name, but search for executable file. */
-static char *print_prog_name = NULL;
+static const char *print_prog_name = NULL;
/* Flag saying to print the relative path we'd use to
find libgcc.a given the current compiler flags. */
static int verbose_flag;
+/* Flag indicating whether we should report subprocess execution times
+ (if this is supported by the system - see pexecute.c). */
+
+static int report_times;
+
/* Nonzero means write "temp" files in source directory
and use the source file's name in them, and don't delete them. */
/* The compiler version. */
-static char *compiler_version;
+static const char *compiler_version;
/* The target version specified with -V */
-static char *spec_version = DEFAULT_TARGET_VERSION;
+static const char *spec_version = DEFAULT_TARGET_VERSION;
/* The target machine specified with -b. */
-static char *spec_machine = DEFAULT_TARGET_MACHINE;
+static const char *spec_machine = DEFAULT_TARGET_MACHINE;
/* Nonzero if cross-compiling.
When -b is used, the value comes from the `specs' file. */
#ifdef CROSS_COMPILE
-static char *cross_compile = "1";
+static const char *cross_compile = "1";
#else
-static char *cross_compile = "0";
+static const char *cross_compile = "0";
#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;
+/* Greatest exit code of sub-processes that has been encountered up to
+ now. */
+static int greatest_status = 1;
+
/* This is the obstack which we use to allocate many strings. */
static struct obstack obstack;
static struct obstack collect_obstack;
-extern char *version_string;
+/* These structs are used to collect resource usage information for
+ subprocesses. */
+#ifdef HAVE_GETRUSAGE
+static struct rusage rus, prus;
+#endif
/* Forward declaration for prototypes. */
struct path_prefix;
-static void init_spec PROTO((void));
-static void read_specs PROTO((char *, int));
-static void set_spec PROTO((char *, char *));
-static struct compiler *lookup_compiler PROTO((char *, size_t, char *));
-static char *build_search_list PROTO((struct path_prefix *, char *, int));
-static void putenv_from_prefixes PROTO((struct path_prefix *, char *));
-static char *find_a_file PROTO((struct path_prefix *, char *, int));
-static void add_prefix PROTO((struct path_prefix *, const char *,
- const char *, int, int, int *));
-static char *skip_whitespace PROTO((char *));
-static void record_temp_file PROTO((char *, int, int));
-static void delete_if_ordinary PROTO((char *));
-static void delete_temp_files PROTO((void));
-static void delete_failure_queue PROTO((void));
-static void clear_failure_queue PROTO((void));
-static int check_live_switch PROTO((int, int));
-static char *handle_braces PROTO((char *));
-static char *save_string PROTO((const char *, int));
-extern int do_spec PROTO((char *));
-static int do_spec_1 PROTO((char *, int, char *));
-static char *find_file PROTO((char *));
-static int is_directory PROTO((char *, char *, int));
-static void validate_switches PROTO((char *));
-static void validate_all_switches PROTO((void));
-static void give_switch PROTO((int, int, int));
-static int used_arg PROTO((char *, int));
-static int default_arg PROTO((char *, int));
-static void set_multilib_dir PROTO((void));
-static void print_multilib_info PROTO((void));
-static void pfatal_with_name PROTO((char *)) ATTRIBUTE_NORETURN;
-static void perror_with_name PROTO((char *));
-static void pfatal_pexecute PROTO((char *, char *)) ATTRIBUTE_NORETURN;
-static void fatal PVPROTO((char *, ...))
- ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF_1;
-static void error PVPROTO((char *, ...)) ATTRIBUTE_PRINTF_1;
-static void display_help PROTO((void));
-
-void fancy_abort PROTO((void)) ATTRIBUTE_NORETURN;
-
-#ifdef LANG_SPECIFIC_DRIVER
-/* Called before processing to change/add/remove arguments. */
-extern void lang_specific_driver PROTO ((void (*) PVPROTO((char *, ...)), int *, char ***, int *));
-
-/* Called before linking. Returns 0 on success and -1 on failure. */
-extern int lang_specific_pre_link ();
-
-/* Number of extra output files that lang_specific_pre_link may generate. */
-extern int lang_specific_extra_outfiles;
-#endif
+static void init_spec PARAMS ((void));
+#ifndef VMS
+static char **split_directories PARAMS ((const char *, int *));
+static void free_split_directories PARAMS ((char **));
+static char *make_relative_prefix PARAMS ((const char *, const char *, const char *));
+#endif /* VMS */
+static void store_arg PARAMS ((const char *, int, int));
+static char *load_specs PARAMS ((const char *));
+static void read_specs PARAMS ((const char *, int));
+static void set_spec PARAMS ((const char *, const char *));
+static struct compiler *lookup_compiler PARAMS ((const char *, size_t, const char *));
+static char *build_search_list PARAMS ((struct path_prefix *, const char *, int));
+static void putenv_from_prefixes PARAMS ((struct path_prefix *, const char *));
+static int access_check PARAMS ((const char *, int));
+static char *find_a_file PARAMS ((struct path_prefix *, const char *, int));
+static void add_prefix PARAMS ((struct path_prefix *, const char *,
+ const char *, int, int, int *));
+static void translate_options PARAMS ((int *, const char ***));
+static char *skip_whitespace PARAMS ((char *));
+static void record_temp_file PARAMS ((const char *, int, int));
+static void delete_if_ordinary PARAMS ((const char *));
+static void delete_temp_files PARAMS ((void));
+static void delete_failure_queue PARAMS ((void));
+static void clear_failure_queue PARAMS ((void));
+static int check_live_switch PARAMS ((int, int));
+static const char *handle_braces PARAMS ((const char *));
+static char *save_string PARAMS ((const char *, int));
+static int do_spec_1 PARAMS ((const char *, int, 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 *));
+static void validate_all_switches PARAMS ((void));
+static void give_switch PARAMS ((int, int, int));
+static int used_arg PARAMS ((const char *, int));
+static int default_arg PARAMS ((const char *, int));
+static void set_multilib_dir PARAMS ((void));
+static void print_multilib_info PARAMS ((void));
+static void pfatal_with_name PARAMS ((const char *)) ATTRIBUTE_NORETURN;
+static void perror_with_name PARAMS ((const char *));
+static void pfatal_pexecute PARAMS ((const char *, const char *))
+ ATTRIBUTE_NORETURN;
+static void error PARAMS ((const char *, ...))
+ ATTRIBUTE_PRINTF_1;
+static void notice PARAMS ((const char *, ...))
+ ATTRIBUTE_PRINTF_1;
+static void display_help PARAMS ((void));
+static void add_preprocessor_option PARAMS ((const char *, int));
+static void add_assembler_option PARAMS ((const char *, int));
+static void add_linker_option PARAMS ((const char *, int));
+static void process_command PARAMS ((int, const char **));
+static int execute PARAMS ((void));
+static void unused_prefix_warnings PARAMS ((struct path_prefix *));
+static void clear_args PARAMS ((void));
+static void fatal_error PARAMS ((int));
+static void set_input PARAMS ((const char *));
\f
/* Specs are strings containing lines, each of which (if not blank)
is made up of a program name, and arguments separated by spaces.
%b substitute the basename of the input file being processed.
This is the substring up to (and not including) the last period
and not including the directory.
+ %B same as %b, but include the file suffix (text after the last period).
%gSUFFIX
substitute a file name that has suffix SUFFIX and is chosen
once per compilation, and mark the argument a la %d. To reduce
chosen in a way that is hard to predict even when previously
chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
- the regexp "[.A-Za-z]*" or the special string "%O", which is
- treated exactly as if %O had been pre-processed. Previously, %g
- was simply substituted with a file name chosen once per compilation,
- without regard to any appended suffix (which was therefore treated
- just like ordinary text), making such attacks more likely to succeed.
+ the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it
+ had been pre-processed. Previously, %g was simply substituted
+ with a file name chosen once per compilation, without regard
+ to any appended suffix (which was therefore treated just like
+ ordinary text), making such attacks more likely to succeed.
%uSUFFIX
like %g, but generates a new temporary file name even if %uSUFFIX
was already seen.
at all, but they are included among the output files, so they will
be linked.
%O substitutes the suffix for object files. Note that this is
- handled specially when it immediately follows %g, %u, or %U,
- because of the need for those to form complete file names. The
- handling is such that %O is treated exactly as if it had already
- been substituted, except that %g, %u, and %U do not currently
- support additional SUFFIX characters following %O as they would
- following, for example, `.o'.
+ handled specially when it immediately follows %g, %u, or %U
+ (with or without a suffix argument) because of the need for
+ those to form complete file names. The handling is such that
+ %O is treated exactly as if it had already been substituted,
+ except that %g, %u, and %U do not currently support additional
+ SUFFIX characters following %O as they would following, for
+ example, `.o'.
%p substitutes the standard macro predefinitions for the
current target machine. Use this when running cpp.
%P like %p, but puts `__' before and after the name of each macro.
%Y Output the accumulated assembler options specified by compilations.
%Z Output the accumulated preprocessor options specified by compilations.
%v1 Substitute the major version number of GCC.
- (For version 2.5.n, this is 2.)
+ (For version 2.5.3, this is 2.)
%v2 Substitute the minor version number of GCC.
- (For version 2.5.n, this is 5.)
+ (For version 2.5.3, this is 5.)
+ %v3 Substitute the patch level number of GCC.
+ (For version 2.5.3, this is 3.)
%a process ASM_SPEC as a spec.
This allows config.h to specify part of the spec for running as.
%A process ASM_FINAL_SPEC as a spec. A capital A is actually
specified to CC. Note that the tail part of the -S option
(i.e. the part matched by the `*') will be substituted for each
occurrence of %* within X.
+ %{<S} remove all occurences of S from the command line.
+ Note - this option is position dependent. % commands in the
+ spec string before this option will see S, % commands in the
+ spec string after this option will not.
%{S:X} substitutes X, but only if the -S switch was given to CC.
%{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
%{|S:X} like %{S:X}, but if no S switch, substitute `-'.
#define LINKER_NAME "collect2"
#endif
-static char *cpp_spec = CPP_SPEC;
-static char *cpp_predefines = CPP_PREDEFINES;
-static char *cc1_spec = CC1_SPEC;
-static char *cc1plus_spec = CC1PLUS_SPEC;
-static char *signed_char_spec = SIGNED_CHAR_SPEC;
-static char *asm_spec = ASM_SPEC;
-static char *asm_final_spec = ASM_FINAL_SPEC;
-static char *link_spec = LINK_SPEC;
-static char *lib_spec = LIB_SPEC;
-static char *libgcc_spec = LIBGCC_SPEC;
-static char *endfile_spec = ENDFILE_SPEC;
-static char *startfile_spec = STARTFILE_SPEC;
-static char *switches_need_spaces = SWITCHES_NEED_SPACES;
-static char *linker_name_spec = LINKER_NAME;
+/* Here is the spec for running the linker, after compiling all files. */
+
+/* -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. */
+/* We want %{T*} after %{L*} and %D so that it can be used to specify linker
+ scripts which exist in user specified directories, or in standard
+ directories. */
+#ifndef LINK_COMMAND_SPEC
+#define LINK_COMMAND_SPEC "\
+%{!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 %L %G}}\
+ %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
+#endif
+
+#ifndef LINK_LIBGCC_SPEC
+# ifdef LINK_LIBGCC_SPECIAL
+/* Don't generate -L options for startfile prefix list. */
+# define LINK_LIBGCC_SPEC ""
+# else
+/* Do generate them. */
+# define LINK_LIBGCC_SPEC "%D"
+# endif
+#endif
+
+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 *signed_char_spec = SIGNED_CHAR_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 *lib_spec = LIB_SPEC;
+static const char *libgcc_spec = LIBGCC_SPEC;
+static const char *endfile_spec = ENDFILE_SPEC;
+static const char *startfile_spec = STARTFILE_SPEC;
+static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
+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;
+
+/* Standard options to cpp, cc1, and as, to reduce duplication in specs.
+ There should be no need to override these in target dependent files,
+ but we need to copy them to the specs file so that newer versions
+ of the GCC driver can correctly drive older tool chains with the
+ appropriate -B options. */
+
+static const char *trad_capable_cpp =
+"%{traditional|ftraditional|traditional-cpp:trad}cpp";
+
+static const char *cpp_options =
+"%{C:%{!E:%eGNU C does not support -C without using -E}}\
+ %{std*} %{nostdinc*}\
+ %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
+ %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
+ %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
+ %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
+ %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
+ %{ffast-math:-D__FAST_MATH__}\
+ %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
+ %{fshow-column} %{fno-show-column}\
+ %{fleading-underscore} %{fno-leading-underscore}\
+ %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z %i\
+ %{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}}";
+
+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*}\
+ %{g*} %{O*} %{W*} %{w} %{pedantic*} %{std*} %{ansi}\
+ %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
+ %{aux-info*} %{Qn:-fno-ident} %{--help:--help}\
+ %{S:%W{o*}%{!o*:-o %b.s}}";
+
+static const char *asm_options =
+"%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
/* Some compilers have limits on line lengths, and the multilib_select
and/or multilib_matches strings can be very long, so we build them at
run time. */
static struct obstack multilib_obstack;
-static char *multilib_select;
-static char *multilib_matches;
-static char *multilib_defaults;
+static const char *multilib_select;
+static const char *multilib_matches;
+static const char *multilib_defaults;
+static const char *multilib_exclusions;
#include "multilib.h"
/* Check whether a particular argument is a default argument. */
#define MULTILIB_DEFAULTS { "" }
#endif
-static char *multilib_defaults_raw[] = MULTILIB_DEFAULTS;
+static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
-struct user_specs {
+struct user_specs
+{
struct user_specs *next;
- char *filename;
+ const char *filename;
};
static struct user_specs *user_specs_head, *user_specs_tail;
struct compiler
{
- char *suffix; /* Use this compiler for input files
+ const char *suffix; /* Use this compiler for input files
whose names end in this suffix. */
- char *spec[4]; /* To use this compiler, concatenate these
- specs and pass to do_spec. */
+ const char *spec; /* To use this compiler, run this spec. */
};
/* Pointer to a vector of `struct compiler' that gives the spec for
were not present when we built the driver, we will hit these copies
and be given a more meaningful error than "file not used since
linking is not done". */
- {".m", {"#Objective-C"}},
- {".cc", {"#C++"}}, {".cxx", {"#C++"}}, {".cpp", {"#C++"}},
- {".c++", {"#C++"}}, {".C", {"#C++"}},
- {".ads", {"#Ada"}}, {".adb", {"#Ada"}}, {".ada", {"#Ada"}},
- {".f", {"#Fortran"}}, {".for", {"#Fortran"}}, {".F", {"#Fortran"}},
- {".fpp", {"#Fortran"}},
- {".p", {"#Pascal"}}, {".pas", {"#Pascal"}},
+ {".m", "#Objective-C"},
+ {".cc", "#C++"}, {".cxx", "#C++"}, {".cpp", "#C++"},
+ {".c++", "#C++"}, {".C", "#C++"},
+ {".ads", "#Ada"}, {".adb", "#Ada"}, {".ada", "#Ada"},
+ {".f", "#Fortran"}, {".for", "#Fortran"}, {".F", "#Fortran"},
+ {".fpp", "#Fortran"}, {".r", "#Ratfor"},
+ {".p", "#Pascal"}, {".pas", "#Pascal"},
+ {".ch", "#Chill"}, {".chi", "#Chill"},
+ {".java", "#Java"}, {".class", "#Java"},
+ {".zip", "#Java"}, {".jar", "#Java"},
/* Next come the entries for C. */
- {".c", {"@c"}},
+ {".c", "@c"},
{"@c",
- {
#if USE_CPPLIB
- "%{E|M|MM:cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
- %{C} %{v} %{A*} %{I*} %{P} %I\
- %{C:%{!E:%eGNU C does not support -C without using -E}}\
- %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
- -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
- %{ansi|std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
- %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
- %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
- %{traditional} %{ftraditional:-traditional}\
- %{traditional-cpp:-traditional}\
- %{fleading-underscore} %{fno-leading-underscore}\
- %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
- %i %{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}}\n}\
- %{!E:%{!M:%{!MM:cc1 %i %1 \
- %{std*} %{nostdinc*} %{A*} %{I*} %I\
- %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a*}\
- %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
- -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
- %{ansi|std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
- %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
- %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
- %{H} %C %{D*} %{U*} %{i*} %Z\
- %{ftraditional:-traditional}\
- %{traditional-cpp:-traditional}\
- %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
- %{aux-info*}\
- %{--help:--help}\
- %{g*} %{O*} %{W*} %{w} %{pedantic*}\
- %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
- %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
- %{!S:as %a %Y\
- %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
- %{!pipe:%g.s} %A\n }}}}"
- }},
+ "%{E|M|MM:cpp -lang-c %{ansi:-std=c89} %(cpp_options)}\
+ %{!E:%{!M:%{!MM:cc1 -lang-c %{ansi:-std=c89} %(cpp_options)\
+ %(cc1_options) %{!S:-o %{|!pipe:%g.s} |\n\
+ as %(asm_options) %{!pipe:%g.s} %A }}}}"
#else /* ! USE_CPPLIB */
- "cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
- %{C} %{v} %{A*} %{I*} %{P} %I\
- %{C:%{!E:%eGNU C does not support -C without using -E}}\
- %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
- -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
- %{ansi|std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
- %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
- %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
- %{traditional} %{ftraditional:-traditional}\
- %{traditional-cpp:-traditional}\
- %{fleading-underscore} %{fno-leading-underscore}\
- %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
- %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
- "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \
- %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a*}\
- %{g*} %{O*} %{W*} %{w} %{pedantic*} %{std*}\
- %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
- %{aux-info*}\
- %{--help:--help} \
- %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
- %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
- %{!S:as %a %Y\
- %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
- %{!pipe:%g.s} %A\n }}}}"
- }},
+ "%(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options) \
+ %{!M:%{!MM:%{!E:%{!pipe:%g.i} |\n\
+ cc1 %{!pipe:%g.i} %(cc1_options) %{!S:-o %{|!pipe:%g.s} |\n\
+ as %(asm_options) %{!pipe:%g.s} %A }}}}\n"
#endif /* ! USE_CPPLIB */
+ },
{"-",
- {"%{E:cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
- %{C} %{v} %{A*} %{I*} %{P} %I\
- %{C:%{!E:%eGNU C does not support -C without using -E}}\
- %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
- -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
- %{ansi|std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
- %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
- %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
- %{traditional} %{ftraditional:-traditional}\
- %{traditional-cpp:-traditional}\
- %{fleading-underscore} %{fno-leading-underscore}\
- %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
- %i %W{o*}}\
- %{!E:%e-E required when input is from standard input}"}},
- {".h", {"@c-header"}},
+ "%{!E:%e-E required when input is from standard input}\
+ %(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)"},
+ {".h", "@c-header"},
{"@c-header",
- {"%{!E:%eCompilation of header file requested} \
- cpp %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
- %{C:%{!E:%eGNU C does not support -C without using -E}}\
- %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
- -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
- %{std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
- %{!undef:%{!std=*:%p}%{std=gnu*:%p} %P} %{trigraphs}\
- %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
- %{traditional} %{ftraditional:-traditional}\
- %{traditional-cpp:-traditional}\
- %{fleading-underscore} %{fno-leading-underscore}\
- %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
- %i %W{o*}"}},
- {".i", {"@cpp-output"}},
+ "%{!E:%eCompilation of header file requested} \
+ %(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)"},
+ {".i", "@cpp-output"},
{"@cpp-output",
- {"%{!M:%{!MM:%{!E:cc1 %i %1 %{!Q:-quiet} %{d*} %{m*} %{a*}\
- %{g*} %{O*} %{W*} %{w} %{pedantic*} %{std*}\
- %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
- %{aux-info*}\
- %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
- %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
- %{!S:as %a %Y\
- %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
- %{!pipe:%g.s} %A\n }}}}"}},
- {".s", {"@assembler"}},
+ "%{!M:%{!MM:%{!E:\
+ cc1 %i %(cc1_options) %{!S:|\n\
+ as %(asm_options) %{!pipe:%g.s} %A }}}}"},
+ {".s", "@assembler"},
{"@assembler",
- {"%{!M:%{!MM:%{!E:%{!S:as %a %Y\
- %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
- %i %A\n }}}}"}},
- {".S", {"@assembler-with-cpp"}},
+ "%{!M:%{!MM:%{!E:%{!S:as %(asm_options) %i %A }}}}"},
+ {".S", "@assembler-with-cpp"},
{"@assembler-with-cpp",
- {"cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
- %{C:%{!E:%eGNU C does not support -C without using -E}}\
- %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG} %{trigraphs}\
- -undef -$ %{!undef:%p %P} -D__ASSEMBLER__ \
- %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
- %{traditional} %{ftraditional:-traditional}\
- %{traditional-cpp:-traditional}\
- %{fleading-underscore} %{fno-leading-underscore}\
- %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
- %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
- "%{!M:%{!MM:%{!E:%{!S:as %a %Y\
- %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
- %{!pipe:%g.s} %A\n }}}}"}},
+ "%(trad_capable_cpp) -lang-asm %(cpp_options) \
+ %{!M:%{!MM:%{!E:%{!S: %{!pipe:%g.s} |\n\
+ as %(asm_options) %{!pipe:%g.s} %A }}}}"},
#include "specs.h"
/* Mark end of table */
- {0, {0}}
+ {0, 0}
};
/* Number of elements in default_compilers, not counting the terminator. */
static int n_default_compilers
= (sizeof default_compilers / sizeof (struct compiler)) - 1;
-/* Here is the spec for running the linker, after compiling all files. */
-
-/* -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. */
-/* We want %{T*} after %{L*} and %D so that it can be used to specify linker
- scripts which exist in user specified directories, or in standard
- directories. */
-#ifdef LINK_COMMAND_SPEC
-/* Provide option to override link_command_spec from machine specific
- configuration files. */
-static char *link_command_spec =
- LINK_COMMAND_SPEC;
-#else
-#ifdef LINK_LIBGCC_SPECIAL
-/* Don't generate -L options. */
-static char *link_command_spec = "\
-%{!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*} %o\
- %{!nostdlib:%{!nodefaultlibs:%G %L %G}}\
- %{!A:%{!nostdlib:%{!nostartfiles:%E}}}\
- %{T*}\
- \n }}}}}}";
-#else
-/* Use -L. */
-static char *link_command_spec = "\
-%{!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*} %D %o\
- %{!nostdlib:%{!nodefaultlibs:%G %L %G}}\
- %{!A:%{!nostdlib:%{!nostartfiles:%E}}}\
- %{T*}\
- \n }}}}}}";
-#endif
-#endif
-
/* A vector of options to give to the linker.
These options are accumulated by %x,
and substituted into the linker command with %X. */
struct option_map
{
/* The long option's name. */
- char *name;
+ const char *name;
/* The equivalent short option. */
- char *equivalent;
+ const char *equivalent;
/* Argument info. A string of flag chars; NULL equals no options.
a => argument required.
o => argument optional.
j => join argument to equivalent, making one word.
* => require other text after NAME as an argument. */
- char *arg_info;
+ const char *arg_info;
};
/* This is the table of mappings. Mappings are tried sequentially
{"--std", "-std=", "aj"},
{"--symbolic", "-symbolic", 0},
{"--target", "-b", "a"},
+ {"--time", "-time", 0},
{"--trace-includes", "-H", 0},
{"--traditional", "-traditional", 0},
{"--traditional-cpp", "-traditional-cpp", 0},
static void
translate_options (argcp, argvp)
int *argcp;
- char ***argvp;
+ const char ***argvp;
{
int i;
int argc = *argcp;
- char **argv = *argvp;
- char **newv = (char **) xmalloc ((argc + 2) * 2 * sizeof (char *));
+ const char **argv = *argvp;
+ const char **newv =
+ (const char **) xmalloc ((argc + 2) * 2 * sizeof (const char *));
int newindex = 0;
i = 0;
size_t optlen = strlen (option_map[j].name);
size_t arglen = strlen (argv[i]);
size_t complen = arglen > optlen ? optlen : arglen;
- char *arginfo = option_map[j].arg_info;
+ const char *arginfo = option_map[j].arg_info;
if (arginfo == 0)
arginfo = "";
if (!strncmp (argv[i], option_map[j].name, complen))
{
- char *arg = 0;
+ const char *arg = 0;
if (arglen < optlen)
{
with their arguments. */
else if (argv[i][0] == '-')
{
- char *p = argv[i] + 1;
+ const char *p = argv[i] + 1;
int c = *p;
int nskip = 1;
*argcp = newindex;
}
\f
-char *
-xstrerror(e)
- int e;
-{
-#ifdef HAVE_STRERROR
-
- return strerror(e);
-
-#else
-
- static char buffer[30];
- if (!e)
- return "cannot access";
-
- if (e > 0 && e < sys_nerr)
- return sys_errlist[e];
-
- sprintf (buffer, "Unknown error %d", e);
- return buffer;
-#endif
-}
-\f
static char *
skip_whitespace (p)
char *p;
{
/* The following 2 fields must be first */
/* to allow EXTRA_SPECS to be initialized */
- char *name; /* name of the spec. */
- char *ptr; /* available ptr if no static pointer */
+ const char *name; /* name of the spec. */
+ const char *ptr; /* available ptr if no static pointer */
/* The following fields are not initialized */
/* by EXTRA_SPECS */
- char **ptr_spec; /* pointer to the spec itself. */
+ const char **ptr_spec; /* pointer to the spec itself. */
struct spec_list *next; /* Next spec in linked list. */
int name_len; /* length of the name */
int alloc_p; /* whether string was allocated */
#define INIT_STATIC_SPEC(NAME,PTR) \
{ NAME, NULL_PTR, PTR, (struct spec_list *)0, sizeof (NAME)-1, 0 }
-/* List of statically defined specs */
-static struct spec_list static_specs[] = {
+/* List of statically defined specs. */
+static struct spec_list static_specs[] =
+{
INIT_STATIC_SPEC ("asm", &asm_spec),
INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
+ INIT_STATIC_SPEC ("asm_options", &asm_options),
INIT_STATIC_SPEC ("cpp", &cpp_spec),
+ INIT_STATIC_SPEC ("cpp_options", &cpp_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 ("endfile", &endfile_spec),
INIT_STATIC_SPEC ("link", &link_spec),
INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
+ INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
INIT_STATIC_SPEC ("linker", &linker_name_spec),
+ INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
};
#ifdef EXTRA_SPECS /* additional specs needed */
/* Structure to keep track of just the first two args of a spec_list.
- That is all that the EXTRA_SPECS macro gives us. */
+ That is all that the EXTRA_SPECS macro gives us. */
struct spec_list_1
{
- char *name;
- char *ptr;
+ const char *name;
+ const char *ptr;
};
static struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
int i;
if (specs)
- return; /* already initialized */
+ return; /* Already initialized. */
if (verbose_flag)
- fprintf (stderr, "Using builtin specs.\n");
+ notice ("Using builtin specs.\n");
#ifdef EXTRA_SPECS
extra_specs = (struct spec_list *)
- xmalloc (sizeof(struct spec_list) *
+ xcalloc (sizeof(struct spec_list),
(sizeof(extra_specs_1)/sizeof(extra_specs_1[0])));
- bzero ((PTR) extra_specs, sizeof(struct spec_list) *
- (sizeof(extra_specs_1)/sizeof(extra_specs_1[0])));
for (i = (sizeof(extra_specs_1) / sizeof(extra_specs_1[0])) - 1; i >= 0; i--)
{
static void
set_spec (name, spec)
- char *name;
- char *spec;
+ const char *name;
+ const char *spec;
{
struct spec_list *sl;
- char *old_spec;
+ const char *old_spec;
int name_len = strlen (name);
int i;
- /* If this is the first call, initialize the statically allocated specs */
+ /* If this is the first call, initialize the statically allocated specs. */
if (!specs)
{
struct spec_list *next = (struct spec_list *)0;
specs = sl;
}
- /* See if the spec already exists */
+ /* See if the spec already exists. */
for (sl = specs; sl; sl = sl->next)
if (name_len == sl->name_len && !strcmp (sl->name, name))
break;
if (!sl)
{
- /* Not found - make it */
+ /* Not found - make it. */
sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
- sl->name = save_string (name, strlen (name));
+ sl->name = xstrdup (name);
sl->name_len = name_len;
sl->ptr_spec = &sl->ptr;
sl->alloc_p = 0;
old_spec = *(sl->ptr_spec);
*(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
? concat (old_spec, spec + 1, NULL_PTR)
- : save_string (spec, strlen (spec)));
+ : xstrdup (spec));
#ifdef DEBUG_SPECS
if (verbose_flag)
- fprintf (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
+ notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
#endif
- /* Free the old spec */
+ /* Free the old spec. */
if (old_spec && sl->alloc_p)
- free (old_spec);
+ free ((PTR) old_spec);
sl->alloc_p = 1;
}
/* Vector of pointers to arguments in the current line of specifications. */
-static char **argbuf;
+static const char **argbuf;
/* Number of elements allocated in argbuf. */
#ifdef MKTEMP_EACH_FILE
-extern char *make_temp_file PROTO((char *));
-
/* This is the list of suffixes and codes (%g/%u/%U) and the associated
temp file. */
static struct temp_name {
- char *suffix; /* suffix associated with the code. */
+ const char *suffix; /* suffix associated with the code. */
int length; /* strlen (suffix). */
int unique; /* Indicates whether %g or %u/%U was used. */
- char *filename; /* associated filename. */
+ const char *filename; /* associated filename. */
int filename_length; /* strlen (filename). */
struct temp_name *next;
} *temp_names;
/* Name with which this program was invoked. */
-static char *programname;
+static const char *programname;
\f
/* Structures to keep track of prefixes to try when looking for files. */
{
struct prefix_list *plist; /* List of prefixes to try */
int max_len; /* Max length of a prefix in PLIST */
- char *name; /* Name of this list (used in config stuff) */
+ const char *name; /* Name of this list (used in config stuff) */
};
/* List of prefixes to try when looking for executables. */
/* Suffix to attach to directories searched for commands.
This looks like `MACHINE/VERSION/'. */
-static char *machine_suffix = 0;
+static const char *machine_suffix = 0;
/* Suffix to attach to directories searched for commands.
This is just `MACHINE/'. */
-static char *just_machine_suffix = 0;
+static const char *just_machine_suffix = 0;
/* Adjusted value of GCC_EXEC_PREFIX envvar. */
-static char *gcc_exec_prefix;
+static const char *gcc_exec_prefix;
/* Default prefixes to attach to command names. */
#define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
#endif /* !defined STANDARD_EXEC_PREFIX */
-static char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
-static char *standard_exec_prefix_1 = "/usr/lib/gcc/";
+static const char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
+static const char *standard_exec_prefix_1 = "/usr/lib/gcc/";
#ifdef MD_EXEC_PREFIX
-static char *md_exec_prefix = MD_EXEC_PREFIX;
+static const char *md_exec_prefix = MD_EXEC_PREFIX;
#endif
#ifndef STANDARD_STARTFILE_PREFIX
#endif /* !defined STANDARD_STARTFILE_PREFIX */
#ifdef MD_STARTFILE_PREFIX
-static char *md_startfile_prefix = MD_STARTFILE_PREFIX;
+static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
#endif
#ifdef MD_STARTFILE_PREFIX_1
-static char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
+static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
#endif
-static char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
-static char *standard_startfile_prefix_1 = "/lib/";
-static char *standard_startfile_prefix_2 = "/usr/lib/";
+static const char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
+static const char *standard_startfile_prefix_1 = "/lib/";
+static const char *standard_startfile_prefix_2 = "/usr/lib/";
#ifndef TOOLDIR_BASE_PREFIX
#define TOOLDIR_BASE_PREFIX "/usr/local/"
#endif
-static char *tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
-static char *tooldir_prefix;
+static const char *tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
+static const char *tooldir_prefix;
+
+#ifndef STANDARD_BINDIR_PREFIX
+#define STANDARD_BINDIR_PREFIX "/usr/local/bin"
+#endif
+static const char *standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
/* Subdirectory to use for locating libraries. Set by
set_multilib_dir based on the compilation options. */
-static char *multilib_dir;
+static const char *multilib_dir;
/* Clear out the vector of arguments (after a command is executed). */
static void
store_arg (arg, delete_always, delete_failure)
- char *arg;
+ const char *arg;
int delete_always, delete_failure;
{
if (argbuf_index + 1 == argbuf_length)
argbuf
- = (char **) xrealloc (argbuf, (argbuf_length *= 2) * sizeof (char *));
+ = (const char **) xrealloc (argbuf,
+ (argbuf_length *= 2) * sizeof (const char *));
argbuf[argbuf_index++] = arg;
argbuf[argbuf_index] = 0;
record_temp_file (arg, delete_always, delete_failure);
}
\f
-/* Read compilation specs from a file named FILENAME,
- replacing the default ones.
-
- A suffix which starts with `*' is a definition for
- one of the machine-specific sub-specs. The "suffix" should be
- *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
- The corresponding spec is stored in asm_spec, etc.,
- rather than in the `compilers' vector.
-
- Anything invalid in the file is a fatal error. */
+/* Load specs from a file name named FILENAME, replacing occurances of
+ various different types of line-endings, \r\n, \n\r and just \r, with
+ a single \n. */
-static void
-read_specs (filename, main_p)
- char *filename;
- int main_p;
+static char*
+load_specs (filename)
+ const char *filename;
{
int desc;
int readlen;
struct stat statbuf;
char *buffer;
- register char *p;
+ char *buffer_p;
+ char *specs;
+ char *specs_p;
if (verbose_flag)
- fprintf (stderr, "Reading specs from %s\n", filename);
+ notice ("Reading specs from %s\n", filename);
/* Open and stat the file. */
desc = open (filename, O_RDONLY, 0);
buffer[readlen] = 0;
close (desc);
+ specs = xmalloc (readlen + 1);
+ specs_p = specs;
+ for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
+ {
+ int skip = 0;
+ char c = *buffer_p;
+ if (c == '\r')
+ {
+ if (buffer_p > buffer && *(buffer_p-1) == '\n') /* \n\r */
+ skip = 1;
+ else if (*(buffer_p+1) == '\n') /* \r\n */
+ skip = 1;
+ else /* \r */
+ c = '\n';
+ }
+ if (! skip)
+ *specs_p++ = c;
+ }
+ *specs_p = '\0';
+
+ free (buffer);
+ return (specs);
+}
+
+/* Read compilation specs from a file named FILENAME,
+ replacing the default ones.
+
+ A suffix which starts with `*' is a definition for
+ one of the machine-specific sub-specs. The "suffix" should be
+ *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
+ The corresponding spec is stored in asm_spec, etc.,
+ rather than in the `compilers' vector.
+
+ Anything invalid in the file is a fatal error. */
+
+static void
+read_specs (filename, main_p)
+ const char *filename;
+ int main_p;
+{
+ char *buffer;
+ register char *p;
+
+ buffer = load_specs (filename);
+
/* Scan BUFFER for specs, putting them in the vector. */
p = buffer;
while (1)
if (new_filename)
read_specs (new_filename, FALSE);
else if (verbose_flag)
- fprintf (stderr, "Could not find specs file %s\n", p1);
+ notice ("Could not find specs file %s\n", p1);
continue;
}
else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
if (verbose_flag)
{
- fprintf (stderr, "rename spec %s to %s\n", p1, p2);
+ notice ("rename spec %s to %s\n", p1, p2);
#ifdef DEBUG_SPECS
- fprintf (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
+ notice ("spec is '%s'\n\n", *(sl->ptr_spec));
#endif
}
set_spec (p2, *(sl->ptr_spec));
if (sl->alloc_p)
- free (*(sl->ptr_spec));
+ free ((PTR) *(sl->ptr_spec));
*(sl->ptr_spec) = "";
sl->alloc_p = 0;
(n_compilers + 2) * sizeof (struct compiler)));
compilers[n_compilers].suffix = suffix;
- bzero ((char *) compilers[n_compilers].spec,
- sizeof compilers[n_compilers].spec);
- compilers[n_compilers].spec[0] = spec;
+ compilers[n_compilers].spec = spec;
n_compilers++;
- bzero ((char *) &compilers[n_compilers],
- sizeof compilers[n_compilers]);
+ memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
}
if (*suffix == 0)
otherwise, in /usr/tmp or /tmp;
or finally the current directory if all else fails. */
-static char *temp_filename;
+static const char *temp_filename;
/* Length of the prefix. */
struct temp_file
{
- char *name;
+ const char *name;
struct temp_file *next;
};
static void
record_temp_file (filename, always_delete, fail_delete)
- char *filename;
+ const char *filename;
int always_delete;
int fail_delete;
{
- register char *name;
- name = xmalloc (strlen (filename) + 1);
- strcpy (name, filename);
+ register char * const name = xstrdup (filename);
if (always_delete)
{
static void
delete_if_ordinary (name)
- char *name;
+ const char *name;
{
struct stat st;
#ifdef DEBUG
static char *
build_search_list (paths, prefix, check_dir_p)
struct path_prefix *paths;
- char *prefix;
+ const char *prefix;
int check_dir_p;
{
int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
struct prefix_list *pprefix;
obstack_grow (&collect_obstack, prefix, strlen (prefix));
+ obstack_1grow (&collect_obstack, '=');
for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
{
static void
putenv_from_prefixes (paths, env_var)
struct path_prefix *paths;
- char *env_var;
+ const char *env_var;
{
putenv (build_search_list (paths, env_var, 1));
}
\f
+#ifndef VMS
+
+/* FIXME: the location independence code for VMS is hairier than this,
+ and hasn't been written. */
+
+/* Split a filename into component directories. */
+
+static char **
+split_directories (name, ptr_num_dirs)
+ const char *name;
+ int *ptr_num_dirs;
+{
+ int num_dirs = 0;
+ char **dirs;
+ const char *p, *q;
+ int ch;
+
+ /* Count the number of directories. Special case MSDOS disk names as part
+ of the initial directory. */
+ p = name;
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+ if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
+ {
+ p += 3;
+ num_dirs++;
+ }
+#endif /* HAVE_DOS_BASED_FILE_SYSTEM */
+
+ while ((ch = *p++) != '\0')
+ {
+ if (IS_DIR_SEPARATOR (ch))
+ {
+ num_dirs++;
+ while (IS_DIR_SEPARATOR (*p))
+ p++;
+ }
+ }
+
+ dirs = (char **) xmalloc (sizeof (char *) * (num_dirs + 2));
+
+ /* Now copy the directory parts. */
+ num_dirs = 0;
+ p = name;
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+ if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
+ {
+ dirs[num_dirs++] = save_string (p, 3);
+ p += 3;
+ }
+#endif /* HAVE_DOS_BASED_FILE_SYSTEM */
+
+ q = p;
+ while ((ch = *p++) != '\0')
+ {
+ if (IS_DIR_SEPARATOR (ch))
+ {
+ while (IS_DIR_SEPARATOR (*p))
+ p++;
+
+ dirs[num_dirs++] = save_string (q, p - q);
+ q = p;
+ }
+ }
+
+ if (p - 1 - q > 0)
+ dirs[num_dirs++] = save_string (q, p - 1 - q);
+
+ dirs[num_dirs] = NULL_PTR;
+ if (ptr_num_dirs)
+ *ptr_num_dirs = num_dirs;
+
+ return dirs;
+}
+
+/* Release storage held by split directories. */
+
+static void
+free_split_directories (dirs)
+ char **dirs;
+{
+ int i = 0;
+
+ while (dirs[i] != NULL_PTR)
+ free (dirs[i++]);
+
+ free ((char *)dirs);
+}
+
+/* Given three strings PROGNAME, BIN_PREFIX, PREFIX, return a string that gets
+ to PREFIX starting with the directory portion of PROGNAME and a relative
+ pathname of the difference between BIN_PREFIX and PREFIX.
+
+ For example, if BIN_PREFIX is /alpha/beta/gamma/gcc/delta, PREFIX is
+ /alpha/beta/gamma/omega/, and PROGNAME is /red/green/blue/gcc, then this
+ function will return /red/green/blue/../omega.
+
+ If no relative prefix can be found, return NULL. */
+
+static char *
+make_relative_prefix (progname, bin_prefix, prefix)
+ const char *progname;
+ const char *bin_prefix;
+ const char *prefix;
+{
+ char **prog_dirs, **bin_dirs, **prefix_dirs;
+ int prog_num, bin_num, prefix_num, std_loc_p;
+ int i, n, common;
+
+ prog_dirs = split_directories (progname, &prog_num);
+ bin_dirs = split_directories (bin_prefix, &bin_num);
+
+ /* If there is no full pathname, try to find the program by checking in each
+ of the directories specified in the PATH environment variable. */
+ if (prog_num == 1)
+ {
+ char *temp;
+
+ GET_ENV_PATH_LIST (temp, "PATH");
+ if (temp)
+ {
+ char *startp, *endp;
+ char *nstore = (char *) alloca (strlen (temp) + strlen (progname) + 1);
+
+ startp = endp = temp;
+ while (1)
+ {
+ if (*endp == PATH_SEPARATOR || *endp == 0)
+ {
+ if (endp == startp)
+ {
+ nstore[0] = '.';
+ nstore[1] = DIR_SEPARATOR;
+ nstore[2] = '\0';
+ }
+ else
+ {
+ strncpy (nstore, startp, endp-startp);
+ if (! IS_DIR_SEPARATOR (endp[-1]))
+ {
+ nstore[endp-startp] = DIR_SEPARATOR;
+ nstore[endp-startp+1] = 0;
+ }
+ else
+ nstore[endp-startp] = 0;
+ }
+ strcat (nstore, progname);
+ if (! access (nstore, X_OK)
+#ifdef HAVE_EXECUTABLE_SUFFIX
+ || ! access (strcat (nstore, EXECUTABLE_SUFFIX), X_OK)
+#endif
+ )
+ {
+ free_split_directories (prog_dirs);
+ progname = nstore;
+ prog_dirs = split_directories (progname, &prog_num);
+ break;
+ }
+
+ if (*endp == 0)
+ break;
+ endp = startp = endp + 1;
+ }
+ else
+ endp++;
+ }
+ }
+ }
+
+ /* Remove the program name from comparison of directory names. */
+ prog_num--;
+
+ /* Determine if the compiler is installed in the standard location, and if
+ so, we don't need to specify relative directories. Also, if argv[0]
+ doesn't contain any directory specifiers, there is not much we can do. */
+ std_loc_p = 0;
+ if (prog_num == bin_num)
+ {
+ for (i = 0; i < bin_num; i++)
+ {
+ if (strcmp (prog_dirs[i], bin_dirs[i]) != 0)
+ break;
+ }
+
+ if (prog_num <= 0 || i == bin_num)
+ {
+ std_loc_p = 1;
+ free_split_directories (prog_dirs);
+ free_split_directories (bin_dirs);
+ prog_dirs = bin_dirs = (char **)0;
+ return NULL_PTR;
+ }
+ }
+
+ prefix_dirs = split_directories (prefix, &prefix_num);
+
+ /* Find how many directories are in common between bin_prefix & prefix. */
+ n = (prefix_num < bin_num) ? prefix_num : bin_num;
+ for (common = 0; common < n; common++)
+ {
+ if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0)
+ break;
+ }
+
+ /* If there are no common directories, there can be no relative prefix. */
+ if (common == 0)
+ {
+ free_split_directories (prog_dirs);
+ free_split_directories (bin_dirs);
+ free_split_directories (prefix_dirs);
+ return NULL_PTR;
+ }
+
+ /* Build up the pathnames in argv[0]. */
+ for (i = 0; i < prog_num; i++)
+ obstack_grow (&obstack, prog_dirs[i], strlen (prog_dirs[i]));
+
+ /* Now build up the ..'s. */
+ for (i = common; i < n; i++)
+ {
+ obstack_grow (&obstack, DIR_UP, sizeof (DIR_UP)-1);
+ obstack_1grow (&obstack, DIR_SEPARATOR);
+ }
+
+ /* Put in directories to move over to prefix. */
+ for (i = common; i < prefix_num; i++)
+ obstack_grow (&obstack, prefix_dirs[i], strlen (prefix_dirs[i]));
+
+ free_split_directories (prog_dirs);
+ free_split_directories (bin_dirs);
+ free_split_directories (prefix_dirs);
+
+ obstack_1grow (&obstack, '\0');
+ return obstack_finish (&obstack);
+}
+#endif /* VMS */
+\f
+/* Check whether NAME can be accessed in MODE. This is like access,
+ except that it never considers directories to be executable. */
+
+static int
+access_check (name, mode)
+ const char *name;
+ int mode;
+{
+ if (mode == X_OK)
+ {
+ struct stat st;
+
+ if (stat (name, &st) < 0
+ || S_ISDIR (st.st_mode))
+ return -1;
+ }
+
+ return access (name, mode);
+}
+
/* Search for NAME using the prefix list PREFIXES. MODE is passed to
access to check permissions.
Return 0 if not found, otherwise return its name, allocated with malloc. */
static char *
find_a_file (pprefix, name, mode)
struct path_prefix *pprefix;
- char *name;
+ const char *name;
int mode;
{
char *temp;
- char *file_suffix = ((mode & X_OK) != 0 ? EXECUTABLE_SUFFIX : "");
+ const char *file_suffix = ((mode & X_OK) != 0 ? EXECUTABLE_SUFFIX : "");
struct prefix_list *pl;
int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
#ifdef DEFAULT_ASSEMBLER
- if (! strcmp(name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0) {
- name = DEFAULT_ASSEMBLER;
- len = strlen(name)+1;
- temp = xmalloc (len);
- strcpy (temp, name);
- return temp;
- }
+ if (! strcmp(name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
+ return xstrdup (DEFAULT_ASSEMBLER);
#endif
#ifdef DEFAULT_LINKER
- if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0) {
- name = DEFAULT_LINKER;
- len = strlen(name)+1;
- temp = xmalloc (len);
- strcpy (temp, name);
- return temp;
- }
+ if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
+ return xstrdup (DEFAULT_LINKER);
#endif
if (machine_suffix)
/* Determine the filename to execute (special case for absolute paths). */
- if (*name == '/' || *name == DIR_SEPARATOR
+ if (IS_DIR_SEPARATOR (*name)
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
/* Check for disk name on MS-DOS-based systems. */
- || (DIR_SEPARATOR == '\\' && name[1] == ':'
- && (name[2] == DIR_SEPARATOR || name[2] == '/')))
+ || (name[0] && name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
+#endif
+ )
{
if (access (name, mode) == 0)
{
strcat (temp, machine_suffix);
strcat (temp, name);
strcat (temp, file_suffix);
- if (access (temp, mode) == 0)
+ if (access_check (temp, mode) == 0)
{
if (pl->used_flag_ptr != 0)
*pl->used_flag_ptr = 1;
strcpy (temp, pl->prefix);
strcat (temp, machine_suffix);
strcat (temp, name);
- if (access (temp, mode) == 0)
+ if (access_check (temp, mode) == 0)
{
if (pl->used_flag_ptr != 0)
*pl->used_flag_ptr = 1;
strcat (temp, just_machine_suffix);
strcat (temp, name);
strcat (temp, file_suffix);
- if (access (temp, mode) == 0)
+ if (access_check (temp, mode) == 0)
{
if (pl->used_flag_ptr != 0)
*pl->used_flag_ptr = 1;
strcpy (temp, pl->prefix);
strcat (temp, just_machine_suffix);
strcat (temp, name);
- if (access (temp, mode) == 0)
+ if (access_check (temp, mode) == 0)
{
if (pl->used_flag_ptr != 0)
*pl->used_flag_ptr = 1;
strcpy (temp, pl->prefix);
strcat (temp, name);
strcat (temp, file_suffix);
- if (access (temp, mode) == 0)
+ if (access_check (temp, mode) == 0)
{
if (pl->used_flag_ptr != 0)
*pl->used_flag_ptr = 1;
strcpy (temp, pl->prefix);
strcat (temp, name);
- if (access (temp, mode) == 0)
+ if (access_check (temp, mode) == 0)
{
if (pl->used_flag_ptr != 0)
*pl->used_flag_ptr = 1;
char *string;
struct command
{
- char *prog; /* program name. */
- char **argv; /* vector of args. */
+ const char *prog; /* program name. */
+ const char **argv; /* vector of args. */
int pid; /* pid of process for this command. */
};
/* Print each piped command as a separate line. */
for (i = 0; i < n_commands ; i++)
{
- char **j;
+ const char **j;
for (j = commands[i].argv; *j; j++)
fprintf (stderr, " %s", *j);
}
fflush (stderr);
#ifdef DEBUG
- fprintf (stderr, "\nGo ahead? (y or n) ");
+ notice ("\nGo ahead? (y or n) ");
fflush (stderr);
i = getchar ();
if (i != '\n')
for (i = 0; i < n_commands; i++)
{
char *errmsg_fmt, *errmsg_arg;
- char *string = commands[i].argv[0];
+ const char *string = commands[i].argv[0];
commands[i].pid = pexecute (string, commands[i].argv,
programname, temp_filename,
pfatal_pexecute (errmsg_fmt, errmsg_arg);
if (string != commands[i].prog)
- free (string);
+ free ((PTR) string);
}
execution_count++;
{
int ret_code = 0;
+#ifdef HAVE_GETRUSAGE
+ struct timeval d;
+ double ut = 0.0, st = 0.0;
+#endif
for (i = 0; i < n_commands; )
{
if (pid < 0)
abort ();
+#ifdef HAVE_GETRUSAGE
+ if (report_times)
+ {
+ /* getrusage returns the total resource usage of all children
+ up to now. Copy the previous values into prus, get the
+ current statistics, then take the difference. */
+
+ prus = rus;
+ getrusage (RUSAGE_CHILDREN, &rus);
+ d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec;
+ d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec;
+ ut = (double)d.tv_sec + (double)d.tv_usec / 1.0e6;
+
+ d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec;
+ d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec;
+ st = (double)d.tv_sec + (double)d.tv_usec / 1.0e6;
+ }
+#endif
+
for (j = 0; j < n_commands; j++)
if (commands[j].pid == pid)
{
i++;
- if (status != 0)
+ if (WIFSIGNALED (status))
{
- if (WIFSIGNALED (status))
- {
- fatal ("Internal compiler error: program %s got fatal signal %d",
- commands[j].prog, WTERMSIG (status));
- signal_count++;
- ret_code = -1;
- }
- else if (WIFEXITED (status)
- && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
- ret_code = -1;
+#ifdef SIGPIPE
+ /* SIGPIPE is a special case. It happens in -pipe mode
+ when the compiler dies before the preprocessor is
+ done, or the assembler dies before the compiler is
+ done. There's generally been an error already, and
+ this is just fallout. So don't generate another error
+ unless we would otherwise have succeeded. */
+ if (WTERMSIG (status) == SIGPIPE
+ && (signal_count || greatest_status >= MIN_FATAL_STATUS))
+ ;
+ else
+#endif
+ fatal ("\
+Internal error: %s (program %s)\n\
+Please submit a full bug report.\n\
+See %s for instructions.",
+ strsignal (WTERMSIG (status)), commands[j].prog,
+ GCCBUGURL);
+ signal_count++;
+ ret_code = -1;
+ }
+ else if (WIFEXITED (status)
+ && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
+ {
+ if (WEXITSTATUS (status) > greatest_status)
+ greatest_status = WEXITSTATUS (status);
+ ret_code = -1;
}
+#ifdef HAVE_GETRUSAGE
+ if (report_times && ut + st != 0)
+ notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st);
+#endif
break;
}
}
If a switch uses following arguments, then the `part1' field
is the switch itself and the `args' field
is a null-terminated vector containing the following arguments.
- The `live_cond' field is 1 if the switch is true in a conditional spec,
- -1 if false (overridden by a later switch), and is initialized to zero.
- The `valid' field is nonzero if any spec has looked at this switch;
+ The `live_cond' field is:
+ 0 when initialized
+ 1 if the switch is true in a conditional spec,
+ -1 if false (overridden by a later switch)
+ -2 if this switch should be ignored (used in %{<S})
+ The `validated' field is nonzero if any spec has looked at this switch;
if it remains zero at the end of the run, it must be meaningless. */
+#define SWITCH_OK 0
+#define SWITCH_FALSE -1
+#define SWITCH_IGNORE -2
+#define SWITCH_LIVE 1
+
struct switchstr
{
- char *part1;
- char **args;
+ const char *part1;
+ const char **args;
int live_cond;
- int valid;
+ int validated;
};
static struct switchstr *switches;
struct infile
{
- char *name;
- char *language;
+ const char *name;
+ const char *language;
};
/* Also a vector of input files specified. */
static int n_infiles;
-/* This counts the number of libraries added by LANG_SPECIFIC_DRIVER, so that
+/* This counts the number of libraries added by lang_specific_driver, so that
we can tell if there were any user supplied any files or libraries. */
static int added_libraries;
/* And a vector of corresponding output files is made up later. */
-static char **outfiles;
+static const char **outfiles;
/* Used to track if none of the -B paths are used. */
static int warn_B;
int do_exe;
{
int i;
- int len = strlen (name);
+ int len;
+
+ if (name == NULL)
+ return NULL;
+
+ len = strlen (name);
#ifdef HAVE_OBJECT_SUFFIX
/* Convert x.o to x.obj if OBJECT_SUFFIX is ".obj". */
return name;
for (i = len - 1; i >= 0; i--)
- if (name[i] == '/' || name[i] == DIR_SEPARATOR)
+ if (IS_DIR_SEPARATOR (name[i]))
break;
for (i++; i < len; i++)
static void
display_help ()
{
- printf ("Usage: %s [options] file...\n", programname);
- printf ("Options:\n");
+ printf (_("Usage: %s [options] file...\n"), programname);
+ fputs (_("Options:\n"), stdout);
- printf (" --help Display this information\n");
+ fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
+ fputs (_(" --help Display this information\n"), stdout);
if (! verbose_flag)
- printf (" (Use '-v --help' to display command line options of sub-processes)\n");
- printf (" -dumpspecs Display all of the built in spec strings\n");
- printf (" -dumpversion Display the version of the compiler\n");
- printf (" -dumpmachine Display the compiler's target processor\n");
- printf (" -print-search-dirs Display the directories in the compiler's search path\n");
- printf (" -print-libgcc-file-name Display the name of the compiler's companion library\n");
- printf (" -print-file-name=<lib> Display the full path to library <lib>\n");
- printf (" -print-prog-name=<prog> Display the full path to compiler component <prog>\n");
- printf (" -print-multi-directory Display the root directory for versions of libgcc\n");
- printf (" -print-multi-lib Display the mapping between command line options and\n");
- printf (" multiple library search directories\n");
- printf (" -Wa,<options> Pass comma-separated <options> on to the assembler\n");
- printf (" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n");
- printf (" -Wl,<options> Pass comma-separated <options> on to the linker\n");
- printf (" -Xlinker <arg> Pass <arg> on to the linker\n");
- printf (" -save-temps Do not delete intermediate files\n");
- printf (" -pipe Use pipes rather than intermediate files\n");
- printf (" -specs=<file> Override builtin specs with the contents of <file>\n");
- printf (" -std=<standard> Assume that the input sources are for <standard>\n");
- printf (" -B <directory> Add <directory> to the compiler's search paths\n");
- printf (" -b <machine> Run gcc for target <machine>, if installed\n");
- printf (" -V <version> Run gcc version number <version>, if installed\n");
- printf (" -v Display the programs invoked by the compiler\n");
- printf (" -E Preprocess only; do not compile, assemble or link\n");
- printf (" -S Compile only; do not assemble or link\n");
- printf (" -c Compile and assemble, but do not link\n");
- printf (" -o <file> Place the output into <file>\n");
- printf (" -x <language> Specify the language of the following input files\n");
- printf (" Permissable languages include: c c++ assembler none\n");
- printf (" 'none' means revert to the default behaviour of\n");
- printf (" guessing the language based on the file's extension\n");
-
- printf ("\nOptions starting with -g, -f, -m, -O or -W are automatically passed on to\n");
- printf ("the various sub-processes invoked by %s. In order to pass other options\n",
- programname);
- printf ("on to these processes the -W<letter> options must be used.\n");
+ fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
+ fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
+ fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
+ fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
+ fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
+ fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
+ fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
+ fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
+ fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
+ fputs (_("\
+ -print-multi-lib Display the mapping between command line options and\n\
+ multiple library search directories\n"), stdout);
+ fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
+ fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
+ fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
+ fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
+ fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
+ fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
+ fputs (_(" -time Time the execution of each subprocess\n"), stdout);
+ fputs (_(" -specs=<file> Override builtin specs with the contents of <file>\n"), stdout);
+ fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
+ fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
+ fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout);
+ fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout);
+ fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
+ fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
+ fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
+ fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
+ fputs (_(" -o <file> Place the output into <file>\n"), stdout);
+ fputs (_("\
+ -x <language> Specify the language of the following input files\n\
+ Permissable languages include: c c++ assembler none\n\
+ 'none' means revert to the default behaviour of\n\
+ guessing the language based on the file's extension\n\
+"), stdout);
+
+ printf (_("\
+\nOptions starting with -g, -f, -m, -O or -W are automatically passed on to\n\
+the various sub-processes invoked by %s. In order to pass other options\n\
+on to these processes the -W<letter> options must be used.\n\
+"), programname);
/* The rest of the options are displayed by invocations of the various
sub-processes. */
static void
add_preprocessor_option (option, len)
- char * option;
- int len;
+ const char * option;
+ int len;
{
- n_preprocessor_options++;
+ n_preprocessor_options++;
- if (! preprocessor_options)
- preprocessor_options
- = (char **) xmalloc (n_preprocessor_options * sizeof (char *));
- else
- preprocessor_options
- = (char **) xrealloc (preprocessor_options,
- n_preprocessor_options * sizeof (char *));
+ if (! preprocessor_options)
+ preprocessor_options
+ = (char **) xmalloc (n_preprocessor_options * sizeof (char *));
+ else
+ preprocessor_options
+ = (char **) xrealloc (preprocessor_options,
+ n_preprocessor_options * sizeof (char *));
- preprocessor_options [n_preprocessor_options - 1] = save_string (option, len);
+ preprocessor_options [n_preprocessor_options - 1] =
+ save_string (option, len);
}
static void
add_assembler_option (option, len)
- char * option;
- int len;
-{
- n_assembler_options++;
-
- if (! assembler_options)
- assembler_options
- = (char **) xmalloc (n_assembler_options * sizeof (char *));
- else
- assembler_options
- = (char **) xrealloc (assembler_options,
- n_assembler_options * sizeof (char *));
-
- assembler_options [n_assembler_options - 1] = save_string (option, len);
+ const char * option;
+ int len;
+{
+ n_assembler_options++;
+
+ if (! assembler_options)
+ assembler_options
+ = (char **) xmalloc (n_assembler_options * sizeof (char *));
+ else
+ assembler_options
+ = (char **) xrealloc (assembler_options,
+ n_assembler_options * sizeof (char *));
+
+ assembler_options [n_assembler_options - 1] = save_string (option, len);
}
static void
add_linker_option (option, len)
- char * option;
- int len;
-{
- n_linker_options++;
-
- if (! linker_options)
- linker_options
- = (char **) xmalloc (n_linker_options * sizeof (char *));
- else
- linker_options
- = (char **) xrealloc (linker_options,
- n_linker_options * sizeof (char *));
-
- linker_options [n_linker_options - 1] = save_string (option, len);
+ const char * option;
+ int len;
+{
+ n_linker_options++;
+
+ if (! linker_options)
+ linker_options
+ = (char **) xmalloc (n_linker_options * sizeof (char *));
+ else
+ linker_options
+ = (char **) xrealloc (linker_options,
+ n_linker_options * sizeof (char *));
+
+ linker_options [n_linker_options - 1] = save_string (option, len);
}
\f
/* Create the vector `switches' and its contents.
static void
process_command (argc, argv)
int argc;
- char **argv;
+ const char **argv;
{
register int i;
- char *temp;
- char *spec_lang = 0;
+ const char *temp;
+ char *temp1;
+ const char *spec_lang = 0;
int last_language_n_infiles;
int have_c = 0;
int have_o = 0;
/* Figure compiler version from version string. */
- compiler_version = save_string (version_string, strlen (version_string));
- for (temp = compiler_version; *temp; ++temp)
+ compiler_version = temp1 = xstrdup (version_string);
+
+ for (; *temp1; ++temp1)
{
- if (*temp == ' ')
+ if (*temp1 == ' ')
{
- *temp = '\0';
+ *temp1 = '\0';
break;
}
}
- /* Set up the default search paths. */
+ /* 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]. */
+
+#ifndef VMS
+ /* FIXME: make_relative_prefix doesn't yet work for VMS. */
+ if (!gcc_exec_prefix)
+ {
+ gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
+ standard_exec_prefix);
+ if (gcc_exec_prefix)
+ putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL_PTR));
+ }
+#endif
if (gcc_exec_prefix)
{
int len = strlen (gcc_exec_prefix);
if (len > (int) sizeof ("/lib/gcc-lib/")-1
- && (gcc_exec_prefix[len-1] == '/'
- || gcc_exec_prefix[len-1] == DIR_SEPARATOR))
+ && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
{
temp = gcc_exec_prefix + len - sizeof ("/lib/gcc-lib/") + 1;
- if ((*temp == '/' || *temp == DIR_SEPARATOR)
+ if (IS_DIR_SEPARATOR (*temp)
&& strncmp (temp+1, "lib", 3) == 0
- && (temp[4] == '/' || temp[4] == DIR_SEPARATOR)
+ && IS_DIR_SEPARATOR (temp[4])
&& strncmp (temp+5, "gcc-lib", 7) == 0)
len -= sizeof ("/lib/gcc-lib/") - 1;
}
GET_ENV_PATH_LIST (temp, "COMPILER_PATH");
if (temp)
{
- char *startp, *endp;
+ const char *startp, *endp;
char *nstore = (char *) alloca (strlen (temp) + 3);
startp = endp = temp;
strncpy (nstore, startp, endp-startp);
if (endp == startp)
strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
- else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR)
+ else if (!IS_DIR_SEPARATOR (endp[-1]))
{
nstore[endp-startp] = DIR_SEPARATOR;
nstore[endp-startp+1] = 0;
}
}
- GET_ENV_PATH_LIST (temp, "LIBRARY_PATH");
+ GET_ENV_PATH_LIST (temp, LIBRARY_PATH_ENV);
if (temp && *cross_compile == '0')
{
- char *startp, *endp;
+ const char *startp, *endp;
char *nstore = (char *) alloca (strlen (temp) + 3);
startp = endp = temp;
strncpy (nstore, startp, endp-startp);
if (endp == startp)
strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
- else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR)
+ else if (!IS_DIR_SEPARATOR (endp[-1]))
{
nstore[endp-startp] = DIR_SEPARATOR;
nstore[endp-startp+1] = 0;
GET_ENV_PATH_LIST (temp, "LPATH");
if (temp && *cross_compile == '0')
{
- char *startp, *endp;
+ const char *startp, *endp;
char *nstore = (char *) alloca (strlen (temp) + 3);
startp = endp = temp;
strncpy (nstore, startp, endp-startp);
if (endp == startp)
strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
- else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR)
+ else if (!IS_DIR_SEPARATOR (endp[-1]))
{
nstore[endp-startp] = DIR_SEPARATOR;
nstore[endp-startp+1] = 0;
/* Convert new-style -- options to old-style. */
translate_options (&argc, &argv);
-#ifdef LANG_SPECIFIC_DRIVER
/* Do language-specific adjustment/addition of flags. */
- lang_specific_driver (fatal, &argc, &argv, &added_libraries);
-#endif
+ lang_specific_driver (&argc, &argv, &added_libraries);
/* 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.
init_spec ();
for (sl = specs; sl; sl = sl->next)
printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
+ if (link_command_spec)
+ printf ("*link_command:\n%s\n\n", link_command_spec);
exit (0);
}
else if (! strcmp (argv[i], "-dumpversion"))
add_assembler_option ("--help", 6);
add_linker_option ("--help", 6);
}
+ else if (! strcmp (argv[i], "-pass-exit-codes"))
+ {
+ pass_exit_codes = 1;
+ n_switches++;
+ }
else if (! strcmp (argv[i], "-print-search-dirs"))
print_search_dirs = 1;
else if (! strcmp (argv[i], "-print-libgcc-file-name"))
user_specs_head = user;
user_specs_tail = user;
}
+ else if (strcmp (argv[i], "-time") == 0)
+ report_times = 1;
else if (argv[i][0] == '-' && argv[i][1] != 0)
{
- register char *p = &argv[i][1];
+ register const char *p = &argv[i][1];
register int c = *p;
switch (c)
case 'B':
{
- char *value;
+ const char *value;
if (p[1] == 0 && i + 1 == argc)
fatal ("argument to `-B' is missing");
if (p[1] == 0)
int len = strlen (value);
if ((len == 7
|| (len > 7
- && (value[len - 8] == '/'
- || value[len - 8] == DIR_SEPARATOR)))
+ && (IS_DIR_SEPARATOR (value[len - 8]))))
&& strncmp (value + len - 7, "stage", 5) == 0
&& ISDIGIT (value[len - 2])
- && (value[len - 1] == '/'
- || value[len - 1] == DIR_SEPARATOR))
+ && (IS_DIR_SEPARATOR (value[len - 1])))
{
if (len == 7)
add_prefix (&include_prefixes, "include", NULL_PTR,
The format of the version string is
([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
{
- char *v = compiler_version;
+ const char *v = compiler_version;
/* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
while (! ISDIGIT (*v))
/* Use 2 as fourth arg meaning try just the machine as a suffix,
as well as trying the machine and the version. */
#ifndef OS2
+ add_prefix (&exec_prefixes, standard_exec_prefix, "GCC",
+ 0, 1, warn_std_ptr);
add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
0, 2, warn_std_ptr);
add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
directories, so that we can search both the user specified directory
and the standard place. */
- if (*tooldir_prefix != '/' && *tooldir_prefix != DIR_SEPARATOR)
+ if (!IS_DIR_SEPARATOR (*tooldir_prefix))
{
if (gcc_exec_prefix)
{
;
else if (! strncmp (argv[i], "-Wp,", 4))
;
+ else if (! strcmp (argv[i], "-pass-exit-codes"))
+ ;
else if (! strcmp (argv[i], "-print-search-dirs"))
;
else if (! strcmp (argv[i], "-print-libgcc-file-name"))
cc1 spec string. */
switches[n_switches].part1 = "--help";
switches[n_switches].args = 0;
- switches[n_switches].live_cond = 0;
- switches[n_switches].valid = 0;
+ switches[n_switches].live_cond = SWITCH_OK;
+ switches[n_switches].validated = 0;
n_switches++;
}
-e0 or -e1 down into the linker. */
switches[n_switches].part1 = &argv[i][0];
switches[n_switches].args = 0;
- switches[n_switches].live_cond = 0;
- switches[n_switches].valid = 0;
+ switches[n_switches].live_cond = SWITCH_OK;
+ switches[n_switches].validated = 0;
n_switches++;
}
else if (strncmp (argv[i], "-Wl,", 4) == 0)
i++;
else if (strncmp (argv[i], "-specs=", 7) == 0)
;
- /* -save-temps overrides -pipe, so that temp files are produced */
- else if (save_temps_flag && strcmp (argv[i], "-pipe") == 0)
- error ("Warning: -pipe ignored since -save-temps specified");
+ else if (strcmp (argv[i], "-time") == 0)
+ ;
+ else if ((save_temps_flag || report_times)
+ && strcmp (argv[i], "-pipe") == 0)
+ {
+ /* -save-temps overrides -pipe, so that temp files are produced */
+ if (save_temps_flag)
+ error ("Warning: -pipe ignored since -save-temps specified");
+ /* -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 since -time specified");
+ }
else if (argv[i][0] == '-' && argv[i][1] != 0)
{
- register char *p = &argv[i][1];
- register int c = *p;
+ const char *p = &argv[i][1];
+ int c = *p;
if (c == 'x')
{
if (i + n_args >= argc)
fatal ("argument to `-%s' is missing", p);
switches[n_switches].args
- = (char **) xmalloc ((n_args + 1) * sizeof (char *));
+ = (const char **) xmalloc ((n_args + 1) * sizeof(const char *));
while (j < n_args)
switches[n_switches].args[j++] = argv[++i];
/* Null-terminate the vector. */
/* On some systems, ld cannot handle some options without
a space. So split the option from its argument. */
char *part1 = (char *) xmalloc (2);
+ char *tmp;
part1[0] = c;
part1[1] = '\0';
switches[n_switches].part1 = part1;
- switches[n_switches].args = (char **) xmalloc (2 * sizeof (char *));
- switches[n_switches].args[0] = xmalloc (strlen (p));
- strcpy (switches[n_switches].args[0], &p[1]);
+ switches[n_switches].args
+ = (const char **) xmalloc (2 * sizeof (const char *));
+ switches[n_switches].args[0] = tmp = xmalloc (strlen (p));
+ strcpy (tmp, &p[1]);
switches[n_switches].args[1] = 0;
}
else
switches[n_switches].args = 0;
- switches[n_switches].live_cond = 0;
- switches[n_switches].valid = 0;
+ switches[n_switches].live_cond = SWITCH_OK;
+ switches[n_switches].validated = 0;
/* This is always valid, since gcc.c itself understands it. */
if (!strcmp (p, "save-temps"))
- switches[n_switches].valid = 1;
+ switches[n_switches].validated = 1;
else
{
char ch = switches[n_switches].part1[0];
if (ch == 'V' || ch == 'b' || ch == 'B')
- switches[n_switches].valid = 1;
+ switches[n_switches].validated = 1;
}
n_switches++;
}
sans all directory names, and basename_length is the number
of characters starting there excluding the suffix .c or whatever. */
-char *input_filename;
+const char *input_filename;
static int input_file_number;
size_t input_filename_length;
static int basename_length;
-static char *input_basename;
-static char *input_suffix;
+static int suffixed_basename_length;
+static const char *input_basename;
+static const char *input_suffix;
/* These are variables used within do_spec and do_spec_1. */
int
do_spec (spec)
- char *spec;
+ const char *spec;
{
int value;
static int
do_spec_1 (spec, inswitch, soft_matched_part)
- char *spec;
+ const char *spec;
int inswitch;
- char *soft_matched_part;
+ const char *soft_matched_part;
{
- register char *p = spec;
+ register const char *p = spec;
register int c;
int i;
- char *string;
+ const char *string;
int value;
while ((c = *p++))
if (i < n_switches)
{
input_from_pipe = 1;
- switches[i].valid = 1;
+ switches[i].validated = 1;
break;
}
else
arg_going = 1;
break;
+ case 'B':
+ obstack_grow (&obstack, input_basename, suffixed_basename_length);
+ arg_going = 1;
+ break;
+
case 'd':
delete_this_arg = 2;
break;
and use them to search for dynamic linking. */
/* Relative directories always come from -B,
and it is better not to use them for searching
- at run time. In particular, stage1 loses */
- if (pl->prefix[0] != '/' && pl->prefix[0] != DIR_SEPARATOR)
+ at run time. In particular, stage1 loses. */
+ if (!IS_DIR_SEPARATOR (pl->prefix[0]))
continue;
#endif
/* Try subdirectory if there is one. */
buffer = (char *) xrealloc (buffer, bufsize);
strcpy (buffer, machine_suffix);
idx = strlen (buffer);
- if (buffer[idx - 1] == '/'
- || buffer[idx - 1] == DIR_SEPARATOR)
+ if (IS_DIR_SEPARATOR (buffer[idx - 1]))
buffer[idx - 1] = 0;
do_spec_1 (buffer, 1, NULL_PTR);
/* Make this a separate argument. */
buffer = (char *) xrealloc (buffer, bufsize);
strcpy (buffer, pl->prefix);
idx = strlen (buffer);
- if (buffer[idx - 1] == '/'
- || buffer[idx - 1] == DIR_SEPARATOR)
+ if (IS_DIR_SEPARATOR (buffer[idx - 1]))
buffer[idx - 1] = 0;
do_spec_1 (buffer, 1, NULL_PTR);
/* Make this a separate argument. */
break;
case 'e':
- /* {...:%efoo} means report an error with `foo' as error message
+ /* %efoo means report an error with `foo' as error message
and don't execute any more commands for this file. */
{
- char *q = p;
+ const char *q = p;
char *buf;
while (*p != 0 && *p != '\n') p++;
buf = (char *) alloca (p - q + 1);
In 2.4, do something about that. */
struct temp_name *t;
int suffix_length;
- char *suffix = p;
+ const char *suffix = p;
+ char *saved_suffix = NULL;
+ while (*p == '.' || ISALPHA ((unsigned char)*p))
+ p++;
+ suffix_length = p - suffix;
if (p[0] == '%' && p[1] == 'O')
{
p += 2;
/* We don't support extra suffix characters after %O. */
if (*p == '.' || ISALPHA ((unsigned char)*p))
abort ();
- suffix = OBJECT_SUFFIX;
- suffix_length = strlen (OBJECT_SUFFIX);
- }
- else
- {
- while (*p == '.' || ISALPHA ((unsigned char)*p))
- p++;
- suffix_length = p - suffix;
+ if (suffix_length == 0)
+ suffix = OBJECT_SUFFIX;
+ else
+ {
+ saved_suffix
+ = (char *) xmalloc (suffix_length
+ + strlen (OBJECT_SUFFIX));
+ strncpy (saved_suffix, suffix, suffix_length);
+ strcpy (saved_suffix + suffix_length,
+ OBJECT_SUFFIX);
+ }
+ suffix_length += strlen (OBJECT_SUFFIX);
}
/* See if we already have an association of %g/%u/%U and
t->filename_length = temp_filename_length;
}
+ if (saved_suffix)
+ free (saved_suffix);
+
obstack_grow (&obstack, t->filename, t->filename_length);
delete_this_arg = 1;
#else
case 'o':
{
int max = n_infiles;
-#ifdef LANG_SPECIFIC_DRIVER
max += lang_specific_extra_outfiles;
-#endif
+
for (i = 0; i < max; i++)
if (outfiles[i])
store_arg (outfiles[i], 0, 0);
/* %x{OPTION} records OPTION for %X to output. */
case 'x':
{
- char *p1 = p;
+ const char *p1 = p;
char *string;
/* Skip past the option value and make a copy. */
{
char *x = (char *) alloca (strlen (cpp_predefines) + 1);
char *buf = x;
- char *y;
+ const char *y;
/* Copy all of the -D options in CPP_PREDEFINES into BUF. */
y = cpp_predefines;
{
char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
char *buf = x;
- char *y;
+ const char *y;
/* Copy all of CPP_PREDEFINES into BUF,
- but put __ after every -D and at the end of each arg. */
+ but force them all into the reserved name space if they
+ aren't already there. The reserved name space is all
+ identifiers beginning with two underscores or with one
+ underscore and a capital letter. We do the forcing by
+ adding up to two underscores to the beginning and end
+ of each symbol. e.g. mips, _mips, mips_, and _mips_ all
+ become __mips__. */
y = cpp_predefines;
while (*y != 0)
{
&& ! ISUPPER ((unsigned char)*(y+1))))
{
/* Stick __ at front of macro name. */
- *x++ = '_';
+ if (*y != '_')
+ *x++ = '_';
*x++ = '_';
/* Arrange to stick __ at the end as well. */
flag = 1;
if (flag)
{
- *x++ = '_';
- *x++ = '_';
+ if (x[-1] != '_')
+ {
+ if (x[-2] != '_')
+ *x++ = '_';
+ *x++ = '_';
+ }
}
/* Copy the value given, if any. */
/* Stick -D__ at front of macro name. */
*x++ = '-';
*x++ = 'D';
- *x++ = '_';
+ if (*y != '_')
+ *x++ = '_';
*x++ = '_';
/* Copy the macro name. */
else if (*y == ' ' || *y == '\t')
/* Copy whitespace to the result. */
*x++ = *y++;
- /* Don't copy -A options */
+ /* Don't copy -A options. */
else
y++;
}
break;
case '*':
- do_spec_1 (soft_matched_part, 1, NULL_PTR);
- do_spec_1 (" ", 0, NULL_PTR);
+ if (soft_matched_part)
+ {
+ do_spec_1 (soft_matched_part, 1, NULL_PTR);
+ do_spec_1 (" ", 0, NULL_PTR);
+ }
+ else
+ /* Catch the case where a spec string contains something like
+ '%{foo:%*}'. ie there is no * in the pattern on the left
+ hand side of the :. */
+ error ("Spec failure: '%%*' has not been initialised by pattern match");
break;
/* Process a string found as the value of a spec given by name.
error ("Warning: use of obsolete %%[ operator in specs");
case '(':
{
- char *name = p;
+ const char *name = p;
struct spec_list *sl;
int len;
while (*p && *p != ')' && *p != ']')
p++;
- /* See if it's in the list */
+ /* See if it's in the list. */
for (len = p - name, sl = specs; sl; sl = sl->next)
if (sl->name_len == len && !strncmp (sl->name, name, len))
{
name = *(sl->ptr_spec);
#ifdef DEBUG_SPECS
- fprintf (stderr, "Processing spec %c%s%c, which is '%s'\n",
- c, sl->name, (c == '(') ? ')' : ']', name);
+ notice ("Processing spec %c%s%c, which is '%s'\n",
+ c, sl->name, (c == '(') ? ')' : ']', name);
#endif
break;
}
{
char *x = (char *) alloca (strlen (name) * 2 + 1);
char *buf = x;
- char *y = name;
+ const char *y = name;
int flag = 0;
/* Copy all of NAME into BUF, but put __ after
- every -D and at the end of each arg, */
+ every -D and at the end of each arg. */
while (1)
{
if (! strncmp (y, "-D", 2))
case 'v':
{
int c1 = *p++; /* Select first or second version number. */
- char *v = compiler_version;
- char *q;
+ const char *v = compiler_version;
+ const char *q;
+ static const char zeroc = '0';
/* The format of the version string is
([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
abort ();
/* If desired, advance to second version number. */
- if (c1 == '2')
+ if (c1 >= '2')
{
/* Set V after the first period. */
while (ISDIGIT (*v))
v++;
}
+ /* If desired, advance to third version number.
+ But don't complain if it's not present */
+ if (c1 == '3')
+ {
+ /* Set V after the second period. */
+ while (ISDIGIT (*v))
+ v++;
+ if ((*v != 0) && (*v != ' ') && (*v != '.') && (*v != '-'))
+ abort ();
+ if (*v != 0)
+ v++;
+ }
+
/* Set Q at the next period or at the end. */
q = v;
while (ISDIGIT (*q))
q++;
- if (*q != 0 && *q != ' ' && *q != '.' && *q != '-')
+ if (*q != 0 && q > v && *q != ' ' && *q != '.' && *q != '-')
abort ();
- /* Put that part into the command. */
- obstack_grow (&obstack, v, q - v);
+ if (q > v)
+ /* Put that part into the command. */
+ obstack_grow (&obstack, v, q - v);
+ else
+ /* Default to "0" */
+ obstack_grow (&obstack, &zeroc, 1);
arg_going = 1;
}
break;
break;
default:
- abort ();
+ error ("Spec failure: Unrecognised spec option '%c'", c);
+ break;
}
break;
/* Return 0 if we call do_spec_1 and that returns -1. */
-static char *
+static const char *
handle_braces (p)
- register char *p;
+ register const char *p;
{
- char *filter, *body = NULL, *endbody;
+ const char *filter, *body = NULL, *endbody = NULL;
int pipe_p = 0;
int negate;
int suffix;
int include_blanks = 1;
+ int elide_switch = 0;
if (*p == '^')
- /* A '^' after the open-brace means to not give blanks before args. */
- include_blanks = 0, ++p;
+ {
+ /* A '^' after the open-brace means to not give blanks before args. */
+ include_blanks = 0;
+ ++p;
+ }
if (*p == '|')
- /* A `|' after the open-brace means,
- if the test fails, output a single minus sign rather than nothing.
- This is used in %{|!pipe:...}. */
- pipe_p = 1, ++p;
+ {
+ /* A `|' after the open-brace means,
+ if the test fails, output a single minus sign rather than nothing.
+ This is used in %{|!pipe:...}. */
+ pipe_p = 1;
+ ++p;
+ }
+
+ if (*p == '<')
+ {
+ /* A `<' after the open-brace means that the switch should be
+ removed from the command-line. */
+ elide_switch = 1;
+ ++p;
+ }
next_member:
negate = suffix = 0;
++p;
}
+ if (elide_switch && (negate || pipe_p || suffix))
+ {
+ /* It doesn't make sense to mix elision with other flags. We
+ could fatal() here, but the standard seems to be to abort. */
+ abort ();
+ }
+
filter = p;
while (*p != ':' && *p != '}' && *p != '|') p++;
if (*p != '}')
{
register int count = 1;
- register char *q = p;
+ register const char *q = p;
while (*q++ != ':') continue;
body = q;
if (p[-1] == '*' && !negate)
{
int substitution;
- char *r = body;
+ const char *r = body;
/* First see whether we have %*. */
substitution = 0;
&& check_live_switch (i, hard_match_len))
{
present = 1;
+ break;
}
}
}
conditional text. */
if (present != negate)
{
- if (*p == '}')
+ if (elide_switch)
+ {
+ switches[i].live_cond = SWITCH_IGNORE;
+ switches[i].validated = 1;
+ }
+ else if (*p == '}')
{
give_switch (i, 0, include_blanks);
}
int switchnum;
int prefix_length;
{
- char *name = switches[switchnum].part1;
+ const char *name = switches[switchnum].part1;
int i;
/* In the common case of {<at-most-one-letter>*}, a negating
for (i = switchnum + 1; i < n_switches; i++)
if (switches[i].part1[0] == 'O')
{
- switches[switchnum].valid = 1;
- switches[switchnum].live_cond = -1;
+ switches[switchnum].validated = 1;
+ switches[switchnum].live_cond = SWITCH_FALSE;
return 0;
}
break;
if (switches[i].part1[0] == name[0]
&& ! strcmp (&switches[i].part1[1], &name[4]))
{
- switches[switchnum].valid = 1;
- switches[switchnum].live_cond = -1;
+ switches[switchnum].validated = 1;
+ switches[switchnum].live_cond = SWITCH_FALSE;
return 0;
}
}
&& switches[i].part1[3] == '-'
&& !strcmp (&switches[i].part1[4], &name[1]))
{
- switches[switchnum].valid = 1;
- switches[switchnum].live_cond = -1;
+ switches[switchnum].validated = 1;
+ switches[switchnum].live_cond = SWITCH_FALSE;
return 0;
}
}
}
/* Otherwise the switch is live. */
- switches[switchnum].live_cond = 1;
+ switches[switchnum].live_cond = SWITCH_LIVE;
return 1;
}
\f
int omit_first_word;
int include_blanks;
{
+ if (switches[switchnum].live_cond == SWITCH_IGNORE)
+ return;
+
if (!omit_first_word)
{
do_spec_1 ("-", 0, NULL_PTR);
if (switches[switchnum].args != 0)
{
- char **p;
+ const char **p;
for (p = switches[switchnum].args; *p; p++)
{
if (include_blanks)
}
do_spec_1 (" ", 0, NULL_PTR);
- switches[switchnum].valid = 1;
+ switches[switchnum].validated = 1;
}
\f
/* Search for a file named NAME trying various prefixes including the
user's -B prefix and some standard ones.
Return the absolute file name found. If nothing is found, return NAME. */
-static char *
+static const char *
find_file (name)
- char *name;
+ const char *name;
{
char *newname;
static int
is_directory (path1, path2, linker)
- char *path1;
- char *path2;
+ const char *path1;
+ const char *path2;
int linker;
{
int len1 = strlen (path1);
memcpy (path, path1, len1);
memcpy (path + len1, path2, len2);
cp = path + len1 + len2;
- if (cp[-1] != '/' && cp[-1] != DIR_SEPARATOR)
+ if (!IS_DIR_SEPARATOR (cp[-1]))
*cp++ = DIR_SEPARATOR;
*cp++ = '.';
*cp = '\0';
return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
}
+
+/* Set up the various global variables to indicate that we're processing
+ the input file named FILENAME. */
+
+static void
+set_input (filename)
+ const char *filename;
+{
+ register const char *p;
+
+ input_filename = filename;
+ input_filename_length = strlen (input_filename);
+
+ input_basename = input_filename;
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+ /* Skip drive name so 'x:foo' is handled properly. */
+ if (input_basename[1] == ':')
+ input_basename += 2;
+#endif
+ for (p = input_basename; *p; p++)
+ if (IS_DIR_SEPARATOR (*p))
+ input_basename = p + 1;
+
+ /* Find a suffix starting with the last period,
+ and set basename_length to exclude that suffix. */
+ basename_length = strlen (input_basename);
+ suffixed_basename_length = basename_length;
+ p = input_basename + basename_length;
+ while (p != input_basename && *p != '.') --p;
+ if (*p == '.' && p != input_basename)
+ {
+ basename_length = p - input_basename;
+ input_suffix = p + 1;
+ }
+ else
+ input_suffix = "";
+}
\f
/* On fatal signals, delete all the temporary files. */
kill (getpid (), signum);
}
+extern int main PARAMS ((int, char **));
+
int
main (argc, argv)
int argc;
char **argv;
{
- register size_t i;
- size_t j;
+ size_t i;
int value;
int linker_was_run = 0;
char *explicit_link_files;
char *specs_file;
- char *p;
+ const char *p;
struct user_specs *uptr;
p = argv[0] + strlen (argv[0]);
- while (p != argv[0] && p[-1] != '/' && p[-1] != DIR_SEPARATOR) --p;
+ while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
+ --p;
programname = p;
+#ifdef HAVE_LC_MESSAGES
+ setlocale (LC_MESSAGES, "");
+#endif
+ (void) bindtextdomain (PACKAGE, localedir);
+ (void) textdomain (PACKAGE);
+
if (signal (SIGINT, SIG_IGN) != SIG_IGN)
signal (SIGINT, fatal_error);
#ifdef SIGHUP
#endif
argbuf_length = 10;
- argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
+ argbuf = (const char **) xmalloc (argbuf_length * sizeof (const char *));
obstack_init (&obstack);
/* Build multilib_select, et. al from the separate lines that make up each
multilib selection. */
{
- char **q = multilib_raw;
+ const char *const *q = multilib_raw;
int need_space;
obstack_init (&multilib_obstack);
obstack_1grow (&multilib_obstack, 0);
multilib_matches = obstack_finish (&multilib_obstack);
+ q = multilib_exclusions_raw;
+ while ((p = *q++) != (char *) 0)
+ obstack_grow (&multilib_obstack, p, strlen (p));
+
+ obstack_1grow (&multilib_obstack, 0);
+ multilib_exclusions = obstack_finish (&multilib_obstack);
+
need_space = FALSE;
for (i = 0;
i < sizeof (multilib_defaults_raw) / sizeof (multilib_defaults_raw[0]);
first_time = TRUE;
for (i = 0; (int)i < n_switches; i++)
{
- char **args;
- char *p, *q;
+ const char **args;
+ const char *p, *q;
if (!first_time)
obstack_grow (&collect_obstack, " ", 1);
init_spec ();
/* We need to check standard_exec_prefix/just_machine_suffix/specs
- for any override of as, ld and libraries. */
+ for any override of as, ld and libraries. */
specs_file = (char *) alloca (strlen (standard_exec_prefix)
+ strlen (just_machine_suffix)
+ sizeof ("specs"));
if (access (specs_file, R_OK) == 0)
read_specs (specs_file, TRUE);
- /* Process any user specified specs in the order given on the command
- line. */
- for (uptr = user_specs_head; uptr; uptr = uptr->next)
- {
- char *filename = find_a_file (&startfile_prefixes, uptr->filename, R_OK);
- read_specs (filename ? filename : uptr->filename, FALSE);
- }
-
/* If not cross-compiling, look for startfiles in the standard places. */
- /* The fact that these are done here, after reading the specs file,
- means that it cannot be found in these directories.
- But that's okay. It should never be there anyway. */
if (*cross_compile == '0')
{
#ifdef MD_EXEC_PREFIX
standard_exec_prefix. This lets us move the installed tree
as a unit. If GCC_EXEC_PREFIX is defined, base
standard_startfile_prefix on that as well. */
- if (*standard_startfile_prefix == '/'
- || *standard_startfile_prefix == DIR_SEPARATOR
- || *standard_startfile_prefix == '$'
-#ifdef __MSDOS__
- /* Check for disk name on MS-DOS-based systems. */
+ if (IS_DIR_SEPARATOR (*standard_startfile_prefix)
+ || *standard_startfile_prefix == '$'
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+ /* Check for disk name on MS-DOS-based systems. */
|| (standard_startfile_prefix[1] == ':'
- && (standard_startfile_prefix[2] == DIR_SEPARATOR
- || standard_startfile_prefix[2] == '/'))
+ && (IS_DIR_SEPARATOR (standard_startfile_prefix[2])))
#endif
)
add_prefix (&startfile_prefixes, standard_startfile_prefix, "BINUTILS",
}
else
{
- if (*standard_startfile_prefix != DIR_SEPARATOR && gcc_exec_prefix)
+ if (!IS_DIR_SEPARATOR (*standard_startfile_prefix) && gcc_exec_prefix)
add_prefix (&startfile_prefixes,
concat (gcc_exec_prefix, machine_suffix,
standard_startfile_prefix, NULL_PTR),
"BINUTILS", 0, 0, NULL_PTR);
}
+ /* Process any user specified specs in the order given on the command
+ line. */
+ for (uptr = user_specs_head; uptr; uptr = uptr->next)
+ {
+ char *filename = find_a_file (&startfile_prefixes, uptr->filename, R_OK);
+ read_specs (filename ? filename : uptr->filename, FALSE);
+ }
+
/* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
if (gcc_exec_prefix)
{
/* Warn about any switches that no pass was interested in. */
for (i = 0; (int)i < n_switches; i++)
- if (! switches[i].valid)
+ if (! switches[i].validated)
error ("unrecognized option `-%s'", switches[i].part1);
/* Obey some of the options. */
if (print_search_dirs)
{
- printf ("install: %s%s\n", standard_exec_prefix, machine_suffix);
- printf ("programs: %s\n", build_search_list (&exec_prefixes, "", 0));
- printf ("libraries: %s\n", build_search_list (&startfile_prefixes, "", 0));
- exit (0);
+ printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix);
+ printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0));
+ printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0));
+ return (0);
}
if (print_file_name)
{
printf ("%s\n", find_file (print_file_name));
- exit (0);
+ return (0);
}
if (print_prog_name)
{
char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK);
printf ("%s\n", (newname ? newname : print_prog_name));
- exit (0);
+ return (0);
}
if (print_multi_lib)
{
print_multilib_info ();
- exit (0);
+ return (0);
}
if (print_multi_directory)
printf (".\n");
else
printf ("%s\n", multilib_dir);
- exit (0);
+ return (0);
}
if (print_help_list)
if (! verbose_flag)
{
- printf ("\nReport bugs to egcs-bugs@cygnus.com.\n");
- printf ("Please see the file BUGS (included with the sources) first.\n");
+ printf (_("\nFor bug reporting instructions, please see:\n"));
+ printf ("%s.\n", GCCBUGURL);
- exit (0);
+ return (0);
}
/* We do not exit here. Instead we have created a fake input file
if (! strncmp (version_string, compiler_version, n)
&& compiler_version[n] == 0)
- fprintf (stderr, "gcc version %s\n", version_string);
+ notice ("gcc version %s\n", version_string);
else
- fprintf (stderr, "gcc driver version %s executing gcc version %s\n",
- version_string, compiler_version);
+ notice ("gcc driver version %s executing gcc version %s\n",
+ version_string, compiler_version);
if (n_infiles == 0)
- exit (0);
+ return (0);
}
if (n_infiles == added_libraries)
that correspond to the input files. */
i = n_infiles;
-#ifdef LANG_SPECIFIC_DRIVER
i += lang_specific_extra_outfiles;
-#endif
- outfiles = (char **) xmalloc (i * sizeof (char *));
- bzero ((char *) outfiles, i * sizeof (char *));
+ outfiles = (const char **) xcalloc (i, sizeof (char *));
/* Record which files were specified explicitly as link input. */
- explicit_link_files = xmalloc (n_infiles);
- bzero (explicit_link_files, n_infiles);
+ explicit_link_files = xcalloc (1, n_infiles);
for (i = 0; (int)i < n_infiles; i++)
{
/* Tell do_spec what to substitute for %i. */
- input_filename = infiles[i].name;
- input_filename_length = strlen (input_filename);
input_file_number = i;
+ set_input (infiles[i].name);
/* Use the same thing in %o, unless cp->spec says otherwise. */
if (cp)
{
/* Ok, we found an applicable compiler. Run its spec. */
- /* First say how much of input_filename to substitute for %b */
- register char *p;
- int len;
- if (cp->spec[0][0] == '#')
+ if (cp->spec[0] == '#')
error ("%s: %s compiler not installed on this system",
- input_filename, &cp->spec[0][1]);
-
- input_basename = input_filename;
- for (p = input_filename; *p; p++)
- if (*p == '/' || *p == DIR_SEPARATOR)
- input_basename = p + 1;
-
- /* Find a suffix starting with the last period,
- and set basename_length to exclude that suffix. */
- basename_length = strlen (input_basename);
- p = input_basename + basename_length;
- while (p != input_basename && *p != '.') --p;
- if (*p == '.' && p != input_basename)
- {
- basename_length = p - input_basename;
- input_suffix = p + 1;
- }
- else
- input_suffix = "";
-
- len = 0;
- for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
- if (cp->spec[j])
- len += strlen (cp->spec[j]);
-
- p = (char *) xmalloc (len + 1);
-
- len = 0;
- for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
- if (cp->spec[j])
- {
- strcpy (p + len, cp->spec[j]);
- len += strlen (cp->spec[j]);
- }
-
- value = do_spec (p);
- free (p);
+ input_filename, &cp->spec[1]);
+ value = do_spec (cp->spec);
if (value < 0)
this_file_error = 1;
}
clear_failure_queue ();
}
-#ifdef LANG_SPECIFIC_DRIVER
+ /* Reset the output file name to the first input file name, for use
+ with %b in LINK_SPEC on a target that prefers not to emit a.out
+ by default. */
+ if (n_infiles > 0)
+ set_input (infiles[0].name);
+
if (error_count == 0)
{
/* Make sure INPUT_FILE_NUMBER points to first available open
if (lang_specific_pre_link ())
error_count++;
}
-#endif
/* Run ld to link all the compiler output files. */
}
/* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
for collect. */
- putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH=");
- putenv_from_prefixes (&startfile_prefixes, "LIBRARY_PATH=");
+ putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH");
+ putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV);
value = do_spec (link_command_spec);
if (value < 0)
if (print_help_list)
{
- printf ("\nReport bugs to egcs-bugs@cygnus.com.\n");
- printf ("Please see the file BUGS (included with the sources) first.\n");
+ printf (("\nFor bug reporting instructions, please see:\n"));
+ printf ("%s\n", GCCBUGURL);
}
- exit (error_count > 0 ? (signal_count ? 2 : 1) : 0);
- /* NOTREACHED */
- return 0;
+ return (signal_count != 0 ? 2
+ : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
+ : 0);
}
/* Find the proper compilation spec for the file name NAME,
static struct compiler *
lookup_compiler (name, length, language)
- char *name;
+ const char *name;
size_t length;
- char *language;
+ const char *language;
{
struct compiler *cp;
- /* If this was specified by the user to be a linker input, indicate that. */
+ /* If this was specified by the user to be a linker input, indicate that. */
if (language != 0 && language[0] == '*')
return 0;
(!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
|| (strlen (cp->suffix) < length
/* See if the suffix matches the end of NAME. */
-#ifdef OS2
- && ((!strcmp (cp->suffix,
- name + length - strlen (cp->suffix))
- || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
- && !strcasecmp (cp->suffix,
- name + length - strlen (cp->suffix)))
-#else
&& !strcmp (cp->suffix,
name + length - strlen (cp->suffix))
-#endif
))
- {
- if (cp->spec[0][0] == '@')
- {
- struct compiler *new;
-
- /* An alias entry maps a suffix to a language.
- Search for the language; pass 0 for NAME and LENGTH
- to avoid infinite recursion if language not found.
- Construct the new compiler spec. */
- language = cp->spec[0] + 1;
- new = (struct compiler *) xmalloc (sizeof (struct compiler));
- new->suffix = cp->suffix;
- bcopy ((char *) lookup_compiler (NULL_PTR, 0, language)->spec,
- (char *) new->spec, sizeof new->spec);
- return new;
- }
-
- /* A non-alias entry: return it. */
- return cp;
- }
+ break;
}
+#if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
+ /* look again, but case-insensitively this time. */
+ if (cp < compilers)
+ for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
+ {
+ if (/* The suffix `-' matches only the file name `-'. */
+ (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
+ || (strlen (cp->suffix) < length
+ /* See if the suffix matches the end of NAME. */
+ && ((!strcmp (cp->suffix,
+ name + length - strlen (cp->suffix))
+ || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
+ && !strcasecmp (cp->suffix,
+ name + length - strlen (cp->suffix)))
+ ))
+ break;
+ }
+#endif
+
+ if (cp >= compilers)
+ {
+ if (cp->spec[0] != '@')
+ /* A non-alias entry: return it. */
+ return cp;
+
+ /* An alias entry maps a suffix to a language.
+ Search for the language; pass 0 for NAME and LENGTH
+ to avoid infinite recursion if language not found. */
+ return lookup_compiler (NULL_PTR, 0, cp->spec + 1);
+ }
return 0;
}
\f
-PTR
-xmalloc (size)
- size_t size;
-{
- register PTR value = (PTR) malloc (size);
- if (value == 0)
- fatal ("virtual memory exhausted");
- return value;
-}
-
-PTR
-xrealloc (ptr, size)
- PTR ptr;
- size_t size;
-{
- register PTR value = (PTR) realloc (ptr, size);
- if (value == 0)
- fatal ("virtual memory exhausted");
- return value;
-}
-
static char *
save_string (s, len)
const char *s;
static void
pfatal_with_name (name)
- char *name;
+ const char *name;
{
- fatal ("%s: %s", name, xstrerror (errno));
+ perror_with_name (name);
+ delete_temp_files ();
+ exit (1);
}
static void
perror_with_name (name)
- char *name;
+ const char *name;
{
error ("%s: %s", name, xstrerror (errno));
}
static void
pfatal_pexecute (errmsg_fmt, errmsg_arg)
- char *errmsg_fmt;
- char *errmsg_arg;
+ const char *errmsg_fmt;
+ const char *errmsg_arg;
{
- int save_errno = errno;
-
if (errmsg_arg)
{
+ int save_errno = errno;
+
/* Space for trailing '\0' is in %s. */
char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
sprintf (msg, errmsg_fmt, errmsg_arg);
errmsg_fmt = msg;
+
+ errno = save_errno;
}
- fatal ("%s: %s", errmsg_fmt, xstrerror (save_errno));
+ pfatal_with_name (errmsg_fmt);
}
-/* More 'friendly' abort that prints the line and file.
- config.h can #define abort fancy_abort if you like that sort of thing. */
+/* Output an error message and exit */
void
fancy_abort ()
\f
/* Output an error message and exit */
-static void
-fatal VPROTO((char *format, ...))
+void
+fatal VPARAMS ((const char *msgid, ...))
{
#ifndef ANSI_PROTOTYPES
- char *format;
+ const char *msgid;
#endif
va_list ap;
- VA_START (ap, format);
+ VA_START (ap, msgid);
#ifndef ANSI_PROTOTYPES
- format = va_arg (ap, char *);
+ msgid = va_arg (ap, const char *);
#endif
fprintf (stderr, "%s: ", programname);
- vfprintf (stderr, format, ap);
+ vfprintf (stderr, _(msgid), ap);
va_end (ap);
fprintf (stderr, "\n");
delete_temp_files ();
}
static void
-error VPROTO((char *format, ...))
+error VPARAMS ((const char *msgid, ...))
{
#ifndef ANSI_PROTOTYPES
- char *format;
+ const char *msgid;
#endif
va_list ap;
- VA_START (ap, format);
+ VA_START (ap, msgid);
#ifndef ANSI_PROTOTYPES
- format = va_arg (ap, char *);
+ msgid = va_arg (ap, const char *);
#endif
fprintf (stderr, "%s: ", programname);
- vfprintf (stderr, format, ap);
+ vfprintf (stderr, _(msgid), ap);
va_end (ap);
fprintf (stderr, "\n");
}
+
+static void
+notice VPARAMS ((const char *msgid, ...))
+{
+#ifndef ANSI_PROTOTYPES
+ const char *msgid;
+#endif
+ va_list ap;
+
+ VA_START (ap, msgid);
+
+#ifndef ANSI_PROTOTYPES
+ msgid = va_arg (ap, const char *);
+#endif
+
+ vfprintf (stderr, _(msgid), ap);
+ va_end (ap);
+}
+
\f
static void
validate_all_switches ()
{
struct compiler *comp;
- register char *p;
+ register const char *p;
register char c;
struct spec_list *spec;
- for (comp = compilers; comp->spec[0]; comp++)
+ for (comp = compilers; comp->spec; comp++)
{
- size_t i;
- for (i = 0; i < sizeof comp->spec / sizeof comp->spec[0] && comp->spec[i]; i++)
- {
- p = comp->spec[i];
- while ((c = *p++))
- if (c == '%' && *p == '{')
- /* We have a switch spec. */
- validate_switches (p + 1);
- }
+ p = comp->spec;
+ while ((c = *p++))
+ if (c == '%' && *p == '{')
+ /* We have a switch spec. */
+ validate_switches (p + 1);
}
- /* look through the linked list of specs read from the specs file */
+ /* Look through the linked list of specs read from the specs file. */
for (spec = specs; spec ; spec = spec->next)
{
p = *(spec->ptr_spec);
static void
validate_switches (start)
- char *start;
+ const char *start;
{
- register char *p = start;
- char *filter;
+ register const char *p = start;
+ const char *filter;
register int i;
int suffix = 0;
--p;
for (i = 0; i < n_switches; i++)
if (!strncmp (switches[i].part1, filter, p - filter))
- switches[i].valid = 1;
+ switches[i].validated = 1;
}
else
{
{
if (!strncmp (switches[i].part1, filter, p - filter)
&& switches[i].part1[p - filter] == 0)
- switches[i].valid = 1;
+ switches[i].validated = 1;
}
}
}
static int
used_arg (p, len)
- char *p;
+ const char *p;
int len;
{
- struct mswitchstr {
- char *str;
- char *replace;
+ struct mswitchstr
+ {
+ const char *str;
+ const char *replace;
int len;
int rep_len;
};
if (!mswitches)
{
struct mswitchstr *matches;
- char *q;
+ const char *q;
int cnt = 0;
/* Break multilib_matches into the component strings of string and replacement
- string */
+ string. */
for (q = multilib_matches; *q != '\0'; q++)
if (*q == ';')
cnt++;
abort ();
q++;
}
- *q = '\0';
matches[i].len = q - matches[i].str;
matches[i].replace = ++q;
matches[i].rep_len = q - matches[i].replace;
i++;
if (*q == ';')
- *q++ = '\0';
- else
- break;
+ q++;
}
/* Now build a list of the replacement string for switches that we care
{
int xlen = strlen (switches[i].part1);
for (j = 0; j < cnt; j++)
- if (xlen == matches[j].len && ! strcmp (switches[i].part1, matches[j].str))
+ if (xlen == matches[j].len
+ && ! strncmp (switches[i].part1, matches[j].str, xlen))
{
mswitches[n_mswitches].str = matches[j].replace;
mswitches[n_mswitches].len = matches[j].rep_len;
static int
default_arg (p, len)
- char *p;
+ const char *p;
int len;
{
- char *start, *end;
+ const char *start, *end;
for (start = multilib_defaults; *start != '\0'; start = end+1)
{
return 0;
}
-/* Work out the subdirectory to use based on the
- options. The format of multilib_select is a list of elements.
- Each element is a subdirectory name followed by a list of options
- followed by a semicolon. gcc will consider each line in turn. If
- none of the options beginning with an exclamation point are
- present, and all of the other options are present, that
- subdirectory will be used. */
+/* Work out the subdirectory to use based on the options. The format of
+ multilib_select is a list of elements. Each element is a subdirectory
+ name followed by a list of options followed by a semicolon. The format
+ of multilib_exclusions is the same, but without the preceding
+ directory. First gcc will check the exclusions, if none of the options
+ beginning with an exclamation point are present, and all of the other
+ options are present, then we will ignore this completely. Passing
+ that, gcc will consider each multilib_select in turn using the same
+ rules for matching the options. If a match is found, that subdirectory
+ will be used. */
static void
set_multilib_dir ()
{
- char *p = multilib_select;
- int this_path_len;
- char *this_path, *this_arg;
+ const char *p;
+ unsigned int this_path_len;
+ const char *this_path, *this_arg;
int not_arg;
int ok;
+ p = multilib_exclusions;
+ while (*p != '\0')
+ {
+ /* Ignore newlines. */
+ if (*p == '\n')
+ {
+ ++p;
+ continue;
+ }
+
+ /* Check the arguments. */
+ ok = 1;
+ while (*p != ';')
+ {
+ if (*p == '\0')
+ abort ();
+
+ if (! ok)
+ {
+ ++p;
+ continue;
+ }
+
+ this_arg = p;
+ while (*p != ' ' && *p != ';')
+ {
+ if (*p == '\0')
+ abort ();
+ ++p;
+ }
+
+ if (*this_arg != '!')
+ not_arg = 0;
+ else
+ {
+ not_arg = 1;
+ ++this_arg;
+ }
+
+ ok = used_arg (this_arg, p - this_arg);
+ if (not_arg)
+ ok = ! ok;
+
+ if (*p == ' ')
+ ++p;
+ }
+
+ if (ok)
+ return;
+
+ ++p;
+ }
+
+ p = multilib_select;
while (*p != '\0')
{
/* Ignore newlines. */
if (this_path_len != 1
|| this_path[0] != '.')
{
- multilib_dir = xmalloc (this_path_len + 1);
- strncpy (multilib_dir, this_path, this_path_len);
- multilib_dir[this_path_len] = '\0';
+ char * new_multilib_dir = xmalloc (this_path_len + 1);
+ strncpy (new_multilib_dir, this_path, this_path_len);
+ new_multilib_dir[this_path_len] = '\0';
+ multilib_dir = new_multilib_dir;
}
break;
}
matches. The options are print without a leading dash. There are
no spaces to make it easy to use the information in the shell.
Each subdirectory is printed only once. This assumes the ordering
- generated by the genmultilib script. */
+ generated by the genmultilib script. Also, we leave out ones that match
+ the exclusions. */
static void
print_multilib_info ()
{
- char *p = multilib_select;
- char *last_path = 0, *this_path;
+ const char *p = multilib_select;
+ const char *last_path = 0, *this_path;
int skip;
- int last_path_len = 0;
+ unsigned int last_path_len = 0;
while (*p != '\0')
{
+ skip = 0;
/* Ignore newlines. */
if (*p == '\n')
{
++p;
}
- /* If this is a duplicate, skip it. */
- skip = (last_path != 0 && p - this_path == last_path_len
- && ! strncmp (last_path, this_path, last_path_len));
+ /* Check for matches with the multilib_exclusions. We don't bother
+ with the '!' in either list. If any of the exclusion rules match
+ all of its options with the select rule, we skip it. */
+ {
+ const char *e = multilib_exclusions;
+ const char *this_arg;
+
+ while (*e != '\0')
+ {
+ int m = 1;
+ /* Ignore newlines. */
+ if (*e == '\n')
+ {
+ ++e;
+ continue;
+ }
+
+ /* Check the arguments. */
+ while (*e != ';')
+ {
+ const char *q;
+ int mp = 0;
- last_path = this_path;
- last_path_len = p - this_path;
+ if (*e == '\0')
+ abort ();
+
+ if (! m)
+ {
+ ++e;
+ continue;
+ }
+
+ this_arg = e;
+
+ while (*e != ' ' && *e != ';')
+ {
+ if (*e == '\0')
+ abort ();
+ ++e;
+ }
+
+ q = p + 1;
+ while (*q != ';')
+ {
+ const char *arg;
+ int len = e - this_arg;
+
+ if (*q == '\0')
+ abort ();
+
+ arg = q;
+
+ while (*q != ' ' && *q != ';')
+ {
+ if (*q == '\0')
+ abort ();
+ ++q;
+ }
+
+ if (! strncmp (arg, this_arg, (len < q - arg) ? q - arg : len) ||
+ default_arg (this_arg, e - this_arg))
+ {
+ mp = 1;
+ break;
+ }
+
+ if (*q == ' ')
+ ++q;
+ }
+
+ if (! mp)
+ m = 0;
+
+ if (*e == ' ')
+ ++e;
+ }
+
+ if (m)
+ {
+ skip = 1;
+ break;
+ }
+
+ if (*e != '\0')
+ ++e;
+ }
+ }
+
+ if (! skip)
+ {
+ /* If this is a duplicate, skip it. */
+ skip = (last_path != 0 && (unsigned int)(p - this_path) == last_path_len
+ && ! strncmp (last_path, this_path, last_path_len));
+
+ last_path = this_path;
+ last_path_len = p - this_path;
+ }
/* If this directory requires any default arguments, we can skip
it. We will already have printed a directory identical to
this one which does not require that default argument. */
if (! skip)
{
- char *q;
+ const char *q;
q = p + 1;
while (*q != ';')
{
- char *arg;
+ const char *arg;
if (*q == '\0')
abort ();
if (! skip)
{
- char *p1;
+ const char *p1;
for (p1 = last_path; p1 < p; p1++)
putchar (*p1);
if (! skip)
{
- /* If there are extra options, print them now */
+ /* If there are extra options, print them now. */
if (multilib_extra && *multilib_extra)
{
int print_at = TRUE;
- char *q;
+ const char *q;
for (q = multilib_extra; *q != '\0'; q++)
{
}
}
}
+
putchar ('\n');
}
OSDN Git Service
