#include "config.h"
#include "system.h"
#include <signal.h>
#if ! defined( SIGCHLD ) && defined( SIGCLD )
# define SIGCHLD SIGCLD
#endif
#include "obstack.h"
#include "intl.h"
#include "prefix.h"
#include "gcc.h"
#include "flags.h"
#include "cppdefault.h"
#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
#ifdef PHAT
#undef STANDARD_EXEC_PREFIX
#define STANDARD_EXEC_PREFIX "/usr/libexec/gcc/darwin/"
#undef STANDARD_EXEC_PREFIX_1
#define STANDARD_EXEC_PREFIX_1 "/usr/local/libexec/gcc/darwin/"
#undef MD_STARTFILE_PREFIX
#define MD_STARTFILE_PREFIX "/usr/lib/gcc/darwin/"
#endif
#if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
#define HAVE_TARGET_EXECUTABLE_SUFFIX
#else
#undef TARGET_EXECUTABLE_SUFFIX
#define TARGET_EXECUTABLE_SUFFIX ""
#endif
#ifdef HOST_EXECUTABLE_SUFFIX
#define HAVE_HOST_EXECUTABLE_SUFFIX
#else
#define HOST_EXECUTABLE_SUFFIX ""
#endif
#ifdef TARGET_OBJECT_SUFFIX
#define HAVE_TARGET_OBJECT_SUFFIX
#else
#define TARGET_OBJECT_SUFFIX ".o"
#endif
#ifndef VMS
#ifndef DIR_UP
#define DIR_UP ".."
#endif
#endif
static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
#ifndef GET_ENV_PATH_LIST
#define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
#endif
#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
int is_cpp_driver;
static int pass_exit_codes;
#include "configargs.h"
static int print_search_dirs;
static const char *print_file_name = NULL;
static const char *print_prog_name = NULL;
static int print_multi_directory;
static int print_multi_lib;
static int print_help_list;
static int verbose_flag;
static int verbose_only_flag;
static int target_help_flag;
static int report_times;
static int save_temps_flag;
static const char *compiler_version;
static const char *spec_version = DEFAULT_TARGET_VERSION;
static const char *spec_machine = DEFAULT_TARGET_MACHINE;
static int use_constant_cfstrings = 0;
static const char *macosx_deployment_target = 0;
static unsigned int macosx_version_min_required = 0;
static struct macosx_vers {
const char *vers_str;
unsigned int vers_num;
} macosx_vers_tbl[] = {
{ "10.0", 1000 },
{ "10.1", 1010 },
{ "10.2", 1020 },
{ "10.3", 1030 },
{ NULL, 0 }
};
#if defined (CROSS_COMPILE) && !defined (PHAT)
static const char *cross_compile = "1";
#else
static const char *cross_compile = "0";
#endif
#ifdef MODIFY_TARGET_NAME
static const struct modify_target
{
const char *const sw;
const enum add_del {ADD, DELETE} add_del;
const char *const str;
}
modify_target[] = MODIFY_TARGET_NAME;
#endif
#define MAX_ARCHES 10
struct arch_out
{
char *name;
char *merge_file;
} arches[MAX_ARCHES];
int num_arches;
int current_arch;
char *final_output = "a.out";
static int error_count = 0;
static int greatest_status = 1;
static struct obstack obstack;
static struct obstack collect_obstack;
#ifdef HAVE_GETRUSAGE
static struct rusage rus, prus;
#endif
struct path_prefix;
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
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));
#ifdef FRAMEWORK_HEADERS
static void safe_add_prefix PARAMS ((struct path_prefix *, char *,
int, int, int *));
#endif
static void add_prefix PARAMS ((struct path_prefix *, const char *,
const char *, int, int, int *));
static void translate_options PARAMS ((int *, const char *const **));
static char *skip_whitespace PARAMS ((char *));
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 void set_collect_gcc_options PARAMS ((void));
static const char *check_basename_derived_file PARAMS ((const char *string));
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 perror_with_name PARAMS ((const char *));
static void pfatal_pexecute PARAMS ((const char *, const char *))
ATTRIBUTE_NORETURN;
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 *const *));
static int execute PARAMS ((void));
static void clear_args PARAMS ((void));
static void fatal_error PARAMS ((int));
#ifdef ENABLE_SHARED_LIBGCC
static void init_gcc_specs PARAMS ((struct obstack *,
const char *, const char *,
const char *));
#endif
#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
static const char *convert_filename PARAMS ((const char *, int, int));
#endif
#ifndef ASM_SPEC
#define ASM_SPEC ""
#endif
#ifndef ASM_FINAL_SPEC
#define ASM_FINAL_SPEC ""
#endif
#ifndef CPP_SPEC
#define CPP_SPEC ""
#endif
#ifndef CC1_SPEC
#define CC1_SPEC ""
#endif
#ifndef CC1PLUS_SPEC
#define CC1PLUS_SPEC ""
#endif
#ifndef LINK_SPEC
#define LINK_SPEC ""
#endif
#ifndef LIB_SPEC
#define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
#endif
#ifndef LIBGCC_SPEC
#if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
#define LIBGCC_SPEC "libgcc.a%s"
#else
#define LIBGCC_SPEC "-lgcc"
#endif
#endif
#ifndef STARTFILE_SPEC
#define STARTFILE_SPEC \
"%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
#endif
#ifndef SWITCHES_NEED_SPACES
#define SWITCHES_NEED_SPACES ""
#endif
#ifndef ENDFILE_SPEC
#define ENDFILE_SPEC ""
#endif
#ifndef LINKER_NAME
#define LINKER_NAME "collect2"
#endif
#ifndef ASM_DEBUG_SPEC
# if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
&& defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
# define ASM_DEBUG_SPEC \
(PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" \
: "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}")
# else
# if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
# define ASM_DEBUG_SPEC "%{g*:--gstabs}"
# endif
# if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
# define ASM_DEBUG_SPEC "%{g*:--gdwarf2}"
# endif
# endif
#endif
#ifndef ASM_DEBUG_SPEC
# define ASM_DEBUG_SPEC ""
#endif
#ifndef LINK_GCC_C_SEQUENCE_SPEC
#define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
#endif
#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:%(link_gcc_c_sequence)}}\
%{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
#endif
#ifndef LINK_LIBGCC_SPEC
# ifdef LINK_LIBGCC_SPECIAL
# define LINK_LIBGCC_SPEC ""
# else
# define LINK_LIBGCC_SPEC "%D"
# endif
#endif
static const char *asm_debug = ASM_DEBUG_SPEC;
static const char *cpp_spec = CPP_SPEC;
static const char *cpp_predefines = CPP_PREDEFINES;
static const char *cc1_spec = CC1_SPEC;
static const char *cc1plus_spec = CC1PLUS_SPEC;
static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
static const char *asm_spec = ASM_SPEC;
static const char *asm_final_spec = ASM_FINAL_SPEC;
static const char *link_spec = LINK_SPEC;
static const char *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;
static char *ofile_merge_spec = "\
%{!M:%{!MM:%{!E:%{!precomp:%{!S:lipo -create %F \
%{c:%W{o}%{!o:-o %w%b%O}}%{!c:-o %w%u%O}\n}}}}}";
static char *exec_merge_spec = "\
%{!M:%{!MM:%{!E:%{!precomp:%{!S:%{!c:lipo -create %F \
%{o}%{!o:-o a.out}\n}}}}}}";
static char *precomp_merge_spec = "\
%{!M:%{!MM:%{!E:%{precomp:%{!S:%{!c:lipo -create %F \
%{o}%{!o:-o %b-gcc3.p}\n}}}}}}";
#ifdef CPP_ALTIVEC_SPEC
static const char *cpp_altivec_flags = CPP_ALTIVEC_SPEC;
#endif
static const char *trad_capable_cpp =
"%{traditional|ftraditional|traditional-cpp:trad}cpp0";
static const char *cpp_precomp =
"/usr/libexec/gcc/darwin/%T/cpp-precomp -smart -arch %T %{precomp} \
%{fdebug-gen-index} ";
static const char *cpp_precomp_options =
" %{MF*:-MD %*} %{!MF:%{MD:-MD %b.d}} %{<MD} %{<MF} %(cpp_options) \
%{fdebug-gen-index}";
static const char *cpp_unique_options =
"%{C:%{!E:%eGNU C does not support -C without using -E}}\
""\
%(cpp_altivec_flags)\
""\
%{!traditional:%{!ftraditional:%{!traditional-cpp:%Q}}}\
%{nostdinc*} %{C} %{v} %{I*} %{F*} %{P} %{$} %I\
%{MD:-MD %W{!o: %b.d}%W{o*:%.d%*}}\
%{MMD:-MMD %W{!o: %b.d}%W{o*:%.d%*}}\
%{M} %{MM} %W{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
%{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
""\
%yV\
%{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
""\
%{!no-gcc:-D__APPLE_CC__=%vA}\
%{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
%{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
%{fno-inline|O0|!O*:-D__NO_INLINE__} %{ffast-math:-D__FAST_MATH__}\
%{fshort-wchar:-U__WCHAR_TYPE__ -D__WCHAR_TYPE__=short\\ unsigned\\ int}\
%{ffreestanding:-D__STDC_HOSTED__=0} %{fno-hosted:-D__STDC_HOSTED__=0}\
%{!ffreestanding:%{!fno-hosted:-D__STDC_HOSTED__=1}} %{remap}\
%{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
%{E|M|MM:%W{o*}}";
static const char *cpp_options =
"%(cpp_unique_options) %{std*} %{d*} %{W*} %{w} %{pedantic*}\
%{fshow-column} %{fno-show-column}\
%{fsigned-char&funsigned-char}\
%{fleading-underscore} %{fno-leading-underscore}\
%{fno-operator-names} %{ftabstop=*}";
static const char *cc1_options =
"%{@:-arch %T}"
"%{fload=*|fdump=*:-farch=%T}"
"%yC"
"%{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*}\
%{Qn:-fno-ident} %{--help:--help}\
%{--target-help:--target-help}\
%{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
%{fsyntax-only:-o %j} %{-param*}";
static const char *asm_options =
"%a %Y %{@:-o %f%u%O}%{!@:%{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}}";
static const char *invoke_as =
"%{!fdump=*:%{!--help:%{!S:-o %{|!pipe:%g.s} |\n as %(asm_options) %{!pipe:%g.s} %A }}}";
static struct obstack multilib_obstack;
static const char *multilib_select;
static const char *multilib_matches;
static const char *multilib_defaults;
static const char *multilib_exclusions;
#include "multilib.h"
#ifndef MULTILIB_DEFAULTS
#define MULTILIB_DEFAULTS { "" }
#endif
static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
struct user_specs
{
struct user_specs *next;
const char *filename;
};
static struct user_specs *user_specs_head, *user_specs_tail;
#define DEFAULT_SWITCH_TAKES_ARG(CHAR) \
((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
|| (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
|| (CHAR) == 'I' || (CHAR) == 'm' || (CHAR) == 'x' \
\
|| (CHAR) == 'F' \
|| (CHAR) == 'L' || (CHAR) == 'A' || (CHAR) == 'V' \
|| (CHAR) == 'B' || (CHAR) == 'b')
#ifndef SWITCH_TAKES_ARG
#define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
#endif
#define DEFAULT_WORD_SWITCH_TAKES_ARG(STR) \
(!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext") \
|| !strcmp (STR, "fload") || !strcmp (STR, "fdump") \
|| !strcmp (STR, "Tbss") || !strcmp (STR, "include") \
|| !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
|| !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
|| !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore") \
|| !strcmp (STR, "isystem") || !strcmp (STR, "-param") \
|| !strcmp (STR, "specs") \
|| !strcmp (STR, "MF") || !strcmp (STR, "MT") || !strcmp (STR, "MQ"))
#ifndef WORD_SWITCH_TAKES_ARG
#define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
#endif
#ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
#define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
((CHAR) == 'c' || (CHAR) == 'S')
#ifndef SWITCH_CURTAILS_COMPILATION
#define SWITCH_CURTAILS_COMPILATION(CHAR) \
DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
#endif
#endif
struct compiler
{
const char *suffix;
const char *spec;
const char *cpp_spec;
};
static struct compiler *compilers;
static int n_compilers;
static const struct compiler default_compilers[] =
{
{".m", "#Objective-C", 0}, {".mi", "#Objective-C", 0},
{".cc", "#C++", 0}, {".cxx", "#C++", 0}, {".cpp", "#C++", 0},
{".cp", "#C++", 0}, {".c++", "#C++", 0}, {".C", "#C++", 0},
{".ii", "#C++", 0},
{".ads", "#Ada", 0}, {".adb", "#Ada", 0},
{".f", "#Fortran", 0}, {".for", "#Fortran", 0}, {".fpp", "#Fortran", 0},
{".F", "#Fortran", 0}, {".FOR", "#Fortran", 0}, {".FPP", "#Fortran", 0},
{".r", "#Ratfor", 0},
{".p", "#Pascal", 0}, {".pas", "#Pascal", 0},
{".java", "#Java", 0}, {".class", "#Java", 0},
{".zip", "#Java", 0}, {".jar", "#Java", 0},
{".c", "@c", 0},
{"@c",
"%{M|MM:%(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)}\
%{E|S:%{@:%e-E and -S are not allowed with multiple -arch flags}}\
%{E:\
%{traditional|ftraditional|traditional-cpp|no-cpp-precomp:\
%(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)}\
%{!traditional:%{!ftraditional:%{!traditional-cpp:%{!no-cpp-precomp:\
%(cpp_precomp) -lang-c %{ansi:-std=c89} %(cpp_precomp_options) %y0}}}}}\
%{!E:%{!M:%{!MM:\
%{save-temps|no-integrated-cpp:\
%{no-cpp-precomp|traditional-cpp|fload=*|fdump=*:\
%(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options) %{save-temps:%b.i} %{!save-temps:%g.i} \n\
cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} %(cc1_options)}\
%{cpp-precomp|!no-cpp-precomp:%{!traditional-cpp:%{!fdump=*:%{!fload=*:\
%(cpp_precomp) -lang-c %{ansi:-std=c89} %(cpp_precomp_options) %y0 %b.i \n\
cc1 -cpp-precomp %b.i %(cc1_options)}}}}}\
%{!save-temps:%{!no-integrated-cpp:\
%{traditional|ftraditional|traditional-cpp:%{!cpp-precomp:\
tradcpp0 -lang-c %{ansi:-std=c89} %(cpp_options) %{!pipe:%g.i} |\n\
cc1 -fpreprocessed %{!pipe:%g.i} %(cc1_options)}}}\
%{!fdump=*:%{!fload=*:%{!no-cpp-precomp|cpp-precomp:%{!precomp:%{!traditional-cpp:\
%(cpp_precomp) -lang-c %{ansi:-std=c89}\
%(cpp_precomp_options) %y0 %{!pipe:%g.i} |\n\
cc1 -cpp-precomp %{!pipe:%g.i} %(cc1_options)}}}}}\
%{precomp:\
%(cpp_precomp) -lang-c %{ansi:-std=c89}\
%(cpp_precomp_options) %y0\
%{@:-o %f%u.p}%{!@:%W{o}%W{!o*:-o %b-gcc3.p}} }\
%{!traditional:%{!ftraditional:%{!traditional-cpp:\
%{fload=*|fdump=*|no-cpp-precomp:%{!precomp:\
cc1 -lang-c %{ansi:-std=c89} %(cpp_unique_options) %(cc1_options)}}}}}}\
%{!fsyntax-only:%{!precomp:%(invoke_as)}}}}}", 0},
{"-",
"%{!E:%e-E required when input is from standard input}\
%(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)", 0},
{".h", "@c-header", 0},
{"@c-header",
"%{!E:%{!precomp:%ecompilation of header file requested}} \
%{E:%{@:%e-E is not allowed with multiple -arch flags}}\
%{traditional-cpp|no-cpp-precomp:%{!precomp:\
%(trad_capable_cpp) -lang-c %{ansi:-std=c89} %(cpp_options)}}\
%{!traditional-cpp:%{!no-cpp-precomp:\
%(cpp_precomp) -lang-c %{ansi:-std=c89}\
%(cpp_precomp_options) %y0\
%{precomp:%{@:-o %f%u.p}%{!@:%W{o}%W{!o*:-o %b-gcc3.p}}} }}", 0},
{".i", "@cpp-output", 0},
{"@cpp-output",
"%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0},
{".s", "@assembler-with-cpp", 0},
{"@assembler",
"%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0},
{".S", "@assembler-with-cpp", 0},
{"@assembler-with-cpp",
"%(trad_capable_cpp) -lang-asm %(cpp_options)\
%{!M:%{!MM:%{!E:%{!S:-o %{|!pipe:%g.s} |\n\
as %(asm_debug) %(asm_options) %{!pipe:%g.s} %A }}}}", 0},
#include "specs.h"
{0, 0, 0}
};
static int n_default_compilers
= (sizeof default_compilers / sizeof (struct compiler)) - 1;
static char *default_language;
static int n_linker_options;
static char **linker_options;
static int n_assembler_options;
static char **assembler_options;
static int n_preprocessor_options;
static char **preprocessor_options;
struct option_map
{
const char *const name;
const char *const equivalent;
const char *const arg_info;
};
static const struct option_map option_map[] =
{
{"--all-warnings", "-Wall", 0},
{"--ansi", "-ansi", 0},
{"--arch", "-arch", "a"},
{"--arch_multiple", "-arch_multiple", 0},
{"--assemble", "-S", 0},
{"--assert", "-A", "a"},
{"--classpath", "-fclasspath=", "aj"},
{"--bootclasspath", "-fbootclasspath=", "aj"},
{"--CLASSPATH", "-fclasspath=", "aj"},
{"--comments", "-C", 0},
{"--compile", "-c", 0},
{"--debug", "-g", "oj"},
{"--define-macro", "-D", "aj"},
{"--dependencies", "-M", 0},
{"--dump", "-d", "a"},
{"--dumpbase", "-dumpbase", "a"},
{"--entry", "-e", 0},
{"--extra-warnings", "-W", 0},
{"--for-assembler", "-Wa", "a"},
{"--for-linker", "-Xlinker", "a"},
{"--force-link", "-u", "a"},
{"--imacros", "-imacros", "a"},
{"--include", "-include", "a"},
{"--include-barrier", "-I-", 0},
{"--include-directory", "-I", "aj"},
{"--include-directory-after", "-idirafter", "a"},
{"--include-prefix", "-iprefix", "a"},
{"--include-with-prefix", "-iwithprefix", "a"},
{"--include-with-prefix-before", "-iwithprefixbefore", "a"},
{"--include-with-prefix-after", "-iwithprefix", "a"},
{"--language", "-x", "a"},
{"--library-directory", "-L", "a"},
{"--machine", "-m", "aj"},
{"--machine-", "-m", "*j"},
{"--no-integrated-cpp", "-no-integrated-cpp", 0},
{"--no-line-commands", "-P", 0},
{"--no-precompiled-includes", "-noprecomp", 0},
{"--no-standard-includes", "-nostdinc", 0},
{"--no-standard-libraries", "-nostdlib", 0},
{"--no-warnings", "-w", 0},
{"--optimize", "-O", "oj"},
{"--output", "-o", "a"},
{"--output-class-directory", "-foutput-class-dir=", "ja"},
{"--param", "--param", "a"},
{"--pedantic", "-pedantic", 0},
{"--pedantic-errors", "-pedantic-errors", 0},
{"--pipe", "-pipe", 0},
{"--precomp-trustfile", "-precomp-trustfile", "a"},
{"--prefix", "-B", "a"},
{"--preprocess", "-E", 0},
{"--print-search-dirs", "-print-search-dirs", 0},
{"--print-file-name", "-print-file-name=", "aj"},
{"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
{"--print-missing-file-dependencies", "-MG", 0},
{"--print-multi-lib", "-print-multi-lib", 0},
{"--print-multi-directory", "-print-multi-directory", 0},
{"--print-prog-name", "-print-prog-name=", "aj"},
{"--profile", "-p", 0},
{"--profile-blocks", "-a", 0},
{"--quiet", "-q", 0},
{"--save-temps", "-save-temps", 0},
{"--shared", "-shared", 0},
{"--silent", "-q", 0},
{"--specs", "-specs=", "aj"},
{"--static", "-static", 0},
{"--std", "-std=", "aj"},
{"--symbolic", "-symbolic", 0},
{"--target", "-b", "a"},
{"--time", "-time", 0},
{"--trace-includes", "-H", 0},
{"--cpp-precomp", "-cpp-precomp", 0},
{"--traditional", "-traditional", 0},
{"--traditional-cpp", "-traditional-cpp", 0},
{"--trigraphs", "-trigraphs", 0},
{"--undefine-macro", "-U", "aj"},
{"--use-version", "-V", "a"},
{"--user-dependencies", "-MM", 0},
{"--verbose", "-v", 0},
{"--warn-", "-W", "*j"},
{"--write-dependencies", "-MD", 0},
{"--write-user-dependencies", "-MMD", 0},
{"--load-pch", "-fload=", "aj"},
{"--dump-pch", "-fdump=", "aj"},
{"--validate-pch", "-fvalidate", 0},
{"--", "-f", "*j"}
};
#ifdef TARGET_OPTION_TRANSLATE_TABLE
static const struct {
const char *const option_found;
const char *const replacements;
} target_option_translations[] =
{
TARGET_OPTION_TRANSLATE_TABLE,
{ 0, 0 }
};
#endif
static void
translate_options (argcp, argvp)
int *argcp;
const char *const **argvp;
{
int i;
int argc = *argcp;
const char *const *argv = *argvp;
int newvsize = (argc + 2) * 2 * sizeof (const char *);
const char **newv =
(const char **) xmalloc (newvsize);
int newindex = 0;
i = 0;
newv[newindex++] = argv[i++];
while (i < argc)
{
#ifdef TARGET_OPTION_TRANSLATE_TABLE
int tott_idx;
for (tott_idx = 0;
target_option_translations[tott_idx].option_found;
tott_idx++)
{
if (strcmp (target_option_translations[tott_idx].option_found,
argv[i]) == 0)
{
int spaces = 1;
const char *sp;
char *np;
for (sp = target_option_translations[tott_idx].replacements;
*sp; sp++)
{
if (*sp == ' ')
spaces ++;
}
newvsize += spaces * sizeof (const char *);
newv = (const char **) xrealloc (newv, newvsize);
sp = target_option_translations[tott_idx].replacements;
np = xstrdup (sp);
while (1)
{
while (*np == ' ')
np++;
if (*np == 0)
break;
newv[newindex++] = np;
while (*np != ' ' && *np)
np++;
if (*np == 0)
break;
*np++ = 0;
}
i ++;
break;
}
}
if (target_option_translations[tott_idx].option_found)
continue;
#endif
if (argv[i][0] == '-' && argv[i][1] == '-')
{
size_t j;
for (j = 0; j < ARRAY_SIZE (option_map); j++)
{
size_t optlen = strlen (option_map[j].name);
size_t arglen = strlen (argv[i]);
size_t complen = arglen > optlen ? optlen : arglen;
const char *arginfo = option_map[j].arg_info;
if (arginfo == 0)
arginfo = "";
if (!strncmp (argv[i], option_map[j].name, complen))
{
const char *arg = 0;
if (arglen < optlen)
{
size_t k;
for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
if (strlen (option_map[k].name) >= arglen
&& !strncmp (argv[i], option_map[k].name, arglen))
{
error ("ambiguous abbreviation %s", argv[i]);
break;
}
if (k != ARRAY_SIZE (option_map))
break;
}
if (arglen > optlen)
{
if (argv[i][optlen] == '=')
arg = argv[i] + optlen + 1;
else if (strchr (arginfo, '*') != 0)
arg = argv[i] + optlen;
else
continue;
}
else if (strchr (arginfo, '*') != 0)
{
error ("incomplete `%s' option", option_map[j].name);
break;
}
if (strchr (arginfo, 'a') != 0)
{
if (arg == 0)
{
if (i + 1 == argc)
{
error ("missing argument to `%s' option",
option_map[j].name);
break;
}
arg = argv[++i];
}
}
else if (strchr (arginfo, '*') != 0)
;
else if (strchr (arginfo, 'o') == 0)
{
if (arg != 0)
error ("extraneous argument to `%s' option",
option_map[j].name);
arg = 0;
}
if (arg != 0 && strchr (arginfo, 'j') != 0)
newv[newindex++] = concat (option_map[j].equivalent, arg,
NULL);
else if (arg != 0)
{
newv[newindex++] = option_map[j].equivalent;
newv[newindex++] = arg;
}
else
newv[newindex++] = option_map[j].equivalent;
break;
}
}
i++;
}
else if (argv[i][0] == '-')
{
const char *p = argv[i] + 1;
int c = *p;
int nskip = 1;
if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
else if (WORD_SWITCH_TAKES_ARG (p))
nskip += WORD_SWITCH_TAKES_ARG (p);
else if ((c == 'B' || c == 'b' || c == 'V' || c == 'x')
&& p[1] == 0)
nskip += 1;
else if (! strcmp (p, "Xlinker"))
nskip += 1;
if (nskip + i > argc)
nskip = argc - i;
while (nskip > 0)
{
newv[newindex++] = argv[i++];
nskip--;
}
}
else
newv[newindex++] = argv[i++];
}
newv[newindex] = 0;
*argvp = newv;
*argcp = newindex;
}
static char *
skip_whitespace (p)
char *p;
{
while (1)
{
if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
return p + 1;
else if (*p == '\n' || *p == ' ' || *p == '\t')
p++;
else if (*p == '#')
{
while (*p != '\n')
p++;
p++;
}
else
break;
}
return p;
}
struct prefix_list
{
const char *prefix;
struct prefix_list *next;
int require_machine_suffix;
int *used_flag_ptr;
int priority;
};
struct path_prefix
{
struct prefix_list *plist;
int max_len;
const char *name;
};
static struct path_prefix exec_prefixes = { 0, 0, "exec" };
static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
static struct path_prefix include_prefixes = { 0, 0, "include" };
#ifdef FRAMEWORK_HEADERS
static struct path_prefix default_framework_paths = {0, 0, "default_frameworks"};
#endif
static const char *machine_suffix = 0;
static const char *just_machine_suffix = 0;
static const char *gcc_exec_prefix;
#if defined (CROSS_COMPILE) && !defined (PHAT)
#undef MD_EXEC_PREFIX
#undef MD_STARTFILE_PREFIX
#undef MD_STARTFILE_PREFIX_1
#endif
#ifndef MD_EXEC_PREFIX
#define MD_EXEC_PREFIX ""
#endif
#ifndef MD_STARTFILE_PREFIX
#define MD_STARTFILE_PREFIX ""
#endif
#ifndef MD_STARTFILE_PREFIX_1
#define MD_STARTFILE_PREFIX_1 ""
#endif
#ifndef STANDARD_EXEC_PREFIX
#define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
#endif
#ifndef STANDARD_EXEC_PREFIX_1
#define STANDARD_EXEC_PREFIX_1 "/usr/lib/gcc/"
#endif
#ifndef STANDARD_STARTFILE_PREFIX
#define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
#endif
#ifndef TOOLDIR_BASE_PREFIX
#define TOOLDIR_BASE_PREFIX "/usr/local/"
#endif
#ifndef STANDARD_BINDIR_PREFIX
#define STANDARD_BINDIR_PREFIX "/usr/local/bin"
#endif
static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
static const char *const standard_exec_prefix_1 = STANDARD_EXEC_PREFIX_1;
static const char *md_exec_prefix = MD_EXEC_PREFIX;
static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
static const char *const standard_startfile_prefix_1 = "/lib/";
static const char *const standard_startfile_prefix_2 = "/usr/lib/";
static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
static const char *tooldir_prefix;
static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
static const char *multilib_dir;
struct spec_list
{
const char *name;
const char *ptr;
const char **ptr_spec;
struct spec_list *next;
int name_len;
int alloc_p;
};
#define INIT_STATIC_SPEC(NAME,PTR) \
{ NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
static struct spec_list static_specs[] =
{
INIT_STATIC_SPEC ("asm", &asm_spec),
INIT_STATIC_SPEC ("asm_debug", &asm_debug),
INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
INIT_STATIC_SPEC ("asm_options", &asm_options),
INIT_STATIC_SPEC ("invoke_as", &invoke_as),
INIT_STATIC_SPEC ("cpp", &cpp_spec),
INIT_STATIC_SPEC ("cpp_options", &cpp_options),
INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
INIT_STATIC_SPEC ("cpp_precomp", &cpp_precomp),
INIT_STATIC_SPEC ("cpp_precomp_options", &cpp_precomp_options),
INIT_STATIC_SPEC ("cc1", &cc1_spec),
INIT_STATIC_SPEC ("cc1_options", &cc1_options),
INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
INIT_STATIC_SPEC ("endfile", &endfile_spec),
INIT_STATIC_SPEC ("link", &link_spec),
INIT_STATIC_SPEC ("lib", &lib_spec),
INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
INIT_STATIC_SPEC ("startfile", &startfile_spec),
INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
INIT_STATIC_SPEC ("predefines", &cpp_predefines),
INIT_STATIC_SPEC ("cross_compile", &cross_compile),
INIT_STATIC_SPEC ("version", &compiler_version),
INIT_STATIC_SPEC ("multilib", &multilib_select),
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),
INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
#ifdef CPP_ALTIVEC_SPEC
INIT_STATIC_SPEC ("cpp_altivec_flags", &cpp_altivec_flags)
#endif
};
#ifdef EXTRA_SPECS
struct spec_list_1
{
const char *const name;
const char *const ptr;
};
static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
static struct spec_list *extra_specs = (struct spec_list *) 0;
#endif
static struct spec_list *specs = (struct spec_list *) 0;
#ifdef ENABLE_SHARED_LIBGCC
static void
init_gcc_specs (obstack, shared_name, static_name, eh_name)
struct obstack *obstack;
const char *shared_name;
const char *static_name;
const char *eh_name;
{
char *buf;
buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name,
"}%{!static:%{!static-libgcc:",
"%{!shared:%{!shared-libgcc:", static_name, " ",
eh_name, "}%{shared-libgcc:", shared_name, " ",
static_name, "}}%{shared:",
#ifdef LINK_EH_SPEC
"%{shared-libgcc:", shared_name,
"}%{!shared-libgcc:", static_name, "}",
#else
shared_name,
#endif
"}}}", NULL);
obstack_grow (obstack, buf, strlen (buf));
free (buf);
}
#endif
static void
init_spec ()
{
struct spec_list *next = (struct spec_list *) 0;
struct spec_list *sl = (struct spec_list *) 0;
int i;
if (specs)
return;
if (verbose_flag)
notice ("Using built-in specs.\n");
#ifdef EXTRA_SPECS
extra_specs = (struct spec_list *)
xcalloc (sizeof (struct spec_list), ARRAY_SIZE (extra_specs_1));
for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
{
sl = &extra_specs[i];
sl->name = extra_specs_1[i].name;
sl->ptr = extra_specs_1[i].ptr;
sl->next = next;
sl->name_len = strlen (sl->name);
sl->ptr_spec = &sl->ptr;
next = sl;
}
#endif
for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
{
sl = &static_specs[i];
sl->next = next;
next = sl;
}
#ifdef ENABLE_SHARED_LIBGCC
{
const char *p = libgcc_spec;
int in_sep = 1;
while (*p)
{
if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
{
init_gcc_specs (&obstack,
#ifdef NO_SHARED_LIBGCC_MULTILIB
"-lgcc_s"
#else
"-lgcc_s%M"
#endif
,
"-lgcc",
"-lgcc_eh");
p += 5;
in_sep = 0;
}
else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
{
init_gcc_specs (&obstack,
#ifdef NO_SHARED_LIBGCC_MULTILIB
"-lgcc_s"
#else
"-lgcc_s%M"
#endif
,
"libgcc.a%s",
"libgcc_eh.a%s");
p += 10;
in_sep = 0;
}
else
{
obstack_1grow (&obstack, *p);
in_sep = (*p == ' ');
p += 1;
}
}
obstack_1grow (&obstack, '\0');
libgcc_spec = obstack_finish (&obstack);
}
#endif
#ifdef USE_AS_TRADITIONAL_FORMAT
{
static const char tf[] = "--traditional-format ";
obstack_grow (&obstack, tf, sizeof(tf) - 1);
obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
asm_spec = obstack_finish (&obstack);
}
#endif
#ifdef LINK_EH_SPEC
obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
obstack_grow0 (&obstack, link_spec, strlen (link_spec));
link_spec = obstack_finish (&obstack);
#endif
specs = sl;
}
static void
set_spec (name, spec)
const char *name;
const char *spec;
{
struct spec_list *sl;
const char *old_spec;
int name_len = strlen (name);
int i;
if (!specs)
{
struct spec_list *next = (struct spec_list *) 0;
for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
{
sl = &static_specs[i];
sl->next = next;
next = sl;
}
specs = sl;
}
for (sl = specs; sl; sl = sl->next)
if (name_len == sl->name_len && !strcmp (sl->name, name))
break;
if (!sl)
{
sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
sl->name = xstrdup (name);
sl->name_len = name_len;
sl->ptr_spec = &sl->ptr;
sl->alloc_p = 0;
*(sl->ptr_spec) = "";
sl->next = specs;
specs = sl;
}
old_spec = *(sl->ptr_spec);
*(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
? concat (old_spec, spec + 1, NULL)
: xstrdup (spec));
#ifdef DEBUG_SPECS
if (verbose_flag)
notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
#endif
if (old_spec && sl->alloc_p)
free ((PTR) old_spec);
sl->alloc_p = 1;
}
static const char **argbuf;
static int argbuf_length;
static int argbuf_index;
static struct temp_name {
const char *suffix;
int length;
int unique;
const char *filename;
int filename_length;
struct temp_name *next;
} *temp_names;
static int execution_count;
static int signal_count;
static const char *programname;
static void
clear_args ()
{
argbuf_index = 0;
}
static void
store_arg (arg, delete_always, delete_failure)
const char *arg;
int delete_always, delete_failure;
{
if (argbuf_index + 1 == argbuf_length)
argbuf
= (const char **) xrealloc (argbuf,
(argbuf_length *= 2) * sizeof (const char *));
argbuf[argbuf_index++] = arg;
argbuf[argbuf_index] = 0;
if (delete_always || delete_failure)
record_temp_file (arg, delete_always, delete_failure);
}
static char *
load_specs (filename)
const char *filename;
{
int desc;
int readlen;
struct stat statbuf;
char *buffer;
char *buffer_p;
char *specs;
char *specs_p;
if (verbose_flag)
notice ("Reading specs from %s\n", filename);
desc = open (filename, O_RDONLY, 0);
if (desc < 0)
pfatal_with_name (filename);
if (stat (filename, &statbuf) < 0)
pfatal_with_name (filename);
buffer = xmalloc ((unsigned) statbuf.st_size + 1);
readlen = read (desc, buffer, (unsigned) statbuf.st_size);
if (readlen < 0)
pfatal_with_name (filename);
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')
skip = 1;
else if (*(buffer_p + 1) == '\n')
skip = 1;
else
c = '\n';
}
if (! skip)
*specs_p++ = c;
}
*specs_p = '\0';
free (buffer);
return (specs);
}
static void
read_specs (filename, main_p)
const char *filename;
int main_p;
{
char *buffer;
char *p;
buffer = load_specs (filename);
p = buffer;
while (1)
{
char *suffix;
char *spec;
char *in, *out, *p1, *p2, *p3;
p = skip_whitespace (p);
if (*p == 0)
break;
if (*p == '%' && !main_p)
{
p1 = p;
while (*p && *p != '\n')
p++;
p++;
if (!strncmp (p1, "%include", sizeof ("%include") - 1)
&& (p1[sizeof "%include" - 1] == ' '
|| p1[sizeof "%include" - 1] == '\t'))
{
char *new_filename;
p1 += sizeof ("%include");
while (*p1 == ' ' || *p1 == '\t')
p1++;
if (*p1++ != '<' || p[-2] != '>')
fatal ("specs %%include syntax malformed after %ld characters",
(long) (p1 - buffer + 1));
p[-2] = '\0';
new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
read_specs (new_filename ? new_filename : p1, FALSE);
continue;
}
else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
&& (p1[sizeof "%include_noerr" - 1] == ' '
|| p1[sizeof "%include_noerr" - 1] == '\t'))
{
char *new_filename;
p1 += sizeof "%include_noerr";
while (*p1 == ' ' || *p1 == '\t')
p1++;
if (*p1++ != '<' || p[-2] != '>')
fatal ("specs %%include syntax malformed after %ld characters",
(long) (p1 - buffer + 1));
p[-2] = '\0';
new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
if (new_filename)
read_specs (new_filename, FALSE);
else if (verbose_flag)
notice ("could not find specs file %s\n", p1);
continue;
}
else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
&& (p1[sizeof "%rename" - 1] == ' '
|| p1[sizeof "%rename" - 1] == '\t'))
{
int name_len;
struct spec_list *sl;
p1 += sizeof "%rename";
while (*p1 == ' ' || *p1 == '\t')
p1++;
if (! ISALPHA ((unsigned char) *p1))
fatal ("specs %%rename syntax malformed after %ld characters",
(long) (p1 - buffer));
p2 = p1;
while (*p2 && !ISSPACE ((unsigned char) *p2))
p2++;
if (*p2 != ' ' && *p2 != '\t')
fatal ("specs %%rename syntax malformed after %ld characters",
(long) (p2 - buffer));
name_len = p2 - p1;
*p2++ = '\0';
while (*p2 == ' ' || *p2 == '\t')
p2++;
if (! ISALPHA ((unsigned char) *p2))
fatal ("specs %%rename syntax malformed after %ld characters",
(long) (p2 - buffer));
p3 = p2;
while (*p3 && !ISSPACE ((unsigned char) *p3))
p3++;
if (p3 != p - 1)
fatal ("specs %%rename syntax malformed after %ld characters",
(long) (p3 - buffer));
*p3 = '\0';
for (sl = specs; sl; sl = sl->next)
if (name_len == sl->name_len && !strcmp (sl->name, p1))
break;
if (!sl)
fatal ("specs %s spec was not found to be renamed", p1);
if (strcmp (p1, p2) == 0)
continue;
if (verbose_flag)
{
notice ("rename spec %s to %s\n", p1, p2);
#ifdef DEBUG_SPECS
notice ("spec is '%s'\n\n", *(sl->ptr_spec));
#endif
}
set_spec (p2, *(sl->ptr_spec));
if (sl->alloc_p)
free ((PTR) *(sl->ptr_spec));
*(sl->ptr_spec) = "";
sl->alloc_p = 0;
continue;
}
else
fatal ("specs unknown %% command after %ld characters",
(long) (p1 - buffer));
}
p1 = p;
while (*p1 && *p1 != ':' && *p1 != '\n')
p1++;
if (*p1 != ':')
fatal ("specs file malformed after %ld characters",
(long) (p1 - buffer));
p2 = p1;
while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
p2--;
suffix = save_string (p, p2 - p);
p = skip_whitespace (p1 + 1);
if (p[1] == 0)
fatal ("specs file malformed after %ld characters",
(long) (p - buffer));
p1 = p;
while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
p1++;
spec = save_string (p, p1 - p);
p = p1;
in = spec;
out = spec;
while (*in != 0)
{
if (in[0] == '\\' && in[1] == '\n')
in += 2;
else if (in[0] == '#')
while (*in && *in != '\n')
in++;
else
*out++ = *in++;
}
*out = 0;
if (suffix[0] == '*')
{
if (! strcmp (suffix, "*link_command"))
link_command_spec = spec;
else
set_spec (suffix + 1, spec);
}
else
{
compilers
= ((struct compiler *)
xrealloc (compilers,
(n_compilers + 2) * sizeof (struct compiler)));
compilers[n_compilers].suffix = suffix;
compilers[n_compilers].spec = spec;
n_compilers++;
memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
}
if (*suffix == 0)
link_command_spec = spec;
}
if (link_command_spec == 0)
fatal ("spec file has no spec for linking");
}
static const char *temp_filename;
static int temp_filename_length;
struct temp_file
{
const char *name;
struct temp_file *next;
};
static struct temp_file *always_delete_queue;
static struct temp_file *failure_delete_queue;
void
record_temp_file (filename, always_delete, fail_delete)
const char *filename;
int always_delete;
int fail_delete;
{
char *const name = xstrdup (filename);
if (always_delete)
{
struct temp_file *temp;
for (temp = always_delete_queue; temp; temp = temp->next)
if (! strcmp (name, temp->name))
goto already1;
temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
temp->next = always_delete_queue;
temp->name = name;
always_delete_queue = temp;
already1:;
}
if (fail_delete)
{
struct temp_file *temp;
for (temp = failure_delete_queue; temp; temp = temp->next)
if (! strcmp (name, temp->name))
goto already2;
temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
temp->next = failure_delete_queue;
temp->name = name;
failure_delete_queue = temp;
already2:;
}
}
static void
delete_if_ordinary (name)
const char *name;
{
struct stat st;
#ifdef DEBUG
int i, c;
printf ("Delete %s? (y or n) ", name);
fflush (stdout);
i = getchar ();
if (i != '\n')
while ((c = getchar ()) != '\n' && c != EOF)
;
if (i == 'y' || i == 'Y')
#endif
if (stat (name, &st) >= 0 && S_ISREG (st.st_mode))
if (unlink (name) < 0)
if (verbose_flag)
perror_with_name (name);
}
static void
delete_temp_files ()
{
struct temp_file *temp;
for (temp = always_delete_queue; temp; temp = temp->next)
delete_if_ordinary (temp->name);
always_delete_queue = 0;
}
static void
delete_failure_queue ()
{
struct temp_file *temp;
for (temp = failure_delete_queue; temp; temp = temp->next)
delete_if_ordinary (temp->name);
}
static void
clear_failure_queue ()
{
failure_delete_queue = 0;
}
static char *
build_search_list (paths, prefix, check_dir_p)
struct path_prefix *paths;
const char *prefix;
int check_dir_p;
{
int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
int just_suffix_len
= (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
int first_time = TRUE;
struct prefix_list *pprefix;
obstack_grow (&collect_obstack, prefix, strlen (prefix));
obstack_1grow (&collect_obstack, '=');
for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
{
int len = strlen (pprefix->prefix);
if (machine_suffix
&& (! check_dir_p
|| is_directory (pprefix->prefix, machine_suffix, 0)))
{
if (!first_time)
obstack_1grow (&collect_obstack, '\n');
first_time = FALSE;
obstack_grow (&collect_obstack, pprefix->prefix, len);
obstack_grow (&collect_obstack, machine_suffix, suffix_len);
}
if (just_machine_suffix
&& pprefix->require_machine_suffix == 2
&& (! check_dir_p
|| is_directory (pprefix->prefix, just_machine_suffix, 0)))
{
if (! first_time)
obstack_1grow (&collect_obstack, '\n');
first_time = FALSE;
obstack_grow (&collect_obstack, pprefix->prefix, len);
obstack_grow (&collect_obstack, just_machine_suffix,
just_suffix_len);
}
if (! pprefix->require_machine_suffix)
{
if (! first_time)
obstack_1grow (&collect_obstack, '\n');
first_time = FALSE;
obstack_grow (&collect_obstack, pprefix->prefix, len);
}
}
obstack_1grow (&collect_obstack, '\0');
return obstack_finish (&collect_obstack);
}
static void
putenv_from_prefixes (paths, env_var)
struct path_prefix *paths;
const char *env_var;
{
putenv (build_search_list (paths, env_var, 1));
}
#ifndef VMS
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;
p = name;
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
{
p += 3;
num_dirs++;
}
#endif
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));
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
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;
if (ptr_num_dirs)
*ptr_num_dirs = num_dirs;
return dirs;
}
static void
free_split_directories (dirs)
char **dirs;
{
int i = 0;
while (dirs[i] != NULL)
free (dirs[i++]);
free ((char *) dirs);
}
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 (prog_num == 1)
{
char *temp;
GET_ENV_PATH_LIST (temp, "PATH");
if (temp)
{
char *startp, *endp, *nstore;
size_t prefixlen = strlen (temp) + 1;
if (prefixlen < 2)
prefixlen = 2;
nstore = (char *) alloca (prefixlen + 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_HOST_EXECUTABLE_SUFFIX
|| ! access (strcat (nstore, HOST_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++;
}
}
}
prog_num--;
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;
}
}
prefix_dirs = split_directories (prefix, &prefix_num);
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 (common == 0)
{
free_split_directories (prog_dirs);
free_split_directories (bin_dirs);
free_split_directories (prefix_dirs);
return NULL;
}
for (i = 0; i < prog_num; i++)
obstack_grow (&obstack, prog_dirs[i], strlen (prog_dirs[i]));
for (i = common; i < n; i++)
{
obstack_grow (&obstack, DIR_UP, sizeof (DIR_UP) - 1);
obstack_1grow (&obstack, DIR_SEPARATOR);
}
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
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);
}
static char *
find_a_file (pprefix, name, mode)
struct path_prefix *pprefix;
const char *name;
int mode;
{
char *temp;
const char *const file_suffix =
((mode & X_OK) != 0 ? HOST_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)
return xstrdup (DEFAULT_ASSEMBLER);
#endif
#ifdef DEFAULT_LINKER
if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
return xstrdup (DEFAULT_LINKER);
#endif
if (machine_suffix)
len += strlen (machine_suffix);
temp = xmalloc (len);
if (IS_ABSOLUTE_PATHNAME (name))
{
if (access (name, mode) == 0)
{
strcpy (temp, name);
return temp;
}
}
else
for (pl = pprefix->plist; pl; pl = pl->next)
{
if (machine_suffix)
{
if (file_suffix[0] != 0)
{
strcpy (temp, pl->prefix);
strcat (temp, machine_suffix);
strcat (temp, name);
strcat (temp, file_suffix);
if (access_check (temp, mode) == 0)
{
if (pl->used_flag_ptr != 0)
*pl->used_flag_ptr = 1;
return temp;
}
}
strcpy (temp, pl->prefix);
strcat (temp, machine_suffix);
strcat (temp, name);
if (access_check (temp, mode) == 0)
{
if (pl->used_flag_ptr != 0)
*pl->used_flag_ptr = 1;
return temp;
}
}
if (just_machine_suffix && pl->require_machine_suffix == 2)
{
if (file_suffix[0] != 0)
{
strcpy (temp, pl->prefix);
strcat (temp, just_machine_suffix);
strcat (temp, name);
strcat (temp, file_suffix);
if (access_check (temp, mode) == 0)
{
if (pl->used_flag_ptr != 0)
*pl->used_flag_ptr = 1;
return temp;
}
}
strcpy (temp, pl->prefix);
strcat (temp, just_machine_suffix);
strcat (temp, name);
if (access_check (temp, mode) == 0)
{
if (pl->used_flag_ptr != 0)
*pl->used_flag_ptr = 1;
return temp;
}
}
if (! pl->require_machine_suffix)
{
if (file_suffix[0] != 0)
{
strcpy (temp, pl->prefix);
strcat (temp, name);
strcat (temp, file_suffix);
if (access_check (temp, mode) == 0)
{
if (pl->used_flag_ptr != 0)
*pl->used_flag_ptr = 1;
return temp;
}
}
strcpy (temp, pl->prefix);
strcat (temp, name);
if (access_check (temp, mode) == 0)
{
if (pl->used_flag_ptr != 0)
*pl->used_flag_ptr = 1;
return temp;
}
}
}
free (temp);
return 0;
}
enum path_prefix_priority
{
PREFIX_PRIORITY_B_OPT,
PREFIX_PRIORITY_LAST
};
static void
add_prefix (pprefix, prefix, component, priority, require_machine_suffix, warn)
struct path_prefix *pprefix;
const char *prefix;
const char *component;
int priority;
int require_machine_suffix;
int *warn;
{
struct prefix_list *pl, **prev;
int len;
for (prev = &pprefix->plist;
(*prev) != NULL && (*prev)->priority <= priority;
prev = &(*prev)->next)
;
prefix = update_path (prefix, component);
len = strlen (prefix);
if (len > pprefix->max_len)
pprefix->max_len = len;
pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
pl->prefix = prefix;
pl->require_machine_suffix = require_machine_suffix;
pl->used_flag_ptr = warn;
pl->priority = priority;
if (warn)
*warn = 0;
pl->next = (*prev);
(*prev) = pl;
}
#ifdef FRAMEWORK_HEADERS
static void
safe_add_prefix (pprefix, prefix, first, require_machine_suffix, warn)
struct path_prefix *pprefix;
char *prefix;
int first;
int require_machine_suffix;
int *warn;
{
int len = strlen (prefix);
char *temp = prefix;
if (prefix[len - 1] != '/')
{
temp = xmalloc (len+2);
strcpy (temp, prefix);
temp[len] = '/';
temp[len+1] = 0;
}
add_prefix (pprefix, temp, "GCC", first, require_machine_suffix, warn);
}
#endif
static int
execute ()
{
int i;
int n_commands;
char *string;
struct command
{
const char *prog;
const char **argv;
int pid;
};
struct command *commands;
for (n_commands = 1, i = 0; i < argbuf_index; i++)
if (strcmp (argbuf[i], "|") == 0)
n_commands++;
commands = (struct command *) alloca (n_commands * sizeof (struct command));
commands[0].prog = argbuf[0];
commands[0].argv = &argbuf[0];
string = find_a_file (&exec_prefixes, commands[0].prog, X_OK);
if (string)
commands[0].argv[0] = string;
for (n_commands = 1, i = 0; i < argbuf_index; i++)
if (strcmp (argbuf[i], "|") == 0)
{
#if defined (__MSDOS__) || defined (OS2) || defined (VMS)
fatal ("-pipe not supported");
#endif
argbuf[i] = 0;
commands[n_commands].prog = argbuf[i + 1];
commands[n_commands].argv = &argbuf[i + 1];
string = find_a_file (&exec_prefixes, commands[n_commands].prog, X_OK);
if (string)
commands[n_commands].argv[0] = string;
else if (strcmp (commands[n_commands].prog, "c++filt3") == 0
&& access ("/usr/bin/c++filt3", X_OK) != 0)
continue;
n_commands++;
}
argbuf[argbuf_index] = 0;
if (verbose_flag)
{
if (print_help_list)
fputc ('\n', stderr);
for (i = 0; i < n_commands; i++)
{
const char *const *j;
if (verbose_only_flag)
{
for (j = commands[i].argv; *j; j++)
{
const char *p;
fprintf (stderr, " \"");
for (p = *j; *p; ++p)
{
if (*p == '"' || *p == '\\' || *p == '$')
fputc ('\\', stderr);
fputc (*p, stderr);
}
fputc ('"', stderr);
}
}
else
for (j = commands[i].argv; *j; j++)
fprintf (stderr, " %s", *j);
if (i + 1 != n_commands)
fprintf (stderr, " |");
fprintf (stderr, "\n");
}
fflush (stderr);
if (verbose_only_flag != 0)
return 0;
#ifdef DEBUG
notice ("\nGo ahead? (y or n) ");
fflush (stderr);
i = getchar ();
if (i != '\n')
while (getchar () != '\n')
;
if (i != 'y' && i != 'Y')
return 0;
#endif
}
for (i = 0; i < n_commands; i++)
{
char *errmsg_fmt, *errmsg_arg;
const char *string = commands[i].argv[0];
if (verbose_flag && print_help_list
&& (!strcmp ("/usr/libexec/gcc/darwin/ppc/cpp-precomp", string)
|| !strcmp ("/usr/libexec/gcc/darwin/ppc/as", string)
|| !strcmp ("/usr/libexec/gcc/darwin/i386/as", string)
|| !strcmp ("ld", string)
|| !strcmp ("/usr/libexec/gcc/darwin/i386/cpp-precomp", string)))
{
}
else
commands[i].pid = pexecute (string, (char *const *) commands[i].argv,
programname, temp_filename,
&errmsg_fmt, &errmsg_arg,
((i == 0 ? PEXECUTE_FIRST : 0)
| (i + 1 == n_commands ? PEXECUTE_LAST : 0)
| (string == commands[i].prog
? PEXECUTE_SEARCH : 0)
| (verbose_flag ? PEXECUTE_VERBOSE : 0)));
if (commands[i].pid == -1)
pfatal_pexecute (errmsg_fmt, errmsg_arg);
if (string != commands[i].prog)
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;)
{
int j;
int status;
int pid;
if (verbose_flag && print_help_list
&& (!strcmp ("/usr/libexec/gcc/darwin/ppc/cpp-precomp", commands[i].prog)
|| !strcmp ("as", commands[i].prog)
|| !strcmp ("ld", commands[i].prog)
|| !strcmp ("/usr/libexec/gcc/darwin/i386/cpp-precomp", commands[i].prog)))
{
i++;
continue;
}
pid = pwait (commands[i].pid, &status, 0);
if (pid < 0)
abort ();
#ifdef HAVE_GETRUSAGE
if (report_times)
{
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 (WIFSIGNALED (status))
{
#ifdef SIGPIPE
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;
}
}
return ret_code;
}
}
#define SWITCH_OK 0
#define SWITCH_FALSE -1
#define SWITCH_IGNORE -2
#define SWITCH_IGNORE_RESTORE -3
#define SWITCH_LIVE 1
struct switchstr
{
const char *part1;
const char **args;
int live_cond;
unsigned char validated;
unsigned char ordering;
};
static struct switchstr *switches;
static int n_switches;
struct infile
{
const char *name;
const char *language;
};
static struct infile *infiles;
int n_infiles;
static int added_libraries;
const char **outfiles;
static int warn_B;
static int warn_std;
static int *warn_std_ptr = 0;
#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
static const char *
convert_filename (name, do_exe, do_obj)
const char *name;
int do_exe ATTRIBUTE_UNUSED;
int do_obj ATTRIBUTE_UNUSED;
{
#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
int i;
#endif
int len;
if (name == NULL)
return NULL;
len = strlen (name);
#ifdef HAVE_TARGET_OBJECT_SUFFIX
if (do_obj && len > 2
&& name[len - 2] == '.'
&& name[len - 1] == 'o')
{
obstack_grow (&obstack, name, len - 2);
obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
name = obstack_finish (&obstack);
}
#endif
#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
return name;
for (i = len - 1; i >= 0; i--)
if (IS_DIR_SEPARATOR (name[i]))
break;
for (i++; i < len; i++)
if (name[i] == '.')
return name;
obstack_grow (&obstack, name, len);
obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
strlen (TARGET_EXECUTABLE_SUFFIX));
name = obstack_finish (&obstack);
#endif
return name;
}
#endif
static void
display_help ()
{
printf (_("Usage: %s [options] file...\n"), programname);
fputs (_("Options:\n"), stdout);
fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
fputs (_(" --help Display this information\n"), stdout);
fputs (_(" --target-help Display target specific command line options\n"), stdout);
if (! verbose_flag)
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 built-in 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 (_(" -### Like -v but options quoted and commands not executed\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 behavior of\n\
guessing the language based on the file's extension\n\
"), stdout);
printf (_("\
\nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
passed on to the various sub-processes invoked by %s. In order to pass\n\
other options on to these processes the -W<letter> options must be used.\n\
"), programname);
}
static void
add_preprocessor_option (option, len)
const char *option;
int len;
{
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 *));
preprocessor_options [n_preprocessor_options - 1] =
save_string (option, len);
}
static void
add_assembler_option (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)
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);
}
static void
process_command (argc, argv)
int argc;
const char *const *argv;
{
int i;
const char *temp;
char *temp1;
const char *spec_lang = 0;
int last_language_n_infiles;
int have_c = 0;
int have_o = 0;
int lang_n_infiles = 0;
#ifdef MODIFY_TARGET_NAME
int is_modify_target_name;
int j;
#endif
GET_ENV_PATH_LIST (gcc_exec_prefix, "GCC_EXEC_PREFIX");
n_switches = 0;
n_infiles = 0;
added_libraries = 0;
compiler_version = temp1 = xstrdup (version_string);
for (; *temp1; ++temp1)
{
if (*temp1 == ' ')
{
*temp1 = '\0';
break;
}
}
#ifndef 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));
}
#endif
#ifndef PHAT
if (gcc_exec_prefix)
{
int len = strlen (gcc_exec_prefix);
if (len > (int) sizeof ("/lib/gcc-lib/") - 1
&& (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
{
temp = gcc_exec_prefix + len - sizeof ("/lib/gcc-lib/") + 1;
if (IS_DIR_SEPARATOR (*temp)
&& strncmp (temp + 1, "lib", 3) == 0
&& IS_DIR_SEPARATOR (temp[4])
&& strncmp (temp + 5, "gcc-lib", 7) == 0)
len -= sizeof ("/lib/gcc-lib/") - 1;
}
set_std_prefix (gcc_exec_prefix, len);
add_prefix (&exec_prefixes, gcc_exec_prefix, "GCC",
PREFIX_PRIORITY_LAST, 0, NULL);
add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
PREFIX_PRIORITY_LAST, 0, NULL);
}
#endif
GET_ENV_PATH_LIST (temp, "COMPILER_PATH");
if (temp)
{
const char *startp, *endp;
char *nstore = (char *) alloca (strlen (temp) + 3);
startp = endp = temp;
while (1)
{
if (*endp == PATH_SEPARATOR || *endp == 0)
{
strncpy (nstore, startp, endp - startp);
if (endp == startp)
strcpy (nstore, concat (".", dir_separator_str, NULL));
else if (!IS_DIR_SEPARATOR (endp[-1]))
{
nstore[endp - startp] = DIR_SEPARATOR;
nstore[endp - startp + 1] = 0;
}
else
nstore[endp - startp] = 0;
add_prefix (&exec_prefixes, nstore, 0,
PREFIX_PRIORITY_LAST, 0, NULL);
add_prefix (&include_prefixes,
concat (nstore, "include", NULL),
0, PREFIX_PRIORITY_LAST, 0, NULL);
if (*endp == 0)
break;
endp = startp = endp + 1;
}
else
endp++;
}
}
GET_ENV_PATH_LIST (temp, LIBRARY_PATH_ENV);
if (temp && *cross_compile == '0')
{
const char *startp, *endp;
char *nstore = (char *) alloca (strlen (temp) + 3);
startp = endp = temp;
while (1)
{
if (*endp == PATH_SEPARATOR || *endp == 0)
{
strncpy (nstore, startp, endp - startp);
if (endp == startp)
strcpy (nstore, concat (".", dir_separator_str, NULL));
else if (!IS_DIR_SEPARATOR (endp[-1]))
{
nstore[endp - startp] = DIR_SEPARATOR;
nstore[endp - startp + 1] = 0;
}
else
nstore[endp - startp] = 0;
add_prefix (&startfile_prefixes, nstore, NULL,
PREFIX_PRIORITY_LAST, 0, NULL);
if (*endp == 0)
break;
endp = startp = endp + 1;
}
else
endp++;
}
}
GET_ENV_PATH_LIST (temp, "LPATH");
if (temp && *cross_compile == '0')
{
const char *startp, *endp;
char *nstore = (char *) alloca (strlen (temp) + 3);
startp = endp = temp;
while (1)
{
if (*endp == PATH_SEPARATOR || *endp == 0)
{
strncpy (nstore, startp, endp - startp);
if (endp == startp)
strcpy (nstore, concat (".", dir_separator_str, NULL));
else if (!IS_DIR_SEPARATOR (endp[-1]))
{
nstore[endp - startp] = DIR_SEPARATOR;
nstore[endp - startp + 1] = 0;
}
else
nstore[endp - startp] = 0;
add_prefix (&startfile_prefixes, nstore, NULL,
PREFIX_PRIORITY_LAST, 0, NULL);
if (*endp == 0)
break;
endp = startp = endp + 1;
}
else
endp++;
}
}
macosx_deployment_target = getenv ("MACOSX_DEPLOYMENT_TARGET");
if (macosx_deployment_target)
{
struct macosx_vers *v = macosx_vers_tbl;
while (v->vers_str && strcmp (macosx_deployment_target, v->vers_str))
v++;
if (v->vers_str)
{
macosx_version_min_required = v->vers_num;
use_constant_cfstrings = (macosx_version_min_required >= 1020);
}
}
translate_options (&argc, &argv);
lang_specific_driver (&argc, &argv, &added_libraries);
for (i = 1; i < argc; i++)
{
if (! strcmp (argv[i], "-dumpspecs"))
{
struct spec_list *sl;
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"))
{
printf ("%s\n", spec_version);
exit (0);
}
else if (! strcmp (argv[i], "-dumpmachine"))
{
printf ("%s\n", spec_machine);
exit (0);
}
else if (strcmp (argv[i], "-fversion") == 0)
{
printf (_("%s (GCC) %s\n"), programname, version_string);
fputs (_("Copyright (C) 2002 Free Software Foundation, Inc.\n"),
stdout);
fputs (_("This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
stdout);
exit (0);
}
else if (strcmp (argv[i], "-fhelp") == 0)
{
print_help_list = 1;
n_infiles++;
n_switches++;
if (is_cpp_driver)
add_preprocessor_option ("--help", 6);
#if 0
add_assembler_option ("--help", 6);
add_linker_option ("--help", 6);
#endif
}
else if (strcmp (argv[i], "-ftarget-help") == 0)
{
target_help_flag = 1;
n_infiles++;
n_switches++;
if (is_cpp_driver)
add_preprocessor_option ("--target-help", 13);
add_assembler_option ("--target-help", 13);
add_linker_option ("--target-help", 13);
}
if (strcmp (argv[i], "-arch") == 0)
{
int a;
if (++i >= argc)
fatal ("argument to `-arch' is missing");
for (a = 0; a < num_arches; ++a)
{
if (strcmp (argv[i], arches[a].name) == 0)
break;
}
if (a >= num_arches)
{
if (num_arches >= MAX_ARCHES)
fatal ("more than %d architectures specified", MAX_ARCHES);
arches[num_arches++].name = argv[i];
}
}
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"))
print_file_name = "libgcc.a";
else if (! strncmp (argv[i], "-print-file-name=", 17))
print_file_name = argv[i] + 17;
else if (! strncmp (argv[i], "-print-prog-name=", 17))
print_prog_name = argv[i] + 17;
else if (! strcmp (argv[i], "-print-multi-lib"))
print_multi_lib = 1;
else if (! strcmp (argv[i], "-print-multi-directory"))
print_multi_directory = 1;
else if (! strncmp (argv[i], "-Wa,", 4))
{
int prev, j;
prev = 4;
for (j = 4; argv[i][j]; j++)
if (argv[i][j] == ',')
{
add_assembler_option (argv[i] + prev, j - prev);
prev = j + 1;
}
add_assembler_option (argv[i] + prev, j - prev);
}
else if (! strncmp (argv[i], "-Wp,", 4))
{
int prev, j;
prev = 4;
for (j = 4; argv[i][j]; j++)
if (argv[i][j] == ',')
{
add_preprocessor_option (argv[i] + prev, j - prev);
prev = j + 1;
}
add_preprocessor_option (argv[i] + prev, j - prev);
}
else if (argv[i][0] == '+' && argv[i][1] == 'e')
n_switches++;
else if (strncmp (argv[i], "-Wl,", 4) == 0)
{
int j;
for (j = 3; argv[i][j]; j++)
n_infiles += (argv[i][j] == ',');
}
else if (strcmp (argv[i], "-Xlinker") == 0)
{
if (i + 1 == argc)
fatal ("argument to `-Xlinker' is missing");
n_infiles++;
i++;
}
else if (strcmp (argv[i], "-l") == 0)
{
if (i + 1 == argc)
fatal ("argument to `-l' is missing");
n_infiles++;
i++;
}
else if (strncmp (argv[i], "-l", 2) == 0)
n_infiles++;
else if (strcmp (argv[i], "-save-temps") == 0)
{
save_temps_flag = 1;
n_switches++;
}
else if (strcmp (argv[i], "-specs") == 0)
{
struct user_specs *user = (struct user_specs *)
xmalloc (sizeof (struct user_specs));
if (++i >= argc)
fatal ("argument to `-specs' is missing");
user->next = (struct user_specs *) 0;
user->filename = argv[i];
if (user_specs_tail)
user_specs_tail->next = user;
else
user_specs_head = user;
user_specs_tail = user;
}
else if (strncmp (argv[i], "-specs=", 7) == 0)
{
struct user_specs *user = (struct user_specs *)
xmalloc (sizeof (struct user_specs));
if (strlen (argv[i]) == 7)
fatal ("argument to `-specs=' is missing");
user->next = (struct user_specs *) 0;
user->filename = argv[i] + 7;
if (user_specs_tail)
user_specs_tail->next = user;
else
user_specs_head = user;
user_specs_tail = user;
}
else if (strcmp (argv[i], "-time") == 0)
report_times = 1;
else if (strcmp (argv[i], "-###") == 0)
{
verbose_only_flag++;
verbose_flag++;
}
else if (strcmp (argv[i], "-fconstant-cfstrings") == 0)
use_constant_cfstrings = 1;
else if (strcmp (argv[i], "-fno-constant-cfstrings") == 0)
use_constant_cfstrings = 0;
else if (strcmp (argv[i], "-framework") == 0)
{
if (i + 1 == argc)
fatal ("argument to `-framework' is missing");
n_infiles += 2;
i++;
}
else if (argv[i][0] == '-' && argv[i][1] != 0)
{
const char *p = &argv[i][1];
int c = *p;
switch (c)
{
case 'b':
n_switches++;
if (p[1] == 0 && i + 1 == argc)
fatal ("argument to `-b' is missing");
if (p[1] == 0)
spec_machine = argv[++i];
else
spec_machine = p + 1;
warn_std_ptr = &warn_std;
break;
case 'B':
{
const char *value;
int len;
if (p[1] == 0 && i + 1 == argc)
fatal ("argument to `-B' is missing");
if (p[1] == 0)
value = argv[++i];
else
value = p + 1;
len = strlen (value);
if (! IS_DIR_SEPARATOR (value [len - 1])
&& is_directory (value, "", 0))
{
char *tmp = xmalloc (len + 2);
strcpy (tmp, value);
tmp[len] = DIR_SEPARATOR;
tmp[++ len] = 0;
value = tmp;
}
if ((len == 7
|| (len > 7
&& (IS_DIR_SEPARATOR (value[len - 8]))))
&& strncmp (value + len - 7, "stage", 5) == 0
&& ISDIGIT (value[len - 2])
&& (IS_DIR_SEPARATOR (value[len - 1])))
{
if (len == 7)
add_prefix (&include_prefixes, "include", NULL,
PREFIX_PRIORITY_B_OPT, 0, NULL);
else
{
char * string = xmalloc (len + 1);
strncpy (string, value, len - 7);
strcpy (string + len - 7, "include");
add_prefix (&include_prefixes, string, NULL,
PREFIX_PRIORITY_B_OPT, 0, NULL);
}
}
add_prefix (&exec_prefixes, value, NULL,
PREFIX_PRIORITY_B_OPT, 0, &warn_B);
add_prefix (&startfile_prefixes, value, NULL,
PREFIX_PRIORITY_B_OPT, 0, &warn_B);
add_prefix (&include_prefixes, concat (value, "include", NULL),
NULL, PREFIX_PRIORITY_B_OPT, 0, NULL);
n_switches++;
}
break;
case 'v':
n_switches++;
if (p[1] != 0)
break;
verbose_flag++;
break;
case 'V':
n_switches++;
if (p[1] == 0 && i + 1 == argc)
fatal ("argument to `-V' is missing");
if (p[1] == 0)
spec_version = argv[++i];
else
spec_version = p + 1;
compiler_version = spec_version;
warn_std_ptr = &warn_std;
{
const char *v = compiler_version;
while (! ISDIGIT (*v))
v++;
if (v > compiler_version && v[-1] != '-')
fatal ("invalid version number format");
while (ISDIGIT (*v))
v++;
if (*v != '.')
fatal ("invalid version number format");
v++;
while (ISDIGIT (*v))
v++;
if (*v != 0 && *v != ' ' && *v != '.' && *v != '-')
fatal ("invalid version number format");
}
break;
case 'S':
case 'c':
if (p[1] == 0)
{
have_c = 1;
n_switches++;
break;
}
goto normal_switch;
case 'o':
have_o = 1;
#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
if (! have_c)
{
int skip;
int j = i + 1;
if (p[1] == 0)
++j;
while (j < argc)
{
if (argv[j][0] == '-')
{
if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
&& argv[j][2] == 0)
{
have_c = 1;
break;
}
else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
j += skip - (argv[j][2] != 0);
else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
j += skip;
}
j++;
}
}
#endif
#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
if (p[1] == 0)
argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
else
argv[i] = convert_filename (argv[i], ! have_c, 0);
#endif
if (p[1] == '\0')
final_output = argv[i + 1];
goto normal_switch;
default:
normal_switch:
#ifdef MODIFY_TARGET_NAME
is_modify_target_name = 0;
for (j = 0;
j < sizeof modify_target / sizeof modify_target[0]; j++)
if (! strcmp (argv[i], modify_target[j].sw))
{
char *new_name
= (char *) xmalloc (strlen (modify_target[j].str)
+ strlen (spec_machine));
const char *p, *r;
char *q;
int made_addition = 0;
is_modify_target_name = 1;
for (p = spec_machine, q = new_name; *p != 0; )
{
if (modify_target[j].add_del == DELETE
&& (! strncmp (q, modify_target[j].str,
strlen (modify_target[j].str))))
p += strlen (modify_target[j].str);
else if (modify_target[j].add_del == ADD
&& ! made_addition && *p == '-')
{
for (r = modify_target[j].str; *r != 0; )
*q++ = *r++;
made_addition = 1;
}
*q++ = *p++;
}
spec_machine = new_name;
}
if (is_modify_target_name)
break;
#endif
n_switches++;
if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
else if (WORD_SWITCH_TAKES_ARG (p))
i += WORD_SWITCH_TAKES_ARG (p);
}
}
else
{
n_infiles++;
lang_n_infiles++;
}
}
if (have_c && have_o && lang_n_infiles > 1)
fatal ("cannot specify -o with -c or -S and multiple compilations");
#ifndef OS2
add_prefix (&exec_prefixes, standard_exec_prefix, "GCC",
PREFIX_PRIORITY_LAST, 1, warn_std_ptr);
add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
PREFIX_PRIORITY_LAST, 2, warn_std_ptr);
add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
PREFIX_PRIORITY_LAST, 2, warn_std_ptr);
#endif
add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
PREFIX_PRIORITY_LAST, 1, warn_std_ptr);
add_prefix (&startfile_prefixes, standard_exec_prefix_1, "BINUTILS",
PREFIX_PRIORITY_LAST, 1, warn_std_ptr);
tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
dir_separator_str, NULL);
if (!IS_ABSOLUTE_PATHNAME (tooldir_prefix))
{
if (gcc_exec_prefix)
{
char *gcc_exec_tooldir_prefix
= concat (gcc_exec_prefix, spec_machine, dir_separator_str,
spec_version, dir_separator_str, tooldir_prefix, NULL);
add_prefix (&exec_prefixes,
concat (gcc_exec_tooldir_prefix, "bin",
dir_separator_str, NULL),
NULL, PREFIX_PRIORITY_LAST, 0, NULL);
add_prefix (&startfile_prefixes,
concat (gcc_exec_tooldir_prefix, "lib",
dir_separator_str, NULL),
NULL, PREFIX_PRIORITY_LAST, 0, NULL);
}
tooldir_prefix = concat (standard_exec_prefix, spec_machine,
dir_separator_str, spec_version,
dir_separator_str, tooldir_prefix, NULL);
}
add_prefix (&exec_prefixes,
concat (tooldir_prefix, "bin", dir_separator_str, NULL),
"BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
add_prefix (&startfile_prefixes,
concat (tooldir_prefix, "lib", dir_separator_str, NULL),
"BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
if (use_constant_cfstrings)
{
if (macosx_version_min_required && macosx_version_min_required < 1020)
{
error ("warning: `-fconstant-cfstrings' ignored because MACOSX_DEPLOYMENT_TARGET is \"%s\"",
macosx_deployment_target);
use_constant_cfstrings = 0;
}
else
add_preprocessor_option ("-D__CONSTANT_CFSTRINGS__", 24);
}
switches = ((struct switchstr *)
xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
n_switches = 0;
n_infiles = 0;
last_language_n_infiles = -1;
for (i = 1; i < argc; i++)
{
#ifdef MODIFY_TARGET_NAME
is_modify_target_name = 0;
for (j = 0; j < sizeof modify_target / sizeof modify_target[0]; j++)
if (! strcmp (argv[i], modify_target[j].sw))
is_modify_target_name = 1;
if (is_modify_target_name)
;
else
#endif
if (! strncmp (argv[i], "-Wa,", 4))
;
else if (! strncmp (argv[i], "-Wp,", 4))
;
else if (strcmp (argv[i], "-arch") == 0)
++i;
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"))
;
else if (! strncmp (argv[i], "-print-file-name=", 17))
;
else if (! strncmp (argv[i], "-print-prog-name=", 17))
;
else if (! strcmp (argv[i], "-print-multi-lib"))
;
else if (! strcmp (argv[i], "-print-multi-directory"))
;
else if (! strcmp (argv[i], "-ftarget-help"))
;
else if (! strcmp (argv[i], "-fhelp"))
;
else if (argv[i][0] == '+' && argv[i][1] == 'e')
{
switches[n_switches].part1 = &argv[i][0];
switches[n_switches].args = 0;
switches[n_switches].live_cond = SWITCH_OK;
switches[n_switches].validated = 0;
n_switches++;
}
else if (strncmp (argv[i], "-Wl,", 4) == 0)
{
int prev, j;
prev = 4;
for (j = 4; argv[i][j]; j++)
if (argv[i][j] == ',')
{
infiles[n_infiles].language = "*";
infiles[n_infiles++].name
= save_string (argv[i] + prev, j - prev);
prev = j + 1;
}
infiles[n_infiles].language = "*";
infiles[n_infiles++].name = argv[i] + prev;
}
else if (strcmp (argv[i], "-Xlinker") == 0)
{
infiles[n_infiles].language = "*";
infiles[n_infiles++].name = argv[++i];
}
else if (strcmp (argv[i], "-l") == 0)
{
infiles[n_infiles].language = "*";
infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
}
else if (strncmp (argv[i], "-l", 2) == 0)
{
infiles[n_infiles].language = "*";
infiles[n_infiles++].name = argv[i];
}
else if (strcmp (argv[i], "-specs") == 0)
i++;
else if (strncmp (argv[i], "-specs=", 7) == 0)
;
else if (strcmp (argv[i], "-ObjC") == 0)
{
default_language = "objective-c";
infiles[n_infiles].language = "*";
infiles[n_infiles++].name = "-ObjC";
}
else if (strcmp (argv[i], "-fobjc") == 0)
default_language = "objective-c";
else if (strcmp (argv[i], "-ObjC++") == 0)
default_language = "objective-c++";
else if (strcmp (argv[i], "-time") == 0)
;
else if ((save_temps_flag || report_times)
&& strcmp (argv[i], "-pipe") == 0)
{
if (save_temps_flag)
error ("warning: -pipe ignored because -save-temps specified");
else if (report_times)
error ("warning: -pipe ignored because -time specified");
}
else if (strcmp (argv[i], "-###") == 0)
;
else if (strcmp (argv[i], "-fconstant-cfstrings") == 0)
;
else if (strcmp (argv[i], "-fno-constant-cfstrings") == 0)
;
else if (strcmp (argv[i], "-framework") == 0)
{
infiles[n_infiles].language = "*";
infiles[n_infiles++].name = argv[i];
infiles[n_infiles].language = "*";
infiles[n_infiles++].name = argv[++i];
}
else if (argv[i][0] == '-' && argv[i][1] != 0)
{
const char *p = &argv[i][1];
int c = *p;
if (c == 'x')
{
if (p[1] == 0 && i + 1 == argc)
fatal ("argument to `-x' is missing");
if (p[1] == 0)
spec_lang = argv[++i];
else
spec_lang = p + 1;
if (! strcmp (spec_lang, "none"))
spec_lang = 0;
else
last_language_n_infiles = n_infiles;
continue;
}
switches[n_switches].part1 = p;
if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
|| WORD_SWITCH_TAKES_ARG (p))
{
int j = 0;
int n_args = WORD_SWITCH_TAKES_ARG (p);
if (n_args == 0)
{
n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
}
if (i + n_args >= argc)
fatal ("argument to `-%s' is missing", p);
switches[n_switches].args
= (const char **) xmalloc ((n_args + 1) * sizeof(const char *));
while (j < n_args)
switches[n_switches].args[j++] = argv[++i];
switches[n_switches].args[j] = 0;
}
else if (strchr (switches_need_spaces, c))
{
char *part1 = (char *) xmalloc (2);
part1[0] = c;
part1[1] = '\0';
switches[n_switches].part1 = part1;
switches[n_switches].args
= (const char **) xmalloc (2 * sizeof (const char *));
switches[n_switches].args[0] = xstrdup (p+1);
switches[n_switches].args[1] = 0;
}
else
switches[n_switches].args = 0;
switches[n_switches].live_cond = SWITCH_OK;
switches[n_switches].validated = 0;
switches[n_switches].ordering = 0;
if (!strcmp (p, "save-temps")
|| !strcmp (p, "static-libgcc")
|| !strcmp (p, "shared-libgcc"))
switches[n_switches].validated = 1;
else
{
char ch = switches[n_switches].part1[0];
if (ch == 'V' || ch == 'b' || ch == 'B')
switches[n_switches].validated = 1;
}
n_switches++;
}
else
{
#ifdef HAVE_TARGET_OBJECT_SUFFIX
argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
#endif
if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0)
{
perror_with_name (argv[i]);
error_count++;
}
else
{
infiles[n_infiles].language = spec_lang;
infiles[n_infiles++].name = argv[i];
}
}
}
if (n_infiles == last_language_n_infiles && spec_lang != 0)
error ("warning: `-x %s' after last input file has no effect", spec_lang);
if (target_help_flag || print_help_list)
{
n_infiles = 1;
infiles[0].language = "c";
infiles[0].name = "help-dummy";
if (target_help_flag)
{
switches[n_switches].part1 = "--target-help";
switches[n_switches].args = 0;
switches[n_switches].live_cond = SWITCH_OK;
switches[n_switches].validated = 0;
n_switches++;
}
if (print_help_list)
{
switches[n_switches].part1 = "--help";
switches[n_switches].args = 0;
switches[n_switches].live_cond = SWITCH_OK;
switches[n_switches].validated = 0;
n_switches++;
}
}
switches[n_switches].part1 = 0;
infiles[n_infiles].name = 0;
}
static void
set_collect_gcc_options ()
{
int i;
int first_time;
obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
sizeof ("COLLECT_GCC_OPTIONS=") - 1);
first_time = TRUE;
for (i = 0; (int) i < n_switches; i++)
{
const char *const *args;
const char *p, *q;
if (!first_time)
obstack_grow (&collect_obstack, " ", 1);
first_time = FALSE;
if (switches[i].live_cond == SWITCH_IGNORE
|| switches[i].live_cond == SWITCH_IGNORE_RESTORE)
continue;
obstack_grow (&collect_obstack, "'-", 2);
q = switches[i].part1;
while ((p = strchr (q, '\'')))
{
obstack_grow (&collect_obstack, q, p - q);
obstack_grow (&collect_obstack, "'\\''", 4);
q = ++p;
}
obstack_grow (&collect_obstack, q, strlen (q));
obstack_grow (&collect_obstack, "'", 1);
for (args = switches[i].args; args && *args; args++)
{
obstack_grow (&collect_obstack, " '", 2);
q = *args;
while ((p = strchr (q, '\'')))
{
obstack_grow (&collect_obstack, q, p - q);
obstack_grow (&collect_obstack, "'\\''", 4);
q = ++p;
}
obstack_grow (&collect_obstack, q, strlen (q));
obstack_grow (&collect_obstack, "'", 1);
}
}
obstack_grow (&collect_obstack, "\0", 1);
putenv (obstack_finish (&collect_obstack));
}
const char *input_filename;
static int input_file_number;
size_t input_filename_length;
static int basename_length;
static int suffixed_basename_length;
static const char *input_basename;
static const char *input_suffix;
static struct stat input_stat;
static int input_stat_set;
static struct compiler *input_file_compiler;
static int arg_going;
static int delete_this_arg;
static int this_is_output_file;
static int this_is_arch_merge_file;
static int this_is_basename_derived_file = 0;
static int this_is_library_file;
static int input_from_pipe;
static const char *suffix_subst;
int
do_spec (spec)
const char *spec;
{
int value;
clear_args ();
arg_going = 0;
delete_this_arg = 0;
this_is_output_file = 0;
this_is_arch_merge_file = 0;
this_is_basename_derived_file = 0;
this_is_library_file = 0;
input_from_pipe = 0;
suffix_subst = NULL;
value = do_spec_1 (spec, 0, NULL);
if (value == 0)
{
if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
argbuf_index--;
set_collect_gcc_options ();
if (argbuf_index > 0)
value = execute ();
}
return value;
}
static const char *
check_basename_derived_file (string)
const char *string;
{
int suffix_length, string_length;
const char *suffix;
static struct base_temp_name {
int suffix_length;
int filename_length;
const char *filename;
struct base_temp_name *next;
} *t, *base_temp_names = NULL;
if (strcmp (string, input_filename) != 0)
{
struct stat st_temp;
if (input_stat_set == 0)
{
input_stat_set = stat (input_filename, &input_stat);
if (input_stat_set >= 0)
input_stat_set = 1;
}
if (input_stat_set != 1
|| stat (string, &st_temp) < 0
|| input_stat.st_dev != st_temp.st_dev
|| input_stat.st_ino != st_temp.st_ino)
{
this_is_basename_derived_file = 0;
return string;
}
}
string_length = strlen (string);
suffix_length = string_length - basename_length;
if (suffix_length > 0)
{
suffix = string + string_length - suffix_length;
for (t = base_temp_names; t; t = t->next)
if (t->suffix_length == suffix_length
&& strcmp (t->filename + t->filename_length - suffix_length,
suffix) == 0)
break;
}
else
t = NULL;
if (!t)
{
t = (struct base_temp_name *) xmalloc (sizeof (struct base_temp_name));
t->next = base_temp_names;
base_temp_names = t;
t->filename = make_temp_file (suffix);
t->filename_length = strlen (t->filename);
t->suffix_length = suffix_length;
}
delete_this_arg = 1;
return t->filename;
}
static int
do_spec_1 (spec, inswitch, soft_matched_part)
const char *spec;
int inswitch;
const char *soft_matched_part;
{
const char *p = spec;
int c;
int i;
const char *string;
int value;
while ((c = *p++))
switch (inswitch ? 'a' : c)
{
case '\n':
if (arg_going)
{
obstack_1grow (&obstack, 0);
string = obstack_finish (&obstack);
if (this_is_basename_derived_file)
string = check_basename_derived_file (string);
else if (this_is_library_file)
string = find_file (string);
store_arg (string, delete_this_arg, this_is_output_file
|| this_is_arch_merge_file
|| this_is_basename_derived_file);
if (this_is_output_file)
outfiles[input_file_number] = string;
else if (this_is_arch_merge_file)
arches[current_arch].merge_file = string;
}
arg_going = 0;
if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
{
for (i = 0; i < n_switches; i++)
if (!strcmp (switches[i].part1, "pipe"))
break;
if (i < n_switches)
{
input_from_pipe = 1;
switches[i].validated = 1;
break;
}
else
argbuf_index--;
}
set_collect_gcc_options ();
if (argbuf_index > 0)
{
value = execute ();
if (value)
return value;
}
clear_args ();
arg_going = 0;
delete_this_arg = 0;
this_is_output_file = 0;
this_is_arch_merge_file = 0;
this_is_basename_derived_file = 0;
this_is_library_file = 0;
input_from_pipe = 0;
break;
case '|':
if (arg_going)
{
obstack_1grow (&obstack, 0);
string = obstack_finish (&obstack);
if (this_is_basename_derived_file)
string = check_basename_derived_file (string);
else if (this_is_library_file)
string = find_file (string);
store_arg (string, delete_this_arg, this_is_output_file
|| this_is_arch_merge_file
|| this_is_basename_derived_file);
if (this_is_output_file)
outfiles[input_file_number] = string;
else if (this_is_arch_merge_file)
arches[current_arch].merge_file = string;
}
obstack_1grow (&obstack, c);
arg_going = 1;
break;
case '\t':
case ' ':
if (arg_going)
{
obstack_1grow (&obstack, 0);
string = obstack_finish (&obstack);
if (this_is_basename_derived_file)
string = check_basename_derived_file (string);
else if (this_is_library_file)
string = find_file (string);
store_arg (string, delete_this_arg, this_is_output_file
|| this_is_arch_merge_file
|| this_is_basename_derived_file);
if (this_is_output_file)
outfiles[input_file_number] = string;
else if (this_is_arch_merge_file)
arches[current_arch].merge_file = string;
}
arg_going = 0;
delete_this_arg = 0;
this_is_output_file = 0;
this_is_arch_merge_file = 0;
this_is_basename_derived_file = 0;
this_is_library_file = 0;
break;
case '%':
switch (c = *p++)
{
case 0:
fatal ("invalid specification! Bug in cc");
case 'b':
this_is_basename_derived_file = 1;
obstack_grow (&obstack, input_basename, basename_length);
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;
case 'D':
{
struct prefix_list *pl = startfile_prefixes.plist;
size_t bufsize = 100;
char *buffer = (char *) xmalloc (bufsize);
int idx;
for (; pl; pl = pl->next)
{
#ifdef RELATIVE_PREFIX_NOT_LINKDIR
if (!IS_ABSOLUTE_PATHNAME (pl->prefix))
continue;
#endif
if (multilib_dir != NULL)
{
if (machine_suffix)
{
if (strlen (pl->prefix) + strlen (machine_suffix)
>= bufsize)
bufsize = (strlen (pl->prefix)
+ strlen (machine_suffix)) * 2 + 1;
buffer = (char *) xrealloc (buffer, bufsize);
strcpy (buffer, pl->prefix);
strcat (buffer, machine_suffix);
if (is_directory (buffer, multilib_dir, 1))
{
do_spec_1 ("-L", 0, NULL);
#ifdef SPACE_AFTER_L_OPTION
do_spec_1 (" ", 0, NULL);
#endif
do_spec_1 (buffer, 1, NULL);
do_spec_1 (multilib_dir, 1, NULL);
do_spec_1 (" ", 0, NULL);
}
}
if (!pl->require_machine_suffix)
{
if (is_directory (pl->prefix, multilib_dir, 1))
{
do_spec_1 ("-L", 0, NULL);
#ifdef SPACE_AFTER_L_OPTION
do_spec_1 (" ", 0, NULL);
#endif
do_spec_1 (pl->prefix, 1, NULL);
do_spec_1 (multilib_dir, 1, NULL);
do_spec_1 (" ", 0, NULL);
}
}
}
if (machine_suffix)
{
if (is_directory (pl->prefix, machine_suffix, 1))
{
do_spec_1 ("-L", 0, NULL);
#ifdef SPACE_AFTER_L_OPTION
do_spec_1 (" ", 0, NULL);
#endif
do_spec_1 (pl->prefix, 1, NULL);
if (strlen (machine_suffix) >= bufsize)
bufsize = strlen (machine_suffix) * 2 + 1;
buffer = (char *) xrealloc (buffer, bufsize);
strcpy (buffer, machine_suffix);
idx = strlen (buffer);
if (IS_DIR_SEPARATOR (buffer[idx - 1]))
buffer[idx - 1] = 0;
do_spec_1 (buffer, 1, NULL);
do_spec_1 (" ", 0, NULL);
}
}
if (!pl->require_machine_suffix)
{
if (is_directory (pl->prefix, "", 1))
{
do_spec_1 ("-L", 0, NULL);
#ifdef SPACE_AFTER_L_OPTION
do_spec_1 (" ", 0, NULL);
#endif
if (strlen (pl->prefix) >= bufsize)
bufsize = strlen (pl->prefix) * 2 + 1;
buffer = (char *) xrealloc (buffer, bufsize);
strcpy (buffer, pl->prefix);
idx = strlen (buffer);
if (IS_DIR_SEPARATOR (buffer[idx - 1]))
buffer[idx - 1] = 0;
do_spec_1 (buffer, 1, NULL);
do_spec_1 (" ", 0, NULL);
}
}
}
free (buffer);
}
break;
case 'e':
{
const char *q = p;
char *buf;
while (*p != 0 && *p != '\n')
p++;
buf = (char *) alloca (p - q + 1);
strncpy (buf, q, p - q);
buf[p - q] = 0;
error ("%s", buf);
return -1;
}
break;
case 'n':
{
const char *q = p;
char *buf;
while (*p != 0 && *p != '\n')
p++;
buf = (char *) alloca (p - q + 1);
strncpy (buf, q, p - q);
buf[p - q] = 0;
notice ("%s\n", buf);
if (*p)
p++;
}
break;
case 'j':
{
struct stat st;
if ((!save_temps_flag)
&& (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
&& (access (HOST_BIT_BUCKET, W_OK) == 0))
{
obstack_grow (&obstack, HOST_BIT_BUCKET,
strlen (HOST_BIT_BUCKET));
delete_this_arg = 0;
arg_going = 1;
break;
}
}
case 'g':
case 'u':
case 'U':
{
struct temp_name *t;
int suffix_length;
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;
if (*p == '.' || ISALPHA ((unsigned char) *p))
abort ();
if (suffix_length == 0)
suffix = TARGET_OBJECT_SUFFIX;
else
{
saved_suffix
= (char *) xmalloc (suffix_length
+ strlen (TARGET_OBJECT_SUFFIX));
strncpy (saved_suffix, suffix, suffix_length);
strcpy (saved_suffix + suffix_length,
TARGET_OBJECT_SUFFIX);
}
suffix_length += strlen (TARGET_OBJECT_SUFFIX);
}
if (save_temps_flag)
{
temp_filename_length = basename_length + suffix_length;
temp_filename = alloca (temp_filename_length + 1);
strncpy ((char *) temp_filename, input_basename, basename_length);
strncpy ((char *) temp_filename + basename_length, suffix,
suffix_length);
*((char *) temp_filename + temp_filename_length) = '\0';
if (strcmp (temp_filename, input_filename) != 0)
{
struct stat st_temp;
if (input_stat_set == 0)
{
input_stat_set = stat (input_filename, &input_stat);
if (input_stat_set >= 0)
input_stat_set = 1;
}
if (input_stat_set != 1
|| stat (temp_filename, &st_temp) < 0
|| input_stat.st_dev != st_temp.st_dev
|| input_stat.st_ino != st_temp.st_ino)
{
temp_filename = save_string (temp_filename,
temp_filename_length + 1);
obstack_grow (&obstack, temp_filename,
temp_filename_length);
delete_this_arg = 0;
arg_going = 1;
break;
}
}
}
for (t = temp_names; t; t = t->next)
if (t->length == suffix_length
&& strncmp (t->suffix, suffix, suffix_length) == 0
&& t->unique == (c != 'g'))
break;
if (t == 0 || c == 'u' || c == 'j')
{
if (t == 0)
{
t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
t->next = temp_names;
temp_names = t;
}
t->length = suffix_length;
if (saved_suffix)
{
t->suffix = saved_suffix;
saved_suffix = NULL;
}
else
t->suffix = save_string (suffix, suffix_length);
t->unique = (c != 'g');
temp_filename = make_temp_file (t->suffix);
temp_filename_length = strlen (temp_filename);
t->filename = temp_filename;
t->filename_length = temp_filename_length;
}
if (saved_suffix)
free (saved_suffix);
obstack_grow (&obstack, t->filename, t->filename_length);
delete_this_arg = (save_temps_flag == 0);
}
arg_going = 1;
break;
case 'i':
obstack_grow (&obstack, input_filename, input_filename_length);
arg_going = 1;
break;
case 'I':
{
struct prefix_list *pl = include_prefixes.plist;
if (gcc_exec_prefix)
{
do_spec_1 ("-iprefix", 1, NULL);
do_spec_1 (" ", 0, NULL);
do_spec_1 (gcc_exec_prefix, 1, NULL);
do_spec_1 (" ", 0, NULL);
}
for (; pl; pl = pl->next)
{
do_spec_1 ("-isystem", 1, NULL);
do_spec_1 (" ", 0, NULL);
do_spec_1 (pl->prefix, 1, NULL);
do_spec_1 (" ", 0, NULL);
}
}
break;
case 'Q':
#ifdef FRAMEWORK_HEADERS
{
struct prefix_list *dfpl = default_framework_paths.plist;
for (; dfpl; dfpl = dfpl->next)
{
char *tmpstr = xmalloc (strlen (dfpl->prefix) + 5);
sprintf (tmpstr, "-F%s", dfpl->prefix);
do_spec_1 (tmpstr, 1, NULL);
do_spec_1 (" ", 0, NULL);
free (tmpstr);
}
}
#endif
break;
case 'y':
{
int c1 = *p++;
if (c1 == 'V')
{
if (macosx_version_min_required)
{
char macro_def[40];
sprintf (macro_def, "-DMAC_OS_X_VERSION_MIN_REQUIRED=%d",
macosx_version_min_required);
do_spec_1 (" ", 0, NULL);
do_spec_1 (macro_def, 1, NULL);
do_spec_1 (" ", 0, NULL);
}
}
else if (c1 == 'C')
{
if (use_constant_cfstrings)
{
do_spec_1 (" ", 0, NULL);
do_spec_1 ("-fconstant-cfstrings", 1, NULL);
do_spec_1 (" ", 0, NULL);
}
}
else
{
char *tmpstr = xmalloc (strlen (STANDARD_EXEC_PREFIX)
+ strlen (DEFAULT_TARGET_VERSION)
+ strlen (DEFAULT_TARGET_MACHINE) + 25);
char *header_path = xmalloc (strlen (STANDARD_EXEC_PREFIX)
+ strlen (DEFAULT_TARGET_VERSION)
+ strlen (DEFAULT_TARGET_MACHINE) + 25);
do_spec_1 ("-isystem", 1, NULL);
do_spec_1 (" ", 0, NULL);
#ifdef PHAT
sprintf (tmpstr, "/usr/include/gcc/darwin/%s",
DEFAULT_TARGET_VERSION);
strcpy (header_path, tmpstr);
do_spec_1 (tmpstr, 1, NULL);
do_spec_1 (" ", 0, NULL);
sprintf (tmpstr, "-ispecs=%s%s/%s/specs",
STANDARD_EXEC_PREFIX,
arches[current_arch].name,
DEFAULT_TARGET_VERSION);
#else
sprintf (tmpstr, "%s%s/%s/include", STANDARD_EXEC_PREFIX,
DEFAULT_TARGET_MACHINE,
DEFAULT_TARGET_VERSION);
strcpy (header_path, tmpstr);
do_spec_1 (tmpstr, 1, NULL);
do_spec_1 (" ", 0, NULL);
sprintf (tmpstr, "-ispecs=%s%s/%s/specs", STANDARD_EXEC_PREFIX,
DEFAULT_TARGET_MACHINE,
DEFAULT_TARGET_VERSION);
#endif
do_spec_1 (tmpstr, 1, NULL);
do_spec_1 (" ", 0, NULL);
if (c1 == '1')
{
do_spec_1 ("-isystem", 1, NULL);
do_spec_1 (" ", 0, NULL);
sprintf (tmpstr, "%s/g++-v3", header_path);
do_spec_1 (tmpstr, 1, NULL);
do_spec_1 (" ", 0, NULL);
do_spec_1 ("-isystem", 1, NULL);
do_spec_1 (" ", 0, NULL);
sprintf (tmpstr, "%s/g++-v3/backward", header_path);
do_spec_1 (tmpstr, 1, NULL);
do_spec_1 (" ", 0, NULL);
do_spec_1 ("-isystem", 1, NULL);
do_spec_1 (" ", 0, NULL);
sprintf (tmpstr, "%s/g++-v3/%s-darwin", header_path,arches[current_arch].name);
do_spec_1 (tmpstr, 1, NULL);
do_spec_1 (" ", 0, NULL);
}
#ifndef NO_BUILTIN_SIZE_TYPE
sprintf (tmpstr, "-D__SIZE_TYPE__=%s", SIZE_TYPE);
do_spec_1 (tmpstr, 1, NULL);
do_spec_1 (" ", 0, NULL);
#endif
#ifndef NO_BUILTIN_PTRDIFF_TYPE
sprintf (tmpstr, "-D__PTRDIFF_TYPE__=%s", PTRDIFF_TYPE);
do_spec_1 (tmpstr, 1, NULL);
do_spec_1 (" ", 0, NULL);
#endif
#ifndef NO_BUILTIN_WCHAR_TYPE
sprintf (tmpstr, "-D__WCHAR_TYPE__=%s", WCHAR_TYPE);
do_spec_1 (tmpstr, 1, NULL);
do_spec_1 (" ", 0, NULL);
#endif
#ifndef NO_BUILTIN_WINT_TYPE
sprintf (tmpstr, "-D__WINT_TYPE__=%s", WINT_TYPE);
do_spec_1 (tmpstr, 1, NULL);
do_spec_1 (" ", 0, NULL);
#endif
free (tmpstr);
free (header_path);
}
}
break;
case 'o':
{
int max = n_infiles;
max += lang_specific_extra_outfiles;
for (i = 0; i < max; i++)
if (outfiles[i])
store_arg (outfiles[i], 0, 0);
if (num_arches > 1)
{
store_arg ("-final_output", 0, 0);
store_arg (final_output, 0, 0);
}
break;
}
case 'O':
obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
arg_going = 1;
break;
case 's':
this_is_library_file = 1;
break;
case 'f':
this_is_arch_merge_file = 1;
break;
case 'F':
{
int a;
for (a = 0; a < num_arches; ++a)
{
store_arg ("-arch", 0, 0);
store_arg (arches[a].name, 0, 0);
store_arg ((arches[a].merge_file ? arches[a].merge_file : "???"), 0, 0);
}
}
break;
case 'T':
obstack_grow (&obstack, arches[current_arch].name,
strlen (arches[current_arch].name));
arg_going = 1;
break;
case 'w':
this_is_output_file = 1;
break;
case 'W':
{
int cur_index = argbuf_index;
if (*p != '{')
abort ();
p = handle_braces (p + 1);
if (p == 0)
return -1;
if (argbuf_index != cur_index)
record_temp_file (argbuf[argbuf_index - 1], 0, 1);
break;
}
case 'x':
{
const char *p1 = p;
char *string;
if (*p != '{')
abort ();
while (*p++ != '}')
;
string = save_string (p1 + 1, p - p1 - 2);
for (i = 0; i < n_linker_options; i++)
if (! strcmp (string, linker_options[i]))
{
free (string);
return 0;
}
add_linker_option (string, strlen (string));
}
break;
case 'X':
for (i = 0; i < n_linker_options; i++)
{
do_spec_1 (linker_options[i], 1, NULL);
do_spec_1 (" ", 0, NULL);
}
break;
case 'Y':
for (i = 0; i < n_assembler_options; i++)
{
do_spec_1 (assembler_options[i], 1, NULL);
do_spec_1 (" ", 0, NULL);
}
break;
case 'Z':
for (i = 0; i < n_preprocessor_options; i++)
{
do_spec_1 (preprocessor_options[i], 1, NULL);
do_spec_1 (" ", 0, NULL);
}
break;
case '1':
value = do_spec_1 (cc1_spec, 0, NULL);
if (value != 0)
return value;
break;
case '2':
value = do_spec_1 (cc1plus_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'a':
value = do_spec_1 (asm_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'A':
value = do_spec_1 (asm_final_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'C':
{
const char *const spec
= (input_file_compiler->cpp_spec
? input_file_compiler->cpp_spec
: cpp_spec);
value = do_spec_1 (spec, 0, NULL);
if (value != 0)
return value;
}
break;
case 'E':
value = do_spec_1 (endfile_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'l':
value = do_spec_1 (link_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'L':
value = do_spec_1 (lib_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'G':
value = do_spec_1 (libgcc_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'M':
if (multilib_dir && strcmp (multilib_dir, ".") != 0)
{
char *p;
const char *q;
size_t len;
len = strlen (multilib_dir);
obstack_blank (&obstack, len + 1);
p = obstack_next_free (&obstack) - (len + 1);
*p++ = '_';
for (q = multilib_dir; *q ; ++q, ++p)
*p = (IS_DIR_SEPARATOR (*q) ? '_' : *q);
}
break;
case 'p':
{
char *x = (char *) alloca (strlen (cpp_predefines) + 1);
char *buf = x;
const char *y;
y = cpp_predefines;
while (*y != 0)
{
if (! strncmp (y, "-D", 2))
while (*y && *y != ' ' && *y != '\t')
*x++ = *y++;
else if (*y == ' ' || *y == '\t')
*x++ = *y++;
else
y++;
}
*x = 0;
value = do_spec_1 (buf, 0, NULL);
if (value != 0)
return value;
}
break;
case 'P':
{
char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
char *buf = x;
const char *y;
y = cpp_predefines;
while (*y != 0)
{
if (! strncmp (y, "-D", 2))
{
int flag = 0;
*x++ = *y++;
*x++ = *y++;
if (*y != '_'
|| (*(y + 1) != '_'
&& ! ISUPPER ((unsigned char) *(y + 1))))
{
if (*y != '_')
*x++ = '_';
*x++ = '_';
flag = 1;
}
while (*y && *y != '=' && *y != ' ' && *y != '\t')
*x++ = *y++;
if (flag)
{
if (x[-1] != '_')
{
if (x[-2] != '_')
*x++ = '_';
*x++ = '_';
}
}
while (*y && *y != ' ' && *y != '\t')
*x++ = *y++;
}
else if (*y == ' ' || *y == '\t')
*x++ = *y++;
else
y++;
}
*x++ = ' ';
y = cpp_predefines;
while (*y != 0)
{
if (! strncmp (y, "-D", 2))
{
y += 2;
if (*y != '_'
|| (*(y + 1) != '_'
&& ! ISUPPER ((unsigned char) *(y + 1))))
{
*x++ = '-';
*x++ = 'D';
if (*y != '_')
*x++ = '_';
*x++ = '_';
while (*y && *y != '=' && *y != ' ' && *y != '\t')
*x++ = *y++;
while (*y && *y != ' ' && *y != '\t')
*x++ = *y++;
}
else
{
while (*y && *y != ' ' && *y != '\t')
y++;
}
}
else if (*y == ' ' || *y == '\t')
*x++ = *y++;
else
y++;
}
*x++ = ' ';
y = cpp_predefines;
while (*y != 0)
{
if (! strncmp (y, "-A", 2))
while (*y && *y != ' ' && *y != '\t')
*x++ = *y++;
else if (*y == ' ' || *y == '\t')
*x++ = *y++;
else
y++;
}
*x = 0;
value = do_spec_1 (buf, 0, NULL);
if (value != 0)
return value;
}
break;
case 'S':
value = do_spec_1 (startfile_spec, 0, NULL);
if (value != 0)
return value;
break;
case '{':
p = handle_braces (p);
if (p == 0)
return -1;
break;
case '%':
obstack_1grow (&obstack, '%');
break;
case '.':
{
unsigned len = 0;
while (p[len] && p[len] != ' ' && p[len] != '%')
len++;
suffix_subst = save_string (p - 1, len + 1);
p += len;
}
break;
case '*':
if (soft_matched_part)
{
do_spec_1 (soft_matched_part, 1, NULL);
do_spec_1 (" ", 0, NULL);
}
else
error ("spec failure: '%%*' has not been initialized by pattern match");
break;
case '[':
error ("warning: use of obsolete %%[ operator in specs");
case '(':
{
const char *name = p;
struct spec_list *sl;
int len;
while (*p && *p != ')' && *p != ']')
p++;
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
notice ("Processing spec %c%s%c, which is '%s'\n",
c, sl->name, (c == '(') ? ')' : ']', name);
#endif
break;
}
if (sl)
{
if (c == '(')
{
value = do_spec_1 (name, 0, NULL);
if (value != 0)
return value;
}
else
{
char *x = (char *) alloca (strlen (name) * 2 + 1);
char *buf = x;
const char *y = name;
int flag = 0;
while (1)
{
if (! strncmp (y, "-D", 2))
{
*x++ = '-';
*x++ = 'D';
*x++ = '_';
*x++ = '_';
y += 2;
flag = 1;
continue;
}
else if (flag
&& (*y == ' ' || *y == '\t' || *y == '='
|| *y == '}' || *y == 0))
{
*x++ = '_';
*x++ = '_';
flag = 0;
}
if (*y == 0)
break;
else
*x++ = *y++;
}
*x = 0;
value = do_spec_1 (buf, 0, NULL);
if (value != 0)
return value;
}
}
if (*p)
p++;
}
break;
case 'v':
{
int c1 = *p++;
const char *v = compiler_version;
const char *q;
static const char zeroc = '0';
while (! ISDIGIT (*v))
v++;
if (v > compiler_version && v[-1] != '-')
abort ();
if (c1 >= '2')
{
while (ISDIGIT (*v))
v++;
if (*v != '.')
abort ();
v++;
}
if (c1 == '3')
{
while (ISDIGIT (*v))
v++;
if ((*v != 0) && (*v != ' ') && (*v != '.') && (*v != '-'))
abort ();
if (*v != 0)
v++;
}
if (c1 == 'A')
v = apple_version_str;
q = v;
while (ISDIGIT (*q))
q++;
if (*q != 0 && q > v && *q != ' ' && *q != '.' && *q != '-')
abort ();
if (q > v)
obstack_grow (&obstack, v, q - v);
else
obstack_grow (&obstack, &zeroc, 1);
arg_going = 1;
}
break;
case '|':
if (input_from_pipe)
do_spec_1 ("-", 0, NULL);
break;
default:
error ("spec failure: unrecognized spec option '%c'", c);
break;
}
break;
case '\\':
c = *p++;
default:
obstack_1grow (&obstack, c);
arg_going = 1;
}
return 0;
}
static const char *
handle_braces (p)
const char *p;
{
const char *filter, *body = NULL, *endbody = NULL;
int pipe_p = 0;
int true_once = 0;
int negate;
int suffix;
int include_blanks = 1;
int elide_switch = 0;
int later_restore_switch = 0;
int ordered = 0;
if (*p == '^')
{
include_blanks = 0;
++p;
}
if (*p == '|')
{
pipe_p = 1;
++p;
}
next_member:
negate = suffix = 0;
if (*p == '!')
negate = 1, ++p;
if (*p == '<')
{
elide_switch = 1;
if (negate)
{
later_restore_switch = 1;
negate = 0;
}
++p;
}
if (*p == '.')
{
if (pipe_p)
abort ();
suffix = 1;
++p;
}
if (elide_switch && (negate || pipe_p || suffix))
{
abort ();
}
next_ampersand:
filter = p;
while (*p != ':' && *p != '}' && *p != '|' && *p != '&')
p++;
if (*p == '|' && (pipe_p || ordered))
abort ();
if (!body)
{
if (*p != '}' && *p != '&')
{
int count = 1;
const char *q = p;
while (*q++ != ':')
continue;
body = q;
while (count > 0)
{
if (*q == '{')
count++;
else if (*q == '}')
count--;
else if (*q == 0)
fatal ("mismatched braces in specs");
q++;
}
endbody = q;
}
else
body = p, endbody = p + 1;
}
if (*filter == '@')
{
if (*p == '}')
fatal ("empty body in `@' conditional");
if (p - filter > 1)
fatal ("`@' condition illegal in spec");
if (negate != (num_arches > 1))
{
if (do_spec_1 (save_string (p + 1, endbody - p - 2), 0, NULL) < 0)
return 0;
do_spec_1 (" ", 0, NULL);
}
return endbody;
}
if (suffix)
{
int found = (input_suffix != 0
&& (long) strlen (input_suffix) == (long) (p - filter)
&& strncmp (input_suffix, filter, p - filter) == 0);
if (body[0] == '}')
abort ();
if (negate != found
&& do_spec_1 (save_string (body, endbody-body-1), 0, NULL) < 0)
return 0;
}
else if (p[-1] == '*' && (p[0] == '}' || p[0] == '&'))
{
int i;
for (i = 0; i < n_switches; i++)
if (!strncmp (switches[i].part1, filter, p - 1 - filter)
&& check_live_switch (i, p - 1 - filter))
{
if (elide_switch)
{
if (later_restore_switch)
switches[i].live_cond = SWITCH_IGNORE_RESTORE;
else
switches[i].live_cond = SWITCH_IGNORE;
switches[i].validated = 1;
}
else
ordered = 1, switches[i].ordering = 1;
}
}
else
{
int i;
int present = 0;
if (p[-1] == '*' && !negate)
{
int substitution;
const char *r = body;
substitution = 0;
while (r < endbody)
{
if (*r == '%' && r[1] == '*')
substitution = 1;
r++;
}
if (substitution)
{
unsigned hard_match_len = p - filter - 1;
char *string = save_string (body, endbody - body - 1);
for (i = 0; i < n_switches; i++)
if (!strncmp (switches[i].part1, filter, hard_match_len)
&& check_live_switch (i, -1))
{
do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
give_switch (i, 1, 1);
suffix_subst = NULL;
}
if (*p++ == '|')
goto next_member;
return endbody;
}
}
if (p[-1] == '*')
{
for (i = 0; i < n_switches; i++)
{
unsigned hard_match_len = p - filter - 1;
if (!strncmp (switches[i].part1, filter, hard_match_len)
&& check_live_switch (i, hard_match_len))
{
present = 1;
break;
}
}
}
else
{
for (i = 0; i < n_switches; i++)
{
if (!strncmp (switches[i].part1, filter, p - filter)
&& switches[i].part1[p - filter] == 0
&& check_live_switch (i, -1))
{
present = 1;
break;
}
}
}
if (present != negate)
{
if (elide_switch)
{
if (later_restore_switch)
switches[i].live_cond = SWITCH_IGNORE_RESTORE;
else
switches[i].live_cond = SWITCH_IGNORE;
switches[i].validated = 1;
}
else if (ordered || *p == '&')
ordered = 1, switches[i].ordering = 1;
else if (*p == '}')
give_switch (i, 0, include_blanks);
else
true_once = 1;
}
else if (pipe_p)
{
do_spec_1 ("-", 0, NULL);
return endbody;
}
}
if (*p++ == '|')
goto next_member;
if (p[-1] == '&')
{
body = 0;
goto next_ampersand;
}
if (ordered)
{
int i;
for (i = 0; i < n_switches; i++)
if (switches[i].ordering == 1)
{
switches[i].ordering = 0;
give_switch (i, 0, include_blanks);
}
}
else if (true_once)
{
if (do_spec_1 (save_string (body, endbody - body - 1),
0, NULL) < 0)
return 0;
}
return endbody;
}
static int
check_live_switch (switchnum, prefix_length)
int switchnum;
int prefix_length;
{
const char *name = switches[switchnum].part1;
int i;
if (prefix_length >= 0 && prefix_length <= 1)
return 1;
if (switches[switchnum].live_cond != 0)
return switches[switchnum].live_cond > 0;
switch (*name)
{
case 'O':
for (i = switchnum + 1; i < n_switches; i++)
if (switches[i].part1[0] == 'O')
{
switches[switchnum].validated = 1;
switches[switchnum].live_cond = SWITCH_FALSE;
return 0;
}
break;
case 'W': case 'f': case 'm':
if (! strncmp (name + 1, "no-", 3))
{
for (i = switchnum + 1; i < n_switches; i++)
if (switches[i].part1[0] == name[0]
&& ! strcmp (&switches[i].part1[1], &name[4]))
{
switches[switchnum].validated = 1;
switches[switchnum].live_cond = SWITCH_FALSE;
return 0;
}
}
else
{
for (i = switchnum + 1; i < n_switches; i++)
if (switches[i].part1[0] == name[0]
&& switches[i].part1[1] == 'n'
&& switches[i].part1[2] == 'o'
&& switches[i].part1[3] == '-'
&& !strcmp (&switches[i].part1[4], &name[1]))
{
switches[switchnum].validated = 1;
switches[switchnum].live_cond = SWITCH_FALSE;
return 0;
}
}
break;
}
switches[switchnum].live_cond = SWITCH_LIVE;
return 1;
}
static void
give_switch (switchnum, omit_first_word, include_blanks)
int switchnum;
int omit_first_word;
int include_blanks;
{
if (switches[switchnum].live_cond == SWITCH_IGNORE
||switches[switchnum].live_cond == SWITCH_IGNORE_RESTORE)
return;
if (!omit_first_word)
{
do_spec_1 ("-", 0, NULL);
do_spec_1 (switches[switchnum].part1, 1, NULL);
}
if (switches[switchnum].args != 0)
{
const char **p;
for (p = switches[switchnum].args; *p; p++)
{
const char *arg = *p;
if (include_blanks)
do_spec_1 (" ", 0, NULL);
if (suffix_subst)
{
unsigned length = strlen (arg);
int dot = 0;
while (length-- && !IS_DIR_SEPARATOR (arg[length]))
if (arg[length] == '.')
{
((char *)arg)[length] = 0;
dot = 1;
break;
}
do_spec_1 (arg, 1, NULL);
if (dot)
((char *)arg)[length] = '.';
do_spec_1 (suffix_subst, 1, NULL);
}
else
do_spec_1 (arg, 1, NULL);
}
}
do_spec_1 (" ", 0, NULL);
switches[switchnum].validated = 1;
}
static const char *
find_file (name)
const char *name;
{
char *newname;
if (multilib_dir != NULL)
{
const char *const try = ACONCAT ((multilib_dir, dir_separator_str, name, NULL));
newname = find_a_file (&startfile_prefixes, try, R_OK);
if (newname != NULL)
return newname;
}
newname = find_a_file (&startfile_prefixes, name, R_OK);
return newname ? newname : name;
}
static int
is_directory (path1, path2, linker)
const char *path1;
const char *path2;
int linker;
{
int len1 = strlen (path1);
int len2 = strlen (path2);
char *path = (char *) alloca (3 + len1 + len2);
char *cp;
struct stat st;
#ifndef SMALL_ARG_MAX
if (! linker)
return 1;
#endif
memcpy (path, path1, len1);
memcpy (path + len1, path2, len2);
cp = path + len1 + len2;
if (!IS_DIR_SEPARATOR (cp[-1]))
*cp++ = DIR_SEPARATOR;
*cp++ = '.';
*cp = '\0';
if (linker
&& ((cp - path == 6
&& strcmp (path, concat (dir_separator_str, "lib",
dir_separator_str, ".", NULL)) == 0)
|| (cp - path == 10
&& strcmp (path, concat (dir_separator_str, "usr",
dir_separator_str, "lib",
dir_separator_str, ".", NULL)) == 0)))
return 0;
return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
}
void
set_input (filename)
const char *filename;
{
const char *p;
input_filename = filename;
input_filename_length = strlen (input_filename);
input_basename = input_filename;
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
if (input_basename[1] == ':')
input_basename += 2;
#endif
for (p = input_basename; *p; p++)
if (IS_DIR_SEPARATOR (*p))
input_basename = p + 1;
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 = "";
input_stat_set = 0;
}
static void
fatal_error (signum)
int signum;
{
signal (signum, SIG_DFL);
delete_failure_queue ();
delete_temp_files ();
kill (getpid (), signum);
}
extern int main PARAMS ((int, const char *const *));
int
main (argc, argv)
int argc;
const char *const *argv;
{
size_t i;
int value;
int linker_was_run = 0;
char *explicit_link_files;
char *specs_file;
const char *p;
struct user_specs *uptr;
p = argv[0] + strlen (argv[0]);
while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
--p;
programname = p;
xmalloc_set_program_name (programname);
#ifdef GCC_DRIVER_HOST_INITIALIZATION
GCC_DRIVER_HOST_INITIALIZATION;
#endif
gcc_init_libintl ();
if (signal (SIGINT, SIG_IGN) != SIG_IGN)
signal (SIGINT, fatal_error);
#ifdef SIGHUP
if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
signal (SIGHUP, fatal_error);
#endif
if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
signal (SIGTERM, fatal_error);
#ifdef SIGPIPE
if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
signal (SIGPIPE, fatal_error);
#endif
#ifdef SIGCHLD
signal (SIGCHLD, SIG_DFL);
#endif
argbuf_length = 10;
argbuf = (const char **) xmalloc (argbuf_length * sizeof (const char *));
obstack_init (&obstack);
{
const char *const *q = multilib_raw;
int need_space;
obstack_init (&multilib_obstack);
while ((p = *q++) != (char *) 0)
obstack_grow (&multilib_obstack, p, strlen (p));
obstack_1grow (&multilib_obstack, 0);
multilib_select = obstack_finish (&multilib_obstack);
q = multilib_matches_raw;
while ((p = *q++) != (char *) 0)
obstack_grow (&multilib_obstack, p, strlen (p));
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 < ARRAY_SIZE (multilib_defaults_raw); i++)
{
if (need_space)
obstack_1grow (&multilib_obstack, ' ');
obstack_grow (&multilib_obstack,
multilib_defaults_raw[i],
strlen (multilib_defaults_raw[i]));
need_space = TRUE;
}
obstack_1grow (&multilib_obstack, 0);
multilib_defaults = obstack_finish (&multilib_obstack);
}
obstack_init (&collect_obstack);
obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
putenv (obstack_finish (&collect_obstack));
#ifdef INIT_ENVIRONMENT
putenv (INIT_ENVIRONMENT);
#endif
process_command (argc, argv);
compilers = (struct compiler *) xmalloc (sizeof default_compilers);
memcpy ((char *) compilers, (char *) default_compilers,
sizeof default_compilers);
n_compilers = n_default_compilers;
#ifdef DEFAULT_TARGET_ARCH
if (num_arches == 0)
arches[num_arches++].name = DEFAULT_TARGET_ARCH;
#else
#error Must have a DEFAULT_TARGET_ARCH!
#endif
#ifdef PHAT
spec_machine = arches[0].name;
#endif
machine_suffix = concat (spec_machine, dir_separator_str,
spec_version, dir_separator_str, NULL);
just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
specs_file = find_a_file (&startfile_prefixes, "specs", R_OK);
if (specs_file != 0 && strcmp (specs_file, "specs"))
read_specs (specs_file, TRUE);
else
init_spec ();
specs_file = (char *) alloca (strlen (standard_exec_prefix)
+ strlen (just_machine_suffix)
+ sizeof ("specs"));
strcpy (specs_file, standard_exec_prefix);
strcat (specs_file, just_machine_suffix);
strcat (specs_file, "specs");
if (access (specs_file, R_OK) == 0)
read_specs (specs_file, TRUE);
if (*cross_compile == '0')
{
if (*md_exec_prefix)
{
add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
PREFIX_PRIORITY_LAST, 0, NULL);
add_prefix (&startfile_prefixes, md_exec_prefix, "GCC",
PREFIX_PRIORITY_LAST, 0, NULL);
}
if (*md_startfile_prefix)
add_prefix (&startfile_prefixes, md_startfile_prefix, "GCC",
PREFIX_PRIORITY_LAST, 0, NULL);
if (*md_startfile_prefix_1)
add_prefix (&startfile_prefixes, md_startfile_prefix_1, "GCC",
PREFIX_PRIORITY_LAST, 0, NULL);
if (IS_ABSOLUTE_PATHNAME (standard_startfile_prefix))
add_prefix (&startfile_prefixes, standard_startfile_prefix, "BINUTILS",
PREFIX_PRIORITY_LAST, 0, NULL);
else
{
if (gcc_exec_prefix)
add_prefix (&startfile_prefixes,
concat (gcc_exec_prefix, machine_suffix,
standard_startfile_prefix, NULL),
NULL, PREFIX_PRIORITY_LAST, 0, NULL);
add_prefix (&startfile_prefixes,
concat (standard_exec_prefix,
machine_suffix,
standard_startfile_prefix, NULL),
NULL, PREFIX_PRIORITY_LAST, 0, NULL);
}
add_prefix (&startfile_prefixes, standard_startfile_prefix_1,
"BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
add_prefix (&startfile_prefixes, standard_startfile_prefix_2,
"BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
#if 0
add_prefix (&startfile_prefixes, "./", NULL,
PREFIX_PRIORITY_LAST, 1, NULL);
#endif
}
else
{
if (!IS_ABSOLUTE_PATHNAME (standard_startfile_prefix)
&& gcc_exec_prefix)
add_prefix (&startfile_prefixes,
concat (gcc_exec_prefix, machine_suffix,
standard_startfile_prefix, NULL),
"BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL);
}
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 (gcc_exec_prefix)
gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
spec_version, dir_separator_str, NULL);
validate_all_switches ();
set_multilib_dir ();
for (i = 0; (int) i < n_switches; i++)
if (! switches[i].validated)
error ("unrecognized option `-%s'", switches[i].part1);
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));
return (0);
}
if (print_file_name)
{
printf ("%s\n", find_file (print_file_name));
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));
return (0);
}
if (print_multi_lib)
{
print_multilib_info ();
return (0);
}
if (print_multi_directory)
{
if (multilib_dir == NULL)
printf (".\n");
else
printf ("%s\n", multilib_dir);
return (0);
}
if (target_help_flag)
{
}
if (print_help_list)
{
display_help ();
if (! verbose_flag)
{
printf (_("\nFor bug reporting instructions, please see:\n"));
printf ("%s.\n", GCCBUGURL);
return (0);
}
}
if (verbose_flag)
{
int n;
const char *thrmod;
#ifndef PHAT
notice ("Configured with: %s\n", configuration_arguments);
#endif
#ifdef THREAD_MODEL_SPEC
obstack_init (&obstack);
do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
obstack_1grow (&obstack, '\0');
thrmod = obstack_finish (&obstack);
#else
thrmod = thread_model;
#endif
notice ("Thread model: %s\n", thrmod);
notice ("Apple Computer, Inc. GCC version %s, based on ",
apple_version_str);
for (n = 0; version_string[n]; n++)
if (version_string[n] == ' ')
break;
if (! strncmp (version_string, compiler_version, n)
&& compiler_version[n] == 0)
notice ("gcc version %s\n", version_string);
else
notice ("gcc driver version %s executing gcc version %s\n",
version_string, compiler_version);
if (n_infiles == 0)
return (0);
}
if (n_infiles == added_libraries)
fatal ("no input files");
i = n_infiles;
i += lang_specific_extra_outfiles;
outfiles = (const char **) xcalloc (i, sizeof (char *));
explicit_link_files = xcalloc (1, n_infiles);
for (i = 0; (int) i < n_infiles; i++)
{
int this_file_error = 0;
input_file_number = i;
set_input (infiles[i].name);
outfiles[i] = input_filename;
input_file_compiler
= lookup_compiler (infiles[i].name, input_filename_length,
infiles[i].language);
if (input_file_compiler)
{
if (input_file_compiler->spec[0] == '#')
{
error ("%s: %s compiler not installed on this system",
input_filename, &input_file_compiler->spec[1]);
this_file_error = 1;
}
else
{
int i;
for (current_arch = 0; current_arch < num_arches; ++current_arch)
arches[current_arch].merge_file = NULL;
for (current_arch = 0; current_arch < num_arches; ++current_arch)
{
if (num_arches > 1)
{
machine_suffix = concat (arches[current_arch].name,
dir_separator_str, spec_version,
dir_separator_str, NULL);
just_machine_suffix = concat (arches[current_arch].name,
dir_separator_str, NULL);
specs_file = find_a_file (&startfile_prefixes,
"specs", R_OK);
if (specs_file != 0 && strcmp (specs_file, "specs"))
read_specs (specs_file, FALSE);
else
fatal ("cannot read specs file for arch `%s'",
arches[current_arch].name);
}
value = do_spec (input_file_compiler->spec);
if (value < 0)
{
this_file_error = 1;
break;
}
for (i = 0; i < n_switches; i++)
if (switches[i].live_cond == SWITCH_IGNORE_RESTORE)
switches[i].live_cond = SWITCH_LIVE;
}
}
if (num_arches > 1 && !this_file_error)
{
value = do_spec (ofile_merge_spec);
if (value < 0)
this_file_error = 1;
value = do_spec (precomp_merge_spec);
if (value < 0)
this_file_error = 1;
}
}
else
explicit_link_files[i] = 1;
if (this_file_error)
{
delete_failure_queue ();
error_count++;
}
clear_failure_queue ();
}
if (n_infiles > 0)
set_input (infiles[0].name);
if (error_count == 0)
{
input_file_number = n_infiles;
if (lang_specific_pre_link ())
error_count++;
}
if (error_count == 0)
{
int tmp = execution_count;
if (! strcmp (linker_name_spec, "collect2"))
{
char *s = find_a_file (&exec_prefixes, "collect2", X_OK);
if (s == NULL)
linker_name_spec = "ld";
}
putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH");
putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV);
for (current_arch = 0; current_arch < num_arches; ++current_arch)
arches[current_arch].merge_file = NULL;
#ifdef PHAT
machine_suffix = concat (spec_version,
dir_separator_str, NULL);
#endif
for (current_arch = 0; current_arch < num_arches; ++current_arch)
{
value = do_spec (link_command_spec);
if (value < 0)
{
error_count = 1;
break;
}
}
linker_was_run = (tmp != execution_count);
}
if (num_arches > 1 && error_count == 0)
{
value = do_spec (exec_merge_spec);
if (value < 0)
error_count = 1;
}
if (! linker_was_run && error_count == 0)
for (i = 0; (int) i < n_infiles; i++)
if (explicit_link_files[i])
error ("%s: linker input file unused because linking not done",
outfiles[i]);
if (error_count)
delete_failure_queue ();
delete_temp_files ();
if (print_help_list)
{
printf (("\nFor bug reporting instructions, please see:\n"));
printf ("%s\n", GCCBUGURL);
}
return (signal_count != 0 ? 2
: error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
: 0);
}
static struct compiler *
lookup_compiler (name, length, language)
const char *name;
size_t length;
const char *language;
{
struct compiler *cp;
if (language != 0 && language[0] == '*')
return 0;
if (language != 0)
{
for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
return cp;
error ("language %s not recognized", language);
return 0;
}
for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
{
if (
(!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
|| (strlen (cp->suffix) < length
&& !strcmp (cp->suffix,
name + length - strlen (cp->suffix))
))
break;
}
#if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
if (cp < compilers)
for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
{
if (
(!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
|| (strlen (cp->suffix) < length
&& ((!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 (default_language)
{
struct compiler *ncomp = lookup_compiler (NULL, 0, default_language);
#if 0
if (cp == ncomp
|| (cp->spec[0] == '@'
&& ncomp
&& strcmp (cp->spec, ncomp->suffix) == 0))
{
if (strcmp (default_language, "objective-c") == 0)
error ("Warning: -ObjC/-fobjc option is redundant");
if (strcmp (default_language, "objective-c++") == 0)
error ("Warning: -ObjC++ option is redundant");
}
#endif
return ncomp;
}
if (cp->spec[0] != '@')
return cp;
return lookup_compiler (NULL, 0, cp->spec + 1);
}
return 0;
}
static char *
save_string (s, len)
const char *s;
int len;
{
char *result = xmalloc (len + 1);
memcpy (result, s, len);
result[len] = 0;
return result;
}
void
pfatal_with_name (name)
const char *name;
{
perror_with_name (name);
delete_temp_files ();
exit (1);
}
static void
perror_with_name (name)
const char *name;
{
error ("%s: %s", name, xstrerror (errno));
}
static void
pfatal_pexecute (errmsg_fmt, errmsg_arg)
const char *errmsg_fmt;
const char *errmsg_arg;
{
if (errmsg_arg)
{
int save_errno = errno;
char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
sprintf (msg, errmsg_fmt, errmsg_arg);
errmsg_fmt = msg;
errno = save_errno;
}
pfatal_with_name (errmsg_fmt);
}
void
fancy_abort ()
{
fatal ("internal gcc abort");
}
void
fatal VPARAMS ((const char *msgid, ...))
{
VA_OPEN (ap, msgid);
VA_FIXEDARG (ap, const char *, msgid);
#ifndef ANSI_PROTOTYPES
msgid = va_arg (ap, const char *);
#endif
fprintf (stderr, "%s: ", programname);
vfprintf (stderr, _(msgid), ap);
VA_CLOSE (ap);
fprintf (stderr, "\n");
delete_temp_files ();
exit (1);
}
void
error VPARAMS ((const char *msgid, ...))
{
VA_OPEN (ap, msgid);
VA_FIXEDARG (ap, const char *, msgid);
fprintf (stderr, "%s: ", programname);
vfprintf (stderr, _(msgid), ap);
VA_CLOSE (ap);
fprintf (stderr, "\n");
}
static void
notice VPARAMS ((const char *msgid, ...))
{
VA_OPEN (ap, msgid);
VA_FIXEDARG (ap, const char *, msgid);
vfprintf (stderr, _(msgid), ap);
VA_CLOSE (ap);
}
static void
validate_all_switches ()
{
struct compiler *comp;
const char *p;
char c;
struct spec_list *spec;
for (comp = compilers; comp->spec; comp++)
{
p = comp->spec;
while ((c = *p++))
if (c == '%' && (*p == '{' || (*p == 'W' && *++p == '{')))
validate_switches (p + 1);
}
for (spec = specs; spec; spec = spec->next)
{
p = *(spec->ptr_spec);
while ((c = *p++))
if (c == '%' && (*p == '{' || (*p == 'W' && *++p == '{')))
validate_switches (p + 1);
}
p = link_command_spec;
while ((c = *p++))
if (c == '%' && (*p == '{' || (*p == 'W' && *++p == '{')))
validate_switches (p + 1);
}
static void
validate_switches (start)
const char *start;
{
const char *p = start;
const char *filter;
int i;
int suffix;
if (*p == '|')
++p;
next_member:
if (*p == '!')
++p;
suffix = 0;
if (*p == '.')
suffix = 1, ++p;
filter = p;
while (*p != ':' && *p != '}' && *p != '|' && *p != '&')
p++;
if (suffix)
;
else if (p[-1] == '*')
{
for (i = 0; i < n_switches; i++)
if (!strncmp (switches[i].part1, filter, p - filter - 1))
switches[i].validated = 1;
}
else
{
for (i = 0; i < n_switches; i++)
{
if (!strncmp (switches[i].part1, filter, p - filter)
&& switches[i].part1[p - filter] == 0)
switches[i].validated = 1;
}
}
if (*p++ == '|' || p[-1] == '&')
goto next_member;
}
static int
used_arg (p, len)
const char *p;
int len;
{
struct mswitchstr
{
const char *str;
const char *replace;
int len;
int rep_len;
};
static struct mswitchstr *mswitches;
static int n_mswitches;
int i, j;
if (!mswitches)
{
struct mswitchstr *matches;
const char *q;
int cnt = 0;
for (q = multilib_matches; *q != '\0'; q++)
if (*q == ';')
cnt++;
matches =
(struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
i = 0;
q = multilib_matches;
while (*q != '\0')
{
matches[i].str = q;
while (*q != ' ')
{
if (*q == '\0')
abort ();
q++;
}
matches[i].len = q - matches[i].str;
matches[i].replace = ++q;
while (*q != ';' && *q != '\0')
{
if (*q == ' ')
abort ();
q++;
}
matches[i].rep_len = q - matches[i].replace;
i++;
if (*q == ';')
q++;
}
mswitches
= (struct mswitchstr *) xmalloc ((sizeof (struct mswitchstr))
* (n_switches ? n_switches : 1));
for (i = 0; i < n_switches; i++)
{
int xlen = strlen (switches[i].part1);
for (j = 0; j < cnt; j++)
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;
mswitches[n_mswitches].replace = (char *) 0;
mswitches[n_mswitches].rep_len = 0;
n_mswitches++;
break;
}
}
}
for (i = 0; i < n_mswitches; i++)
if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
return 1;
return 0;
}
static int
default_arg (p, len)
const char *p;
int len;
{
const char *start, *end;
for (start = multilib_defaults; *start != '\0'; start = end + 1)
{
while (*start == ' ' || *start == '\t')
start++;
if (*start == '\0')
break;
for (end = start + 1; *end != ' ' && *end != '\t' && *end != '\0'; end++)
;
if ((end - start) == len && strncmp (p, start, len) == 0)
return 1;
if (*end == '\0')
break;
}
return 0;
}
static void
set_multilib_dir ()
{
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')
{
if (*p == '\n')
{
++p;
continue;
}
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')
{
if (*p == '\n')
{
++p;
continue;
}
this_path = p;
while (*p != ' ')
{
if (*p == '\0')
abort ();
++p;
}
this_path_len = p - this_path;
ok = 1;
++p;
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;
}
if (! default_arg (this_arg, p - this_arg))
{
ok = used_arg (this_arg, p - this_arg);
if (not_arg)
ok = ! ok;
}
if (*p == ' ')
++p;
}
if (ok)
{
if (this_path_len != 1
|| this_path[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;
}
++p;
}
}
static void
print_multilib_info ()
{
const char *p = multilib_select;
const char *last_path = 0, *this_path;
int skip;
unsigned int last_path_len = 0;
while (*p != '\0')
{
skip = 0;
if (*p == '\n')
{
++p;
continue;
}
this_path = p;
while (*p != ' ')
{
if (*p == '\0')
abort ();
++p;
}
{
const char *e = multilib_exclusions;
const char *this_arg;
while (*e != '\0')
{
int m = 1;
if (*e == '\n')
{
++e;
continue;
}
while (*e != ';')
{
const char *q;
int mp = 0;
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)
{
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 (! skip)
{
const char *q;
q = p + 1;
while (*q != ';')
{
const char *arg;
if (*q == '\0')
abort ();
if (*q == '!')
arg = NULL;
else
arg = q;
while (*q != ' ' && *q != ';')
{
if (*q == '\0')
abort ();
++q;
}
if (arg != NULL
&& default_arg (arg, q - arg))
{
skip = 1;
break;
}
if (*q == ' ')
++q;
}
}
if (! skip)
{
const char *p1;
for (p1 = last_path; p1 < p; p1++)
putchar (*p1);
putchar (';');
}
++p;
while (*p != ';')
{
int use_arg;
if (*p == '\0')
abort ();
if (skip)
{
++p;
continue;
}
use_arg = *p != '!';
if (use_arg)
putchar ('@');
while (*p != ' ' && *p != ';')
{
if (*p == '\0')
abort ();
if (use_arg)
putchar (*p);
++p;
}
if (*p == ' ')
++p;
}
if (! skip)
{
if (multilib_extra && *multilib_extra)
{
int print_at = TRUE;
const char *q;
for (q = multilib_extra; *q != '\0'; q++)
{
if (*q == ' ')
print_at = TRUE;
else
{
if (print_at)
putchar ('@');
putchar (*q);
print_at = FALSE;
}
}
}
putchar ('\n');
}
++p;
}
}