918 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0}, 919 {".h", "@c-header", 0}, 920 {"@c-header", 921 /* cc1 has an integrated ISO C preprocessor. We should invoke the 922 external preprocessor if -save-temps is given. */ 923 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\ 924 %{!E:%{!M:%{!MM:\ 925 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \ 926 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\ 927 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \ 928 %(cc1_options)\ 929 -o %g.s %{!o*:--output-pch=%i.gch}\ 930 %W{o*:--output-pch=%*}%V}\ 931 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\ 932 cc1 %(cpp_unique_options) %(cc1_options)\ 933 -o %g.s %{!o*:--output-pch=%i.gch}\ 934 %W{o*:--output-pch=%*}%V}}}}}}", 0}, 935 {".i", "@cpp-output", 0}, 936 {"@cpp-output", 937 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0}, 938 {".s", "@assembler", 0}, 939 {"@assembler", 940 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0}, 941 {".S", "@assembler-with-cpp", 0}, 942 {"@assembler-with-cpp", 943#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT 944 "%(trad_capable_cpp) -lang-asm %(cpp_options)\ 945 %{E|M|MM:%(cpp_debug_options)}\ 946 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\ 947 as %(asm_debug) %(asm_options) %|.s %A }}}}" 948#else 949 "%(trad_capable_cpp) -lang-asm %(cpp_options)\ 950 %{E|M|MM:%(cpp_debug_options)}\ 951 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\ 952 as %(asm_debug) %(asm_options) %m.s %A }}}}" 953#endif 954 , 0}, 955 956#include "specs.h" 957 /* Mark end of table. */ 958 {0, 0, 0} 959}; 960 961/* Number of elements in default_compilers, not counting the terminator. */ 962 963static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1; 964 965/* A vector of options to give to the linker. 966 These options are accumulated by %x, 967 and substituted into the linker command with %X. */ 968static int n_linker_options; 969static char **linker_options; 970 971/* A vector of options to give to the assembler. 972 These options are accumulated by -Wa, 973 and substituted into the assembler command with %Y. */ 974static int n_assembler_options; 975static char **assembler_options; 976 977/* A vector of options to give to the preprocessor. 978 These options are accumulated by -Wp, 979 and substituted into the preprocessor command with %Z. */ 980static int n_preprocessor_options; 981static char **preprocessor_options; 982 983/* Define how to map long options into short ones. */ 984 985/* This structure describes one mapping. */ 986struct option_map 987{ 988 /* The long option's name. */ 989 const char *const name; 990 /* The equivalent short option. */ 991 const char *const equivalent; 992 /* Argument info. A string of flag chars; NULL equals no options. 993 a => argument required. 994 o => argument optional. 995 j => join argument to equivalent, making one word. 996 * => require other text after NAME as an argument. */ 997 const char *const arg_info; 998}; 999 1000/* This is the table of mappings. Mappings are tried sequentially 1001 for each option encountered; the first one that matches, wins. */ 1002 1003static const struct option_map option_map[] = 1004 { 1005 {"--all-warnings", "-Wall", 0}, 1006 {"--ansi", "-ansi", 0}, 1007 {"--assemble", "-S", 0}, 1008 {"--assert", "-A", "a"}, 1009 {"--classpath", "-fclasspath=", "aj"}, 1010 {"--bootclasspath", "-fbootclasspath=", "aj"}, 1011 {"--CLASSPATH", "-fclasspath=", "aj"}, 1012 {"--comments", "-C", 0}, 1013 {"--comments-in-macros", "-CC", 0}, 1014 {"--compile", "-c", 0}, 1015 {"--debug", "-g", "oj"}, 1016 {"--define-macro", "-D", "aj"}, 1017 {"--dependencies", "-M", 0}, 1018 {"--dump", "-d", "a"}, 1019 {"--dumpbase", "-dumpbase", "a"}, 1020 {"--entry", "-e", 0}, 1021 {"--extra-warnings", "-W", 0}, 1022 {"--for-assembler", "-Wa", "a"}, 1023 {"--for-linker", "-Xlinker", "a"}, 1024 {"--force-link", "-u", "a"}, 1025 {"--imacros", "-imacros", "a"}, 1026 {"--include", "-include", "a"}, 1027 {"--include-barrier", "-I-", 0}, 1028 {"--include-directory", "-I", "aj"}, 1029 {"--include-directory-after", "-idirafter", "a"}, 1030 {"--include-prefix", "-iprefix", "a"}, 1031 {"--include-with-prefix", "-iwithprefix", "a"}, 1032 {"--include-with-prefix-before", "-iwithprefixbefore", "a"}, 1033 {"--include-with-prefix-after", "-iwithprefix", "a"}, 1034 {"--language", "-x", "a"}, 1035 {"--library-directory", "-L", "a"}, 1036 {"--machine", "-m", "aj"}, 1037 {"--machine-", "-m", "*j"}, 1038 {"--no-integrated-cpp", "-no-integrated-cpp", 0}, 1039 {"--no-line-commands", "-P", 0}, 1040 {"--no-precompiled-includes", "-noprecomp", 0}, 1041 {"--no-standard-includes", "-nostdinc", 0}, 1042 {"--no-standard-libraries", "-nostdlib", 0}, 1043 {"--no-warnings", "-w", 0}, 1044 {"--optimize", "-O", "oj"}, 1045 {"--output", "-o", "a"}, 1046 {"--output-class-directory", "-foutput-class-dir=", "ja"}, 1047 {"--param", "--param", "a"}, 1048 {"--pedantic", "-pedantic", 0}, 1049 {"--pedantic-errors", "-pedantic-errors", 0}, 1050 {"--pie", "-pie", 0}, 1051 {"--pipe", "-pipe", 0}, 1052 {"--prefix", "-B", "a"}, 1053 {"--preprocess", "-E", 0}, 1054 {"--print-search-dirs", "-print-search-dirs", 0}, 1055 {"--print-file-name", "-print-file-name=", "aj"}, 1056 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0}, 1057 {"--print-missing-file-dependencies", "-MG", 0}, 1058 {"--print-multi-lib", "-print-multi-lib", 0}, 1059 {"--print-multi-directory", "-print-multi-directory", 0}, 1060 {"--print-multi-os-directory", "-print-multi-os-directory", 0}, 1061 {"--print-prog-name", "-print-prog-name=", "aj"}, 1062 {"--profile", "-p", 0}, 1063 {"--profile-blocks", "-a", 0}, 1064 {"--quiet", "-q", 0}, 1065 {"--resource", "-fcompile-resource=", "aj"}, 1066 {"--save-temps", "-save-temps", 0}, 1067 {"--shared", "-shared", 0}, 1068 {"--silent", "-q", 0}, 1069 {"--specs", "-specs=", "aj"}, 1070 {"--static", "-static", 0}, 1071 {"--std", "-std=", "aj"}, 1072 {"--symbolic", "-symbolic", 0}, 1073 {"--time", "-time", 0}, 1074 {"--trace-includes", "-H", 0}, 1075 {"--traditional", "-traditional", 0}, 1076 {"--traditional-cpp", "-traditional-cpp", 0}, 1077 {"--trigraphs", "-trigraphs", 0}, 1078 {"--undefine-macro", "-U", "aj"}, 1079 {"--user-dependencies", "-MM", 0}, 1080 {"--verbose", "-v", 0}, 1081 {"--warn-", "-W", "*j"}, 1082 {"--write-dependencies", "-MD", 0}, 1083 {"--write-user-dependencies", "-MMD", 0}, 1084 {"--", "-f", "*j"} 1085 }; 1086 1087 1088#ifdef TARGET_OPTION_TRANSLATE_TABLE 1089static const struct { 1090 const char *const option_found; 1091 const char *const replacements; 1092} target_option_translations[] = 1093{ 1094 TARGET_OPTION_TRANSLATE_TABLE, 1095 { 0, 0 } 1096}; 1097#endif 1098 1099/* Translate the options described by *ARGCP and *ARGVP. 1100 Make a new vector and store it back in *ARGVP, 1101 and store its length in *ARGVC. */ 1102 1103static void 1104translate_options (int *argcp, const char *const **argvp) 1105{ 1106 int i; 1107 int argc = *argcp; 1108 const char *const *argv = *argvp; 1109 int newvsize = (argc + 2) * 2 * sizeof (const char *); 1110 const char **newv = xmalloc (newvsize); 1111 int newindex = 0; 1112 1113 i = 0; 1114 newv[newindex++] = argv[i++]; 1115 1116 while (i < argc) 1117 { 1118#ifdef TARGET_OPTION_TRANSLATE_TABLE 1119 int tott_idx; 1120 1121 for (tott_idx = 0; 1122 target_option_translations[tott_idx].option_found; 1123 tott_idx++) 1124 { 1125 if (strcmp (target_option_translations[tott_idx].option_found, 1126 argv[i]) == 0) 1127 { 1128 int spaces = 1; 1129 const char *sp; 1130 char *np; 1131 1132 for (sp = target_option_translations[tott_idx].replacements; 1133 *sp; sp++) 1134 { 1135 if (*sp == ' ') 1136 spaces ++; 1137 } 1138 1139 newvsize += spaces * sizeof (const char *); 1140 newv = xrealloc (newv, newvsize); 1141 1142 sp = target_option_translations[tott_idx].replacements; 1143 np = xstrdup (sp); 1144 1145 while (1) 1146 { 1147 while (*np == ' ') 1148 np++; 1149 if (*np == 0) 1150 break; 1151 newv[newindex++] = np; 1152 while (*np != ' ' && *np) 1153 np++; 1154 if (*np == 0) 1155 break; 1156 *np++ = 0; 1157 } 1158 1159 i ++; 1160 break; 1161 } 1162 } 1163 if (target_option_translations[tott_idx].option_found) 1164 continue; 1165#endif 1166 1167 /* Translate -- options. */ 1168 if (argv[i][0] == '-' && argv[i][1] == '-') 1169 { 1170 size_t j; 1171 /* Find a mapping that applies to this option. */ 1172 for (j = 0; j < ARRAY_SIZE (option_map); j++) 1173 { 1174 size_t optlen = strlen (option_map[j].name); 1175 size_t arglen = strlen (argv[i]); 1176 size_t complen = arglen > optlen ? optlen : arglen; 1177 const char *arginfo = option_map[j].arg_info; 1178 1179 if (arginfo == 0) 1180 arginfo = ""; 1181 1182 if (!strncmp (argv[i], option_map[j].name, complen)) 1183 { 1184 const char *arg = 0; 1185 1186 if (arglen < optlen) 1187 { 1188 size_t k; 1189 for (k = j + 1; k < ARRAY_SIZE (option_map); k++) 1190 if (strlen (option_map[k].name) >= arglen 1191 && !strncmp (argv[i], option_map[k].name, arglen)) 1192 { 1193 error ("ambiguous abbreviation %s", argv[i]); 1194 break; 1195 } 1196 1197 if (k != ARRAY_SIZE (option_map)) 1198 break; 1199 } 1200 1201 if (arglen > optlen) 1202 { 1203 /* If the option has an argument, accept that. */ 1204 if (argv[i][optlen] == '=') 1205 arg = argv[i] + optlen + 1; 1206 1207 /* If this mapping requires extra text at end of name, 1208 accept that as "argument". */ 1209 else if (strchr (arginfo, '*') != 0) 1210 arg = argv[i] + optlen; 1211 1212 /* Otherwise, extra text at end means mismatch. 1213 Try other mappings. */ 1214 else 1215 continue; 1216 } 1217 1218 else if (strchr (arginfo, '*') != 0) 1219 { 1220 error ("incomplete `%s' option", option_map[j].name); 1221 break; 1222 } 1223 1224 /* Handle arguments. */ 1225 if (strchr (arginfo, 'a') != 0) 1226 { 1227 if (arg == 0) 1228 { 1229 if (i + 1 == argc) 1230 { 1231 error ("missing argument to `%s' option", 1232 option_map[j].name); 1233 break; 1234 } 1235 1236 arg = argv[++i]; 1237 } 1238 } 1239 else if (strchr (arginfo, '*') != 0) 1240 ; 1241 else if (strchr (arginfo, 'o') == 0) 1242 { 1243 if (arg != 0) 1244 error ("extraneous argument to `%s' option", 1245 option_map[j].name); 1246 arg = 0; 1247 } 1248 1249 /* Store the translation as one argv elt or as two. */ 1250 if (arg != 0 && strchr (arginfo, 'j') != 0) 1251 newv[newindex++] = concat (option_map[j].equivalent, arg, 1252 NULL); 1253 else if (arg != 0) 1254 { 1255 newv[newindex++] = option_map[j].equivalent; 1256 newv[newindex++] = arg; 1257 } 1258 else 1259 newv[newindex++] = option_map[j].equivalent; 1260 1261 break; 1262 } 1263 } 1264 i++; 1265 } 1266 1267 /* Handle old-fashioned options--just copy them through, 1268 with their arguments. */ 1269 else if (argv[i][0] == '-') 1270 { 1271 const char *p = argv[i] + 1; 1272 int c = *p; 1273 int nskip = 1; 1274 1275 if (SWITCH_TAKES_ARG (c) > (p[1] != 0)) 1276 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0); 1277 else if (WORD_SWITCH_TAKES_ARG (p)) 1278 nskip += WORD_SWITCH_TAKES_ARG (p); 1279 else if ((c == 'B' || c == 'b' || c == 'x') 1280 && p[1] == 0) 1281 nskip += 1; 1282 else if (! strcmp (p, "Xlinker")) 1283 nskip += 1; 1284 else if (! strcmp (p, "Xpreprocessor")) 1285 nskip += 1; 1286 else if (! strcmp (p, "Xassembler")) 1287 nskip += 1; 1288 1289 /* Watch out for an option at the end of the command line that 1290 is missing arguments, and avoid skipping past the end of the 1291 command line. */ 1292 if (nskip + i > argc) 1293 nskip = argc - i; 1294 1295 while (nskip > 0) 1296 { 1297 newv[newindex++] = argv[i++]; 1298 nskip--; 1299 } 1300 } 1301 else 1302 /* Ordinary operands, or +e options. */ 1303 newv[newindex++] = argv[i++]; 1304 } 1305 1306 newv[newindex] = 0; 1307 1308 *argvp = newv; 1309 *argcp = newindex; 1310} 1311 1312static char * 1313skip_whitespace (char *p) 1314{ 1315 while (1) 1316 { 1317 /* A fully-blank line is a delimiter in the SPEC file and shouldn't 1318 be considered whitespace. */ 1319 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n') 1320 return p + 1; 1321 else if (*p == '\n' || *p == ' ' || *p == '\t') 1322 p++; 1323 else if (*p == '#') 1324 { 1325 while (*p != '\n') 1326 p++; 1327 p++; 1328 } 1329 else 1330 break; 1331 } 1332 1333 return p; 1334} 1335/* Structures to keep track of prefixes to try when looking for files. */ 1336 1337struct prefix_list 1338{ 1339 const char *prefix; /* String to prepend to the path. */ 1340 struct prefix_list *next; /* Next in linked list. */ 1341 int require_machine_suffix; /* Don't use without machine_suffix. */ 1342 /* 2 means try both machine_suffix and just_machine_suffix. */ 1343 int *used_flag_ptr; /* 1 if a file was found with this prefix. */ 1344 int priority; /* Sort key - priority within list. */ 1345 int os_multilib; /* 1 if OS multilib scheme should be used, 1346 0 for GCC multilib scheme. */ 1347}; 1348 1349struct path_prefix 1350{ 1351 struct prefix_list *plist; /* List of prefixes to try */ 1352 int max_len; /* Max length of a prefix in PLIST */ 1353 const char *name; /* Name of this list (used in config stuff) */ 1354}; 1355 1356/* List of prefixes to try when looking for executables. */ 1357 1358static struct path_prefix exec_prefixes = { 0, 0, "exec" }; 1359 1360/* List of prefixes to try when looking for startup (crt0) files. */ 1361 1362static struct path_prefix startfile_prefixes = { 0, 0, "startfile" }; 1363 1364/* List of prefixes to try when looking for include files. */ 1365 1366static struct path_prefix include_prefixes = { 0, 0, "include" }; 1367 1368/* Suffix to attach to directories searched for commands. 1369 This looks like `MACHINE/VERSION/'. */ 1370 1371static const char *machine_suffix = 0; 1372 1373/* Suffix to attach to directories searched for commands. 1374 This is just `MACHINE/'. */ 1375 1376static const char *just_machine_suffix = 0; 1377 1378/* Adjusted value of GCC_EXEC_PREFIX envvar. */ 1379 1380static const char *gcc_exec_prefix; 1381 1382/* Adjusted value of standard_libexec_prefix. */ 1383 1384static const char *gcc_libexec_prefix; 1385 1386/* Default prefixes to attach to command names. */ 1387 1388#ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */ 1389#undef MD_EXEC_PREFIX 1390#undef MD_STARTFILE_PREFIX 1391#undef MD_STARTFILE_PREFIX_1 1392#endif 1393 1394/* If no prefixes defined, use the null string, which will disable them. */ 1395#ifndef MD_EXEC_PREFIX 1396#define MD_EXEC_PREFIX "" 1397#endif 1398#ifndef MD_STARTFILE_PREFIX 1399#define MD_STARTFILE_PREFIX "" 1400#endif 1401#ifndef MD_STARTFILE_PREFIX_1 1402#define MD_STARTFILE_PREFIX_1 "" 1403#endif 1404 1405static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX; 1406static const char *const standard_exec_prefix_1 = "/usr/libexec/gcc/"; 1407static const char *const standard_exec_prefix_2 = "/usr/lib/gcc/"; 1408static const char *md_exec_prefix = MD_EXEC_PREFIX; 1409 1410static const char *md_startfile_prefix = MD_STARTFILE_PREFIX; 1411static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1; 1412static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX; 1413static const char *const standard_startfile_prefix_1 = "/lib/"; 1414static const char *const standard_startfile_prefix_2 = "/usr/lib/"; 1415 1416static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX; 1417static const char *tooldir_prefix; 1418 1419#ifndef FREEBSD_NATIVE 1420static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX; 1421#endif /* not FREEBSD_NATIVE */ 1422 1423static const char *standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX; 1424 1425/* Subdirectory to use for locating libraries. Set by 1426 set_multilib_dir based on the compilation options. */ 1427 1428static const char *multilib_dir; 1429 1430/* Subdirectory to use for locating libraries in OS conventions. Set by 1431 set_multilib_dir based on the compilation options. */ 1432 1433static const char *multilib_os_dir; 1434 1435/* Structure to keep track of the specs that have been defined so far. 1436 These are accessed using %(specname) or %[specname] in a compiler 1437 or link spec. */ 1438 1439struct spec_list 1440{ 1441 /* The following 2 fields must be first */ 1442 /* to allow EXTRA_SPECS to be initialized */ 1443 const char *name; /* name of the spec. */ 1444 const char *ptr; /* available ptr if no static pointer */ 1445 1446 /* The following fields are not initialized */ 1447 /* by EXTRA_SPECS */ 1448 const char **ptr_spec; /* pointer to the spec itself. */ 1449 struct spec_list *next; /* Next spec in linked list. */ 1450 int name_len; /* length of the name */ 1451 int alloc_p; /* whether string was allocated */ 1452}; 1453 1454#define INIT_STATIC_SPEC(NAME,PTR) \ 1455{ NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 } 1456 1457/* List of statically defined specs. */ 1458static struct spec_list static_specs[] = 1459{ 1460 INIT_STATIC_SPEC ("asm", &asm_spec), 1461 INIT_STATIC_SPEC ("asm_debug", &asm_debug), 1462 INIT_STATIC_SPEC ("asm_final", &asm_final_spec), 1463 INIT_STATIC_SPEC ("asm_options", &asm_options), 1464 INIT_STATIC_SPEC ("invoke_as", &invoke_as), 1465 INIT_STATIC_SPEC ("cpp", &cpp_spec), 1466 INIT_STATIC_SPEC ("cpp_options", &cpp_options), 1467 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options), 1468 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options), 1469 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp), 1470 INIT_STATIC_SPEC ("cc1", &cc1_spec), 1471 INIT_STATIC_SPEC ("cc1_options", &cc1_options), 1472 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec), 1473 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec), 1474 INIT_STATIC_SPEC ("endfile", &endfile_spec), 1475 INIT_STATIC_SPEC ("link", &link_spec), 1476 INIT_STATIC_SPEC ("lib", &lib_spec), 1477 INIT_STATIC_SPEC ("libgcc", &libgcc_spec), 1478 INIT_STATIC_SPEC ("startfile", &startfile_spec), 1479 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces), 1480 INIT_STATIC_SPEC ("cross_compile", &cross_compile), 1481 INIT_STATIC_SPEC ("version", &compiler_version), 1482 INIT_STATIC_SPEC ("multilib", &multilib_select), 1483 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults), 1484 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra), 1485 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches), 1486 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions), 1487 INIT_STATIC_SPEC ("multilib_options", &multilib_options), 1488 INIT_STATIC_SPEC ("linker", &linker_name_spec), 1489 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec), 1490 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix), 1491 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix), 1492 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1), 1493 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec), 1494 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec), 1495 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec), 1496}; 1497 1498#ifdef EXTRA_SPECS /* additional specs needed */ 1499/* Structure to keep track of just the first two args of a spec_list. 1500 That is all that the EXTRA_SPECS macro gives us. */ 1501struct spec_list_1 1502{ 1503 const char *const name; 1504 const char *const ptr; 1505}; 1506 1507static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS }; 1508static struct spec_list *extra_specs = (struct spec_list *) 0; 1509#endif 1510 1511/* List of dynamically allocates specs that have been defined so far. */ 1512 1513static struct spec_list *specs = (struct spec_list *) 0; 1514 1515/* List of static spec functions. */ 1516 1517static const struct spec_function static_spec_functions[] = 1518{ 1519 { "if-exists", if_exists_spec_function }, 1520 { "if-exists-else", if_exists_else_spec_function }, 1521 { 0, 0 } 1522}; 1523 1524static int processing_spec_function; 1525 1526/* Add appropriate libgcc specs to OBSTACK, taking into account 1527 various permutations of -shared-libgcc, -shared, and such. */ 1528 1529#ifdef ENABLE_SHARED_LIBGCC 1530static void 1531init_gcc_specs (struct obstack *obstack, const char *shared_name, 1532 const char *static_name, const char *eh_name) 1533{ 1534 char *buf; 1535 1536 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, 1537 "}%{!static:%{!static-libgcc:", 1538#ifdef HAVE_LD_AS_NEEDED 1539 "%{!shared-libgcc:", static_name, 1540 " --as-needed ", shared_name, " --no-as-needed}" 1541 "%{shared-libgcc:", shared_name, "%{!shared: ", static_name, 1542 "}", 1543#else 1544 "%{!shared:%{!shared-libgcc:", static_name, " ", 1545 eh_name, "}%{shared-libgcc:", shared_name, " ", 1546 static_name, "}}%{shared:", 1547#ifdef LINK_EH_SPEC 1548 "%{shared-libgcc:", shared_name, 1549 "}%{!shared-libgcc:", static_name, "}", 1550#else 1551 shared_name, 1552#endif 1553#endif 1554 "}}}", NULL); 1555 1556 obstack_grow (obstack, buf, strlen (buf)); 1557 free (buf); 1558} 1559#endif /* ENABLE_SHARED_LIBGCC */ 1560 1561/* Initialize the specs lookup routines. */ 1562 1563static void 1564init_spec (void) 1565{ 1566 struct spec_list *next = (struct spec_list *) 0; 1567 struct spec_list *sl = (struct spec_list *) 0; 1568 int i; 1569 1570 if (specs) 1571 return; /* Already initialized. */ 1572 1573 if (verbose_flag) 1574 notice ("Using built-in specs.\n"); 1575 1576#ifdef EXTRA_SPECS 1577 extra_specs = xcalloc (sizeof (struct spec_list), 1578 ARRAY_SIZE (extra_specs_1)); 1579 1580 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--) 1581 { 1582 sl = &extra_specs[i]; 1583 sl->name = extra_specs_1[i].name; 1584 sl->ptr = extra_specs_1[i].ptr; 1585 sl->next = next; 1586 sl->name_len = strlen (sl->name); 1587 sl->ptr_spec = &sl->ptr; 1588 next = sl; 1589 } 1590#endif 1591 1592 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes 1593 on ?: in file-scope variable initializations. */ 1594 asm_debug = ASM_DEBUG_SPEC; 1595 1596 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--) 1597 { 1598 sl = &static_specs[i]; 1599 sl->next = next; 1600 next = sl; 1601 } 1602 1603#ifdef ENABLE_SHARED_LIBGCC 1604 /* ??? If neither -shared-libgcc nor --static-libgcc was 1605 seen, then we should be making an educated guess. Some proposed 1606 heuristics for ELF include: 1607 1608 (1) If "-Wl,--export-dynamic", then it's a fair bet that the 1609 program will be doing dynamic loading, which will likely 1610 need the shared libgcc. 1611 1612 (2) If "-ldl", then it's also a fair bet that we're doing 1613 dynamic loading. 1614 1615 (3) For each ET_DYN we're linking against (either through -lfoo 1616 or /some/path/foo.so), check to see whether it or one of 1617 its dependencies depends on a shared libgcc. 1618 1619 (4) If "-shared" 1620 1621 If the runtime is fixed to look for program headers instead 1622 of calling __register_frame_info at all, for each object, 1623 use the shared libgcc if any EH symbol referenced. 1624 1625 If crtstuff is fixed to not invoke __register_frame_info 1626 automatically, for each object, use the shared libgcc if 1627 any non-empty unwind section found. 1628 1629 Doing any of this probably requires invoking an external program to 1630 do the actual object file scanning. */ 1631 { 1632 const char *p = libgcc_spec; 1633 int in_sep = 1; 1634 1635 /* Transform the extant libgcc_spec into one that uses the shared libgcc 1636 when given the proper command line arguments. */ 1637 while (*p) 1638 { 1639 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0) 1640 { 1641 init_gcc_specs (&obstack, 1642#ifdef NO_SHARED_LIBGCC_MULTILIB 1643 "-lgcc_s" 1644#else 1645 "-lgcc_s%M" 1646#endif
| 919 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0}, 920 {".h", "@c-header", 0}, 921 {"@c-header", 922 /* cc1 has an integrated ISO C preprocessor. We should invoke the 923 external preprocessor if -save-temps is given. */ 924 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\ 925 %{!E:%{!M:%{!MM:\ 926 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \ 927 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\ 928 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \ 929 %(cc1_options)\ 930 -o %g.s %{!o*:--output-pch=%i.gch}\ 931 %W{o*:--output-pch=%*}%V}\ 932 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\ 933 cc1 %(cpp_unique_options) %(cc1_options)\ 934 -o %g.s %{!o*:--output-pch=%i.gch}\ 935 %W{o*:--output-pch=%*}%V}}}}}}", 0}, 936 {".i", "@cpp-output", 0}, 937 {"@cpp-output", 938 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0}, 939 {".s", "@assembler", 0}, 940 {"@assembler", 941 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0}, 942 {".S", "@assembler-with-cpp", 0}, 943 {"@assembler-with-cpp", 944#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT 945 "%(trad_capable_cpp) -lang-asm %(cpp_options)\ 946 %{E|M|MM:%(cpp_debug_options)}\ 947 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\ 948 as %(asm_debug) %(asm_options) %|.s %A }}}}" 949#else 950 "%(trad_capable_cpp) -lang-asm %(cpp_options)\ 951 %{E|M|MM:%(cpp_debug_options)}\ 952 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\ 953 as %(asm_debug) %(asm_options) %m.s %A }}}}" 954#endif 955 , 0}, 956 957#include "specs.h" 958 /* Mark end of table. */ 959 {0, 0, 0} 960}; 961 962/* Number of elements in default_compilers, not counting the terminator. */ 963 964static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1; 965 966/* A vector of options to give to the linker. 967 These options are accumulated by %x, 968 and substituted into the linker command with %X. */ 969static int n_linker_options; 970static char **linker_options; 971 972/* A vector of options to give to the assembler. 973 These options are accumulated by -Wa, 974 and substituted into the assembler command with %Y. */ 975static int n_assembler_options; 976static char **assembler_options; 977 978/* A vector of options to give to the preprocessor. 979 These options are accumulated by -Wp, 980 and substituted into the preprocessor command with %Z. */ 981static int n_preprocessor_options; 982static char **preprocessor_options; 983 984/* Define how to map long options into short ones. */ 985 986/* This structure describes one mapping. */ 987struct option_map 988{ 989 /* The long option's name. */ 990 const char *const name; 991 /* The equivalent short option. */ 992 const char *const equivalent; 993 /* Argument info. A string of flag chars; NULL equals no options. 994 a => argument required. 995 o => argument optional. 996 j => join argument to equivalent, making one word. 997 * => require other text after NAME as an argument. */ 998 const char *const arg_info; 999}; 1000 1001/* This is the table of mappings. Mappings are tried sequentially 1002 for each option encountered; the first one that matches, wins. */ 1003 1004static const struct option_map option_map[] = 1005 { 1006 {"--all-warnings", "-Wall", 0}, 1007 {"--ansi", "-ansi", 0}, 1008 {"--assemble", "-S", 0}, 1009 {"--assert", "-A", "a"}, 1010 {"--classpath", "-fclasspath=", "aj"}, 1011 {"--bootclasspath", "-fbootclasspath=", "aj"}, 1012 {"--CLASSPATH", "-fclasspath=", "aj"}, 1013 {"--comments", "-C", 0}, 1014 {"--comments-in-macros", "-CC", 0}, 1015 {"--compile", "-c", 0}, 1016 {"--debug", "-g", "oj"}, 1017 {"--define-macro", "-D", "aj"}, 1018 {"--dependencies", "-M", 0}, 1019 {"--dump", "-d", "a"}, 1020 {"--dumpbase", "-dumpbase", "a"}, 1021 {"--entry", "-e", 0}, 1022 {"--extra-warnings", "-W", 0}, 1023 {"--for-assembler", "-Wa", "a"}, 1024 {"--for-linker", "-Xlinker", "a"}, 1025 {"--force-link", "-u", "a"}, 1026 {"--imacros", "-imacros", "a"}, 1027 {"--include", "-include", "a"}, 1028 {"--include-barrier", "-I-", 0}, 1029 {"--include-directory", "-I", "aj"}, 1030 {"--include-directory-after", "-idirafter", "a"}, 1031 {"--include-prefix", "-iprefix", "a"}, 1032 {"--include-with-prefix", "-iwithprefix", "a"}, 1033 {"--include-with-prefix-before", "-iwithprefixbefore", "a"}, 1034 {"--include-with-prefix-after", "-iwithprefix", "a"}, 1035 {"--language", "-x", "a"}, 1036 {"--library-directory", "-L", "a"}, 1037 {"--machine", "-m", "aj"}, 1038 {"--machine-", "-m", "*j"}, 1039 {"--no-integrated-cpp", "-no-integrated-cpp", 0}, 1040 {"--no-line-commands", "-P", 0}, 1041 {"--no-precompiled-includes", "-noprecomp", 0}, 1042 {"--no-standard-includes", "-nostdinc", 0}, 1043 {"--no-standard-libraries", "-nostdlib", 0}, 1044 {"--no-warnings", "-w", 0}, 1045 {"--optimize", "-O", "oj"}, 1046 {"--output", "-o", "a"}, 1047 {"--output-class-directory", "-foutput-class-dir=", "ja"}, 1048 {"--param", "--param", "a"}, 1049 {"--pedantic", "-pedantic", 0}, 1050 {"--pedantic-errors", "-pedantic-errors", 0}, 1051 {"--pie", "-pie", 0}, 1052 {"--pipe", "-pipe", 0}, 1053 {"--prefix", "-B", "a"}, 1054 {"--preprocess", "-E", 0}, 1055 {"--print-search-dirs", "-print-search-dirs", 0}, 1056 {"--print-file-name", "-print-file-name=", "aj"}, 1057 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0}, 1058 {"--print-missing-file-dependencies", "-MG", 0}, 1059 {"--print-multi-lib", "-print-multi-lib", 0}, 1060 {"--print-multi-directory", "-print-multi-directory", 0}, 1061 {"--print-multi-os-directory", "-print-multi-os-directory", 0}, 1062 {"--print-prog-name", "-print-prog-name=", "aj"}, 1063 {"--profile", "-p", 0}, 1064 {"--profile-blocks", "-a", 0}, 1065 {"--quiet", "-q", 0}, 1066 {"--resource", "-fcompile-resource=", "aj"}, 1067 {"--save-temps", "-save-temps", 0}, 1068 {"--shared", "-shared", 0}, 1069 {"--silent", "-q", 0}, 1070 {"--specs", "-specs=", "aj"}, 1071 {"--static", "-static", 0}, 1072 {"--std", "-std=", "aj"}, 1073 {"--symbolic", "-symbolic", 0}, 1074 {"--time", "-time", 0}, 1075 {"--trace-includes", "-H", 0}, 1076 {"--traditional", "-traditional", 0}, 1077 {"--traditional-cpp", "-traditional-cpp", 0}, 1078 {"--trigraphs", "-trigraphs", 0}, 1079 {"--undefine-macro", "-U", "aj"}, 1080 {"--user-dependencies", "-MM", 0}, 1081 {"--verbose", "-v", 0}, 1082 {"--warn-", "-W", "*j"}, 1083 {"--write-dependencies", "-MD", 0}, 1084 {"--write-user-dependencies", "-MMD", 0}, 1085 {"--", "-f", "*j"} 1086 }; 1087 1088 1089#ifdef TARGET_OPTION_TRANSLATE_TABLE 1090static const struct { 1091 const char *const option_found; 1092 const char *const replacements; 1093} target_option_translations[] = 1094{ 1095 TARGET_OPTION_TRANSLATE_TABLE, 1096 { 0, 0 } 1097}; 1098#endif 1099 1100/* Translate the options described by *ARGCP and *ARGVP. 1101 Make a new vector and store it back in *ARGVP, 1102 and store its length in *ARGVC. */ 1103 1104static void 1105translate_options (int *argcp, const char *const **argvp) 1106{ 1107 int i; 1108 int argc = *argcp; 1109 const char *const *argv = *argvp; 1110 int newvsize = (argc + 2) * 2 * sizeof (const char *); 1111 const char **newv = xmalloc (newvsize); 1112 int newindex = 0; 1113 1114 i = 0; 1115 newv[newindex++] = argv[i++]; 1116 1117 while (i < argc) 1118 { 1119#ifdef TARGET_OPTION_TRANSLATE_TABLE 1120 int tott_idx; 1121 1122 for (tott_idx = 0; 1123 target_option_translations[tott_idx].option_found; 1124 tott_idx++) 1125 { 1126 if (strcmp (target_option_translations[tott_idx].option_found, 1127 argv[i]) == 0) 1128 { 1129 int spaces = 1; 1130 const char *sp; 1131 char *np; 1132 1133 for (sp = target_option_translations[tott_idx].replacements; 1134 *sp; sp++) 1135 { 1136 if (*sp == ' ') 1137 spaces ++; 1138 } 1139 1140 newvsize += spaces * sizeof (const char *); 1141 newv = xrealloc (newv, newvsize); 1142 1143 sp = target_option_translations[tott_idx].replacements; 1144 np = xstrdup (sp); 1145 1146 while (1) 1147 { 1148 while (*np == ' ') 1149 np++; 1150 if (*np == 0) 1151 break; 1152 newv[newindex++] = np; 1153 while (*np != ' ' && *np) 1154 np++; 1155 if (*np == 0) 1156 break; 1157 *np++ = 0; 1158 } 1159 1160 i ++; 1161 break; 1162 } 1163 } 1164 if (target_option_translations[tott_idx].option_found) 1165 continue; 1166#endif 1167 1168 /* Translate -- options. */ 1169 if (argv[i][0] == '-' && argv[i][1] == '-') 1170 { 1171 size_t j; 1172 /* Find a mapping that applies to this option. */ 1173 for (j = 0; j < ARRAY_SIZE (option_map); j++) 1174 { 1175 size_t optlen = strlen (option_map[j].name); 1176 size_t arglen = strlen (argv[i]); 1177 size_t complen = arglen > optlen ? optlen : arglen; 1178 const char *arginfo = option_map[j].arg_info; 1179 1180 if (arginfo == 0) 1181 arginfo = ""; 1182 1183 if (!strncmp (argv[i], option_map[j].name, complen)) 1184 { 1185 const char *arg = 0; 1186 1187 if (arglen < optlen) 1188 { 1189 size_t k; 1190 for (k = j + 1; k < ARRAY_SIZE (option_map); k++) 1191 if (strlen (option_map[k].name) >= arglen 1192 && !strncmp (argv[i], option_map[k].name, arglen)) 1193 { 1194 error ("ambiguous abbreviation %s", argv[i]); 1195 break; 1196 } 1197 1198 if (k != ARRAY_SIZE (option_map)) 1199 break; 1200 } 1201 1202 if (arglen > optlen) 1203 { 1204 /* If the option has an argument, accept that. */ 1205 if (argv[i][optlen] == '=') 1206 arg = argv[i] + optlen + 1; 1207 1208 /* If this mapping requires extra text at end of name, 1209 accept that as "argument". */ 1210 else if (strchr (arginfo, '*') != 0) 1211 arg = argv[i] + optlen; 1212 1213 /* Otherwise, extra text at end means mismatch. 1214 Try other mappings. */ 1215 else 1216 continue; 1217 } 1218 1219 else if (strchr (arginfo, '*') != 0) 1220 { 1221 error ("incomplete `%s' option", option_map[j].name); 1222 break; 1223 } 1224 1225 /* Handle arguments. */ 1226 if (strchr (arginfo, 'a') != 0) 1227 { 1228 if (arg == 0) 1229 { 1230 if (i + 1 == argc) 1231 { 1232 error ("missing argument to `%s' option", 1233 option_map[j].name); 1234 break; 1235 } 1236 1237 arg = argv[++i]; 1238 } 1239 } 1240 else if (strchr (arginfo, '*') != 0) 1241 ; 1242 else if (strchr (arginfo, 'o') == 0) 1243 { 1244 if (arg != 0) 1245 error ("extraneous argument to `%s' option", 1246 option_map[j].name); 1247 arg = 0; 1248 } 1249 1250 /* Store the translation as one argv elt or as two. */ 1251 if (arg != 0 && strchr (arginfo, 'j') != 0) 1252 newv[newindex++] = concat (option_map[j].equivalent, arg, 1253 NULL); 1254 else if (arg != 0) 1255 { 1256 newv[newindex++] = option_map[j].equivalent; 1257 newv[newindex++] = arg; 1258 } 1259 else 1260 newv[newindex++] = option_map[j].equivalent; 1261 1262 break; 1263 } 1264 } 1265 i++; 1266 } 1267 1268 /* Handle old-fashioned options--just copy them through, 1269 with their arguments. */ 1270 else if (argv[i][0] == '-') 1271 { 1272 const char *p = argv[i] + 1; 1273 int c = *p; 1274 int nskip = 1; 1275 1276 if (SWITCH_TAKES_ARG (c) > (p[1] != 0)) 1277 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0); 1278 else if (WORD_SWITCH_TAKES_ARG (p)) 1279 nskip += WORD_SWITCH_TAKES_ARG (p); 1280 else if ((c == 'B' || c == 'b' || c == 'x') 1281 && p[1] == 0) 1282 nskip += 1; 1283 else if (! strcmp (p, "Xlinker")) 1284 nskip += 1; 1285 else if (! strcmp (p, "Xpreprocessor")) 1286 nskip += 1; 1287 else if (! strcmp (p, "Xassembler")) 1288 nskip += 1; 1289 1290 /* Watch out for an option at the end of the command line that 1291 is missing arguments, and avoid skipping past the end of the 1292 command line. */ 1293 if (nskip + i > argc) 1294 nskip = argc - i; 1295 1296 while (nskip > 0) 1297 { 1298 newv[newindex++] = argv[i++]; 1299 nskip--; 1300 } 1301 } 1302 else 1303 /* Ordinary operands, or +e options. */ 1304 newv[newindex++] = argv[i++]; 1305 } 1306 1307 newv[newindex] = 0; 1308 1309 *argvp = newv; 1310 *argcp = newindex; 1311} 1312 1313static char * 1314skip_whitespace (char *p) 1315{ 1316 while (1) 1317 { 1318 /* A fully-blank line is a delimiter in the SPEC file and shouldn't 1319 be considered whitespace. */ 1320 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n') 1321 return p + 1; 1322 else if (*p == '\n' || *p == ' ' || *p == '\t') 1323 p++; 1324 else if (*p == '#') 1325 { 1326 while (*p != '\n') 1327 p++; 1328 p++; 1329 } 1330 else 1331 break; 1332 } 1333 1334 return p; 1335} 1336/* Structures to keep track of prefixes to try when looking for files. */ 1337 1338struct prefix_list 1339{ 1340 const char *prefix; /* String to prepend to the path. */ 1341 struct prefix_list *next; /* Next in linked list. */ 1342 int require_machine_suffix; /* Don't use without machine_suffix. */ 1343 /* 2 means try both machine_suffix and just_machine_suffix. */ 1344 int *used_flag_ptr; /* 1 if a file was found with this prefix. */ 1345 int priority; /* Sort key - priority within list. */ 1346 int os_multilib; /* 1 if OS multilib scheme should be used, 1347 0 for GCC multilib scheme. */ 1348}; 1349 1350struct path_prefix 1351{ 1352 struct prefix_list *plist; /* List of prefixes to try */ 1353 int max_len; /* Max length of a prefix in PLIST */ 1354 const char *name; /* Name of this list (used in config stuff) */ 1355}; 1356 1357/* List of prefixes to try when looking for executables. */ 1358 1359static struct path_prefix exec_prefixes = { 0, 0, "exec" }; 1360 1361/* List of prefixes to try when looking for startup (crt0) files. */ 1362 1363static struct path_prefix startfile_prefixes = { 0, 0, "startfile" }; 1364 1365/* List of prefixes to try when looking for include files. */ 1366 1367static struct path_prefix include_prefixes = { 0, 0, "include" }; 1368 1369/* Suffix to attach to directories searched for commands. 1370 This looks like `MACHINE/VERSION/'. */ 1371 1372static const char *machine_suffix = 0; 1373 1374/* Suffix to attach to directories searched for commands. 1375 This is just `MACHINE/'. */ 1376 1377static const char *just_machine_suffix = 0; 1378 1379/* Adjusted value of GCC_EXEC_PREFIX envvar. */ 1380 1381static const char *gcc_exec_prefix; 1382 1383/* Adjusted value of standard_libexec_prefix. */ 1384 1385static const char *gcc_libexec_prefix; 1386 1387/* Default prefixes to attach to command names. */ 1388 1389#ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */ 1390#undef MD_EXEC_PREFIX 1391#undef MD_STARTFILE_PREFIX 1392#undef MD_STARTFILE_PREFIX_1 1393#endif 1394 1395/* If no prefixes defined, use the null string, which will disable them. */ 1396#ifndef MD_EXEC_PREFIX 1397#define MD_EXEC_PREFIX "" 1398#endif 1399#ifndef MD_STARTFILE_PREFIX 1400#define MD_STARTFILE_PREFIX "" 1401#endif 1402#ifndef MD_STARTFILE_PREFIX_1 1403#define MD_STARTFILE_PREFIX_1 "" 1404#endif 1405 1406static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX; 1407static const char *const standard_exec_prefix_1 = "/usr/libexec/gcc/"; 1408static const char *const standard_exec_prefix_2 = "/usr/lib/gcc/"; 1409static const char *md_exec_prefix = MD_EXEC_PREFIX; 1410 1411static const char *md_startfile_prefix = MD_STARTFILE_PREFIX; 1412static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1; 1413static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX; 1414static const char *const standard_startfile_prefix_1 = "/lib/"; 1415static const char *const standard_startfile_prefix_2 = "/usr/lib/"; 1416 1417static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX; 1418static const char *tooldir_prefix; 1419 1420#ifndef FREEBSD_NATIVE 1421static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX; 1422#endif /* not FREEBSD_NATIVE */ 1423 1424static const char *standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX; 1425 1426/* Subdirectory to use for locating libraries. Set by 1427 set_multilib_dir based on the compilation options. */ 1428 1429static const char *multilib_dir; 1430 1431/* Subdirectory to use for locating libraries in OS conventions. Set by 1432 set_multilib_dir based on the compilation options. */ 1433 1434static const char *multilib_os_dir; 1435 1436/* Structure to keep track of the specs that have been defined so far. 1437 These are accessed using %(specname) or %[specname] in a compiler 1438 or link spec. */ 1439 1440struct spec_list 1441{ 1442 /* The following 2 fields must be first */ 1443 /* to allow EXTRA_SPECS to be initialized */ 1444 const char *name; /* name of the spec. */ 1445 const char *ptr; /* available ptr if no static pointer */ 1446 1447 /* The following fields are not initialized */ 1448 /* by EXTRA_SPECS */ 1449 const char **ptr_spec; /* pointer to the spec itself. */ 1450 struct spec_list *next; /* Next spec in linked list. */ 1451 int name_len; /* length of the name */ 1452 int alloc_p; /* whether string was allocated */ 1453}; 1454 1455#define INIT_STATIC_SPEC(NAME,PTR) \ 1456{ NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 } 1457 1458/* List of statically defined specs. */ 1459static struct spec_list static_specs[] = 1460{ 1461 INIT_STATIC_SPEC ("asm", &asm_spec), 1462 INIT_STATIC_SPEC ("asm_debug", &asm_debug), 1463 INIT_STATIC_SPEC ("asm_final", &asm_final_spec), 1464 INIT_STATIC_SPEC ("asm_options", &asm_options), 1465 INIT_STATIC_SPEC ("invoke_as", &invoke_as), 1466 INIT_STATIC_SPEC ("cpp", &cpp_spec), 1467 INIT_STATIC_SPEC ("cpp_options", &cpp_options), 1468 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options), 1469 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options), 1470 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp), 1471 INIT_STATIC_SPEC ("cc1", &cc1_spec), 1472 INIT_STATIC_SPEC ("cc1_options", &cc1_options), 1473 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec), 1474 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec), 1475 INIT_STATIC_SPEC ("endfile", &endfile_spec), 1476 INIT_STATIC_SPEC ("link", &link_spec), 1477 INIT_STATIC_SPEC ("lib", &lib_spec), 1478 INIT_STATIC_SPEC ("libgcc", &libgcc_spec), 1479 INIT_STATIC_SPEC ("startfile", &startfile_spec), 1480 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces), 1481 INIT_STATIC_SPEC ("cross_compile", &cross_compile), 1482 INIT_STATIC_SPEC ("version", &compiler_version), 1483 INIT_STATIC_SPEC ("multilib", &multilib_select), 1484 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults), 1485 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra), 1486 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches), 1487 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions), 1488 INIT_STATIC_SPEC ("multilib_options", &multilib_options), 1489 INIT_STATIC_SPEC ("linker", &linker_name_spec), 1490 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec), 1491 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix), 1492 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix), 1493 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1), 1494 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec), 1495 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec), 1496 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec), 1497}; 1498 1499#ifdef EXTRA_SPECS /* additional specs needed */ 1500/* Structure to keep track of just the first two args of a spec_list. 1501 That is all that the EXTRA_SPECS macro gives us. */ 1502struct spec_list_1 1503{ 1504 const char *const name; 1505 const char *const ptr; 1506}; 1507 1508static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS }; 1509static struct spec_list *extra_specs = (struct spec_list *) 0; 1510#endif 1511 1512/* List of dynamically allocates specs that have been defined so far. */ 1513 1514static struct spec_list *specs = (struct spec_list *) 0; 1515 1516/* List of static spec functions. */ 1517 1518static const struct spec_function static_spec_functions[] = 1519{ 1520 { "if-exists", if_exists_spec_function }, 1521 { "if-exists-else", if_exists_else_spec_function }, 1522 { 0, 0 } 1523}; 1524 1525static int processing_spec_function; 1526 1527/* Add appropriate libgcc specs to OBSTACK, taking into account 1528 various permutations of -shared-libgcc, -shared, and such. */ 1529 1530#ifdef ENABLE_SHARED_LIBGCC 1531static void 1532init_gcc_specs (struct obstack *obstack, const char *shared_name, 1533 const char *static_name, const char *eh_name) 1534{ 1535 char *buf; 1536 1537 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, 1538 "}%{!static:%{!static-libgcc:", 1539#ifdef HAVE_LD_AS_NEEDED 1540 "%{!shared-libgcc:", static_name, 1541 " --as-needed ", shared_name, " --no-as-needed}" 1542 "%{shared-libgcc:", shared_name, "%{!shared: ", static_name, 1543 "}", 1544#else 1545 "%{!shared:%{!shared-libgcc:", static_name, " ", 1546 eh_name, "}%{shared-libgcc:", shared_name, " ", 1547 static_name, "}}%{shared:", 1548#ifdef LINK_EH_SPEC 1549 "%{shared-libgcc:", shared_name, 1550 "}%{!shared-libgcc:", static_name, "}", 1551#else 1552 shared_name, 1553#endif 1554#endif 1555 "}}}", NULL); 1556 1557 obstack_grow (obstack, buf, strlen (buf)); 1558 free (buf); 1559} 1560#endif /* ENABLE_SHARED_LIBGCC */ 1561 1562/* Initialize the specs lookup routines. */ 1563 1564static void 1565init_spec (void) 1566{ 1567 struct spec_list *next = (struct spec_list *) 0; 1568 struct spec_list *sl = (struct spec_list *) 0; 1569 int i; 1570 1571 if (specs) 1572 return; /* Already initialized. */ 1573 1574 if (verbose_flag) 1575 notice ("Using built-in specs.\n"); 1576 1577#ifdef EXTRA_SPECS 1578 extra_specs = xcalloc (sizeof (struct spec_list), 1579 ARRAY_SIZE (extra_specs_1)); 1580 1581 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--) 1582 { 1583 sl = &extra_specs[i]; 1584 sl->name = extra_specs_1[i].name; 1585 sl->ptr = extra_specs_1[i].ptr; 1586 sl->next = next; 1587 sl->name_len = strlen (sl->name); 1588 sl->ptr_spec = &sl->ptr; 1589 next = sl; 1590 } 1591#endif 1592 1593 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes 1594 on ?: in file-scope variable initializations. */ 1595 asm_debug = ASM_DEBUG_SPEC; 1596 1597 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--) 1598 { 1599 sl = &static_specs[i]; 1600 sl->next = next; 1601 next = sl; 1602 } 1603 1604#ifdef ENABLE_SHARED_LIBGCC 1605 /* ??? If neither -shared-libgcc nor --static-libgcc was 1606 seen, then we should be making an educated guess. Some proposed 1607 heuristics for ELF include: 1608 1609 (1) If "-Wl,--export-dynamic", then it's a fair bet that the 1610 program will be doing dynamic loading, which will likely 1611 need the shared libgcc. 1612 1613 (2) If "-ldl", then it's also a fair bet that we're doing 1614 dynamic loading. 1615 1616 (3) For each ET_DYN we're linking against (either through -lfoo 1617 or /some/path/foo.so), check to see whether it or one of 1618 its dependencies depends on a shared libgcc. 1619 1620 (4) If "-shared" 1621 1622 If the runtime is fixed to look for program headers instead 1623 of calling __register_frame_info at all, for each object, 1624 use the shared libgcc if any EH symbol referenced. 1625 1626 If crtstuff is fixed to not invoke __register_frame_info 1627 automatically, for each object, use the shared libgcc if 1628 any non-empty unwind section found. 1629 1630 Doing any of this probably requires invoking an external program to 1631 do the actual object file scanning. */ 1632 { 1633 const char *p = libgcc_spec; 1634 int in_sep = 1; 1635 1636 /* Transform the extant libgcc_spec into one that uses the shared libgcc 1637 when given the proper command line arguments. */ 1638 while (*p) 1639 { 1640 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0) 1641 { 1642 init_gcc_specs (&obstack, 1643#ifdef NO_SHARED_LIBGCC_MULTILIB 1644 "-lgcc_s" 1645#else 1646 "-lgcc_s%M" 1647#endif
|
1652#endif 1653 ); 1654 1655 p += 5; 1656 in_sep = 0; 1657 } 1658 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0) 1659 { 1660 /* Ug. We don't know shared library extensions. Hope that 1661 systems that use this form don't do shared libraries. */ 1662 init_gcc_specs (&obstack, 1663#ifdef NO_SHARED_LIBGCC_MULTILIB 1664 "-lgcc_s" 1665#else 1666 "-lgcc_s%M" 1667#endif 1668 , 1669 "libgcc.a%s", 1670 "libgcc_eh.a%s" 1671#ifdef USE_LIBUNWIND_EXCEPTIONS 1672 " -lunwind" 1673#endif 1674 ); 1675 p += 10; 1676 in_sep = 0; 1677 } 1678 else 1679 { 1680 obstack_1grow (&obstack, *p); 1681 in_sep = (*p == ' '); 1682 p += 1; 1683 } 1684 } 1685 1686 obstack_1grow (&obstack, '\0'); 1687 libgcc_spec = obstack_finish (&obstack); 1688 } 1689#endif 1690#ifdef USE_AS_TRADITIONAL_FORMAT 1691 /* Prepend "--traditional-format" to whatever asm_spec we had before. */ 1692 { 1693 static const char tf[] = "--traditional-format "; 1694 obstack_grow (&obstack, tf, sizeof(tf) - 1); 1695 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec)); 1696 asm_spec = obstack_finish (&obstack); 1697 } 1698#endif 1699#ifdef LINK_EH_SPEC 1700 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */ 1701 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1); 1702 obstack_grow0 (&obstack, link_spec, strlen (link_spec)); 1703 link_spec = obstack_finish (&obstack); 1704#endif 1705 1706 specs = sl; 1707} 1708 1709/* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is 1710 removed; If the spec starts with a + then SPEC is added to the end of the 1711 current spec. */ 1712 1713static void 1714set_spec (const char *name, const char *spec) 1715{ 1716 struct spec_list *sl; 1717 const char *old_spec; 1718 int name_len = strlen (name); 1719 int i; 1720 1721 /* If this is the first call, initialize the statically allocated specs. */ 1722 if (!specs) 1723 { 1724 struct spec_list *next = (struct spec_list *) 0; 1725 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--) 1726 { 1727 sl = &static_specs[i]; 1728 sl->next = next; 1729 next = sl; 1730 } 1731 specs = sl; 1732 } 1733 1734 /* See if the spec already exists. */ 1735 for (sl = specs; sl; sl = sl->next) 1736 if (name_len == sl->name_len && !strcmp (sl->name, name)) 1737 break; 1738 1739 if (!sl) 1740 { 1741 /* Not found - make it. */ 1742 sl = xmalloc (sizeof (struct spec_list)); 1743 sl->name = xstrdup (name); 1744 sl->name_len = name_len; 1745 sl->ptr_spec = &sl->ptr; 1746 sl->alloc_p = 0; 1747 *(sl->ptr_spec) = ""; 1748 sl->next = specs; 1749 specs = sl; 1750 } 1751 1752 old_spec = *(sl->ptr_spec); 1753 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1])) 1754 ? concat (old_spec, spec + 1, NULL) 1755 : xstrdup (spec)); 1756 1757#ifdef DEBUG_SPECS 1758 if (verbose_flag) 1759 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec)); 1760#endif 1761 1762 /* Free the old spec. */ 1763 if (old_spec && sl->alloc_p) 1764 free ((void *) old_spec); 1765 1766 sl->alloc_p = 1; 1767} 1768 1769/* Accumulate a command (program name and args), and run it. */ 1770 1771/* Vector of pointers to arguments in the current line of specifications. */ 1772 1773static const char **argbuf; 1774 1775/* Number of elements allocated in argbuf. */ 1776 1777static int argbuf_length; 1778 1779/* Number of elements in argbuf currently in use (containing args). */ 1780 1781static int argbuf_index; 1782 1783/* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated 1784 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for 1785 it here. */ 1786 1787static struct temp_name { 1788 const char *suffix; /* suffix associated with the code. */ 1789 int length; /* strlen (suffix). */ 1790 int unique; /* Indicates whether %g or %u/%U was used. */ 1791 const char *filename; /* associated filename. */ 1792 int filename_length; /* strlen (filename). */ 1793 struct temp_name *next; 1794} *temp_names; 1795 1796/* Number of commands executed so far. */ 1797 1798static int execution_count; 1799 1800/* Number of commands that exited with a signal. */ 1801 1802static int signal_count; 1803 1804/* Name with which this program was invoked. */ 1805 1806static const char *programname; 1807 1808/* Allocate the argument vector. */ 1809 1810static void 1811alloc_args (void) 1812{ 1813 argbuf_length = 10; 1814 argbuf = xmalloc (argbuf_length * sizeof (const char *)); 1815} 1816 1817/* Clear out the vector of arguments (after a command is executed). */ 1818 1819static void 1820clear_args (void) 1821{ 1822 argbuf_index = 0; 1823} 1824 1825/* Add one argument to the vector at the end. 1826 This is done when a space is seen or at the end of the line. 1827 If DELETE_ALWAYS is nonzero, the arg is a filename 1828 and the file should be deleted eventually. 1829 If DELETE_FAILURE is nonzero, the arg is a filename 1830 and the file should be deleted if this compilation fails. */ 1831 1832static void 1833store_arg (const char *arg, int delete_always, int delete_failure) 1834{ 1835 if (argbuf_index + 1 == argbuf_length) 1836 argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *)); 1837 1838 argbuf[argbuf_index++] = arg; 1839 argbuf[argbuf_index] = 0; 1840 1841 if (delete_always || delete_failure) 1842 record_temp_file (arg, delete_always, delete_failure); 1843} 1844 1845/* Load specs from a file name named FILENAME, replacing occurrences of 1846 various different types of line-endings, \r\n, \n\r and just \r, with 1847 a single \n. */ 1848 1849static char * 1850load_specs (const char *filename) 1851{ 1852 int desc; 1853 int readlen; 1854 struct stat statbuf; 1855 char *buffer; 1856 char *buffer_p; 1857 char *specs; 1858 char *specs_p; 1859 1860 if (verbose_flag) 1861 notice ("Reading specs from %s\n", filename); 1862 1863 /* Open and stat the file. */ 1864 desc = open (filename, O_RDONLY, 0); 1865 if (desc < 0) 1866 pfatal_with_name (filename); 1867 if (stat (filename, &statbuf) < 0) 1868 pfatal_with_name (filename); 1869 1870 /* Read contents of file into BUFFER. */ 1871 buffer = xmalloc ((unsigned) statbuf.st_size + 1); 1872 readlen = read (desc, buffer, (unsigned) statbuf.st_size); 1873 if (readlen < 0) 1874 pfatal_with_name (filename); 1875 buffer[readlen] = 0; 1876 close (desc); 1877 1878 specs = xmalloc (readlen + 1); 1879 specs_p = specs; 1880 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++) 1881 { 1882 int skip = 0; 1883 char c = *buffer_p; 1884 if (c == '\r') 1885 { 1886 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */ 1887 skip = 1; 1888 else if (*(buffer_p + 1) == '\n') /* \r\n */ 1889 skip = 1; 1890 else /* \r */ 1891 c = '\n'; 1892 } 1893 if (! skip) 1894 *specs_p++ = c; 1895 } 1896 *specs_p = '\0'; 1897 1898 free (buffer); 1899 return (specs); 1900} 1901 1902/* Read compilation specs from a file named FILENAME, 1903 replacing the default ones. 1904 1905 A suffix which starts with `*' is a definition for 1906 one of the machine-specific sub-specs. The "suffix" should be 1907 *asm, *cc1, *cpp, *link, *startfile, etc. 1908 The corresponding spec is stored in asm_spec, etc., 1909 rather than in the `compilers' vector. 1910 1911 Anything invalid in the file is a fatal error. */ 1912 1913static void 1914read_specs (const char *filename, int main_p) 1915{ 1916 char *buffer; 1917 char *p; 1918 1919 buffer = load_specs (filename); 1920 1921 /* Scan BUFFER for specs, putting them in the vector. */ 1922 p = buffer; 1923 while (1) 1924 { 1925 char *suffix; 1926 char *spec; 1927 char *in, *out, *p1, *p2, *p3; 1928 1929 /* Advance P in BUFFER to the next nonblank nocomment line. */ 1930 p = skip_whitespace (p); 1931 if (*p == 0) 1932 break; 1933 1934 /* Is this a special command that starts with '%'? */ 1935 /* Don't allow this for the main specs file, since it would 1936 encourage people to overwrite it. */ 1937 if (*p == '%' && !main_p) 1938 { 1939 p1 = p; 1940 while (*p && *p != '\n') 1941 p++; 1942 1943 /* Skip '\n'. */ 1944 p++; 1945 1946 if (!strncmp (p1, "%include", sizeof ("%include") - 1) 1947 && (p1[sizeof "%include" - 1] == ' ' 1948 || p1[sizeof "%include" - 1] == '\t')) 1949 { 1950 char *new_filename; 1951 1952 p1 += sizeof ("%include"); 1953 while (*p1 == ' ' || *p1 == '\t') 1954 p1++; 1955 1956 if (*p1++ != '<' || p[-2] != '>') 1957 fatal ("specs %%include syntax malformed after %ld characters", 1958 (long) (p1 - buffer + 1)); 1959 1960 p[-2] = '\0'; 1961 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0); 1962 read_specs (new_filename ? new_filename : p1, FALSE); 1963 continue; 1964 } 1965 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1) 1966 && (p1[sizeof "%include_noerr" - 1] == ' ' 1967 || p1[sizeof "%include_noerr" - 1] == '\t')) 1968 { 1969 char *new_filename; 1970 1971 p1 += sizeof "%include_noerr"; 1972 while (*p1 == ' ' || *p1 == '\t') 1973 p1++; 1974 1975 if (*p1++ != '<' || p[-2] != '>') 1976 fatal ("specs %%include syntax malformed after %ld characters", 1977 (long) (p1 - buffer + 1)); 1978 1979 p[-2] = '\0'; 1980 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0); 1981 if (new_filename) 1982 read_specs (new_filename, FALSE); 1983 else if (verbose_flag) 1984 notice ("could not find specs file %s\n", p1); 1985 continue; 1986 } 1987 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1) 1988 && (p1[sizeof "%rename" - 1] == ' ' 1989 || p1[sizeof "%rename" - 1] == '\t')) 1990 { 1991 int name_len; 1992 struct spec_list *sl; 1993 struct spec_list *newsl; 1994 1995 /* Get original name. */ 1996 p1 += sizeof "%rename"; 1997 while (*p1 == ' ' || *p1 == '\t') 1998 p1++; 1999 2000 if (! ISALPHA ((unsigned char) *p1)) 2001 fatal ("specs %%rename syntax malformed after %ld characters", 2002 (long) (p1 - buffer)); 2003 2004 p2 = p1; 2005 while (*p2 && !ISSPACE ((unsigned char) *p2)) 2006 p2++; 2007 2008 if (*p2 != ' ' && *p2 != '\t') 2009 fatal ("specs %%rename syntax malformed after %ld characters", 2010 (long) (p2 - buffer)); 2011 2012 name_len = p2 - p1; 2013 *p2++ = '\0'; 2014 while (*p2 == ' ' || *p2 == '\t') 2015 p2++; 2016 2017 if (! ISALPHA ((unsigned char) *p2)) 2018 fatal ("specs %%rename syntax malformed after %ld characters", 2019 (long) (p2 - buffer)); 2020 2021 /* Get new spec name. */ 2022 p3 = p2; 2023 while (*p3 && !ISSPACE ((unsigned char) *p3)) 2024 p3++; 2025 2026 if (p3 != p - 1) 2027 fatal ("specs %%rename syntax malformed after %ld characters", 2028 (long) (p3 - buffer)); 2029 *p3 = '\0'; 2030 2031 for (sl = specs; sl; sl = sl->next) 2032 if (name_len == sl->name_len && !strcmp (sl->name, p1)) 2033 break; 2034 2035 if (!sl) 2036 fatal ("specs %s spec was not found to be renamed", p1); 2037 2038 if (strcmp (p1, p2) == 0) 2039 continue; 2040 2041 for (newsl = specs; newsl; newsl = newsl->next) 2042 if (strcmp (newsl->name, p2) == 0) 2043 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'", 2044 filename, p1, p2); 2045 2046 if (verbose_flag) 2047 { 2048 notice ("rename spec %s to %s\n", p1, p2); 2049#ifdef DEBUG_SPECS 2050 notice ("spec is '%s'\n\n", *(sl->ptr_spec)); 2051#endif 2052 } 2053 2054 set_spec (p2, *(sl->ptr_spec)); 2055 if (sl->alloc_p) 2056 free ((void *) *(sl->ptr_spec)); 2057 2058 *(sl->ptr_spec) = ""; 2059 sl->alloc_p = 0; 2060 continue; 2061 } 2062 else 2063 fatal ("specs unknown %% command after %ld characters", 2064 (long) (p1 - buffer)); 2065 } 2066 2067 /* Find the colon that should end the suffix. */ 2068 p1 = p; 2069 while (*p1 && *p1 != ':' && *p1 != '\n') 2070 p1++; 2071 2072 /* The colon shouldn't be missing. */ 2073 if (*p1 != ':') 2074 fatal ("specs file malformed after %ld characters", 2075 (long) (p1 - buffer)); 2076 2077 /* Skip back over trailing whitespace. */ 2078 p2 = p1; 2079 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t')) 2080 p2--; 2081 2082 /* Copy the suffix to a string. */ 2083 suffix = save_string (p, p2 - p); 2084 /* Find the next line. */ 2085 p = skip_whitespace (p1 + 1); 2086 if (p[1] == 0) 2087 fatal ("specs file malformed after %ld characters", 2088 (long) (p - buffer)); 2089 2090 p1 = p; 2091 /* Find next blank line or end of string. */ 2092 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0'))) 2093 p1++; 2094 2095 /* Specs end at the blank line and do not include the newline. */ 2096 spec = save_string (p, p1 - p); 2097 p = p1; 2098 2099 /* Delete backslash-newline sequences from the spec. */ 2100 in = spec; 2101 out = spec; 2102 while (*in != 0) 2103 { 2104 if (in[0] == '\\' && in[1] == '\n') 2105 in += 2; 2106 else if (in[0] == '#') 2107 while (*in && *in != '\n') 2108 in++; 2109 2110 else 2111 *out++ = *in++; 2112 } 2113 *out = 0; 2114 2115 if (suffix[0] == '*') 2116 { 2117 if (! strcmp (suffix, "*link_command")) 2118 link_command_spec = spec; 2119 else 2120 set_spec (suffix + 1, spec); 2121 } 2122 else 2123 { 2124 /* Add this pair to the vector. */ 2125 compilers 2126 = xrealloc (compilers, 2127 (n_compilers + 2) * sizeof (struct compiler)); 2128 2129 compilers[n_compilers].suffix = suffix; 2130 compilers[n_compilers].spec = spec; 2131 n_compilers++; 2132 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]); 2133 } 2134 2135 if (*suffix == 0) 2136 link_command_spec = spec; 2137 } 2138 2139 if (link_command_spec == 0) 2140 fatal ("spec file has no spec for linking"); 2141} 2142 2143/* Record the names of temporary files we tell compilers to write, 2144 and delete them at the end of the run. */ 2145 2146/* This is the common prefix we use to make temp file names. 2147 It is chosen once for each run of this program. 2148 It is substituted into a spec by %g or %j. 2149 Thus, all temp file names contain this prefix. 2150 In practice, all temp file names start with this prefix. 2151 2152 This prefix comes from the envvar TMPDIR if it is defined; 2153 otherwise, from the P_tmpdir macro if that is defined; 2154 otherwise, in /usr/tmp or /tmp; 2155 or finally the current directory if all else fails. */ 2156 2157static const char *temp_filename; 2158 2159/* Length of the prefix. */ 2160 2161static int temp_filename_length; 2162 2163/* Define the list of temporary files to delete. */ 2164 2165struct temp_file 2166{ 2167 const char *name; 2168 struct temp_file *next; 2169}; 2170 2171/* Queue of files to delete on success or failure of compilation. */ 2172static struct temp_file *always_delete_queue; 2173/* Queue of files to delete on failure of compilation. */ 2174static struct temp_file *failure_delete_queue; 2175 2176/* Record FILENAME as a file to be deleted automatically. 2177 ALWAYS_DELETE nonzero means delete it if all compilation succeeds; 2178 otherwise delete it in any case. 2179 FAIL_DELETE nonzero means delete it if a compilation step fails; 2180 otherwise delete it in any case. */ 2181 2182void 2183record_temp_file (const char *filename, int always_delete, int fail_delete) 2184{ 2185 char *const name = xstrdup (filename); 2186 2187 if (always_delete) 2188 { 2189 struct temp_file *temp; 2190 for (temp = always_delete_queue; temp; temp = temp->next) 2191 if (! strcmp (name, temp->name)) 2192 goto already1; 2193 2194 temp = xmalloc (sizeof (struct temp_file)); 2195 temp->next = always_delete_queue; 2196 temp->name = name; 2197 always_delete_queue = temp; 2198 2199 already1:; 2200 } 2201 2202 if (fail_delete) 2203 { 2204 struct temp_file *temp; 2205 for (temp = failure_delete_queue; temp; temp = temp->next) 2206 if (! strcmp (name, temp->name)) 2207 goto already2; 2208 2209 temp = xmalloc (sizeof (struct temp_file)); 2210 temp->next = failure_delete_queue; 2211 temp->name = name; 2212 failure_delete_queue = temp; 2213 2214 already2:; 2215 } 2216} 2217 2218/* Delete all the temporary files whose names we previously recorded. */ 2219 2220static void 2221delete_if_ordinary (const char *name) 2222{ 2223 struct stat st; 2224#ifdef DEBUG 2225 int i, c; 2226 2227 printf ("Delete %s? (y or n) ", name); 2228 fflush (stdout); 2229 i = getchar (); 2230 if (i != '\n') 2231 while ((c = getchar ()) != '\n' && c != EOF) 2232 ; 2233 2234 if (i == 'y' || i == 'Y') 2235#endif /* DEBUG */ 2236 if (stat (name, &st) >= 0 && S_ISREG (st.st_mode)) 2237 if (unlink (name) < 0) 2238 if (verbose_flag) 2239 perror_with_name (name); 2240} 2241 2242static void 2243delete_temp_files (void) 2244{ 2245 struct temp_file *temp; 2246 2247 for (temp = always_delete_queue; temp; temp = temp->next) 2248 delete_if_ordinary (temp->name); 2249 always_delete_queue = 0; 2250} 2251 2252/* Delete all the files to be deleted on error. */ 2253 2254static void 2255delete_failure_queue (void) 2256{ 2257 struct temp_file *temp; 2258 2259 for (temp = failure_delete_queue; temp; temp = temp->next) 2260 delete_if_ordinary (temp->name); 2261} 2262 2263static void 2264clear_failure_queue (void) 2265{ 2266 failure_delete_queue = 0; 2267} 2268 2269/* Build a list of search directories from PATHS. 2270 PREFIX is a string to prepend to the list. 2271 If CHECK_DIR_P is nonzero we ensure the directory exists. 2272 This is used mostly by putenv_from_prefixes so we use `collect_obstack'. 2273 It is also used by the --print-search-dirs flag. */ 2274 2275static char * 2276build_search_list (struct path_prefix *paths, const char *prefix, 2277 int check_dir_p) 2278{ 2279 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0; 2280 int just_suffix_len 2281 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0; 2282 int first_time = TRUE; 2283 struct prefix_list *pprefix; 2284 2285 obstack_grow (&collect_obstack, prefix, strlen (prefix)); 2286 obstack_1grow (&collect_obstack, '='); 2287 2288 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next) 2289 { 2290 int len = strlen (pprefix->prefix); 2291 2292 if (machine_suffix 2293 && (! check_dir_p 2294 || is_directory (pprefix->prefix, machine_suffix, 0))) 2295 { 2296 if (!first_time) 2297 obstack_1grow (&collect_obstack, PATH_SEPARATOR); 2298 2299 first_time = FALSE; 2300 obstack_grow (&collect_obstack, pprefix->prefix, len); 2301 obstack_grow (&collect_obstack, machine_suffix, suffix_len); 2302 } 2303 2304 if (just_machine_suffix 2305 && pprefix->require_machine_suffix == 2 2306 && (! check_dir_p 2307 || is_directory (pprefix->prefix, just_machine_suffix, 0))) 2308 { 2309 if (! first_time) 2310 obstack_1grow (&collect_obstack, PATH_SEPARATOR); 2311 2312 first_time = FALSE; 2313 obstack_grow (&collect_obstack, pprefix->prefix, len); 2314 obstack_grow (&collect_obstack, just_machine_suffix, 2315 just_suffix_len); 2316 } 2317 2318 if (! pprefix->require_machine_suffix) 2319 { 2320 if (! first_time) 2321 obstack_1grow (&collect_obstack, PATH_SEPARATOR); 2322 2323 first_time = FALSE; 2324 obstack_grow (&collect_obstack, pprefix->prefix, len); 2325 } 2326 } 2327 2328 obstack_1grow (&collect_obstack, '\0'); 2329 return obstack_finish (&collect_obstack); 2330} 2331 2332/* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables 2333 for collect. */ 2334 2335static void 2336putenv_from_prefixes (struct path_prefix *paths, const char *env_var) 2337{ 2338 putenv (build_search_list (paths, env_var, 1)); 2339} 2340 2341/* Check whether NAME can be accessed in MODE. This is like access, 2342 except that it never considers directories to be executable. */ 2343 2344static int 2345access_check (const char *name, int mode) 2346{ 2347 if (mode == X_OK) 2348 { 2349 struct stat st; 2350 2351 if (stat (name, &st) < 0 2352 || S_ISDIR (st.st_mode)) 2353 return -1; 2354 } 2355 2356 return access (name, mode); 2357} 2358 2359/* Search for NAME using the prefix list PREFIXES. MODE is passed to 2360 access to check permissions. 2361 Return 0 if not found, otherwise return its name, allocated with malloc. */ 2362 2363static char * 2364find_a_file (struct path_prefix *pprefix, const char *name, int mode, 2365 int multilib) 2366{ 2367 char *temp; 2368 const char *const file_suffix = 2369 ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : ""); 2370 struct prefix_list *pl; 2371 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1; 2372 const char *multilib_name, *multilib_os_name; 2373 2374#ifdef DEFAULT_ASSEMBLER 2375 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0) 2376 return xstrdup (DEFAULT_ASSEMBLER); 2377#endif 2378 2379#ifdef DEFAULT_LINKER 2380 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0) 2381 return xstrdup (DEFAULT_LINKER); 2382#endif 2383 2384 if (machine_suffix) 2385 len += strlen (machine_suffix); 2386 2387 multilib_name = name; 2388 multilib_os_name = name; 2389 if (multilib && multilib_os_dir) 2390 { 2391 int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0; 2392 int len2 = strlen (multilib_os_dir) + 1; 2393 2394 len += len1 > len2 ? len1 : len2; 2395 if (multilib_dir) 2396 multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name, 2397 NULL)); 2398 if (strcmp (multilib_os_dir, ".") != 0) 2399 multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name, 2400 NULL)); 2401 } 2402 2403 temp = xmalloc (len); 2404 2405 /* Determine the filename to execute (special case for absolute paths). */ 2406 2407 if (IS_ABSOLUTE_PATH (name)) 2408 { 2409 if (access (name, mode) == 0) 2410 { 2411 strcpy (temp, name); 2412 return temp; 2413 } 2414 } 2415 else 2416 for (pl = pprefix->plist; pl; pl = pl->next) 2417 { 2418 const char *this_name 2419 = pl->os_multilib ? multilib_os_name : multilib_name; 2420 2421 if (machine_suffix) 2422 { 2423 /* Some systems have a suffix for executable files. 2424 So try appending that first. */ 2425 if (file_suffix[0] != 0) 2426 { 2427 strcpy (temp, pl->prefix); 2428 strcat (temp, machine_suffix); 2429 strcat (temp, multilib_name); 2430 strcat (temp, file_suffix); 2431 if (access_check (temp, mode) == 0) 2432 { 2433 if (pl->used_flag_ptr != 0) 2434 *pl->used_flag_ptr = 1; 2435 return temp; 2436 } 2437 } 2438 2439 /* Now try just the multilib_name. */ 2440 strcpy (temp, pl->prefix); 2441 strcat (temp, machine_suffix); 2442 strcat (temp, multilib_name); 2443 if (access_check (temp, mode) == 0) 2444 { 2445 if (pl->used_flag_ptr != 0) 2446 *pl->used_flag_ptr = 1; 2447 return temp; 2448 } 2449 } 2450 2451 /* Certain prefixes are tried with just the machine type, 2452 not the version. This is used for finding as, ld, etc. */ 2453 if (just_machine_suffix && pl->require_machine_suffix == 2) 2454 { 2455 /* Some systems have a suffix for executable files. 2456 So try appending that first. */ 2457 if (file_suffix[0] != 0) 2458 { 2459 strcpy (temp, pl->prefix); 2460 strcat (temp, just_machine_suffix); 2461 strcat (temp, multilib_name); 2462 strcat (temp, file_suffix); 2463 if (access_check (temp, mode) == 0) 2464 { 2465 if (pl->used_flag_ptr != 0) 2466 *pl->used_flag_ptr = 1; 2467 return temp; 2468 } 2469 } 2470 2471 strcpy (temp, pl->prefix); 2472 strcat (temp, just_machine_suffix); 2473 strcat (temp, multilib_name); 2474 if (access_check (temp, mode) == 0) 2475 { 2476 if (pl->used_flag_ptr != 0) 2477 *pl->used_flag_ptr = 1; 2478 return temp; 2479 } 2480 } 2481 2482 /* Certain prefixes can't be used without the machine suffix 2483 when the machine or version is explicitly specified. */ 2484 if (! pl->require_machine_suffix) 2485 { 2486 /* Some systems have a suffix for executable files. 2487 So try appending that first. */ 2488 if (file_suffix[0] != 0) 2489 { 2490 strcpy (temp, pl->prefix); 2491 strcat (temp, this_name); 2492 strcat (temp, file_suffix); 2493 if (access_check (temp, mode) == 0) 2494 { 2495 if (pl->used_flag_ptr != 0) 2496 *pl->used_flag_ptr = 1; 2497 return temp; 2498 } 2499 } 2500 2501 strcpy (temp, pl->prefix); 2502 strcat (temp, this_name); 2503 if (access_check (temp, mode) == 0) 2504 { 2505 if (pl->used_flag_ptr != 0) 2506 *pl->used_flag_ptr = 1; 2507 return temp; 2508 } 2509 } 2510 } 2511 2512 free (temp); 2513 return 0; 2514} 2515 2516/* Ranking of prefixes in the sort list. -B prefixes are put before 2517 all others. */ 2518 2519enum path_prefix_priority 2520{ 2521 PREFIX_PRIORITY_B_OPT, 2522 PREFIX_PRIORITY_LAST 2523}; 2524 2525/* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending 2526 order according to PRIORITY. Within each PRIORITY, new entries are 2527 appended. 2528 2529 If WARN is nonzero, we will warn if no file is found 2530 through this prefix. WARN should point to an int 2531 which will be set to 1 if this entry is used. 2532 2533 COMPONENT is the value to be passed to update_path. 2534 2535 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without 2536 the complete value of machine_suffix. 2537 2 means try both machine_suffix and just_machine_suffix. */ 2538 2539static void 2540add_prefix (struct path_prefix *pprefix, const char *prefix, 2541 const char *component, /* enum prefix_priority */ int priority, 2542 int require_machine_suffix, int *warn, int os_multilib) 2543{ 2544 struct prefix_list *pl, **prev; 2545 int len; 2546 2547 for (prev = &pprefix->plist; 2548 (*prev) != NULL && (*prev)->priority <= priority; 2549 prev = &(*prev)->next) 2550 ; 2551 2552 /* Keep track of the longest prefix. */ 2553 2554 prefix = update_path (prefix, component); 2555 len = strlen (prefix); 2556 if (len > pprefix->max_len) 2557 pprefix->max_len = len; 2558 2559 pl = xmalloc (sizeof (struct prefix_list)); 2560 pl->prefix = prefix; 2561 pl->require_machine_suffix = require_machine_suffix; 2562 pl->used_flag_ptr = warn; 2563 pl->priority = priority; 2564 pl->os_multilib = os_multilib; 2565 if (warn) 2566 *warn = 0; 2567 2568 /* Insert after PREV. */ 2569 pl->next = (*prev); 2570 (*prev) = pl; 2571} 2572 2573/* Same as add_prefix, but prepending target_system_root to prefix. */ 2574static void 2575add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix, 2576 const char *component, 2577 /* enum prefix_priority */ int priority, 2578 int require_machine_suffix, int *warn, int os_multilib) 2579{ 2580 if (!IS_ABSOLUTE_PATH (prefix)) 2581 abort (); 2582 2583 if (target_system_root) 2584 { 2585 if (target_sysroot_suffix) 2586 prefix = concat (target_sysroot_suffix, prefix, NULL); 2587 prefix = concat (target_system_root, prefix, NULL); 2588 2589 /* We have to override this because GCC's notion of sysroot 2590 moves along with GCC. */ 2591 component = "GCC"; 2592 } 2593 2594 add_prefix (pprefix, prefix, component, priority, 2595 require_machine_suffix, warn, os_multilib); 2596} 2597 2598/* Execute the command specified by the arguments on the current line of spec. 2599 When using pipes, this includes several piped-together commands 2600 with `|' between them. 2601 2602 Return 0 if successful, -1 if failed. */ 2603 2604static int 2605execute (void) 2606{ 2607 int i; 2608 int n_commands; /* # of command. */ 2609 char *string; 2610 struct command 2611 { 2612 const char *prog; /* program name. */ 2613 const char **argv; /* vector of args. */ 2614 int pid; /* pid of process for this command. */ 2615 }; 2616 2617 struct command *commands; /* each command buffer with above info. */ 2618 2619 if (processing_spec_function) 2620 abort (); 2621 2622 /* Count # of piped commands. */ 2623 for (n_commands = 1, i = 0; i < argbuf_index; i++) 2624 if (strcmp (argbuf[i], "|") == 0) 2625 n_commands++; 2626 2627 /* Get storage for each command. */ 2628 commands = alloca (n_commands * sizeof (struct command)); 2629 2630 /* Split argbuf into its separate piped processes, 2631 and record info about each one. 2632 Also search for the programs that are to be run. */ 2633 2634 commands[0].prog = argbuf[0]; /* first command. */ 2635 commands[0].argv = &argbuf[0]; 2636 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0); 2637 2638 if (string) 2639 commands[0].argv[0] = string; 2640 2641 for (n_commands = 1, i = 0; i < argbuf_index; i++) 2642 if (strcmp (argbuf[i], "|") == 0) 2643 { /* each command. */ 2644#if defined (__MSDOS__) || defined (OS2) || defined (VMS) 2645 fatal ("-pipe not supported"); 2646#endif 2647 argbuf[i] = 0; /* termination of command args. */ 2648 commands[n_commands].prog = argbuf[i + 1]; 2649 commands[n_commands].argv = &argbuf[i + 1]; 2650 string = find_a_file (&exec_prefixes, commands[n_commands].prog, 2651 X_OK, 0); 2652 if (string) 2653 commands[n_commands].argv[0] = string; 2654 n_commands++; 2655 } 2656 2657 argbuf[argbuf_index] = 0; 2658 2659 /* If -v, print what we are about to do, and maybe query. */ 2660 2661 if (verbose_flag) 2662 { 2663 /* For help listings, put a blank line between sub-processes. */ 2664 if (print_help_list) 2665 fputc ('\n', stderr); 2666 2667 /* Print each piped command as a separate line. */ 2668 for (i = 0; i < n_commands; i++) 2669 { 2670 const char *const *j; 2671 2672 if (verbose_only_flag) 2673 { 2674 for (j = commands[i].argv; *j; j++) 2675 { 2676 const char *p; 2677 fprintf (stderr, " \""); 2678 for (p = *j; *p; ++p) 2679 { 2680 if (*p == '"' || *p == '\\' || *p == '$') 2681 fputc ('\\', stderr); 2682 fputc (*p, stderr); 2683 } 2684 fputc ('"', stderr); 2685 } 2686 } 2687 else 2688 for (j = commands[i].argv; *j; j++) 2689 fprintf (stderr, " %s", *j); 2690 2691 /* Print a pipe symbol after all but the last command. */ 2692 if (i + 1 != n_commands) 2693 fprintf (stderr, " |"); 2694 fprintf (stderr, "\n"); 2695 } 2696 fflush (stderr); 2697 if (verbose_only_flag != 0) 2698 { 2699 /* verbose_only_flag should act as if the spec was 2700 executed, so increment execution_count before 2701 returning. This prevents spurious warnings about 2702 unused linker input files, etc. */ 2703 execution_count++; 2704 return 0; 2705 } 2706#ifdef DEBUG 2707 notice ("\nGo ahead? (y or n) "); 2708 fflush (stderr); 2709 i = getchar (); 2710 if (i != '\n') 2711 while (getchar () != '\n') 2712 ; 2713 2714 if (i != 'y' && i != 'Y') 2715 return 0; 2716#endif /* DEBUG */ 2717 } 2718 2719#ifdef ENABLE_VALGRIND_CHECKING 2720 /* Run the each command through valgrind. To simplify prepending the 2721 path to valgrind and the option "-q" (for quiet operation unless 2722 something triggers), we allocate a separate argv array. */ 2723 2724 for (i = 0; i < n_commands; i++) 2725 { 2726 const char **argv; 2727 int argc; 2728 int j; 2729 2730 for (argc = 0; commands[i].argv[argc] != NULL; argc++) 2731 ; 2732 2733 argv = alloca ((argc + 3) * sizeof (char *)); 2734 2735 argv[0] = VALGRIND_PATH; 2736 argv[1] = "-q"; 2737 for (j = 2; j < argc + 2; j++) 2738 argv[j] = commands[i].argv[j - 2]; 2739 argv[j] = NULL; 2740 2741 commands[i].argv = argv; 2742 commands[i].prog = argv[0]; 2743 } 2744#endif 2745 2746 /* Run each piped subprocess. */ 2747 2748 for (i = 0; i < n_commands; i++) 2749 { 2750 char *errmsg_fmt, *errmsg_arg; 2751 const char *string = commands[i].argv[0]; 2752 2753 /* For some bizarre reason, the second argument of execvp() is 2754 char *const *, not const char *const *. */ 2755 commands[i].pid = pexecute (string, (char *const *) commands[i].argv, 2756 programname, temp_filename, 2757 &errmsg_fmt, &errmsg_arg, 2758 ((i == 0 ? PEXECUTE_FIRST : 0) 2759 | (i + 1 == n_commands ? PEXECUTE_LAST : 0) 2760 | (string == commands[i].prog 2761 ? PEXECUTE_SEARCH : 0) 2762 | (verbose_flag ? PEXECUTE_VERBOSE : 0))); 2763 2764 if (commands[i].pid == -1) 2765 pfatal_pexecute (errmsg_fmt, errmsg_arg); 2766 2767 if (string != commands[i].prog) 2768 free ((void *) string); 2769 } 2770 2771 execution_count++; 2772 2773 /* Wait for all the subprocesses to finish. 2774 We don't care what order they finish in; 2775 we know that N_COMMANDS waits will get them all. 2776 Ignore subprocesses that we don't know about, 2777 since they can be spawned by the process that exec'ed us. */ 2778 2779 { 2780 int ret_code = 0; 2781#ifdef HAVE_GETRUSAGE 2782 struct timeval d; 2783 double ut = 0.0, st = 0.0; 2784#endif 2785 2786 for (i = 0; i < n_commands;) 2787 { 2788 int j; 2789 int status; 2790 int pid; 2791 2792 pid = pwait (commands[i].pid, &status, 0); 2793 if (pid < 0) 2794 abort (); 2795 2796#ifdef HAVE_GETRUSAGE 2797 if (report_times) 2798 { 2799 /* getrusage returns the total resource usage of all children 2800 up to now. Copy the previous values into prus, get the 2801 current statistics, then take the difference. */ 2802 2803 prus = rus; 2804 getrusage (RUSAGE_CHILDREN, &rus); 2805 d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec; 2806 d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec; 2807 ut = (double) d.tv_sec + (double) d.tv_usec / 1.0e6; 2808 2809 d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec; 2810 d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec; 2811 st = (double) d.tv_sec + (double) d.tv_usec / 1.0e6; 2812 } 2813#endif 2814 2815 for (j = 0; j < n_commands; j++) 2816 if (commands[j].pid == pid) 2817 { 2818 i++; 2819 if (WIFSIGNALED (status)) 2820 { 2821#ifdef SIGPIPE 2822 /* SIGPIPE is a special case. It happens in -pipe mode 2823 when the compiler dies before the preprocessor is 2824 done, or the assembler dies before the compiler is 2825 done. There's generally been an error already, and 2826 this is just fallout. So don't generate another error 2827 unless we would otherwise have succeeded. */ 2828 if (WTERMSIG (status) == SIGPIPE 2829 && (signal_count || greatest_status >= MIN_FATAL_STATUS)) 2830 ; 2831 else 2832#endif 2833 fatal ("\ 2834Internal error: %s (program %s)\n\ 2835Please submit a full bug report.\n\ 2836See %s for instructions.", 2837 strsignal (WTERMSIG (status)), commands[j].prog, 2838 bug_report_url); 2839 signal_count++; 2840 ret_code = -1; 2841 } 2842 else if (WIFEXITED (status) 2843 && WEXITSTATUS (status) >= MIN_FATAL_STATUS) 2844 { 2845 if (WEXITSTATUS (status) > greatest_status) 2846 greatest_status = WEXITSTATUS (status); 2847 ret_code = -1; 2848 } 2849#ifdef HAVE_GETRUSAGE 2850 if (report_times && ut + st != 0) 2851 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st); 2852#endif 2853 break; 2854 } 2855 } 2856 return ret_code; 2857 } 2858} 2859 2860/* Find all the switches given to us 2861 and make a vector describing them. 2862 The elements of the vector are strings, one per switch given. 2863 If a switch uses following arguments, then the `part1' field 2864 is the switch itself and the `args' field 2865 is a null-terminated vector containing the following arguments. 2866 The `live_cond' field is: 2867 0 when initialized 2868 1 if the switch is true in a conditional spec, 2869 -1 if false (overridden by a later switch) 2870 -2 if this switch should be ignored (used in %<S) 2871 The `validated' field is nonzero if any spec has looked at this switch; 2872 if it remains zero at the end of the run, it must be meaningless. */ 2873 2874#define SWITCH_OK 0 2875#define SWITCH_FALSE -1 2876#define SWITCH_IGNORE -2 2877#define SWITCH_LIVE 1 2878 2879struct switchstr 2880{ 2881 const char *part1; 2882 const char **args; 2883 int live_cond; 2884 unsigned char validated; 2885 unsigned char ordering; 2886}; 2887 2888static struct switchstr *switches; 2889 2890static int n_switches; 2891 2892struct infile 2893{ 2894 const char *name; 2895 const char *language; 2896}; 2897 2898/* Also a vector of input files specified. */ 2899 2900static struct infile *infiles; 2901 2902int n_infiles; 2903 2904/* True if multiple input files are being compiled to a single 2905 assembly file. */ 2906 2907static bool combine_inputs; 2908 2909/* This counts the number of libraries added by lang_specific_driver, so that 2910 we can tell if there were any user supplied any files or libraries. */ 2911 2912static int added_libraries; 2913 2914/* And a vector of corresponding output files is made up later. */ 2915 2916const char **outfiles; 2917 2918/* Used to track if none of the -B paths are used. */ 2919static int warn_B; 2920 2921/* Gives value to pass as "warn" to add_prefix for standard prefixes. */ 2922static int *warn_std_ptr = 0; 2923 2924#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 2925 2926/* Convert NAME to a new name if it is the standard suffix. DO_EXE 2927 is true if we should look for an executable suffix. DO_OBJ 2928 is true if we should look for an object suffix. */ 2929 2930static const char * 2931convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED, 2932 int do_obj ATTRIBUTE_UNUSED) 2933{ 2934#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 2935 int i; 2936#endif 2937 int len; 2938 2939 if (name == NULL) 2940 return NULL; 2941 2942 len = strlen (name); 2943 2944#ifdef HAVE_TARGET_OBJECT_SUFFIX 2945 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */ 2946 if (do_obj && len > 2 2947 && name[len - 2] == '.' 2948 && name[len - 1] == 'o') 2949 { 2950 obstack_grow (&obstack, name, len - 2); 2951 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX)); 2952 name = obstack_finish (&obstack); 2953 } 2954#endif 2955 2956#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 2957 /* If there is no filetype, make it the executable suffix (which includes 2958 the "."). But don't get confused if we have just "-o". */ 2959 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-')) 2960 return name; 2961 2962 for (i = len - 1; i >= 0; i--) 2963 if (IS_DIR_SEPARATOR (name[i])) 2964 break; 2965 2966 for (i++; i < len; i++) 2967 if (name[i] == '.') 2968 return name; 2969 2970 obstack_grow (&obstack, name, len); 2971 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX, 2972 strlen (TARGET_EXECUTABLE_SUFFIX)); 2973 name = obstack_finish (&obstack); 2974#endif 2975 2976 return name; 2977} 2978#endif 2979 2980/* Display the command line switches accepted by gcc. */ 2981static void 2982display_help (void) 2983{ 2984 printf (_("Usage: %s [options] file...\n"), programname); 2985 fputs (_("Options:\n"), stdout); 2986 2987 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout); 2988 fputs (_(" --help Display this information\n"), stdout); 2989 fputs (_(" --target-help Display target specific command line options\n"), stdout); 2990 if (! verbose_flag) 2991 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout); 2992 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout); 2993 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout); 2994 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout); 2995 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout); 2996 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout); 2997 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout); 2998 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout); 2999 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout); 3000 fputs (_("\ 3001 -print-multi-lib Display the mapping between command line options and\n\ 3002 multiple library search directories\n"), stdout); 3003 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout); 3004 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout); 3005 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout); 3006 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout); 3007 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout); 3008 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout); 3009 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout); 3010 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout); 3011 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout); 3012 fputs (_(" -time Time the execution of each subprocess\n"), stdout); 3013 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout); 3014 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout); 3015 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout); 3016 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout); 3017 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout); 3018 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout); 3019 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout); 3020 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout); 3021 fputs (_(" -S Compile only; do not assemble or link\n"), stdout); 3022 fputs (_(" -c Compile and assemble, but do not link\n"), stdout); 3023 fputs (_(" -o <file> Place the output into <file>\n"), stdout); 3024 fputs (_("\ 3025 -x <language> Specify the language of the following input files\n\ 3026 Permissible languages include: c c++ assembler none\n\ 3027 'none' means revert to the default behavior of\n\ 3028 guessing the language based on the file's extension\n\ 3029"), stdout); 3030 3031 printf (_("\ 3032\nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\ 3033 passed on to the various sub-processes invoked by %s. In order to pass\n\ 3034 other options on to these processes the -W<letter> options must be used.\n\ 3035"), programname); 3036 3037 /* The rest of the options are displayed by invocations of the various 3038 sub-processes. */ 3039} 3040 3041static void 3042add_preprocessor_option (const char *option, int len) 3043{ 3044 n_preprocessor_options++; 3045 3046 if (! preprocessor_options) 3047 preprocessor_options = xmalloc (n_preprocessor_options * sizeof (char *)); 3048 else 3049 preprocessor_options = xrealloc (preprocessor_options, 3050 n_preprocessor_options * sizeof (char *)); 3051 3052 preprocessor_options [n_preprocessor_options - 1] = 3053 save_string (option, len); 3054} 3055 3056static void 3057add_assembler_option (const char *option, int len) 3058{ 3059 n_assembler_options++; 3060 3061 if (! assembler_options) 3062 assembler_options = xmalloc (n_assembler_options * sizeof (char *)); 3063 else 3064 assembler_options = xrealloc (assembler_options, 3065 n_assembler_options * sizeof (char *)); 3066 3067 assembler_options [n_assembler_options - 1] = save_string (option, len); 3068} 3069 3070static void 3071add_linker_option (const char *option, int len) 3072{ 3073 n_linker_options++; 3074 3075 if (! linker_options) 3076 linker_options = xmalloc (n_linker_options * sizeof (char *)); 3077 else 3078 linker_options = xrealloc (linker_options, 3079 n_linker_options * sizeof (char *)); 3080 3081 linker_options [n_linker_options - 1] = save_string (option, len); 3082} 3083 3084/* Create the vector `switches' and its contents. 3085 Store its length in `n_switches'. */ 3086 3087static void 3088process_command (int argc, const char **argv) 3089{ 3090 int i; 3091 const char *temp; 3092 char *temp1; 3093 const char *spec_lang = 0; 3094 int last_language_n_infiles; 3095 int have_c = 0; 3096 int have_o = 0; 3097 int lang_n_infiles = 0; 3098#ifdef MODIFY_TARGET_NAME 3099 int is_modify_target_name; 3100 int j; 3101#endif 3102 3103 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX"); 3104 3105 n_switches = 0; 3106 n_infiles = 0; 3107 added_libraries = 0; 3108 3109 /* Figure compiler version from version string. */ 3110 3111 compiler_version = temp1 = xstrdup (version_string); 3112 3113 for (; *temp1; ++temp1) 3114 { 3115 if (*temp1 == ' ') 3116 { 3117 *temp1 = '\0'; 3118 break; 3119 } 3120 } 3121 3122 /* If there is a -V or -b option (or both), process it now, before 3123 trying to interpret the rest of the command line. */ 3124 if (argc > 1 && argv[1][0] == '-' 3125 && (argv[1][1] == 'V' || argv[1][1] == 'b')) 3126 { 3127 const char *new_version = DEFAULT_TARGET_VERSION; 3128 const char *new_machine = DEFAULT_TARGET_MACHINE; 3129 const char *progname = argv[0]; 3130 char **new_argv; 3131 char *new_argv0; 3132 int baselen; 3133 3134 while (argc > 1 && argv[1][0] == '-' 3135 && (argv[1][1] == 'V' || argv[1][1] == 'b')) 3136 { 3137 char opt = argv[1][1]; 3138 const char *arg; 3139 if (argv[1][2] != '\0') 3140 { 3141 arg = argv[1] + 2; 3142 argc -= 1; 3143 argv += 1; 3144 } 3145 else if (argc > 2) 3146 { 3147 arg = argv[2]; 3148 argc -= 2; 3149 argv += 2; 3150 } 3151 else 3152 fatal ("`-%c' option must have argument", opt); 3153 if (opt == 'V') 3154 new_version = arg; 3155 else 3156 new_machine = arg; 3157 } 3158 3159 for (baselen = strlen (progname); baselen > 0; baselen--) 3160 if (IS_DIR_SEPARATOR (progname[baselen-1])) 3161 break; 3162 new_argv0 = xmemdup (progname, baselen, 3163 baselen + concat_length (new_version, new_machine, 3164 "-gcc-", NULL) + 1); 3165 strcpy (new_argv0 + baselen, new_machine); 3166 strcat (new_argv0, "-gcc-"); 3167 strcat (new_argv0, new_version); 3168 3169 new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]), 3170 (argc + 1) * sizeof (argv[0])); 3171 new_argv[0] = new_argv0; 3172 3173 execvp (new_argv0, new_argv); 3174 fatal ("couldn't run `%s': %s", new_argv0, xstrerror (errno)); 3175 } 3176 3177 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX, 3178 see if we can create it from the pathname specified in argv[0]. */ 3179 3180 gcc_libexec_prefix = standard_libexec_prefix; 3181#ifndef FREEBSD_NATIVE 3182#ifndef VMS 3183 /* FIXME: make_relative_prefix doesn't yet work for VMS. */ 3184 if (!gcc_exec_prefix) 3185 { 3186 gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix, 3187 standard_exec_prefix); 3188 gcc_libexec_prefix = make_relative_prefix (argv[0], 3189 standard_bindir_prefix, 3190 standard_libexec_prefix); 3191 if (gcc_exec_prefix) 3192 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL)); 3193 } 3194 else 3195 gcc_libexec_prefix = make_relative_prefix (gcc_exec_prefix, 3196 standard_exec_prefix, 3197 standard_libexec_prefix); 3198#else 3199#endif 3200#endif /* not FREEBSD_NATIVE */ 3201 3202 if (gcc_exec_prefix) 3203 { 3204 int len = strlen (gcc_exec_prefix); 3205 3206 if (len > (int) sizeof ("/lib/gcc/") - 1 3207 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1]))) 3208 { 3209 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1; 3210 if (IS_DIR_SEPARATOR (*temp) 3211 && strncmp (temp + 1, "lib", 3) == 0 3212 && IS_DIR_SEPARATOR (temp[4]) 3213 && strncmp (temp + 5, "gcc", 3) == 0) 3214 len -= sizeof ("/lib/gcc/") - 1; 3215 } 3216 3217 set_std_prefix (gcc_exec_prefix, len); 3218 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC", 3219 PREFIX_PRIORITY_LAST, 0, NULL, 0); 3220 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC", 3221 PREFIX_PRIORITY_LAST, 0, NULL, 0); 3222 } 3223 3224 /* COMPILER_PATH and LIBRARY_PATH have values 3225 that are lists of directory names with colons. */ 3226 3227 GET_ENVIRONMENT (temp, "COMPILER_PATH"); 3228 if (temp) 3229 { 3230 const char *startp, *endp; 3231 char *nstore = alloca (strlen (temp) + 3); 3232 3233 startp = endp = temp; 3234 while (1) 3235 { 3236 if (*endp == PATH_SEPARATOR || *endp == 0) 3237 { 3238 strncpy (nstore, startp, endp - startp); 3239 if (endp == startp) 3240 strcpy (nstore, concat (".", dir_separator_str, NULL)); 3241 else if (!IS_DIR_SEPARATOR (endp[-1])) 3242 { 3243 nstore[endp - startp] = DIR_SEPARATOR; 3244 nstore[endp - startp + 1] = 0; 3245 } 3246 else 3247 nstore[endp - startp] = 0; 3248 add_prefix (&exec_prefixes, nstore, 0, 3249 PREFIX_PRIORITY_LAST, 0, NULL, 0); 3250 add_prefix (&include_prefixes, 3251 concat (nstore, "include", NULL), 3252 0, PREFIX_PRIORITY_LAST, 0, NULL, 0); 3253 if (*endp == 0) 3254 break; 3255 endp = startp = endp + 1; 3256 } 3257 else 3258 endp++; 3259 } 3260 } 3261 3262 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV); 3263 if (temp && *cross_compile == '0') 3264 { 3265 const char *startp, *endp; 3266 char *nstore = alloca (strlen (temp) + 3); 3267 3268 startp = endp = temp; 3269 while (1) 3270 { 3271 if (*endp == PATH_SEPARATOR || *endp == 0) 3272 { 3273 strncpy (nstore, startp, endp - startp); 3274 if (endp == startp) 3275 strcpy (nstore, concat (".", dir_separator_str, NULL)); 3276 else if (!IS_DIR_SEPARATOR (endp[-1])) 3277 { 3278 nstore[endp - startp] = DIR_SEPARATOR; 3279 nstore[endp - startp + 1] = 0; 3280 } 3281 else 3282 nstore[endp - startp] = 0; 3283 add_prefix (&startfile_prefixes, nstore, NULL, 3284 PREFIX_PRIORITY_LAST, 0, NULL, 1); 3285 if (*endp == 0) 3286 break; 3287 endp = startp = endp + 1; 3288 } 3289 else 3290 endp++; 3291 } 3292 } 3293 3294 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */ 3295 GET_ENVIRONMENT (temp, "LPATH"); 3296 if (temp && *cross_compile == '0') 3297 { 3298 const char *startp, *endp; 3299 char *nstore = alloca (strlen (temp) + 3); 3300 3301 startp = endp = temp; 3302 while (1) 3303 { 3304 if (*endp == PATH_SEPARATOR || *endp == 0) 3305 { 3306 strncpy (nstore, startp, endp - startp); 3307 if (endp == startp) 3308 strcpy (nstore, concat (".", dir_separator_str, NULL)); 3309 else if (!IS_DIR_SEPARATOR (endp[-1])) 3310 { 3311 nstore[endp - startp] = DIR_SEPARATOR; 3312 nstore[endp - startp + 1] = 0; 3313 } 3314 else 3315 nstore[endp - startp] = 0; 3316 add_prefix (&startfile_prefixes, nstore, NULL, 3317 PREFIX_PRIORITY_LAST, 0, NULL, 1); 3318 if (*endp == 0) 3319 break; 3320 endp = startp = endp + 1; 3321 } 3322 else 3323 endp++; 3324 } 3325 } 3326 3327 /* Options specified as if they appeared on the command line. */ 3328 temp = getenv ("GCC_OPTIONS"); 3329 if ((temp) && (strlen (temp) > 0)) 3330 { 3331 int len; 3332 int optc = 1; 3333 int new_argc; 3334 const char **new_argv; 3335 char *envopts; 3336 3337 while (isspace (*temp)) 3338 temp++; 3339 len = strlen (temp); 3340 envopts = (char *) xmalloc (len + 1); 3341 strcpy (envopts, temp); 3342 3343 for (i = 0; i < (len - 1); i++) 3344 if ((isspace (envopts[i])) && ! (isspace (envopts[i+1]))) 3345 optc++; 3346 3347 new_argv = (const char **) alloca ((optc + argc) * sizeof(char *)); 3348 3349 for (i = 0, new_argc = 1; new_argc <= optc; new_argc++) 3350 { 3351 while (isspace (envopts[i])) 3352 i++; 3353 new_argv[new_argc] = envopts + i; 3354 while (!isspace (envopts[i]) && (envopts[i] != '\0')) 3355 i++; 3356 envopts[i++] = '\0'; 3357 } 3358 for (i = 1; i < argc; i++) 3359 new_argv[new_argc++] = argv[i]; 3360 3361 argv = new_argv; 3362 argc = new_argc; 3363 } 3364 3365 /* Convert new-style -- options to old-style. */ 3366 translate_options (&argc, (const char *const **) &argv); 3367 3368 /* Do language-specific adjustment/addition of flags. */ 3369 lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries); 3370 3371 /* Scan argv twice. Here, the first time, just count how many switches 3372 there will be in their vector, and how many input files in theirs. 3373 Here we also parse the switches that cc itself uses (e.g. -v). */ 3374 3375 for (i = 1; i < argc; i++) 3376 { 3377 if (! strcmp (argv[i], "-dumpspecs")) 3378 { 3379 struct spec_list *sl; 3380 init_spec (); 3381 for (sl = specs; sl; sl = sl->next) 3382 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec)); 3383 if (link_command_spec) 3384 printf ("*link_command:\n%s\n\n", link_command_spec); 3385 exit (0); 3386 } 3387 else if (! strcmp (argv[i], "-dumpversion")) 3388 { 3389 printf ("%s\n", spec_version); 3390 exit (0); 3391 } 3392 else if (! strcmp (argv[i], "-dumpmachine")) 3393 { 3394 printf ("%s\n", spec_machine); 3395 exit (0); 3396 } 3397 else if (strcmp (argv[i], "-fversion") == 0) 3398 { 3399 /* translate_options () has turned --version into -fversion. */ 3400 printf (_("%s (GCC) %s\n"), programname, version_string); 3401 printf ("Copyright %s 2004 Free Software Foundation, Inc.\n", 3402 _("(C)")); 3403 fputs (_("This is free software; see the source for copying conditions. There is NO\n\ 3404warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"), 3405 stdout); 3406 exit (0); 3407 } 3408 else if (strcmp (argv[i], "-fhelp") == 0) 3409 { 3410 /* translate_options () has turned --help into -fhelp. */ 3411 print_help_list = 1; 3412 3413 /* We will be passing a dummy file on to the sub-processes. */ 3414 n_infiles++; 3415 n_switches++; 3416 3417 /* CPP driver cannot obtain switch from cc1_options. */ 3418 if (is_cpp_driver) 3419 add_preprocessor_option ("--help", 6); 3420 add_assembler_option ("--help", 6); 3421 add_linker_option ("--help", 6); 3422 } 3423 else if (strcmp (argv[i], "-ftarget-help") == 0) 3424 { 3425 /* translate_options() has turned --target-help into -ftarget-help. */ 3426 target_help_flag = 1; 3427 3428 /* We will be passing a dummy file on to the sub-processes. */ 3429 n_infiles++; 3430 n_switches++; 3431 3432 /* CPP driver cannot obtain switch from cc1_options. */ 3433 if (is_cpp_driver) 3434 add_preprocessor_option ("--target-help", 13); 3435 add_assembler_option ("--target-help", 13); 3436 add_linker_option ("--target-help", 13); 3437 } 3438 else if (! strcmp (argv[i], "-pass-exit-codes")) 3439 { 3440 pass_exit_codes = 1; 3441 n_switches++; 3442 } 3443 else if (! strcmp (argv[i], "-print-search-dirs")) 3444 print_search_dirs = 1; 3445 else if (! strcmp (argv[i], "-print-libgcc-file-name")) 3446 print_file_name = "libgcc.a"; 3447 else if (! strncmp (argv[i], "-print-file-name=", 17)) 3448 print_file_name = argv[i] + 17; 3449 else if (! strncmp (argv[i], "-print-prog-name=", 17)) 3450 print_prog_name = argv[i] + 17; 3451 else if (! strcmp (argv[i], "-print-multi-lib")) 3452 print_multi_lib = 1; 3453 else if (! strcmp (argv[i], "-print-multi-directory")) 3454 print_multi_directory = 1; 3455 else if (! strcmp (argv[i], "-print-multi-os-directory")) 3456 print_multi_os_directory = 1; 3457 else if (! strncmp (argv[i], "-Wa,", 4)) 3458 { 3459 int prev, j; 3460 /* Pass the rest of this option to the assembler. */ 3461 3462 /* Split the argument at commas. */ 3463 prev = 4; 3464 for (j = 4; argv[i][j]; j++) 3465 if (argv[i][j] == ',') 3466 { 3467 add_assembler_option (argv[i] + prev, j - prev); 3468 prev = j + 1; 3469 } 3470 3471 /* Record the part after the last comma. */ 3472 add_assembler_option (argv[i] + prev, j - prev); 3473 } 3474 else if (! strncmp (argv[i], "-Wp,", 4)) 3475 { 3476 int prev, j; 3477 /* Pass the rest of this option to the preprocessor. */ 3478 3479 /* Split the argument at commas. */ 3480 prev = 4; 3481 for (j = 4; argv[i][j]; j++) 3482 if (argv[i][j] == ',') 3483 { 3484 add_preprocessor_option (argv[i] + prev, j - prev); 3485 prev = j + 1; 3486 } 3487 3488 /* Record the part after the last comma. */ 3489 add_preprocessor_option (argv[i] + prev, j - prev); 3490 } 3491 else if (argv[i][0] == '+' && argv[i][1] == 'e') 3492 /* The +e options to the C++ front-end. */ 3493 n_switches++; 3494 else if (strncmp (argv[i], "-Wl,", 4) == 0) 3495 { 3496 int j; 3497 /* Split the argument at commas. */ 3498 for (j = 3; argv[i][j]; j++) 3499 n_infiles += (argv[i][j] == ','); 3500 } 3501 else if (strcmp (argv[i], "-Xlinker") == 0) 3502 { 3503 if (i + 1 == argc) 3504 fatal ("argument to `-Xlinker' is missing"); 3505 3506 n_infiles++; 3507 i++; 3508 } 3509 else if (strcmp (argv[i], "-Xpreprocessor") == 0) 3510 { 3511 if (i + 1 == argc) 3512 fatal ("argument to `-Xpreprocessor' is missing"); 3513 3514 add_preprocessor_option (argv[i+1], strlen (argv[i+1])); 3515 } 3516 else if (strcmp (argv[i], "-Xassembler") == 0) 3517 { 3518 if (i + 1 == argc) 3519 fatal ("argument to `-Xassembler' is missing"); 3520 3521 add_assembler_option (argv[i+1], strlen (argv[i+1])); 3522 } 3523 else if (strcmp (argv[i], "-l") == 0) 3524 { 3525 if (i + 1 == argc) 3526 fatal ("argument to `-l' is missing"); 3527 3528 n_infiles++; 3529 i++; 3530 } 3531 else if (strncmp (argv[i], "-l", 2) == 0) 3532 n_infiles++; 3533 else if (strcmp (argv[i], "-save-temps") == 0) 3534 { 3535 save_temps_flag = 1; 3536 n_switches++; 3537 } 3538 else if (strcmp (argv[i], "-specs") == 0) 3539 { 3540 struct user_specs *user = xmalloc (sizeof (struct user_specs)); 3541 if (++i >= argc) 3542 fatal ("argument to `-specs' is missing"); 3543 3544 user->next = (struct user_specs *) 0; 3545 user->filename = argv[i]; 3546 if (user_specs_tail) 3547 user_specs_tail->next = user; 3548 else 3549 user_specs_head = user; 3550 user_specs_tail = user; 3551 } 3552 else if (strncmp (argv[i], "-specs=", 7) == 0) 3553 { 3554 struct user_specs *user = xmalloc (sizeof (struct user_specs)); 3555 if (strlen (argv[i]) == 7) 3556 fatal ("argument to `-specs=' is missing"); 3557 3558 user->next = (struct user_specs *) 0; 3559 user->filename = argv[i] + 7; 3560 if (user_specs_tail) 3561 user_specs_tail->next = user; 3562 else 3563 user_specs_head = user; 3564 user_specs_tail = user; 3565 } 3566 else if (strcmp (argv[i], "-time") == 0) 3567 report_times = 1; 3568 else if (strcmp (argv[i], "-pipe") == 0) 3569 { 3570 /* -pipe has to go into the switches array as well as 3571 setting a flag. */ 3572 use_pipes = 1; 3573 n_switches++; 3574 } 3575 else if (strcmp (argv[i], "-###") == 0) 3576 { 3577 /* This is similar to -v except that there is no execution 3578 of the commands and the echoed arguments are quoted. It 3579 is intended for use in shell scripts to capture the 3580 driver-generated command line. */ 3581 verbose_only_flag++; 3582 verbose_flag++; 3583 } 3584 else if (argv[i][0] == '-' && argv[i][1] != 0) 3585 { 3586 const char *p = &argv[i][1]; 3587 int c = *p; 3588 3589 switch (c) 3590 { 3591 case 'b': 3592 case 'V': 3593 fatal ("`-%c' must come at the start of the command line", c); 3594 break; 3595 3596 case 'B': 3597 { 3598 const char *value; 3599 int len; 3600 3601 if (p[1] == 0 && i + 1 == argc) 3602 fatal ("argument to `-B' is missing"); 3603 if (p[1] == 0) 3604 value = argv[++i]; 3605 else 3606 value = p + 1; 3607 3608 len = strlen (value); 3609 3610 /* Catch the case where the user has forgotten to append a 3611 directory separator to the path. Note, they may be using 3612 -B to add an executable name prefix, eg "i386-elf-", in 3613 order to distinguish between multiple installations of 3614 GCC in the same directory. Hence we must check to see 3615 if appending a directory separator actually makes a 3616 valid directory name. */ 3617 if (! IS_DIR_SEPARATOR (value [len - 1]) 3618 && is_directory (value, "", 0)) 3619 { 3620 char *tmp = xmalloc (len + 2); 3621 strcpy (tmp, value); 3622 tmp[len] = DIR_SEPARATOR; 3623 tmp[++ len] = 0; 3624 value = tmp; 3625 } 3626 3627 /* As a kludge, if the arg is "[foo/]stageN/", just 3628 add "[foo/]include" to the include prefix. */ 3629 if ((len == 7 3630 || (len > 7 3631 && (IS_DIR_SEPARATOR (value[len - 8])))) 3632 && strncmp (value + len - 7, "stage", 5) == 0 3633 && ISDIGIT (value[len - 2]) 3634 && (IS_DIR_SEPARATOR (value[len - 1]))) 3635 { 3636 if (len == 7) 3637 add_prefix (&include_prefixes, "include", NULL, 3638 PREFIX_PRIORITY_B_OPT, 0, NULL, 0); 3639 else 3640 { 3641 char * string = xmalloc (len + 1); 3642 3643 strncpy (string, value, len - 7); 3644 strcpy (string + len - 7, "include"); 3645 add_prefix (&include_prefixes, string, NULL, 3646 PREFIX_PRIORITY_B_OPT, 0, NULL, 0); 3647 } 3648 } 3649 3650 add_prefix (&exec_prefixes, value, NULL, 3651 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0); 3652 add_prefix (&startfile_prefixes, value, NULL, 3653 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0); 3654 add_prefix (&include_prefixes, concat (value, "include", NULL), 3655 NULL, PREFIX_PRIORITY_B_OPT, 0, NULL, 0); 3656 n_switches++; 3657 } 3658 break; 3659 3660 case 'v': /* Print our subcommands and print versions. */ 3661 n_switches++; 3662 /* If they do anything other than exactly `-v', don't set 3663 verbose_flag; rather, continue on to give the error. */ 3664 if (p[1] != 0) 3665 break; 3666 verbose_flag++; 3667 break; 3668 3669 case 'S': 3670 case 'c': 3671 if (p[1] == 0) 3672 { 3673 have_c = 1; 3674 n_switches++; 3675 break; 3676 } 3677 goto normal_switch; 3678 3679 case 'o': 3680 have_o = 1; 3681#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 3682 if (! have_c) 3683 { 3684 int skip; 3685 3686 /* Forward scan, just in case -S or -c is specified 3687 after -o. */ 3688 int j = i + 1; 3689 if (p[1] == 0) 3690 ++j; 3691 while (j < argc) 3692 { 3693 if (argv[j][0] == '-') 3694 { 3695 if (SWITCH_CURTAILS_COMPILATION (argv[j][1]) 3696 && argv[j][2] == 0) 3697 { 3698 have_c = 1; 3699 break; 3700 } 3701 else if ((skip = SWITCH_TAKES_ARG (argv[j][1]))) 3702 j += skip - (argv[j][2] != 0); 3703 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1))) 3704 j += skip; 3705 } 3706 j++; 3707 } 3708 } 3709#endif 3710#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX) 3711 if (p[1] == 0) 3712 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0); 3713 else 3714 argv[i] = convert_filename (argv[i], ! have_c, 0); 3715#endif 3716 goto normal_switch; 3717 3718 default: 3719 normal_switch: 3720 3721#ifdef MODIFY_TARGET_NAME 3722 is_modify_target_name = 0; 3723 3724 for (j = 0; j < ARRAY_SIZE (modify_target); j++) 3725 if (! strcmp (argv[i], modify_target[j].sw)) 3726 { 3727 char *new_name = xmalloc (strlen (modify_target[j].str) 3728 + strlen (spec_machine)); 3729 const char *p, *r; 3730 char *q; 3731 int made_addition = 0; 3732 3733 is_modify_target_name = 1; 3734 for (p = spec_machine, q = new_name; *p != 0; ) 3735 { 3736 if (modify_target[j].add_del == DELETE 3737 && (! strncmp (q, modify_target[j].str, 3738 strlen (modify_target[j].str)))) 3739 p += strlen (modify_target[j].str); 3740 else if (modify_target[j].add_del == ADD 3741 && ! made_addition && *p == '-') 3742 { 3743 for (r = modify_target[j].str; *r != 0; ) 3744 *q++ = *r++; 3745 made_addition = 1; 3746 } 3747 3748 *q++ = *p++; 3749 } 3750 3751 spec_machine = new_name; 3752 } 3753 3754 if (is_modify_target_name) 3755 break; 3756#endif 3757 3758 n_switches++; 3759 3760 if (SWITCH_TAKES_ARG (c) > (p[1] != 0)) 3761 i += SWITCH_TAKES_ARG (c) - (p[1] != 0); 3762 else if (WORD_SWITCH_TAKES_ARG (p)) 3763 i += WORD_SWITCH_TAKES_ARG (p); 3764 } 3765 } 3766 else 3767 { 3768 n_infiles++; 3769 lang_n_infiles++; 3770 } 3771 } 3772 3773 combine_inputs = (have_c && have_o && lang_n_infiles > 1); 3774 3775 if ((save_temps_flag || report_times) && use_pipes) 3776 { 3777 /* -save-temps overrides -pipe, so that temp files are produced */ 3778 if (save_temps_flag) 3779 error ("warning: -pipe ignored because -save-temps specified"); 3780 /* -time overrides -pipe because we can't get correct stats when 3781 multiple children are running at once. */ 3782 else if (report_times) 3783 error ("warning: -pipe ignored because -time specified"); 3784 3785 use_pipes = 0; 3786 } 3787 3788 /* Set up the search paths before we go looking for config files. */ 3789 3790 /* These come before the md prefixes so that we will find gcc's subcommands 3791 (such as cpp) rather than those of the host system. */ 3792 /* Use 2 as fourth arg meaning try just the machine as a suffix, 3793 as well as trying the machine and the version. */ 3794#ifdef FREEBSD_NATIVE 3795 add_prefix (&exec_prefixes, PREFIX"/bin/", "BINUTILS", 3796 PREFIX_PRIORITY_LAST, 0, warn_std_ptr, 0); 3797#endif /* FREEBSD_NATIVE */ 3798#ifndef OS2 3799 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC", 3800 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0); 3801 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS", 3802 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3803#ifndef FREEBSD_NATIVE 3804 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS", 3805 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3806 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS", 3807 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3808 add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS", 3809 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3810#endif /* FREEBSD_NATIVE */ 3811#endif 3812 3813#ifndef FREEBSD_NATIVE 3814 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS", 3815 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0); 3816 add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS", 3817 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0); 3818#endif /* not FREEBSD_NATIVE */ 3819 3820 tooldir_prefix = concat (tooldir_base_prefix, spec_machine, 3821 dir_separator_str, NULL); 3822 3823 /* If tooldir is relative, base it on exec_prefixes. A relative 3824 tooldir lets us move the installed tree as a unit. 3825 3826 If GCC_EXEC_PREFIX is defined, then we want to add two relative 3827 directories, so that we can search both the user specified directory 3828 and the standard place. */ 3829 3830 if (!IS_ABSOLUTE_PATH (tooldir_prefix)) 3831 { 3832 if (gcc_exec_prefix) 3833 { 3834 char *gcc_exec_tooldir_prefix 3835 = concat (gcc_exec_prefix, spec_machine, dir_separator_str, 3836 spec_version, dir_separator_str, tooldir_prefix, NULL); 3837 3838 add_prefix (&exec_prefixes, 3839 concat (gcc_exec_tooldir_prefix, "bin", 3840 dir_separator_str, NULL), 3841 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 0); 3842 add_prefix (&startfile_prefixes, 3843 concat (gcc_exec_tooldir_prefix, "lib", 3844 dir_separator_str, NULL), 3845 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1); 3846 } 3847 3848 tooldir_prefix = concat (standard_exec_prefix, spec_machine, 3849 dir_separator_str, spec_version, 3850 dir_separator_str, tooldir_prefix, NULL); 3851 } 3852 3853#ifndef FREEBSD_NATIVE 3854 add_prefix (&exec_prefixes, 3855 concat (tooldir_prefix, "bin", dir_separator_str, NULL), 3856 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 0); 3857 add_prefix (&startfile_prefixes, 3858 concat (tooldir_prefix, "lib", dir_separator_str, NULL), 3859 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1); 3860 3861#if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS) 3862 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix, 3863 then consider it to relocate with the rest of the GCC installation 3864 if GCC_EXEC_PREFIX is set. 3865 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */ 3866 if (target_system_root && gcc_exec_prefix) 3867 { 3868 char *tmp_prefix = make_relative_prefix (argv[0], 3869 standard_bindir_prefix, 3870 target_system_root); 3871 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0) 3872 { 3873 target_system_root = tmp_prefix; 3874 target_system_root_changed = 1; 3875 } 3876 } 3877#endif 3878#endif /* FREEBSD_NATIVE */ 3879 3880 /* More prefixes are enabled in main, after we read the specs file 3881 and determine whether this is cross-compilation or not. */ 3882 3883 /* Then create the space for the vectors and scan again. */ 3884 3885 switches = xmalloc ((n_switches + 1) * sizeof (struct switchstr)); 3886 infiles = xmalloc ((n_infiles + 1) * sizeof (struct infile)); 3887 n_switches = 0; 3888 n_infiles = 0; 3889 last_language_n_infiles = -1; 3890 3891 /* This, time, copy the text of each switch and store a pointer 3892 to the copy in the vector of switches. 3893 Store all the infiles in their vector. */ 3894 3895 for (i = 1; i < argc; i++) 3896 { 3897 /* Just skip the switches that were handled by the preceding loop. */ 3898#ifdef MODIFY_TARGET_NAME 3899 is_modify_target_name = 0; 3900 3901 for (j = 0; j < ARRAY_SIZE (modify_target); j++) 3902 if (! strcmp (argv[i], modify_target[j].sw)) 3903 is_modify_target_name = 1; 3904 3905 if (is_modify_target_name) 3906 ; 3907 else 3908#endif 3909 if (! strncmp (argv[i], "-Wa,", 4)) 3910 ; 3911 else if (! strncmp (argv[i], "-Wp,", 4)) 3912 ; 3913 else if (! strcmp (argv[i], "-pass-exit-codes")) 3914 ; 3915 else if (! strcmp (argv[i], "-print-search-dirs")) 3916 ; 3917 else if (! strcmp (argv[i], "-print-libgcc-file-name")) 3918 ; 3919 else if (! strncmp (argv[i], "-print-file-name=", 17)) 3920 ; 3921 else if (! strncmp (argv[i], "-print-prog-name=", 17)) 3922 ; 3923 else if (! strcmp (argv[i], "-print-multi-lib")) 3924 ; 3925 else if (! strcmp (argv[i], "-print-multi-directory")) 3926 ; 3927 else if (! strcmp (argv[i], "-print-multi-os-directory")) 3928 ; 3929 else if (! strcmp (argv[i], "-ftarget-help")) 3930 ; 3931 else if (! strcmp (argv[i], "-fhelp")) 3932 ; 3933 else if (argv[i][0] == '+' && argv[i][1] == 'e') 3934 { 3935 /* Compensate for the +e options to the C++ front-end; 3936 they're there simply for cfront call-compatibility. We do 3937 some magic in default_compilers to pass them down properly. 3938 Note we deliberately start at the `+' here, to avoid passing 3939 -e0 or -e1 down into the linker. */ 3940 switches[n_switches].part1 = &argv[i][0]; 3941 switches[n_switches].args = 0; 3942 switches[n_switches].live_cond = SWITCH_OK; 3943 switches[n_switches].validated = 0; 3944 n_switches++; 3945 } 3946 else if (strncmp (argv[i], "-Wl,", 4) == 0) 3947 { 3948 int prev, j; 3949 /* Split the argument at commas. */ 3950 prev = 4; 3951 for (j = 4; argv[i][j]; j++) 3952 if (argv[i][j] == ',') 3953 { 3954 infiles[n_infiles].language = "*"; 3955 infiles[n_infiles++].name 3956 = save_string (argv[i] + prev, j - prev); 3957 prev = j + 1; 3958 } 3959 /* Record the part after the last comma. */ 3960 infiles[n_infiles].language = "*"; 3961 infiles[n_infiles++].name = argv[i] + prev; 3962 } 3963 else if (strcmp (argv[i], "-Xlinker") == 0) 3964 { 3965 infiles[n_infiles].language = "*"; 3966 infiles[n_infiles++].name = argv[++i]; 3967 } 3968 else if (strcmp (argv[i], "-Xassembler") == 0) 3969 { 3970 infiles[n_infiles].language = "*"; 3971 infiles[n_infiles++].name = argv[++i]; 3972 } 3973 else if (strcmp (argv[i], "-Xpreprocessor") == 0) 3974 { 3975 infiles[n_infiles].language = "*"; 3976 infiles[n_infiles++].name = argv[++i]; 3977 } 3978 else if (strcmp (argv[i], "-l") == 0) 3979 { /* POSIX allows separation of -l and the lib arg; 3980 canonicalize by concatenating -l with its arg */ 3981 infiles[n_infiles].language = "*"; 3982 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL); 3983 } 3984 else if (strncmp (argv[i], "-l", 2) == 0) 3985 { 3986 infiles[n_infiles].language = "*"; 3987 infiles[n_infiles++].name = argv[i]; 3988 } 3989 else if (strcmp (argv[i], "-specs") == 0) 3990 i++; 3991 else if (strncmp (argv[i], "-specs=", 7) == 0) 3992 ; 3993 else if (strcmp (argv[i], "-time") == 0) 3994 ; 3995 else if (strcmp (argv[i], "-###") == 0) 3996 ; 3997 else if (argv[i][0] == '-' && argv[i][1] != 0) 3998 { 3999 const char *p = &argv[i][1]; 4000 int c = *p; 4001 4002 if (c == 'x') 4003 { 4004 if (p[1] == 0 && i + 1 == argc) 4005 fatal ("argument to `-x' is missing"); 4006 if (p[1] == 0) 4007 spec_lang = argv[++i]; 4008 else 4009 spec_lang = p + 1; 4010 if (! strcmp (spec_lang, "none")) 4011 /* Suppress the warning if -xnone comes after the last input 4012 file, because alternate command interfaces like g++ might 4013 find it useful to place -xnone after each input file. */ 4014 spec_lang = 0; 4015 else 4016 last_language_n_infiles = n_infiles; 4017 continue; 4018 } 4019 switches[n_switches].part1 = p; 4020 /* Deal with option arguments in separate argv elements. */ 4021 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0)) 4022 || WORD_SWITCH_TAKES_ARG (p)) 4023 { 4024 int j = 0; 4025 int n_args = WORD_SWITCH_TAKES_ARG (p); 4026 4027 if (n_args == 0) 4028 { 4029 /* Count only the option arguments in separate argv elements. */ 4030 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0); 4031 } 4032 if (i + n_args >= argc) 4033 fatal ("argument to `-%s' is missing", p); 4034 switches[n_switches].args 4035 = xmalloc ((n_args + 1) * sizeof(const char *)); 4036 while (j < n_args) 4037 switches[n_switches].args[j++] = argv[++i]; 4038 /* Null-terminate the vector. */ 4039 switches[n_switches].args[j] = 0; 4040 } 4041 else if (strchr (switches_need_spaces, c)) 4042 { 4043 /* On some systems, ld cannot handle some options without 4044 a space. So split the option from its argument. */ 4045 char *part1 = xmalloc (2); 4046 part1[0] = c; 4047 part1[1] = '\0'; 4048 4049 switches[n_switches].part1 = part1; 4050 switches[n_switches].args = xmalloc (2 * sizeof (const char *)); 4051 switches[n_switches].args[0] = xstrdup (p+1); 4052 switches[n_switches].args[1] = 0; 4053 } 4054 else 4055 switches[n_switches].args = 0; 4056 4057 switches[n_switches].live_cond = SWITCH_OK; 4058 switches[n_switches].validated = 0; 4059 switches[n_switches].ordering = 0; 4060 /* These are always valid, since gcc.c itself understands them. */ 4061 if (!strcmp (p, "save-temps") 4062 || !strcmp (p, "static-libgcc") 4063 || !strcmp (p, "shared-libgcc") 4064 || !strcmp (p, "pipe")) 4065 switches[n_switches].validated = 1; 4066 else 4067 { 4068 char ch = switches[n_switches].part1[0]; 4069 if (ch == 'B') 4070 switches[n_switches].validated = 1; 4071 } 4072 n_switches++; 4073 } 4074 else 4075 { 4076#ifdef HAVE_TARGET_OBJECT_SUFFIX 4077 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK)); 4078#endif 4079 4080 if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0) 4081 { 4082 perror_with_name (argv[i]); 4083 error_count++; 4084 } 4085 else 4086 { 4087 infiles[n_infiles].language = spec_lang; 4088 infiles[n_infiles++].name = argv[i]; 4089 } 4090 } 4091 } 4092 4093 if (n_infiles == last_language_n_infiles && spec_lang != 0) 4094 error ("warning: `-x %s' after last input file has no effect", spec_lang); 4095 4096 /* Ensure we only invoke each subprocess once. */ 4097 if (target_help_flag || print_help_list) 4098 { 4099 n_infiles = 1; 4100 4101 /* Create a dummy input file, so that we can pass --target-help on to 4102 the various sub-processes. */ 4103 infiles[0].language = "c"; 4104 infiles[0].name = "help-dummy"; 4105 4106 if (target_help_flag) 4107 { 4108 switches[n_switches].part1 = "--target-help"; 4109 switches[n_switches].args = 0; 4110 switches[n_switches].live_cond = SWITCH_OK; 4111 switches[n_switches].validated = 0; 4112 4113 n_switches++; 4114 } 4115 4116 if (print_help_list) 4117 { 4118 switches[n_switches].part1 = "--help"; 4119 switches[n_switches].args = 0; 4120 switches[n_switches].live_cond = SWITCH_OK; 4121 switches[n_switches].validated = 0; 4122 4123 n_switches++; 4124 } 4125 } 4126 4127 switches[n_switches].part1 = 0; 4128 infiles[n_infiles].name = 0; 4129} 4130 4131/* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS 4132 and place that in the environment. */ 4133 4134static void 4135set_collect_gcc_options (void) 4136{ 4137 int i; 4138 int first_time; 4139 4140 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to 4141 the compiler. */ 4142 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=", 4143 sizeof ("COLLECT_GCC_OPTIONS=") - 1); 4144 4145 first_time = TRUE; 4146 for (i = 0; (int) i < n_switches; i++) 4147 { 4148 const char *const *args; 4149 const char *p, *q; 4150 if (!first_time) 4151 obstack_grow (&collect_obstack, " ", 1); 4152 4153 first_time = FALSE; 4154 4155 /* Ignore elided switches. */ 4156 if (switches[i].live_cond == SWITCH_IGNORE) 4157 continue; 4158 4159 obstack_grow (&collect_obstack, "'-", 2); 4160 q = switches[i].part1; 4161 while ((p = strchr (q, '\''))) 4162 { 4163 obstack_grow (&collect_obstack, q, p - q); 4164 obstack_grow (&collect_obstack, "'\\''", 4); 4165 q = ++p; 4166 } 4167 obstack_grow (&collect_obstack, q, strlen (q)); 4168 obstack_grow (&collect_obstack, "'", 1); 4169 4170 for (args = switches[i].args; args && *args; args++) 4171 { 4172 obstack_grow (&collect_obstack, " '", 2); 4173 q = *args; 4174 while ((p = strchr (q, '\''))) 4175 { 4176 obstack_grow (&collect_obstack, q, p - q); 4177 obstack_grow (&collect_obstack, "'\\''", 4); 4178 q = ++p; 4179 } 4180 obstack_grow (&collect_obstack, q, strlen (q)); 4181 obstack_grow (&collect_obstack, "'", 1); 4182 } 4183 } 4184 obstack_grow (&collect_obstack, "\0", 1); 4185 putenv (obstack_finish (&collect_obstack)); 4186} 4187 4188/* Process a spec string, accumulating and running commands. */ 4189 4190/* These variables describe the input file name. 4191 input_file_number is the index on outfiles of this file, 4192 so that the output file name can be stored for later use by %o. 4193 input_basename is the start of the part of the input file 4194 sans all directory names, and basename_length is the number 4195 of characters starting there excluding the suffix .c or whatever. */ 4196 4197static const char *input_filename; 4198static int input_file_number; 4199size_t input_filename_length; 4200static int basename_length; 4201static int suffixed_basename_length; 4202static const char *input_basename; 4203static const char *input_suffix; 4204static struct stat input_stat; 4205static int input_stat_set; 4206 4207/* The compiler used to process the current input file. */ 4208static struct compiler *input_file_compiler; 4209 4210/* These are variables used within do_spec and do_spec_1. */ 4211 4212/* Nonzero if an arg has been started and not yet terminated 4213 (with space, tab or newline). */ 4214static int arg_going; 4215 4216/* Nonzero means %d or %g has been seen; the next arg to be terminated 4217 is a temporary file name. */ 4218static int delete_this_arg; 4219 4220/* Nonzero means %w has been seen; the next arg to be terminated 4221 is the output file name of this compilation. */ 4222static int this_is_output_file; 4223 4224/* Nonzero means %s has been seen; the next arg to be terminated 4225 is the name of a library file and we should try the standard 4226 search dirs for it. */ 4227static int this_is_library_file; 4228 4229/* Nonzero means that the input of this command is coming from a pipe. */ 4230static int input_from_pipe; 4231 4232/* Nonnull means substitute this for any suffix when outputting a switches 4233 arguments. */ 4234static const char *suffix_subst; 4235 4236/* Process the spec SPEC and run the commands specified therein. 4237 Returns 0 if the spec is successfully processed; -1 if failed. */ 4238 4239int 4240do_spec (const char *spec) 4241{ 4242 int value; 4243 4244 value = do_spec_2 (spec); 4245 4246 /* Force out any unfinished command. 4247 If -pipe, this forces out the last command if it ended in `|'. */ 4248 if (value == 0) 4249 { 4250 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|")) 4251 argbuf_index--; 4252 4253 set_collect_gcc_options (); 4254 4255 if (argbuf_index > 0) 4256 value = execute (); 4257 } 4258 4259 return value; 4260} 4261 4262static int 4263do_spec_2 (const char *spec) 4264{ 4265 const char *string; 4266 int result; 4267 4268 clear_args (); 4269 arg_going = 0; 4270 delete_this_arg = 0; 4271 this_is_output_file = 0; 4272 this_is_library_file = 0; 4273 input_from_pipe = 0; 4274 suffix_subst = NULL; 4275 4276 result = do_spec_1 (spec, 0, NULL); 4277 4278 /* End any pending argument. */ 4279 if (arg_going) 4280 { 4281 obstack_1grow (&obstack, 0); 4282 string = obstack_finish (&obstack); 4283 if (this_is_library_file) 4284 string = find_file (string); 4285 store_arg (string, delete_this_arg, this_is_output_file); 4286 if (this_is_output_file) 4287 outfiles[input_file_number] = string; 4288 arg_going = 0; 4289 } 4290 4291 return result; 4292} 4293 4294 4295/* Process the given spec string and add any new options to the end 4296 of the switches/n_switches array. */ 4297 4298static void 4299do_option_spec (const char *name, const char *spec) 4300{ 4301 unsigned int i, value_count, value_len; 4302 const char *p, *q, *value; 4303 char *tmp_spec, *tmp_spec_p; 4304 4305 if (configure_default_options[0].name == NULL) 4306 return; 4307 4308 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++) 4309 if (strcmp (configure_default_options[i].name, name) == 0) 4310 break; 4311 if (i == ARRAY_SIZE (configure_default_options)) 4312 return; 4313 4314 value = configure_default_options[i].value; 4315 value_len = strlen (value); 4316 4317 /* Compute the size of the final spec. */ 4318 value_count = 0; 4319 p = spec; 4320 while ((p = strstr (p, "%(VALUE)")) != NULL) 4321 { 4322 p ++; 4323 value_count ++; 4324 } 4325 4326 /* Replace each %(VALUE) by the specified value. */ 4327 tmp_spec = alloca (strlen (spec) + 1 4328 + value_count * (value_len - strlen ("%(VALUE)"))); 4329 tmp_spec_p = tmp_spec; 4330 q = spec; 4331 while ((p = strstr (q, "%(VALUE)")) != NULL) 4332 { 4333 memcpy (tmp_spec_p, q, p - q); 4334 tmp_spec_p = tmp_spec_p + (p - q); 4335 memcpy (tmp_spec_p, value, value_len); 4336 tmp_spec_p += value_len; 4337 q = p + strlen ("%(VALUE)"); 4338 } 4339 strcpy (tmp_spec_p, q); 4340 4341 do_self_spec (tmp_spec); 4342} 4343 4344/* Process the given spec string and add any new options to the end 4345 of the switches/n_switches array. */ 4346 4347static void 4348do_self_spec (const char *spec) 4349{ 4350 do_spec_2 (spec); 4351 do_spec_1 (" ", 0, NULL); 4352 4353 if (argbuf_index > 0) 4354 { 4355 int i, first; 4356 4357 first = n_switches; 4358 n_switches += argbuf_index; 4359 switches = xrealloc (switches, 4360 sizeof (struct switchstr) * (n_switches + 1)); 4361 4362 switches[n_switches] = switches[first]; 4363 for (i = 0; i < argbuf_index; i++) 4364 { 4365 struct switchstr *sw; 4366 4367 /* Each switch should start with '-'. */ 4368 if (argbuf[i][0] != '-') 4369 abort (); 4370 4371 sw = &switches[i + first]; 4372 sw->part1 = &argbuf[i][1]; 4373 sw->args = 0; 4374 sw->live_cond = SWITCH_OK; 4375 sw->validated = 0; 4376 sw->ordering = 0; 4377 } 4378 } 4379} 4380 4381/* Process the sub-spec SPEC as a portion of a larger spec. 4382 This is like processing a whole spec except that we do 4383 not initialize at the beginning and we do not supply a 4384 newline by default at the end. 4385 INSWITCH nonzero means don't process %-sequences in SPEC; 4386 in this case, % is treated as an ordinary character. 4387 This is used while substituting switches. 4388 INSWITCH nonzero also causes SPC not to terminate an argument. 4389 4390 Value is zero unless a line was finished 4391 and the command on that line reported an error. */ 4392 4393static int 4394do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part) 4395{ 4396 const char *p = spec; 4397 int c; 4398 int i; 4399 const char *string; 4400 int value; 4401 4402 while ((c = *p++)) 4403 /* If substituting a switch, treat all chars like letters. 4404 Otherwise, NL, SPC, TAB and % are special. */ 4405 switch (inswitch ? 'a' : c) 4406 { 4407 case '\n': 4408 /* End of line: finish any pending argument, 4409 then run the pending command if one has been started. */ 4410 if (arg_going) 4411 { 4412 obstack_1grow (&obstack, 0); 4413 string = obstack_finish (&obstack); 4414 if (this_is_library_file) 4415 string = find_file (string); 4416 store_arg (string, delete_this_arg, this_is_output_file); 4417 if (this_is_output_file) 4418 outfiles[input_file_number] = string; 4419 } 4420 arg_going = 0; 4421 4422 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|")) 4423 { 4424 /* A `|' before the newline means use a pipe here, 4425 but only if -pipe was specified. 4426 Otherwise, execute now and don't pass the `|' as an arg. */ 4427 if (use_pipes) 4428 { 4429 input_from_pipe = 1; 4430 break; 4431 } 4432 else 4433 argbuf_index--; 4434 } 4435 4436 set_collect_gcc_options (); 4437 4438 if (argbuf_index > 0) 4439 { 4440 value = execute (); 4441 if (value) 4442 return value; 4443 } 4444 /* Reinitialize for a new command, and for a new argument. */ 4445 clear_args (); 4446 arg_going = 0; 4447 delete_this_arg = 0; 4448 this_is_output_file = 0; 4449 this_is_library_file = 0; 4450 input_from_pipe = 0; 4451 break; 4452 4453 case '|': 4454 /* End any pending argument. */ 4455 if (arg_going) 4456 { 4457 obstack_1grow (&obstack, 0); 4458 string = obstack_finish (&obstack); 4459 if (this_is_library_file) 4460 string = find_file (string); 4461 store_arg (string, delete_this_arg, this_is_output_file); 4462 if (this_is_output_file) 4463 outfiles[input_file_number] = string; 4464 } 4465 4466 /* Use pipe */ 4467 obstack_1grow (&obstack, c); 4468 arg_going = 1; 4469 break; 4470 4471 case '\t': 4472 case ' ': 4473 /* Space or tab ends an argument if one is pending. */ 4474 if (arg_going) 4475 { 4476 obstack_1grow (&obstack, 0); 4477 string = obstack_finish (&obstack); 4478 if (this_is_library_file) 4479 string = find_file (string); 4480 store_arg (string, delete_this_arg, this_is_output_file); 4481 if (this_is_output_file) 4482 outfiles[input_file_number] = string; 4483 } 4484 /* Reinitialize for a new argument. */ 4485 arg_going = 0; 4486 delete_this_arg = 0; 4487 this_is_output_file = 0; 4488 this_is_library_file = 0; 4489 break; 4490 4491 case '%': 4492 switch (c = *p++) 4493 { 4494 case 0: 4495 fatal ("invalid specification! Bug in cc"); 4496 4497 case 'b': 4498 obstack_grow (&obstack, input_basename, basename_length); 4499 arg_going = 1; 4500 break; 4501 4502 case 'B': 4503 obstack_grow (&obstack, input_basename, suffixed_basename_length); 4504 arg_going = 1; 4505 break; 4506 4507 case 'd': 4508 delete_this_arg = 2; 4509 break; 4510 4511 /* Dump out the directories specified with LIBRARY_PATH, 4512 followed by the absolute directories 4513 that we search for startfiles. */ 4514 case 'D': 4515 { 4516 struct prefix_list *pl = startfile_prefixes.plist; 4517 size_t bufsize = 100; 4518 char *buffer = xmalloc (bufsize); 4519 int idx; 4520 4521 for (; pl; pl = pl->next) 4522 { 4523#ifdef RELATIVE_PREFIX_NOT_LINKDIR 4524 /* Used on systems which record the specified -L dirs 4525 and use them to search for dynamic linking. */ 4526 /* Relative directories always come from -B, 4527 and it is better not to use them for searching 4528 at run time. In particular, stage1 loses. */ 4529 if (!IS_ABSOLUTE_PATH (pl->prefix)) 4530 continue; 4531#endif 4532 /* Try subdirectory if there is one. */ 4533 if (multilib_dir != NULL 4534 || (pl->os_multilib && multilib_os_dir != NULL)) 4535 { 4536 const char *multi_dir; 4537 4538 multi_dir = pl->os_multilib ? multilib_os_dir 4539 : multilib_dir; 4540 if (machine_suffix && multilib_dir) 4541 { 4542 if (strlen (pl->prefix) + strlen (machine_suffix) 4543 >= bufsize) 4544 bufsize = (strlen (pl->prefix) 4545 + strlen (machine_suffix)) * 2 + 1; 4546 buffer = xrealloc (buffer, bufsize); 4547 strcpy (buffer, pl->prefix); 4548 strcat (buffer, machine_suffix); 4549 if (is_directory (buffer, multilib_dir, 1)) 4550 { 4551 do_spec_1 ("-L", 0, NULL); 4552#ifdef SPACE_AFTER_L_OPTION 4553 do_spec_1 (" ", 0, NULL); 4554#endif 4555 do_spec_1 (buffer, 1, NULL); 4556 do_spec_1 (multilib_dir, 1, NULL); 4557 /* Make this a separate argument. */ 4558 do_spec_1 (" ", 0, NULL); 4559 } 4560 } 4561 if (!pl->require_machine_suffix) 4562 { 4563 if (is_directory (pl->prefix, multi_dir, 1)) 4564 { 4565 do_spec_1 ("-L", 0, NULL); 4566#ifdef SPACE_AFTER_L_OPTION 4567 do_spec_1 (" ", 0, NULL); 4568#endif 4569 do_spec_1 (pl->prefix, 1, NULL); 4570 do_spec_1 (multi_dir, 1, NULL); 4571 /* Make this a separate argument. */ 4572 do_spec_1 (" ", 0, NULL); 4573 } 4574 } 4575 } 4576 if (machine_suffix) 4577 { 4578 if (is_directory (pl->prefix, machine_suffix, 1)) 4579 { 4580 do_spec_1 ("-L", 0, NULL); 4581#ifdef SPACE_AFTER_L_OPTION 4582 do_spec_1 (" ", 0, NULL); 4583#endif 4584 do_spec_1 (pl->prefix, 1, NULL); 4585 /* Remove slash from machine_suffix. */ 4586 if (strlen (machine_suffix) >= bufsize) 4587 bufsize = strlen (machine_suffix) * 2 + 1; 4588 buffer = xrealloc (buffer, bufsize); 4589 strcpy (buffer, machine_suffix); 4590 idx = strlen (buffer); 4591 if (IS_DIR_SEPARATOR (buffer[idx - 1])) 4592 buffer[idx - 1] = 0; 4593 do_spec_1 (buffer, 1, NULL); 4594 /* Make this a separate argument. */ 4595 do_spec_1 (" ", 0, NULL); 4596 } 4597 } 4598 if (!pl->require_machine_suffix) 4599 { 4600 if (is_directory (pl->prefix, "", 1)) 4601 { 4602 do_spec_1 ("-L", 0, NULL); 4603#ifdef SPACE_AFTER_L_OPTION 4604 do_spec_1 (" ", 0, NULL); 4605#endif 4606 /* Remove slash from pl->prefix. */ 4607 if (strlen (pl->prefix) >= bufsize) 4608 bufsize = strlen (pl->prefix) * 2 + 1; 4609 buffer = xrealloc (buffer, bufsize); 4610 strcpy (buffer, pl->prefix); 4611 idx = strlen (buffer); 4612 if (IS_DIR_SEPARATOR (buffer[idx - 1])) 4613 buffer[idx - 1] = 0; 4614 do_spec_1 (buffer, 1, NULL); 4615 /* Make this a separate argument. */ 4616 do_spec_1 (" ", 0, NULL); 4617 } 4618 } 4619 } 4620 free (buffer); 4621 } 4622 break; 4623 4624 case 'e': 4625 /* %efoo means report an error with `foo' as error message 4626 and don't execute any more commands for this file. */ 4627 { 4628 const char *q = p; 4629 char *buf; 4630 while (*p != 0 && *p != '\n') 4631 p++; 4632 buf = alloca (p - q + 1); 4633 strncpy (buf, q, p - q); 4634 buf[p - q] = 0; 4635 error ("%s", buf); 4636 return -1; 4637 } 4638 break; 4639 case 'n': 4640 /* %nfoo means report a notice with `foo' on stderr. */ 4641 { 4642 const char *q = p; 4643 char *buf; 4644 while (*p != 0 && *p != '\n') 4645 p++; 4646 buf = alloca (p - q + 1); 4647 strncpy (buf, q, p - q); 4648 buf[p - q] = 0; 4649 notice ("%s\n", buf); 4650 if (*p) 4651 p++; 4652 } 4653 break; 4654 4655 case 'j': 4656 { 4657 struct stat st; 4658 4659 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is 4660 defined, and it is not a directory, and it is 4661 writable, use it. Otherwise, treat this like any 4662 other temporary file. */ 4663 4664 if ((!save_temps_flag) 4665 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode)) 4666 && (access (HOST_BIT_BUCKET, W_OK) == 0)) 4667 { 4668 obstack_grow (&obstack, HOST_BIT_BUCKET, 4669 strlen (HOST_BIT_BUCKET)); 4670 delete_this_arg = 0; 4671 arg_going = 1; 4672 break; 4673 } 4674 } 4675 goto create_temp_file; 4676 case '|': 4677 if (use_pipes) 4678 { 4679 obstack_1grow (&obstack, '-'); 4680 delete_this_arg = 0; 4681 arg_going = 1; 4682 4683 /* consume suffix */ 4684 while (*p == '.' || ISALPHA ((unsigned char) *p)) 4685 p++; 4686 if (p[0] == '%' && p[1] == 'O') 4687 p += 2; 4688 4689 break; 4690 } 4691 goto create_temp_file; 4692 case 'm': 4693 if (use_pipes) 4694 { 4695 /* consume suffix */ 4696 while (*p == '.' || ISALPHA ((unsigned char) *p)) 4697 p++; 4698 if (p[0] == '%' && p[1] == 'O') 4699 p += 2; 4700 4701 break; 4702 } 4703 goto create_temp_file; 4704 case 'g': 4705 case 'u': 4706 case 'U': 4707 create_temp_file: 4708 { 4709 struct temp_name *t; 4710 int suffix_length; 4711 const char *suffix = p; 4712 char *saved_suffix = NULL; 4713 4714 while (*p == '.' || ISALPHA ((unsigned char) *p)) 4715 p++; 4716 suffix_length = p - suffix; 4717 if (p[0] == '%' && p[1] == 'O') 4718 { 4719 p += 2; 4720 /* We don't support extra suffix characters after %O. */ 4721 if (*p == '.' || ISALPHA ((unsigned char) *p)) 4722 abort (); 4723 if (suffix_length == 0) 4724 suffix = TARGET_OBJECT_SUFFIX; 4725 else 4726 { 4727 saved_suffix 4728 = xmalloc (suffix_length 4729 + strlen (TARGET_OBJECT_SUFFIX)); 4730 strncpy (saved_suffix, suffix, suffix_length); 4731 strcpy (saved_suffix + suffix_length, 4732 TARGET_OBJECT_SUFFIX); 4733 } 4734 suffix_length += strlen (TARGET_OBJECT_SUFFIX); 4735 } 4736 4737 /* If the input_filename has the same suffix specified 4738 for the %g, %u, or %U, and -save-temps is specified, 4739 we could end up using that file as an intermediate 4740 thus clobbering the user's source file (.e.g., 4741 gcc -save-temps foo.s would clobber foo.s with the 4742 output of cpp0). So check for this condition and 4743 generate a temp file as the intermediate. */ 4744 4745 if (save_temps_flag) 4746 { 4747 temp_filename_length = basename_length + suffix_length; 4748 temp_filename = alloca (temp_filename_length + 1); 4749 strncpy ((char *) temp_filename, input_basename, basename_length); 4750 strncpy ((char *) temp_filename + basename_length, suffix, 4751 suffix_length); 4752 *((char *) temp_filename + temp_filename_length) = '\0'; 4753 if (strcmp (temp_filename, input_filename) != 0) 4754 { 4755 struct stat st_temp; 4756 4757 /* Note, set_input() resets input_stat_set to 0. */ 4758 if (input_stat_set == 0) 4759 { 4760 input_stat_set = stat (input_filename, &input_stat); 4761 if (input_stat_set >= 0) 4762 input_stat_set = 1; 4763 } 4764 4765 /* If we have the stat for the input_filename 4766 and we can do the stat for the temp_filename 4767 then the they could still refer to the same 4768 file if st_dev/st_ino's are the same. */ 4769 4770 if (input_stat_set != 1 4771 || stat (temp_filename, &st_temp) < 0 4772 || input_stat.st_dev != st_temp.st_dev 4773 || input_stat.st_ino != st_temp.st_ino) 4774 { 4775 temp_filename = save_string (temp_filename, 4776 temp_filename_length + 1); 4777 obstack_grow (&obstack, temp_filename, 4778 temp_filename_length); 4779 arg_going = 1; 4780 delete_this_arg = 0; 4781 break; 4782 } 4783 } 4784 } 4785 4786 /* See if we already have an association of %g/%u/%U and 4787 suffix. */ 4788 for (t = temp_names; t; t = t->next) 4789 if (t->length == suffix_length 4790 && strncmp (t->suffix, suffix, suffix_length) == 0 4791 && t->unique == (c == 'u' || c == 'U' || c == 'j')) 4792 break; 4793 4794 /* Make a new association if needed. %u and %j 4795 require one. */ 4796 if (t == 0 || c == 'u' || c == 'j') 4797 { 4798 if (t == 0) 4799 { 4800 t = xmalloc (sizeof (struct temp_name)); 4801 t->next = temp_names; 4802 temp_names = t; 4803 } 4804 t->length = suffix_length; 4805 if (saved_suffix) 4806 { 4807 t->suffix = saved_suffix; 4808 saved_suffix = NULL; 4809 } 4810 else 4811 t->suffix = save_string (suffix, suffix_length); 4812 t->unique = (c == 'u' || c == 'U' || c == 'j'); 4813 temp_filename = make_temp_file (t->suffix); 4814 temp_filename_length = strlen (temp_filename); 4815 t->filename = temp_filename; 4816 t->filename_length = temp_filename_length; 4817 } 4818 4819 if (saved_suffix) 4820 free (saved_suffix); 4821 4822 obstack_grow (&obstack, t->filename, t->filename_length); 4823 delete_this_arg = 1; 4824 } 4825 arg_going = 1; 4826 break; 4827 4828 case 'i': 4829 if (combine_inputs) 4830 { 4831 for (i = 0; (int) i < n_infiles; i++) 4832 store_arg (infiles[i].name, 0, 0); 4833 } 4834 else 4835 { 4836 obstack_grow (&obstack, input_filename, input_filename_length); 4837 arg_going = 1; 4838 } 4839 break; 4840 4841 case 'I': 4842 { 4843 struct prefix_list *pl = include_prefixes.plist; 4844 4845 if (gcc_exec_prefix) 4846 { 4847 do_spec_1 ("-iprefix", 1, NULL); 4848 /* Make this a separate argument. */ 4849 do_spec_1 (" ", 0, NULL); 4850 do_spec_1 (gcc_exec_prefix, 1, NULL); 4851 do_spec_1 (" ", 0, NULL); 4852 } 4853 4854 if (target_system_root_changed || 4855 (target_system_root && target_sysroot_hdrs_suffix)) 4856 { 4857 do_spec_1 ("-isysroot", 1, NULL); 4858 /* Make this a separate argument. */ 4859 do_spec_1 (" ", 0, NULL); 4860 do_spec_1 (target_system_root, 1, NULL); 4861 if (target_sysroot_hdrs_suffix) 4862 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL); 4863 do_spec_1 (" ", 0, NULL); 4864 } 4865 4866 for (; pl; pl = pl->next) 4867 { 4868 do_spec_1 ("-isystem", 1, NULL); 4869 /* Make this a separate argument. */ 4870 do_spec_1 (" ", 0, NULL); 4871 do_spec_1 (pl->prefix, 1, NULL); 4872 do_spec_1 (" ", 0, NULL); 4873 } 4874 } 4875 break; 4876 4877 case 'o': 4878 { 4879 int max = n_infiles; 4880 max += lang_specific_extra_outfiles; 4881 4882 for (i = 0; i < max; i++) 4883 if (outfiles[i]) 4884 store_arg (outfiles[i], 0, 0); 4885 break; 4886 } 4887 4888 case 'O': 4889 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX)); 4890 arg_going = 1; 4891 break; 4892 4893 case 's': 4894 this_is_library_file = 1; 4895 break; 4896 4897 case 'V': 4898 outfiles[input_file_number] = NULL; 4899 break; 4900 4901 case 'w': 4902 this_is_output_file = 1; 4903 break; 4904 4905 case 'W': 4906 { 4907 int cur_index = argbuf_index; 4908 /* Handle the {...} following the %W. */ 4909 if (*p != '{') 4910 abort (); 4911 p = handle_braces (p + 1); 4912 if (p == 0) 4913 return -1; 4914 /* End any pending argument. */ 4915 if (arg_going) 4916 { 4917 obstack_1grow (&obstack, 0); 4918 string = obstack_finish (&obstack); 4919 if (this_is_library_file) 4920 string = find_file (string); 4921 store_arg (string, delete_this_arg, this_is_output_file); 4922 if (this_is_output_file) 4923 outfiles[input_file_number] = string; 4924 arg_going = 0; 4925 } 4926 /* If any args were output, mark the last one for deletion 4927 on failure. */ 4928 if (argbuf_index != cur_index) 4929 record_temp_file (argbuf[argbuf_index - 1], 0, 1); 4930 break; 4931 } 4932 4933 /* %x{OPTION} records OPTION for %X to output. */ 4934 case 'x': 4935 { 4936 const char *p1 = p; 4937 char *string; 4938 4939 /* Skip past the option value and make a copy. */ 4940 if (*p != '{') 4941 abort (); 4942 while (*p++ != '}') 4943 ; 4944 string = save_string (p1 + 1, p - p1 - 2); 4945 4946 /* See if we already recorded this option. */ 4947 for (i = 0; i < n_linker_options; i++) 4948 if (! strcmp (string, linker_options[i])) 4949 { 4950 free (string); 4951 return 0; 4952 } 4953 4954 /* This option is new; add it. */ 4955 add_linker_option (string, strlen (string)); 4956 } 4957 break; 4958 4959 /* Dump out the options accumulated previously using %x. */ 4960 case 'X': 4961 for (i = 0; i < n_linker_options; i++) 4962 { 4963 do_spec_1 (linker_options[i], 1, NULL); 4964 /* Make each accumulated option a separate argument. */ 4965 do_spec_1 (" ", 0, NULL); 4966 } 4967 break; 4968 4969 /* Dump out the options accumulated previously using -Wa,. */ 4970 case 'Y': 4971 for (i = 0; i < n_assembler_options; i++) 4972 { 4973 do_spec_1 (assembler_options[i], 1, NULL); 4974 /* Make each accumulated option a separate argument. */ 4975 do_spec_1 (" ", 0, NULL); 4976 } 4977 break; 4978 4979 /* Dump out the options accumulated previously using -Wp,. */ 4980 case 'Z': 4981 for (i = 0; i < n_preprocessor_options; i++) 4982 { 4983 do_spec_1 (preprocessor_options[i], 1, NULL); 4984 /* Make each accumulated option a separate argument. */ 4985 do_spec_1 (" ", 0, NULL); 4986 } 4987 break; 4988 4989 /* Here are digits and numbers that just process 4990 a certain constant string as a spec. */ 4991 4992 case '1': 4993 value = do_spec_1 (cc1_spec, 0, NULL); 4994 if (value != 0) 4995 return value; 4996 break; 4997 4998 case '2': 4999 value = do_spec_1 (cc1plus_spec, 0, NULL); 5000 if (value != 0) 5001 return value; 5002 break; 5003 5004 case 'a': 5005 value = do_spec_1 (asm_spec, 0, NULL); 5006 if (value != 0) 5007 return value; 5008 break; 5009 5010 case 'A': 5011 value = do_spec_1 (asm_final_spec, 0, NULL); 5012 if (value != 0) 5013 return value; 5014 break; 5015 5016 case 'C': 5017 { 5018 const char *const spec 5019 = (input_file_compiler->cpp_spec 5020 ? input_file_compiler->cpp_spec 5021 : cpp_spec); 5022 value = do_spec_1 (spec, 0, NULL); 5023 if (value != 0) 5024 return value; 5025 } 5026 break; 5027 5028 case 'E': 5029 value = do_spec_1 (endfile_spec, 0, NULL); 5030 if (value != 0) 5031 return value; 5032 break; 5033 5034 case 'l': 5035 value = do_spec_1 (link_spec, 0, NULL); 5036 if (value != 0) 5037 return value; 5038 break; 5039 5040 case 'L': 5041 value = do_spec_1 (lib_spec, 0, NULL); 5042 if (value != 0) 5043 return value; 5044 break; 5045 5046 case 'G': 5047 value = do_spec_1 (libgcc_spec, 0, NULL); 5048 if (value != 0) 5049 return value; 5050 break; 5051 5052 case 'M': 5053 if (multilib_dir && strcmp (multilib_dir, ".") != 0) 5054 { 5055 char *p; 5056 const char *q; 5057 size_t len; 5058 5059 len = strlen (multilib_dir); 5060 obstack_blank (&obstack, len + 1); 5061 p = obstack_next_free (&obstack) - (len + 1); 5062 5063 *p++ = '_'; 5064 for (q = multilib_dir; *q ; ++q, ++p) 5065 *p = (IS_DIR_SEPARATOR (*q) ? '_' : *q); 5066 } 5067 break; 5068 5069 case 'R': 5070 /* We assume there is a directory 5071 separator at the end of this string. */ 5072 if (target_system_root) 5073 { 5074 obstack_grow (&obstack, target_system_root, 5075 strlen (target_system_root)); 5076 if (target_sysroot_suffix) 5077 obstack_grow (&obstack, target_sysroot_suffix, 5078 strlen (target_sysroot_suffix)); 5079 } 5080 break; 5081 5082 case 'S': 5083 value = do_spec_1 (startfile_spec, 0, NULL); 5084 if (value != 0) 5085 return value; 5086 break; 5087 5088 /* Here we define characters other than letters and digits. */ 5089 5090 case '{': 5091 p = handle_braces (p); 5092 if (p == 0) 5093 return -1; 5094 break; 5095 5096 case ':': 5097 p = handle_spec_function (p); 5098 if (p == 0) 5099 return -1; 5100 break; 5101 5102 case '%': 5103 obstack_1grow (&obstack, '%'); 5104 break; 5105 5106 case '.': 5107 { 5108 unsigned len = 0; 5109 5110 while (p[len] && p[len] != ' ' && p[len] != '%') 5111 len++; 5112 suffix_subst = save_string (p - 1, len + 1); 5113 p += len; 5114 } 5115 break; 5116 5117 /* Henceforth ignore the option(s) matching the pattern 5118 after the %<. */ 5119 case '<': 5120 { 5121 unsigned len = 0; 5122 int have_wildcard = 0; 5123 int i; 5124 5125 while (p[len] && p[len] != ' ' && p[len] != '\t') 5126 len++; 5127 5128 if (p[len-1] == '*') 5129 have_wildcard = 1; 5130 5131 for (i = 0; i < n_switches; i++) 5132 if (!strncmp (switches[i].part1, p, len - have_wildcard) 5133 && (have_wildcard || switches[i].part1[len] == '\0')) 5134 { 5135 switches[i].live_cond = SWITCH_IGNORE; 5136 switches[i].validated = 1; 5137 } 5138 5139 p += len; 5140 } 5141 break; 5142 5143 case '*': 5144 if (soft_matched_part) 5145 { 5146 do_spec_1 (soft_matched_part, 1, NULL); 5147 do_spec_1 (" ", 0, NULL); 5148 } 5149 else 5150 /* Catch the case where a spec string contains something like 5151 '%{foo:%*}'. ie there is no * in the pattern on the left 5152 hand side of the :. */ 5153 error ("spec failure: '%%*' has not been initialized by pattern match"); 5154 break; 5155 5156 /* Process a string found as the value of a spec given by name. 5157 This feature allows individual machine descriptions 5158 to add and use their own specs. 5159 %[...] modifies -D options the way %P does; 5160 %(...) uses the spec unmodified. */ 5161 case '[': 5162 error ("warning: use of obsolete %%[ operator in specs"); 5163 case '(': 5164 { 5165 const char *name = p; 5166 struct spec_list *sl; 5167 int len; 5168 5169 /* The string after the S/P is the name of a spec that is to be 5170 processed. */ 5171 while (*p && *p != ')' && *p != ']') 5172 p++; 5173 5174 /* See if it's in the list. */ 5175 for (len = p - name, sl = specs; sl; sl = sl->next) 5176 if (sl->name_len == len && !strncmp (sl->name, name, len)) 5177 { 5178 name = *(sl->ptr_spec); 5179#ifdef DEBUG_SPECS 5180 notice ("Processing spec %c%s%c, which is '%s'\n", 5181 c, sl->name, (c == '(') ? ')' : ']', name); 5182#endif 5183 break; 5184 } 5185 5186 if (sl) 5187 { 5188 if (c == '(') 5189 { 5190 value = do_spec_1 (name, 0, NULL); 5191 if (value != 0) 5192 return value; 5193 } 5194 else 5195 { 5196 char *x = alloca (strlen (name) * 2 + 1); 5197 char *buf = x; 5198 const char *y = name; 5199 int flag = 0; 5200 5201 /* Copy all of NAME into BUF, but put __ after 5202 every -D and at the end of each arg. */ 5203 while (1) 5204 { 5205 if (! strncmp (y, "-D", 2)) 5206 { 5207 *x++ = '-'; 5208 *x++ = 'D'; 5209 *x++ = '_'; 5210 *x++ = '_'; 5211 y += 2; 5212 flag = 1; 5213 continue; 5214 } 5215 else if (flag 5216 && (*y == ' ' || *y == '\t' || *y == '=' 5217 || *y == '}' || *y == 0)) 5218 { 5219 *x++ = '_'; 5220 *x++ = '_'; 5221 flag = 0; 5222 } 5223 if (*y == 0) 5224 break; 5225 else 5226 *x++ = *y++; 5227 } 5228 *x = 0; 5229 5230 value = do_spec_1 (buf, 0, NULL); 5231 if (value != 0) 5232 return value; 5233 } 5234 } 5235 5236 /* Discard the closing paren or bracket. */ 5237 if (*p) 5238 p++; 5239 } 5240 break; 5241 5242 default: 5243 error ("spec failure: unrecognized spec option '%c'", c); 5244 break; 5245 } 5246 break; 5247 5248 case '\\': 5249 /* Backslash: treat next character as ordinary. */ 5250 c = *p++; 5251 5252 /* Fall through. */ 5253 default: 5254 /* Ordinary character: put it into the current argument. */ 5255 obstack_1grow (&obstack, c); 5256 arg_going = 1; 5257 } 5258 5259 /* End of string. If we are processing a spec function, we need to 5260 end any pending argument. */ 5261 if (processing_spec_function && arg_going) 5262 { 5263 obstack_1grow (&obstack, 0); 5264 string = obstack_finish (&obstack); 5265 if (this_is_library_file) 5266 string = find_file (string); 5267 store_arg (string, delete_this_arg, this_is_output_file); 5268 if (this_is_output_file) 5269 outfiles[input_file_number] = string; 5270 arg_going = 0; 5271 } 5272 5273 return 0; 5274} 5275 5276/* Look up a spec function. */ 5277 5278static const struct spec_function * 5279lookup_spec_function (const char *name) 5280{ 5281 static const struct spec_function * const spec_function_tables[] = 5282 { 5283 static_spec_functions, 5284 lang_specific_spec_functions, 5285 }; 5286 const struct spec_function *sf; 5287 unsigned int i; 5288 5289 for (i = 0; i < ARRAY_SIZE (spec_function_tables); i++) 5290 { 5291 for (sf = spec_function_tables[i]; sf->name != NULL; sf++) 5292 if (strcmp (sf->name, name) == 0) 5293 return sf; 5294 } 5295 5296 return NULL; 5297} 5298 5299/* Evaluate a spec function. */ 5300 5301static const char * 5302eval_spec_function (const char *func, const char *args) 5303{ 5304 const struct spec_function *sf; 5305 const char *funcval; 5306 5307 /* Saved spec processing context. */ 5308 int save_argbuf_index; 5309 int save_argbuf_length; 5310 const char **save_argbuf; 5311 5312 int save_arg_going; 5313 int save_delete_this_arg; 5314 int save_this_is_output_file; 5315 int save_this_is_library_file; 5316 int save_input_from_pipe; 5317 const char *save_suffix_subst; 5318 5319 5320 sf = lookup_spec_function (func); 5321 if (sf == NULL) 5322 fatal ("unknown spec function `%s'", func); 5323 5324 /* Push the spec processing context. */ 5325 save_argbuf_index = argbuf_index; 5326 save_argbuf_length = argbuf_length; 5327 save_argbuf = argbuf; 5328 5329 save_arg_going = arg_going; 5330 save_delete_this_arg = delete_this_arg; 5331 save_this_is_output_file = this_is_output_file; 5332 save_this_is_library_file = this_is_library_file; 5333 save_input_from_pipe = input_from_pipe; 5334 save_suffix_subst = suffix_subst; 5335 5336 /* Create a new spec processing context, and build the function 5337 arguments. */ 5338 5339 alloc_args (); 5340 if (do_spec_2 (args) < 0) 5341 fatal ("error in args to spec function `%s'", func); 5342 5343 /* argbuf_index is an index for the next argument to be inserted, and 5344 so contains the count of the args already inserted. */ 5345 5346 funcval = (*sf->func) (argbuf_index, argbuf); 5347 5348 /* Pop the spec processing context. */ 5349 argbuf_index = save_argbuf_index; 5350 argbuf_length = save_argbuf_length; 5351 free (argbuf); 5352 argbuf = save_argbuf; 5353 5354 arg_going = save_arg_going; 5355 delete_this_arg = save_delete_this_arg; 5356 this_is_output_file = save_this_is_output_file; 5357 this_is_library_file = save_this_is_library_file; 5358 input_from_pipe = save_input_from_pipe; 5359 suffix_subst = save_suffix_subst; 5360 5361 return funcval; 5362} 5363 5364/* Handle a spec function call of the form: 5365 5366 %:function(args) 5367 5368 ARGS is processed as a spec in a separate context and split into an 5369 argument vector in the normal fashion. The function returns a string 5370 containing a spec which we then process in the caller's context, or 5371 NULL if no processing is required. */ 5372 5373static const char * 5374handle_spec_function (const char *p) 5375{ 5376 char *func, *args; 5377 const char *endp, *funcval; 5378 int count; 5379 5380 processing_spec_function++; 5381 5382 /* Get the function name. */ 5383 for (endp = p; *endp != '\0'; endp++) 5384 { 5385 if (*endp == '(') /* ) */ 5386 break; 5387 /* Only allow [A-Za-z0-9], -, and _ in function names. */ 5388 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_')) 5389 fatal ("malformed spec function name"); 5390 } 5391 if (*endp != '(') /* ) */ 5392 fatal ("no arguments for spec function"); 5393 func = save_string (p, endp - p); 5394 p = ++endp; 5395 5396 /* Get the arguments. */ 5397 for (count = 0; *endp != '\0'; endp++) 5398 { 5399 /* ( */ 5400 if (*endp == ')') 5401 { 5402 if (count == 0) 5403 break; 5404 count--; 5405 } 5406 else if (*endp == '(') /* ) */ 5407 count++; 5408 } 5409 /* ( */ 5410 if (*endp != ')') 5411 fatal ("malformed spec function arguments"); 5412 args = save_string (p, endp - p); 5413 p = ++endp; 5414 5415 /* p now points to just past the end of the spec function expression. */ 5416 5417 funcval = eval_spec_function (func, args); 5418 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0) 5419 p = NULL; 5420 5421 free (func); 5422 free (args); 5423 5424 processing_spec_function--; 5425 5426 return p; 5427} 5428 5429/* Inline subroutine of handle_braces. Returns true if the current 5430 input suffix matches the atom bracketed by ATOM and END_ATOM. */ 5431static inline bool 5432input_suffix_matches (const char *atom, const char *end_atom) 5433{ 5434 return (input_suffix 5435 && !strncmp (input_suffix, atom, end_atom - atom) 5436 && input_suffix[end_atom - atom] == '\0'); 5437} 5438 5439/* Inline subroutine of handle_braces. Returns true if a switch 5440 matching the atom bracketed by ATOM and END_ATOM appeared on the 5441 command line. */ 5442static inline bool 5443switch_matches (const char *atom, const char *end_atom, int starred) 5444{ 5445 int i; 5446 int len = end_atom - atom; 5447 int plen = starred ? len : -1; 5448 5449 for (i = 0; i < n_switches; i++) 5450 if (!strncmp (switches[i].part1, atom, len) 5451 && (starred || switches[i].part1[len] == '\0') 5452 && check_live_switch (i, plen)) 5453 return true; 5454 5455 return false; 5456} 5457 5458/* Inline subroutine of handle_braces. Mark all of the switches which 5459 match ATOM (extends to END_ATOM; STARRED indicates whether there 5460 was a star after the atom) for later processing. */ 5461static inline void 5462mark_matching_switches (const char *atom, const char *end_atom, int starred) 5463{ 5464 int i; 5465 int len = end_atom - atom; 5466 int plen = starred ? len : -1; 5467 5468 for (i = 0; i < n_switches; i++) 5469 if (!strncmp (switches[i].part1, atom, len) 5470 && (starred || switches[i].part1[len] == '\0') 5471 && check_live_switch (i, plen)) 5472 switches[i].ordering = 1; 5473} 5474 5475/* Inline subroutine of handle_braces. Process all the currently 5476 marked switches through give_switch, and clear the marks. */ 5477static inline void 5478process_marked_switches (void) 5479{ 5480 int i; 5481 5482 for (i = 0; i < n_switches; i++) 5483 if (switches[i].ordering == 1) 5484 { 5485 switches[i].ordering = 0; 5486 give_switch (i, 0); 5487 } 5488} 5489 5490/* Handle a %{ ... } construct. P points just inside the leading {. 5491 Returns a pointer one past the end of the brace block, or 0 5492 if we call do_spec_1 and that returns -1. */ 5493 5494static const char * 5495handle_braces (const char *p) 5496{ 5497 const char *atom, *end_atom; 5498 const char *d_atom = NULL, *d_end_atom = NULL; 5499 5500 bool a_is_suffix; 5501 bool a_is_starred; 5502 bool a_is_negated; 5503 bool a_matched; 5504 5505 bool a_must_be_last = false; 5506 bool ordered_set = false; 5507 bool disjunct_set = false; 5508 bool disj_matched = false; 5509 bool disj_starred = true; 5510 bool n_way_choice = false; 5511 bool n_way_matched = false; 5512 5513#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0) 5514 5515 do 5516 { 5517 if (a_must_be_last) 5518 abort (); 5519 5520 /* Scan one "atom" (S in the description above of %{}, possibly 5521 with !, ., or * modifiers). */ 5522 a_matched = a_is_suffix = a_is_starred = a_is_negated = false; 5523 5524 SKIP_WHITE(); 5525 if (*p == '!') 5526 p++, a_is_negated = true; 5527 5528 SKIP_WHITE(); 5529 if (*p == '.') 5530 p++, a_is_suffix = true; 5531 5532 atom = p; 5533 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '=' 5534 || *p == ',' || *p == '.' || *p == '@') 5535 p++; 5536 end_atom = p; 5537 5538 if (*p == '*') 5539 p++, a_is_starred = 1; 5540 5541 SKIP_WHITE(); 5542 if (*p == '&' || *p == '}') 5543 { 5544 /* Substitute the switch(es) indicated by the current atom. */ 5545 ordered_set = true; 5546 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix 5547 || atom == end_atom) 5548 abort (); 5549 5550 mark_matching_switches (atom, end_atom, a_is_starred); 5551 5552 if (*p == '}') 5553 process_marked_switches (); 5554 } 5555 else if (*p == '|' || *p == ':') 5556 { 5557 /* Substitute some text if the current atom appears as a switch 5558 or suffix. */ 5559 disjunct_set = true; 5560 if (ordered_set) 5561 abort (); 5562 5563 if (atom == end_atom) 5564 { 5565 if (!n_way_choice || disj_matched || *p == '|' 5566 || a_is_negated || a_is_suffix || a_is_starred) 5567 abort (); 5568 5569 /* An empty term may appear as the last choice of an 5570 N-way choice set; it means "otherwise". */ 5571 a_must_be_last = true; 5572 disj_matched = !n_way_matched; 5573 disj_starred = false; 5574 } 5575 else 5576 { 5577 if (a_is_suffix && a_is_starred) 5578 abort (); 5579 5580 if (!a_is_starred) 5581 disj_starred = false; 5582 5583 /* Don't bother testing this atom if we already have a 5584 match. */ 5585 if (!disj_matched && !n_way_matched) 5586 { 5587 if (a_is_suffix) 5588 a_matched = input_suffix_matches (atom, end_atom); 5589 else 5590 a_matched = switch_matches (atom, end_atom, a_is_starred); 5591 5592 if (a_matched != a_is_negated) 5593 { 5594 disj_matched = true; 5595 d_atom = atom; 5596 d_end_atom = end_atom; 5597 } 5598 } 5599 } 5600 5601 if (*p == ':') 5602 { 5603 /* Found the body, that is, the text to substitute if the 5604 current disjunction matches. */ 5605 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred, 5606 disj_matched && !n_way_matched); 5607 if (p == 0) 5608 return 0; 5609 5610 /* If we have an N-way choice, reset state for the next 5611 disjunction. */ 5612 if (*p == ';') 5613 { 5614 n_way_choice = true; 5615 n_way_matched |= disj_matched; 5616 disj_matched = false; 5617 disj_starred = true; 5618 d_atom = d_end_atom = NULL; 5619 } 5620 } 5621 } 5622 else 5623 abort (); 5624 } 5625 while (*p++ != '}'); 5626 5627 return p; 5628 5629#undef SKIP_WHITE 5630} 5631 5632/* Subroutine of handle_braces. Scan and process a brace substitution body 5633 (X in the description of %{} syntax). P points one past the colon; 5634 ATOM and END_ATOM bracket the first atom which was found to be true 5635 (present) in the current disjunction; STARRED indicates whether all 5636 the atoms in the current disjunction were starred (for syntax validation); 5637 MATCHED indicates whether the disjunction matched or not, and therefore 5638 whether or not the body is to be processed through do_spec_1 or just 5639 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1 5640 returns -1. */ 5641 5642static const char * 5643process_brace_body (const char *p, const char *atom, const char *end_atom, 5644 int starred, int matched) 5645{ 5646 const char *body, *end_body; 5647 unsigned int nesting_level; 5648 bool have_subst = false; 5649 5650 /* Locate the closing } or ;, honoring nested braces. 5651 Trim trailing whitespace. */ 5652 body = p; 5653 nesting_level = 1; 5654 for (;;) 5655 { 5656 if (*p == '{') 5657 nesting_level++; 5658 else if (*p == '}') 5659 { 5660 if (!--nesting_level) 5661 break; 5662 } 5663 else if (*p == ';' && nesting_level == 1) 5664 break; 5665 else if (*p == '%' && p[1] == '*' && nesting_level == 1) 5666 have_subst = true; 5667 else if (*p == '\0') 5668 abort (); 5669 p++; 5670 } 5671 5672 end_body = p; 5673 while (end_body[-1] == ' ' || end_body[-1] == '\t') 5674 end_body--; 5675 5676 if (have_subst && !starred) 5677 abort (); 5678 5679 if (matched) 5680 { 5681 /* Copy the substitution body to permanent storage and execute it. 5682 If have_subst is false, this is a simple matter of running the 5683 body through do_spec_1... */ 5684 char *string = save_string (body, end_body - body); 5685 if (!have_subst) 5686 { 5687 if (do_spec_1 (string, 0, NULL) < 0) 5688 return 0; 5689 } 5690 else 5691 { 5692 /* ... but if have_subst is true, we have to process the 5693 body once for each matching switch, with %* set to the 5694 variant part of the switch. */ 5695 unsigned int hard_match_len = end_atom - atom; 5696 int i; 5697 5698 for (i = 0; i < n_switches; i++) 5699 if (!strncmp (switches[i].part1, atom, hard_match_len) 5700 && check_live_switch (i, hard_match_len)) 5701 { 5702 if (do_spec_1 (string, 0, 5703 &switches[i].part1[hard_match_len]) < 0) 5704 return 0; 5705 /* Pass any arguments this switch has. */ 5706 give_switch (i, 1); 5707 suffix_subst = NULL; 5708 } 5709 } 5710 } 5711 5712 return p; 5713} 5714 5715/* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch 5716 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*} 5717 spec, or -1 if either exact match or %* is used. 5718 5719 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch 5720 whose value does not begin with "no-" is obsoleted by the same value 5721 with the "no-", similarly for a switch with the "no-" prefix. */ 5722 5723static int 5724check_live_switch (int switchnum, int prefix_length) 5725{ 5726 const char *name = switches[switchnum].part1; 5727 int i; 5728 5729 /* In the common case of {<at-most-one-letter>*}, a negating 5730 switch would always match, so ignore that case. We will just 5731 send the conflicting switches to the compiler phase. */ 5732 if (prefix_length >= 0 && prefix_length <= 1) 5733 return 1; 5734 5735 /* If we already processed this switch and determined if it was 5736 live or not, return our past determination. */ 5737 if (switches[switchnum].live_cond != 0) 5738 return switches[switchnum].live_cond > 0; 5739 5740 /* Now search for duplicate in a manner that depends on the name. */ 5741 switch (*name) 5742 { 5743 case 'O': 5744 for (i = switchnum + 1; i < n_switches; i++) 5745 if (switches[i].part1[0] == 'O') 5746 { 5747 switches[switchnum].validated = 1; 5748 switches[switchnum].live_cond = SWITCH_FALSE; 5749 return 0; 5750 } 5751 break; 5752 5753 case 'W': case 'f': case 'm': 5754 if (! strncmp (name + 1, "no-", 3)) 5755 { 5756 /* We have Xno-YYY, search for XYYY. */ 5757 for (i = switchnum + 1; i < n_switches; i++) 5758 if (switches[i].part1[0] == name[0] 5759 && ! strcmp (&switches[i].part1[1], &name[4])) 5760 { 5761 switches[switchnum].validated = 1; 5762 switches[switchnum].live_cond = SWITCH_FALSE; 5763 return 0; 5764 } 5765 } 5766 else 5767 { 5768 /* We have XYYY, search for Xno-YYY. */ 5769 for (i = switchnum + 1; i < n_switches; i++) 5770 if (switches[i].part1[0] == name[0] 5771 && switches[i].part1[1] == 'n' 5772 && switches[i].part1[2] == 'o' 5773 && switches[i].part1[3] == '-' 5774 && !strcmp (&switches[i].part1[4], &name[1])) 5775 { 5776 switches[switchnum].validated = 1; 5777 switches[switchnum].live_cond = SWITCH_FALSE; 5778 return 0; 5779 } 5780 } 5781 break; 5782 } 5783 5784 /* Otherwise the switch is live. */ 5785 switches[switchnum].live_cond = SWITCH_LIVE; 5786 return 1; 5787} 5788 5789/* Pass a switch to the current accumulating command 5790 in the same form that we received it. 5791 SWITCHNUM identifies the switch; it is an index into 5792 the vector of switches gcc received, which is `switches'. 5793 This cannot fail since it never finishes a command line. 5794 5795 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */ 5796 5797static void 5798give_switch (int switchnum, int omit_first_word) 5799{ 5800 if (switches[switchnum].live_cond == SWITCH_IGNORE) 5801 return; 5802 5803 if (!omit_first_word) 5804 { 5805 do_spec_1 ("-", 0, NULL); 5806 do_spec_1 (switches[switchnum].part1, 1, NULL); 5807 } 5808 5809 if (switches[switchnum].args != 0) 5810 { 5811 const char **p; 5812 for (p = switches[switchnum].args; *p; p++) 5813 { 5814 const char *arg = *p; 5815 5816 do_spec_1 (" ", 0, NULL); 5817 if (suffix_subst) 5818 { 5819 unsigned length = strlen (arg); 5820 int dot = 0; 5821 5822 while (length-- && !IS_DIR_SEPARATOR (arg[length])) 5823 if (arg[length] == '.') 5824 { 5825 ((char *)arg)[length] = 0; 5826 dot = 1; 5827 break; 5828 } 5829 do_spec_1 (arg, 1, NULL); 5830 if (dot) 5831 ((char *)arg)[length] = '.'; 5832 do_spec_1 (suffix_subst, 1, NULL); 5833 } 5834 else 5835 do_spec_1 (arg, 1, NULL); 5836 } 5837 } 5838 5839 do_spec_1 (" ", 0, NULL); 5840 switches[switchnum].validated = 1; 5841} 5842 5843/* Search for a file named NAME trying various prefixes including the 5844 user's -B prefix and some standard ones. 5845 Return the absolute file name found. If nothing is found, return NAME. */ 5846 5847static const char * 5848find_file (const char *name) 5849{ 5850 char *newname; 5851 5852 /* Try multilib_dir if it is defined. */ 5853 if (multilib_os_dir != NULL) 5854 { 5855 newname = find_a_file (&startfile_prefixes, name, R_OK, 1); 5856 5857 /* If we don't find it in the multi library dir, then fall 5858 through and look for it in the normal places. */ 5859 if (newname != NULL) 5860 return newname; 5861 } 5862 5863 newname = find_a_file (&startfile_prefixes, name, R_OK, 0); 5864 return newname ? newname : name; 5865} 5866 5867/* Determine whether a directory exists. If LINKER, return 0 for 5868 certain fixed names not needed by the linker. If not LINKER, it is 5869 only important to return 0 if the host machine has a small ARG_MAX 5870 limit. */ 5871 5872static int 5873is_directory (const char *path1, const char *path2, int linker) 5874{ 5875 int len1 = strlen (path1); 5876 int len2 = strlen (path2); 5877 char *path = alloca (3 + len1 + len2); 5878 char *cp; 5879 struct stat st; 5880 5881#ifndef SMALL_ARG_MAX 5882 if (! linker) 5883 return 1; 5884#endif 5885 5886 /* Construct the path from the two parts. Ensure the string ends with "/.". 5887 The resulting path will be a directory even if the given path is a 5888 symbolic link. */ 5889 memcpy (path, path1, len1); 5890 memcpy (path + len1, path2, len2); 5891 cp = path + len1 + len2; 5892 if (!IS_DIR_SEPARATOR (cp[-1])) 5893 *cp++ = DIR_SEPARATOR; 5894 *cp++ = '.'; 5895 *cp = '\0'; 5896 5897#ifndef FREEBSD_NATIVE 5898 /* Exclude directories that the linker is known to search. */ 5899 if (linker 5900 && ((cp - path == 6 5901 && strcmp (path, concat (dir_separator_str, "lib", 5902 dir_separator_str, ".", NULL)) == 0) 5903 || (cp - path == 10 5904 && strcmp (path, concat (dir_separator_str, "usr", 5905 dir_separator_str, "lib", 5906 dir_separator_str, ".", NULL)) == 0))) 5907 return 0; 5908#endif /* FREEBSD_NATIVE */ 5909 5910 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode)); 5911} 5912 5913/* Set up the various global variables to indicate that we're processing 5914 the input file named FILENAME. */ 5915 5916void 5917set_input (const char *filename) 5918{ 5919 const char *p; 5920 5921 input_filename = filename; 5922 input_filename_length = strlen (input_filename); 5923 5924 input_basename = input_filename; 5925#ifdef HAVE_DOS_BASED_FILE_SYSTEM 5926 /* Skip drive name so 'x:foo' is handled properly. */ 5927 if (input_basename[1] == ':') 5928 input_basename += 2; 5929#endif 5930 for (p = input_basename; *p; p++) 5931 if (IS_DIR_SEPARATOR (*p)) 5932 input_basename = p + 1; 5933 5934 /* Find a suffix starting with the last period, 5935 and set basename_length to exclude that suffix. */ 5936 basename_length = strlen (input_basename); 5937 suffixed_basename_length = basename_length; 5938 p = input_basename + basename_length; 5939 while (p != input_basename && *p != '.') 5940 --p; 5941 if (*p == '.' && p != input_basename) 5942 { 5943 basename_length = p - input_basename; 5944 input_suffix = p + 1; 5945 } 5946 else 5947 input_suffix = ""; 5948 5949 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then 5950 we will need to do a stat on the input_filename. The 5951 INPUT_STAT_SET signals that the stat is needed. */ 5952 input_stat_set = 0; 5953} 5954 5955/* On fatal signals, delete all the temporary files. */ 5956 5957static void 5958fatal_error (int signum) 5959{ 5960 signal (signum, SIG_DFL); 5961 delete_failure_queue (); 5962 delete_temp_files (); 5963 /* Get the same signal again, this time not handled, 5964 so its normal effect occurs. */ 5965 kill (getpid (), signum); 5966} 5967 5968extern int main (int, const char **); 5969 5970int 5971main (int argc, const char **argv) 5972{ 5973 size_t i; 5974 int value; 5975 int linker_was_run = 0; 5976 int num_linker_inputs = 0; 5977 char *explicit_link_files; 5978 char *specs_file; 5979 const char *p; 5980 struct user_specs *uptr; 5981 5982 p = argv[0] + strlen (argv[0]); 5983 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1])) 5984 --p; 5985 programname = p; 5986 5987 xmalloc_set_program_name (programname); 5988 5989#ifdef GCC_DRIVER_HOST_INITIALIZATION 5990 /* Perform host dependent initialization when needed. */ 5991 GCC_DRIVER_HOST_INITIALIZATION; 5992#endif 5993 5994 gcc_init_libintl (); 5995 5996 if (signal (SIGINT, SIG_IGN) != SIG_IGN) 5997 signal (SIGINT, fatal_error); 5998#ifdef SIGHUP 5999 if (signal (SIGHUP, SIG_IGN) != SIG_IGN) 6000 signal (SIGHUP, fatal_error); 6001#endif 6002 if (signal (SIGTERM, SIG_IGN) != SIG_IGN) 6003 signal (SIGTERM, fatal_error); 6004#ifdef SIGPIPE 6005 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN) 6006 signal (SIGPIPE, fatal_error); 6007#endif 6008#ifdef SIGCHLD 6009 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will 6010 receive the signal. A different setting is inheritable */ 6011 signal (SIGCHLD, SIG_DFL); 6012#endif 6013 6014 /* Allocate the argument vector. */ 6015 alloc_args (); 6016 6017 obstack_init (&obstack); 6018 6019 /* Build multilib_select, et. al from the separate lines that make up each 6020 multilib selection. */ 6021 { 6022 const char *const *q = multilib_raw; 6023 int need_space; 6024 6025 obstack_init (&multilib_obstack); 6026 while ((p = *q++) != (char *) 0) 6027 obstack_grow (&multilib_obstack, p, strlen (p)); 6028 6029 obstack_1grow (&multilib_obstack, 0); 6030 multilib_select = obstack_finish (&multilib_obstack); 6031 6032 q = multilib_matches_raw; 6033 while ((p = *q++) != (char *) 0) 6034 obstack_grow (&multilib_obstack, p, strlen (p)); 6035 6036 obstack_1grow (&multilib_obstack, 0); 6037 multilib_matches = obstack_finish (&multilib_obstack); 6038 6039 q = multilib_exclusions_raw; 6040 while ((p = *q++) != (char *) 0) 6041 obstack_grow (&multilib_obstack, p, strlen (p)); 6042 6043 obstack_1grow (&multilib_obstack, 0); 6044 multilib_exclusions = obstack_finish (&multilib_obstack); 6045 6046 need_space = FALSE; 6047 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++) 6048 { 6049 if (need_space) 6050 obstack_1grow (&multilib_obstack, ' '); 6051 obstack_grow (&multilib_obstack, 6052 multilib_defaults_raw[i], 6053 strlen (multilib_defaults_raw[i])); 6054 need_space = TRUE; 6055 } 6056 6057 obstack_1grow (&multilib_obstack, 0); 6058 multilib_defaults = obstack_finish (&multilib_obstack); 6059 } 6060 6061 /* Set up to remember the pathname of gcc and any options 6062 needed for collect. We use argv[0] instead of programname because 6063 we need the complete pathname. */ 6064 obstack_init (&collect_obstack); 6065 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1); 6066 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1); 6067 putenv (obstack_finish (&collect_obstack)); 6068 6069#ifdef INIT_ENVIRONMENT 6070 /* Set up any other necessary machine specific environment variables. */ 6071 putenv (INIT_ENVIRONMENT); 6072#endif 6073 6074 /* Make a table of what switches there are (switches, n_switches). 6075 Make a table of specified input files (infiles, n_infiles). 6076 Decode switches that are handled locally. */ 6077 6078 process_command (argc, argv); 6079 6080 /* Initialize the vector of specs to just the default. 6081 This means one element containing 0s, as a terminator. */ 6082 6083 compilers = xmalloc (sizeof default_compilers); 6084 memcpy (compilers, default_compilers, sizeof default_compilers); 6085 n_compilers = n_default_compilers; 6086 6087 /* Read specs from a file if there is one. */ 6088 6089#ifdef FREEBSD_NATIVE 6090 just_machine_suffix = ""; 6091#else /* FREEBSD_NATIVE */ 6092 machine_suffix = concat (spec_machine, dir_separator_str, 6093 spec_version, dir_separator_str, NULL); 6094 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL); 6095#endif /* FREEBSD_NATIVE */ 6096 6097 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, 0); 6098 /* Read the specs file unless it is a default one. */ 6099 if (specs_file != 0 && strcmp (specs_file, "specs")) 6100 read_specs (specs_file, TRUE); 6101 else 6102 init_spec (); 6103 6104 /* We need to check standard_exec_prefix/just_machine_suffix/specs 6105 for any override of as, ld and libraries. */ 6106 specs_file = (char *) alloca (strlen (FBSD_DATA_PREFIX) 6107 + strlen (just_machine_suffix) 6108 + sizeof ("specs")); 6109 6110 strcpy (specs_file, FBSD_DATA_PREFIX); 6111 strcat (specs_file, just_machine_suffix); 6112 strcat (specs_file, "specs"); 6113 if (access (specs_file, R_OK) == 0) 6114 read_specs (specs_file, TRUE); 6115 6116 /* Process any configure-time defaults specified for the command line 6117 options, via OPTION_DEFAULT_SPECS. */ 6118 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++) 6119 do_option_spec (option_default_specs[i].name, 6120 option_default_specs[i].spec); 6121 6122 /* Process DRIVER_SELF_SPECS, adding any new options to the end 6123 of the command line. */ 6124 6125 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++) 6126 do_self_spec (driver_self_specs[i]); 6127 6128 /* If not cross-compiling, look for executables in the standard 6129 places. */ 6130 if (*cross_compile == '0') 6131 { 6132 if (*md_exec_prefix) 6133 { 6134 add_prefix (&exec_prefixes, md_exec_prefix, "GCC", 6135 PREFIX_PRIORITY_LAST, 0, NULL, 0); 6136 } 6137 } 6138 6139 /* Process sysroot_suffix_spec. */ 6140 if (*sysroot_suffix_spec != 0 6141 && do_spec_2 (sysroot_suffix_spec) == 0) 6142 { 6143 if (argbuf_index > 1) 6144 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC."); 6145 else if (argbuf_index == 1) 6146 target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]); 6147 } 6148 6149 /* Process sysroot_hdrs_suffix_spec. */ 6150 if (*sysroot_hdrs_suffix_spec != 0 6151 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0) 6152 { 6153 if (argbuf_index > 1) 6154 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC."); 6155 else if (argbuf_index == 1) 6156 target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]); 6157 } 6158 6159 /* Look for startfiles in the standard places. */ 6160 if (*startfile_prefix_spec != 0 6161 && do_spec_2 (startfile_prefix_spec) == 0 6162 && do_spec_1 (" ", 0, NULL) == 0) 6163 { 6164 int ndx; 6165 for (ndx = 0; ndx < argbuf_index; ndx++) 6166 add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS", 6167 PREFIX_PRIORITY_LAST, 0, NULL, 1); 6168 } 6169 /* We should eventually get rid of all these and stick to 6170 startfile_prefix_spec exclusively. */ 6171 else if (*cross_compile == '0' || target_system_root) 6172 { 6173 if (*md_exec_prefix) 6174 add_sysrooted_prefix (&startfile_prefixes, md_exec_prefix, "GCC", 6175 PREFIX_PRIORITY_LAST, 0, NULL, 1); 6176 6177 if (*md_startfile_prefix) 6178 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix, 6179 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6180 6181 if (*md_startfile_prefix_1) 6182 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1, 6183 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6184 6185 /* If standard_startfile_prefix is relative, base it on 6186 standard_exec_prefix. This lets us move the installed tree 6187 as a unit. If GCC_EXEC_PREFIX is defined, base 6188 standard_startfile_prefix on that as well. 6189 6190 If the prefix is relative, only search it for native compilers; 6191 otherwise we will search a directory containing host libraries. */ 6192 if (IS_ABSOLUTE_PATH (standard_startfile_prefix)) 6193 add_sysrooted_prefix (&startfile_prefixes, 6194 standard_startfile_prefix, "BINUTILS", 6195 PREFIX_PRIORITY_LAST, 0, NULL, 1); 6196 else if (*cross_compile == '0') 6197 { 6198 if (gcc_exec_prefix) 6199 add_prefix (&startfile_prefixes, 6200 concat (gcc_exec_prefix, machine_suffix, 6201 standard_startfile_prefix, NULL), 6202 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1); 6203 add_prefix (&startfile_prefixes, 6204 concat (standard_exec_prefix, 6205 machine_suffix, 6206 standard_startfile_prefix, NULL), 6207 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1); 6208 } 6209 6210#ifndef FREEBSD_NATIVE 6211 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_1, 6212 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6213 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_2, 6214 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6215#endif /* not FREEBSD_NATIVE */ 6216#if 0 /* Can cause surprises, and one can use -B./ instead. */ 6217 add_prefix (&startfile_prefixes, "./", NULL, 6218 PREFIX_PRIORITY_LAST, 1, NULL, 0); 6219#endif 6220 } 6221 6222 /* Process any user specified specs in the order given on the command 6223 line. */ 6224 for (uptr = user_specs_head; uptr; uptr = uptr->next) 6225 { 6226 char *filename = find_a_file (&startfile_prefixes, uptr->filename, 6227 R_OK, 0); 6228 read_specs (filename ? filename : uptr->filename, FALSE); 6229 } 6230 6231 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */ 6232 if (gcc_exec_prefix) 6233 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str, 6234 spec_version, dir_separator_str, NULL); 6235 6236 /* Now we have the specs. 6237 Set the `valid' bits for switches that match anything in any spec. */ 6238 6239 validate_all_switches (); 6240 6241 /* Now that we have the switches and the specs, set 6242 the subdirectory based on the options. */ 6243 set_multilib_dir (); 6244 6245 /* Warn about any switches that no pass was interested in. */ 6246 6247 for (i = 0; (int) i < n_switches; i++) 6248 if (! switches[i].validated) 6249 error ("unrecognized option `-%s'", switches[i].part1); 6250 6251 /* Obey some of the options. */ 6252 6253 if (print_search_dirs) 6254 { 6255 printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix); 6256 printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0)); 6257 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0)); 6258 return (0); 6259 } 6260 6261 if (print_file_name) 6262 { 6263 printf ("%s\n", find_file (print_file_name)); 6264 return (0); 6265 } 6266 6267 if (print_prog_name) 6268 { 6269 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0); 6270 printf ("%s\n", (newname ? newname : print_prog_name)); 6271 return (0); 6272 } 6273 6274 if (print_multi_lib) 6275 { 6276 print_multilib_info (); 6277 return (0); 6278 } 6279 6280 if (print_multi_directory) 6281 { 6282 if (multilib_dir == NULL) 6283 printf (".\n"); 6284 else 6285 printf ("%s\n", multilib_dir); 6286 return (0); 6287 } 6288 6289 if (print_multi_os_directory) 6290 { 6291 if (multilib_os_dir == NULL) 6292 printf (".\n"); 6293 else 6294 printf ("%s\n", multilib_os_dir); 6295 return (0); 6296 } 6297 6298 if (target_help_flag) 6299 { 6300 /* Print if any target specific options. */ 6301 6302 /* We do not exit here. Instead we have created a fake input file 6303 called 'target-dummy' which needs to be compiled, and we pass this 6304 on to the various sub-processes, along with the --target-help 6305 switch. */ 6306 } 6307 6308 if (print_help_list) 6309 { 6310 display_help (); 6311 6312 if (! verbose_flag) 6313 { 6314 printf (_("\nFor bug reporting instructions, please see:\n")); 6315 printf ("%s.\n", bug_report_url); 6316 6317 return (0); 6318 } 6319 6320 /* We do not exit here. Instead we have created a fake input file 6321 called 'help-dummy' which needs to be compiled, and we pass this 6322 on the various sub-processes, along with the --help switch. */ 6323 } 6324 6325 if (verbose_flag) 6326 { 6327 int n; 6328 const char *thrmod; 6329 6330 notice ("Configured with: %s\n", configuration_arguments); 6331 6332#ifdef THREAD_MODEL_SPEC 6333 /* We could have defined THREAD_MODEL_SPEC to "%*" by default, 6334 but there's no point in doing all this processing just to get 6335 thread_model back. */ 6336 obstack_init (&obstack); 6337 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model); 6338 obstack_1grow (&obstack, '\0'); 6339 thrmod = obstack_finish (&obstack); 6340#else 6341 thrmod = thread_model; 6342#endif 6343 6344 notice ("Thread model: %s\n", thrmod); 6345 6346 /* compiler_version is truncated at the first space when initialized 6347 from version string, so truncate version_string at the first space 6348 before comparing. */ 6349 for (n = 0; version_string[n]; n++) 6350 if (version_string[n] == ' ') 6351 break; 6352 6353 if (! strncmp (version_string, compiler_version, n) 6354 && compiler_version[n] == 0) 6355 notice ("gcc version %s\n", version_string); 6356 else 6357 notice ("gcc driver version %s executing gcc version %s\n", 6358 version_string, compiler_version); 6359 6360 if (n_infiles == 0) 6361 return (0); 6362 } 6363 6364 if (n_infiles == added_libraries) 6365 fatal ("No input files specified"); 6366 6367 /* Make a place to record the compiler output file names 6368 that correspond to the input files. */ 6369 6370 i = n_infiles; 6371 i += lang_specific_extra_outfiles; 6372 outfiles = xcalloc (i, sizeof (char *)); 6373 6374 /* Record which files were specified explicitly as link input. */ 6375 6376 explicit_link_files = xcalloc (1, n_infiles); 6377 6378 if (combine_inputs) 6379 { 6380 int lang_n_infiles = 0; 6381 for (i = 0; (int) i < n_infiles; i++) 6382 { 6383 const char *name = infiles[i].name; 6384 struct compiler *compiler 6385 = lookup_compiler (name, strlen (name), infiles[i].language); 6386 if (compiler == NULL) 6387 error ("%s: linker input file unused because linking not done", 6388 name); 6389 else if (lang_n_infiles > 0 && compiler != input_file_compiler) 6390 fatal ("cannot specify -o with -c or -S and multiple languages"); 6391 else 6392 { 6393 lang_n_infiles++; 6394 input_file_compiler = compiler; 6395 } 6396 } 6397 } 6398 6399 for (i = 0; (int) i < (combine_inputs ? 1 : n_infiles); i++) 6400 { 6401 int this_file_error = 0; 6402 6403 /* Tell do_spec what to substitute for %i. */ 6404 6405 input_file_number = i; 6406 set_input (infiles[i].name); 6407 6408 /* Use the same thing in %o, unless cp->spec says otherwise. */ 6409 6410 outfiles[i] = input_filename; 6411 6412 /* Figure out which compiler from the file's suffix. */ 6413 6414 if (! combine_inputs) 6415 input_file_compiler 6416 = lookup_compiler (infiles[i].name, input_filename_length, 6417 infiles[i].language); 6418 6419 if (input_file_compiler) 6420 { 6421 /* Ok, we found an applicable compiler. Run its spec. */ 6422 6423 if (input_file_compiler->spec[0] == '#') 6424 { 6425 error ("%s: %s compiler not installed on this system", 6426 input_filename, &input_file_compiler->spec[1]); 6427 this_file_error = 1; 6428 } 6429 else 6430 { 6431 value = do_spec (input_file_compiler->spec); 6432 if (value < 0) 6433 this_file_error = 1; 6434 } 6435 } 6436 6437 /* If this file's name does not contain a recognized suffix, 6438 record it as explicit linker input. */ 6439 6440 else 6441 explicit_link_files[i] = 1; 6442 6443 /* Clear the delete-on-failure queue, deleting the files in it 6444 if this compilation failed. */ 6445 6446 if (this_file_error) 6447 { 6448 delete_failure_queue (); 6449 error_count++; 6450 } 6451 /* If this compilation succeeded, don't delete those files later. */ 6452 clear_failure_queue (); 6453 } 6454 6455 /* Reset the output file name to the first input file name, for use 6456 with %b in LINK_SPEC on a target that prefers not to emit a.out 6457 by default. */ 6458 if (n_infiles > 0) 6459 set_input (infiles[0].name); 6460 6461 if (error_count == 0) 6462 { 6463 /* Make sure INPUT_FILE_NUMBER points to first available open 6464 slot. */ 6465 input_file_number = n_infiles; 6466 if (lang_specific_pre_link ()) 6467 error_count++; 6468 } 6469 6470 /* Determine if there are any linker input files. */ 6471 num_linker_inputs = 0; 6472 for (i = 0; (int) i < n_infiles; i++) 6473 if (explicit_link_files[i] || outfiles[i] != NULL) 6474 num_linker_inputs++; 6475 6476 /* Run ld to link all the compiler output files. */ 6477 6478 if (num_linker_inputs > 0 && error_count == 0) 6479 { 6480 int tmp = execution_count; 6481 6482 /* We'll use ld if we can't find collect2. */ 6483 if (! strcmp (linker_name_spec, "collect2")) 6484 { 6485 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, 0); 6486 if (s == NULL) 6487 linker_name_spec = "ld"; 6488 } 6489 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables 6490 for collect. */ 6491 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH"); 6492 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV); 6493 6494 value = do_spec (link_command_spec); 6495 if (value < 0) 6496 error_count = 1; 6497 linker_was_run = (tmp != execution_count); 6498 } 6499 6500 /* If options said don't run linker, 6501 complain about input files to be given to the linker. */ 6502 6503 if (! linker_was_run && error_count == 0) 6504 for (i = 0; (int) i < n_infiles; i++) 6505 if (explicit_link_files[i]) 6506 error ("%s: linker input file unused because linking not done", 6507 outfiles[i]); 6508 6509 /* Delete some or all of the temporary files we made. */ 6510 6511 if (error_count) 6512 delete_failure_queue (); 6513 delete_temp_files (); 6514 6515 if (print_help_list) 6516 { 6517 printf (("\nFor bug reporting instructions, please see:\n")); 6518 printf ("%s\n", bug_report_url); 6519 } 6520 6521 return (signal_count != 0 ? 2 6522 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1) 6523 : 0); 6524} 6525 6526/* Find the proper compilation spec for the file name NAME, 6527 whose length is LENGTH. LANGUAGE is the specified language, 6528 or 0 if this file is to be passed to the linker. */ 6529 6530static struct compiler * 6531lookup_compiler (const char *name, size_t length, const char *language) 6532{ 6533 struct compiler *cp; 6534 6535 /* If this was specified by the user to be a linker input, indicate that. */ 6536 if (language != 0 && language[0] == '*') 6537 return 0; 6538 6539 /* Otherwise, look for the language, if one is spec'd. */ 6540 if (language != 0) 6541 { 6542 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 6543 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language)) 6544 return cp; 6545 6546 error ("language %s not recognized", language); 6547 return 0; 6548 } 6549 6550 /* Look for a suffix. */ 6551 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 6552 { 6553 if (/* The suffix `-' matches only the file name `-'. */ 6554 (!strcmp (cp->suffix, "-") && !strcmp (name, "-")) 6555 || (strlen (cp->suffix) < length 6556 /* See if the suffix matches the end of NAME. */ 6557 && !strcmp (cp->suffix, 6558 name + length - strlen (cp->suffix)) 6559 )) 6560 break; 6561 } 6562 6563#if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM) 6564 /* look again, but case-insensitively this time. */ 6565 if (cp < compilers) 6566 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 6567 { 6568 if (/* The suffix `-' matches only the file name `-'. */ 6569 (!strcmp (cp->suffix, "-") && !strcmp (name, "-")) 6570 || (strlen (cp->suffix) < length 6571 /* See if the suffix matches the end of NAME. */ 6572 && ((!strcmp (cp->suffix, 6573 name + length - strlen (cp->suffix)) 6574 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ")) 6575 && !strcasecmp (cp->suffix, 6576 name + length - strlen (cp->suffix))) 6577 )) 6578 break; 6579 } 6580#endif 6581 6582 if (cp >= compilers) 6583 { 6584 if (cp->spec[0] != '@') 6585 /* A non-alias entry: return it. */ 6586 return cp; 6587 6588 /* An alias entry maps a suffix to a language. 6589 Search for the language; pass 0 for NAME and LENGTH 6590 to avoid infinite recursion if language not found. */ 6591 return lookup_compiler (NULL, 0, cp->spec + 1); 6592 } 6593 return 0; 6594} 6595 6596static char * 6597save_string (const char *s, int len) 6598{ 6599 char *result = xmalloc (len + 1); 6600 6601 memcpy (result, s, len); 6602 result[len] = 0; 6603 return result; 6604} 6605 6606void 6607pfatal_with_name (const char *name) 6608{ 6609 perror_with_name (name); 6610 delete_temp_files (); 6611 exit (1); 6612} 6613 6614static void 6615perror_with_name (const char *name) 6616{ 6617 error ("%s: %s", name, xstrerror (errno)); 6618} 6619 6620static void 6621pfatal_pexecute (const char *errmsg_fmt, const char *errmsg_arg) 6622{ 6623 if (errmsg_arg) 6624 { 6625 int save_errno = errno; 6626 6627 /* Space for trailing '\0' is in %s. */ 6628 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg)); 6629 sprintf (msg, errmsg_fmt, errmsg_arg); 6630 errmsg_fmt = msg; 6631 6632 errno = save_errno; 6633 } 6634 6635 pfatal_with_name (errmsg_fmt); 6636} 6637 6638/* Output an error message and exit. */ 6639 6640void 6641fancy_abort (void) 6642{ 6643 fatal ("internal gcc abort"); 6644} 6645 6646/* Output an error message and exit. */ 6647 6648void 6649fatal (const char *msgid, ...) 6650{ 6651 va_list ap; 6652 6653 va_start (ap, msgid); 6654 6655 fprintf (stderr, "%s: ", programname); 6656 vfprintf (stderr, _(msgid), ap); 6657 va_end (ap); 6658 fprintf (stderr, "\n"); 6659 delete_temp_files (); 6660 exit (1); 6661} 6662 6663void 6664error (const char *msgid, ...) 6665{ 6666 va_list ap; 6667 6668 va_start (ap, msgid); 6669 fprintf (stderr, "%s: ", programname); 6670 vfprintf (stderr, _(msgid), ap); 6671 va_end (ap); 6672 6673 fprintf (stderr, "\n"); 6674} 6675 6676static void 6677notice (const char *msgid, ...) 6678{ 6679 va_list ap; 6680 6681 va_start (ap, msgid); 6682 vfprintf (stderr, _(msgid), ap); 6683 va_end (ap); 6684} 6685 6686static inline void 6687validate_switches_from_spec (const char *spec) 6688{ 6689 const char *p = spec; 6690 char c; 6691 while ((c = *p++)) 6692 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{'))) 6693 /* We have a switch spec. */ 6694 p = validate_switches (p + 1); 6695} 6696 6697static void 6698validate_all_switches (void) 6699{ 6700 struct compiler *comp; 6701 struct spec_list *spec; 6702 6703 for (comp = compilers; comp->spec; comp++) 6704 validate_switches_from_spec (comp->spec); 6705 6706 /* Look through the linked list of specs read from the specs file. */ 6707 for (spec = specs; spec; spec = spec->next) 6708 validate_switches_from_spec (*spec->ptr_spec); 6709 6710 validate_switches_from_spec (link_command_spec); 6711} 6712 6713/* Look at the switch-name that comes after START 6714 and mark as valid all supplied switches that match it. */ 6715 6716static const char * 6717validate_switches (const char *start) 6718{ 6719 const char *p = start; 6720 const char *atom; 6721 size_t len; 6722 int i; 6723 bool suffix = false; 6724 bool starred = false; 6725 6726#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0) 6727 6728next_member: 6729 SKIP_WHITE (); 6730 6731 if (*p == '!') 6732 p++; 6733 6734 SKIP_WHITE (); 6735 if (*p == '.') 6736 suffix = true, p++; 6737 6738 atom = p; 6739 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '=' 6740 || *p == ',' || *p == '.' || *p == '@') 6741 p++; 6742 len = p - atom; 6743 6744 if (*p == '*') 6745 starred = true, p++; 6746 6747 SKIP_WHITE (); 6748 6749 if (!suffix) 6750 { 6751 /* Mark all matching switches as valid. */ 6752 for (i = 0; i < n_switches; i++) 6753 if (!strncmp (switches[i].part1, atom, len) 6754 && (starred || switches[i].part1[len] == 0)) 6755 switches[i].validated = 1; 6756 } 6757 6758 if (*p) p++; 6759 if (*p && (p[-1] == '|' || p[-1] == '&')) 6760 goto next_member; 6761 6762 if (*p && p[-1] == ':') 6763 { 6764 while (*p && *p != ';' && *p != '}') 6765 { 6766 if (*p == '%') 6767 { 6768 p++; 6769 if (*p == '{' || *p == '<') 6770 p = validate_switches (p+1); 6771 else if (p[0] == 'W' && p[1] == '{') 6772 p = validate_switches (p+2); 6773 } 6774 else 6775 p++; 6776 } 6777 6778 if (*p) p++; 6779 if (*p && p[-1] == ';') 6780 goto next_member; 6781 } 6782 6783 return p; 6784#undef SKIP_WHITE 6785} 6786 6787struct mdswitchstr 6788{ 6789 const char *str; 6790 int len; 6791}; 6792 6793static struct mdswitchstr *mdswitches; 6794static int n_mdswitches; 6795 6796/* Check whether a particular argument was used. The first time we 6797 canonicalize the switches to keep only the ones we care about. */ 6798 6799static int 6800used_arg (const char *p, int len) 6801{ 6802 struct mswitchstr 6803 { 6804 const char *str; 6805 const char *replace; 6806 int len; 6807 int rep_len; 6808 }; 6809 6810 static struct mswitchstr *mswitches; 6811 static int n_mswitches; 6812 int i, j; 6813 6814 if (!mswitches) 6815 { 6816 struct mswitchstr *matches; 6817 const char *q; 6818 int cnt = 0; 6819 6820 /* Break multilib_matches into the component strings of string 6821 and replacement string. */ 6822 for (q = multilib_matches; *q != '\0'; q++) 6823 if (*q == ';') 6824 cnt++; 6825 6826 matches = alloca ((sizeof (struct mswitchstr)) * cnt); 6827 i = 0; 6828 q = multilib_matches; 6829 while (*q != '\0') 6830 { 6831 matches[i].str = q; 6832 while (*q != ' ') 6833 { 6834 if (*q == '\0') 6835 abort (); 6836 q++; 6837 } 6838 matches[i].len = q - matches[i].str; 6839 6840 matches[i].replace = ++q; 6841 while (*q != ';' && *q != '\0') 6842 { 6843 if (*q == ' ') 6844 abort (); 6845 q++; 6846 } 6847 matches[i].rep_len = q - matches[i].replace; 6848 i++; 6849 if (*q == ';') 6850 q++; 6851 } 6852 6853 /* Now build a list of the replacement string for switches that we care 6854 about. Make sure we allocate at least one entry. This prevents 6855 xmalloc from calling fatal, and prevents us from re-executing this 6856 block of code. */ 6857 mswitches 6858 = xmalloc (sizeof (struct mswitchstr) 6859 * (n_mdswitches + (n_switches ? n_switches : 1))); 6860 for (i = 0; i < n_switches; i++) 6861 { 6862 int xlen = strlen (switches[i].part1); 6863 for (j = 0; j < cnt; j++) 6864 if (xlen == matches[j].len 6865 && ! strncmp (switches[i].part1, matches[j].str, xlen)) 6866 { 6867 mswitches[n_mswitches].str = matches[j].replace; 6868 mswitches[n_mswitches].len = matches[j].rep_len; 6869 mswitches[n_mswitches].replace = (char *) 0; 6870 mswitches[n_mswitches].rep_len = 0; 6871 n_mswitches++; 6872 break; 6873 } 6874 } 6875 6876 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present 6877 on the command line nor any options mutually incompatible with 6878 them. */ 6879 for (i = 0; i < n_mdswitches; i++) 6880 { 6881 const char *r; 6882 6883 for (q = multilib_options; *q != '\0'; q++) 6884 { 6885 while (*q == ' ') 6886 q++; 6887 6888 r = q; 6889 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0 6890 || strchr (" /", q[mdswitches[i].len]) == NULL) 6891 { 6892 while (*q != ' ' && *q != '/' && *q != '\0') 6893 q++; 6894 if (*q != '/') 6895 break; 6896 q++; 6897 } 6898 6899 if (*q != ' ' && *q != '\0') 6900 { 6901 while (*r != ' ' && *r != '\0') 6902 { 6903 q = r; 6904 while (*q != ' ' && *q != '/' && *q != '\0') 6905 q++; 6906 6907 if (used_arg (r, q - r)) 6908 break; 6909 6910 if (*q != '/') 6911 { 6912 mswitches[n_mswitches].str = mdswitches[i].str; 6913 mswitches[n_mswitches].len = mdswitches[i].len; 6914 mswitches[n_mswitches].replace = (char *) 0; 6915 mswitches[n_mswitches].rep_len = 0; 6916 n_mswitches++; 6917 break; 6918 } 6919 6920 r = q + 1; 6921 } 6922 break; 6923 } 6924 } 6925 } 6926 } 6927 6928 for (i = 0; i < n_mswitches; i++) 6929 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len)) 6930 return 1; 6931 6932 return 0; 6933} 6934 6935static int 6936default_arg (const char *p, int len) 6937{ 6938 int i; 6939 6940 for (i = 0; i < n_mdswitches; i++) 6941 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len)) 6942 return 1; 6943 6944 return 0; 6945} 6946 6947/* Work out the subdirectory to use based on the options. The format of 6948 multilib_select is a list of elements. Each element is a subdirectory 6949 name followed by a list of options followed by a semicolon. The format 6950 of multilib_exclusions is the same, but without the preceding 6951 directory. First gcc will check the exclusions, if none of the options 6952 beginning with an exclamation point are present, and all of the other 6953 options are present, then we will ignore this completely. Passing 6954 that, gcc will consider each multilib_select in turn using the same 6955 rules for matching the options. If a match is found, that subdirectory 6956 will be used. */ 6957 6958static void 6959set_multilib_dir (void) 6960{ 6961 const char *p; 6962 unsigned int this_path_len; 6963 const char *this_path, *this_arg; 6964 const char *start, *end; 6965 int not_arg; 6966 int ok, ndfltok, first; 6967 6968 n_mdswitches = 0; 6969 start = multilib_defaults; 6970 while (*start == ' ' || *start == '\t') 6971 start++; 6972 while (*start != '\0') 6973 { 6974 n_mdswitches++; 6975 while (*start != ' ' && *start != '\t' && *start != '\0') 6976 start++; 6977 while (*start == ' ' || *start == '\t') 6978 start++; 6979 } 6980 6981 if (n_mdswitches) 6982 { 6983 int i = 0; 6984 6985 mdswitches = xmalloc (sizeof (struct mdswitchstr) * n_mdswitches); 6986 for (start = multilib_defaults; *start != '\0'; start = end + 1) 6987 { 6988 while (*start == ' ' || *start == '\t') 6989 start++; 6990 6991 if (*start == '\0') 6992 break; 6993 6994 for (end = start + 1; 6995 *end != ' ' && *end != '\t' && *end != '\0'; end++) 6996 ; 6997 6998 obstack_grow (&multilib_obstack, start, end - start); 6999 obstack_1grow (&multilib_obstack, 0); 7000 mdswitches[i].str = obstack_finish (&multilib_obstack); 7001 mdswitches[i++].len = end - start; 7002 7003 if (*end == '\0') 7004 break; 7005 } 7006 } 7007 7008 p = multilib_exclusions; 7009 while (*p != '\0') 7010 { 7011 /* Ignore newlines. */ 7012 if (*p == '\n') 7013 { 7014 ++p; 7015 continue; 7016 } 7017 7018 /* Check the arguments. */ 7019 ok = 1; 7020 while (*p != ';') 7021 { 7022 if (*p == '\0') 7023 abort (); 7024 7025 if (! ok) 7026 { 7027 ++p; 7028 continue; 7029 } 7030 7031 this_arg = p; 7032 while (*p != ' ' && *p != ';') 7033 { 7034 if (*p == '\0') 7035 abort (); 7036 ++p; 7037 } 7038 7039 if (*this_arg != '!') 7040 not_arg = 0; 7041 else 7042 { 7043 not_arg = 1; 7044 ++this_arg; 7045 } 7046 7047 ok = used_arg (this_arg, p - this_arg); 7048 if (not_arg) 7049 ok = ! ok; 7050 7051 if (*p == ' ') 7052 ++p; 7053 } 7054 7055 if (ok) 7056 return; 7057 7058 ++p; 7059 } 7060 7061 first = 1; 7062 p = multilib_select; 7063 while (*p != '\0') 7064 { 7065 /* Ignore newlines. */ 7066 if (*p == '\n') 7067 { 7068 ++p; 7069 continue; 7070 } 7071 7072 /* Get the initial path. */ 7073 this_path = p; 7074 while (*p != ' ') 7075 { 7076 if (*p == '\0') 7077 abort (); 7078 ++p; 7079 } 7080 this_path_len = p - this_path; 7081 7082 /* Check the arguments. */ 7083 ok = 1; 7084 ndfltok = 1; 7085 ++p; 7086 while (*p != ';') 7087 { 7088 if (*p == '\0') 7089 abort (); 7090 7091 if (! ok) 7092 { 7093 ++p; 7094 continue; 7095 } 7096 7097 this_arg = p; 7098 while (*p != ' ' && *p != ';') 7099 { 7100 if (*p == '\0') 7101 abort (); 7102 ++p; 7103 } 7104 7105 if (*this_arg != '!') 7106 not_arg = 0; 7107 else 7108 { 7109 not_arg = 1; 7110 ++this_arg; 7111 } 7112 7113 /* If this is a default argument, we can just ignore it. 7114 This is true even if this_arg begins with '!'. Beginning 7115 with '!' does not mean that this argument is necessarily 7116 inappropriate for this library: it merely means that 7117 there is a more specific library which uses this 7118 argument. If this argument is a default, we need not 7119 consider that more specific library. */ 7120 ok = used_arg (this_arg, p - this_arg); 7121 if (not_arg) 7122 ok = ! ok; 7123 7124 if (! ok) 7125 ndfltok = 0; 7126 7127 if (default_arg (this_arg, p - this_arg)) 7128 ok = 1; 7129 7130 if (*p == ' ') 7131 ++p; 7132 } 7133 7134 if (ok && first) 7135 { 7136 if (this_path_len != 1 7137 || this_path[0] != '.') 7138 { 7139 char *new_multilib_dir = xmalloc (this_path_len + 1); 7140 char *q; 7141 7142 strncpy (new_multilib_dir, this_path, this_path_len); 7143 new_multilib_dir[this_path_len] = '\0'; 7144 q = strchr (new_multilib_dir, ':'); 7145 if (q != NULL) 7146 *q = '\0'; 7147 multilib_dir = new_multilib_dir; 7148 } 7149 first = 0; 7150 } 7151 7152 if (ndfltok) 7153 { 7154 const char *q = this_path, *end = this_path + this_path_len; 7155 7156 while (q < end && *q != ':') 7157 q++; 7158 if (q < end) 7159 { 7160 char *new_multilib_os_dir = xmalloc (end - q); 7161 memcpy (new_multilib_os_dir, q + 1, end - q - 1); 7162 new_multilib_os_dir[end - q - 1] = '\0'; 7163 multilib_os_dir = new_multilib_os_dir; 7164 break; 7165 } 7166 } 7167 7168 ++p; 7169 } 7170 7171 if (multilib_dir == NULL && multilib_os_dir != NULL 7172 && strcmp (multilib_os_dir, ".") == 0) 7173 { 7174 free ((char *) multilib_os_dir); 7175 multilib_os_dir = NULL; 7176 } 7177 else if (multilib_dir != NULL && multilib_os_dir == NULL) 7178 multilib_os_dir = multilib_dir; 7179} 7180 7181/* Print out the multiple library subdirectory selection 7182 information. This prints out a series of lines. Each line looks 7183 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is 7184 required. Only the desired options are printed out, the negative 7185 matches. The options are print without a leading dash. There are 7186 no spaces to make it easy to use the information in the shell. 7187 Each subdirectory is printed only once. This assumes the ordering 7188 generated by the genmultilib script. Also, we leave out ones that match 7189 the exclusions. */ 7190 7191static void 7192print_multilib_info (void) 7193{ 7194 const char *p = multilib_select; 7195 const char *last_path = 0, *this_path; 7196 int skip; 7197 unsigned int last_path_len = 0; 7198 7199 while (*p != '\0') 7200 { 7201 skip = 0; 7202 /* Ignore newlines. */ 7203 if (*p == '\n') 7204 { 7205 ++p; 7206 continue; 7207 } 7208 7209 /* Get the initial path. */ 7210 this_path = p; 7211 while (*p != ' ') 7212 { 7213 if (*p == '\0') 7214 abort (); 7215 ++p; 7216 } 7217 7218 /* When --disable-multilib was used but target defines 7219 MULTILIB_OSDIRNAMES, entries starting with .: are there just 7220 to find multilib_os_dir, so skip them from output. */ 7221 if (this_path[0] == '.' && this_path[1] == ':') 7222 skip = 1; 7223 7224 /* Check for matches with the multilib_exclusions. We don't bother 7225 with the '!' in either list. If any of the exclusion rules match 7226 all of its options with the select rule, we skip it. */ 7227 { 7228 const char *e = multilib_exclusions; 7229 const char *this_arg; 7230 7231 while (*e != '\0') 7232 { 7233 int m = 1; 7234 /* Ignore newlines. */ 7235 if (*e == '\n') 7236 { 7237 ++e; 7238 continue; 7239 } 7240 7241 /* Check the arguments. */ 7242 while (*e != ';') 7243 { 7244 const char *q; 7245 int mp = 0; 7246 7247 if (*e == '\0') 7248 abort (); 7249 7250 if (! m) 7251 { 7252 ++e; 7253 continue; 7254 } 7255 7256 this_arg = e; 7257 7258 while (*e != ' ' && *e != ';') 7259 { 7260 if (*e == '\0') 7261 abort (); 7262 ++e; 7263 } 7264 7265 q = p + 1; 7266 while (*q != ';') 7267 { 7268 const char *arg; 7269 int len = e - this_arg; 7270 7271 if (*q == '\0') 7272 abort (); 7273 7274 arg = q; 7275 7276 while (*q != ' ' && *q != ';') 7277 { 7278 if (*q == '\0') 7279 abort (); 7280 ++q; 7281 } 7282 7283 if (! strncmp (arg, this_arg, (len < q - arg) ? q - arg : len) || 7284 default_arg (this_arg, e - this_arg)) 7285 { 7286 mp = 1; 7287 break; 7288 } 7289 7290 if (*q == ' ') 7291 ++q; 7292 } 7293 7294 if (! mp) 7295 m = 0; 7296 7297 if (*e == ' ') 7298 ++e; 7299 } 7300 7301 if (m) 7302 { 7303 skip = 1; 7304 break; 7305 } 7306 7307 if (*e != '\0') 7308 ++e; 7309 } 7310 } 7311 7312 if (! skip) 7313 { 7314 /* If this is a duplicate, skip it. */ 7315 skip = (last_path != 0 && (unsigned int) (p - this_path) == last_path_len 7316 && ! strncmp (last_path, this_path, last_path_len)); 7317 7318 last_path = this_path; 7319 last_path_len = p - this_path; 7320 } 7321 7322 /* If this directory requires any default arguments, we can skip 7323 it. We will already have printed a directory identical to 7324 this one which does not require that default argument. */ 7325 if (! skip) 7326 { 7327 const char *q; 7328 7329 q = p + 1; 7330 while (*q != ';') 7331 { 7332 const char *arg; 7333 7334 if (*q == '\0') 7335 abort (); 7336 7337 if (*q == '!') 7338 arg = NULL; 7339 else 7340 arg = q; 7341 7342 while (*q != ' ' && *q != ';') 7343 { 7344 if (*q == '\0') 7345 abort (); 7346 ++q; 7347 } 7348 7349 if (arg != NULL 7350 && default_arg (arg, q - arg)) 7351 { 7352 skip = 1; 7353 break; 7354 } 7355 7356 if (*q == ' ') 7357 ++q; 7358 } 7359 } 7360 7361 if (! skip) 7362 { 7363 const char *p1; 7364 7365 for (p1 = last_path; p1 < p && *p1 != ':'; p1++) 7366 putchar (*p1); 7367 putchar (';'); 7368 } 7369 7370 ++p; 7371 while (*p != ';') 7372 { 7373 int use_arg; 7374 7375 if (*p == '\0') 7376 abort (); 7377 7378 if (skip) 7379 { 7380 ++p; 7381 continue; 7382 } 7383 7384 use_arg = *p != '!'; 7385 7386 if (use_arg) 7387 putchar ('@'); 7388 7389 while (*p != ' ' && *p != ';') 7390 { 7391 if (*p == '\0') 7392 abort (); 7393 if (use_arg) 7394 putchar (*p); 7395 ++p; 7396 } 7397 7398 if (*p == ' ') 7399 ++p; 7400 } 7401 7402 if (! skip) 7403 { 7404 /* If there are extra options, print them now. */ 7405 if (multilib_extra && *multilib_extra) 7406 { 7407 int print_at = TRUE; 7408 const char *q; 7409 7410 for (q = multilib_extra; *q != '\0'; q++) 7411 { 7412 if (*q == ' ') 7413 print_at = TRUE; 7414 else 7415 { 7416 if (print_at) 7417 putchar ('@'); 7418 putchar (*q); 7419 print_at = FALSE; 7420 } 7421 } 7422 } 7423 7424 putchar ('\n'); 7425 } 7426 7427 ++p; 7428 } 7429} 7430 7431/* if-exists built-in spec function. 7432 7433 Checks to see if the file specified by the absolute pathname in 7434 ARGS exists. Returns that pathname if found. 7435 7436 The usual use for this function is to check for a library file 7437 (whose name has been expanded with %s). */ 7438 7439static const char * 7440if_exists_spec_function (int argc, const char **argv) 7441{ 7442 /* Must have only one argument. */ 7443 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK)) 7444 return argv[0]; 7445 7446 return NULL; 7447} 7448 7449/* if-exists-else built-in spec function. 7450 7451 This is like if-exists, but takes an additional argument which 7452 is returned if the first argument does not exist. */ 7453 7454static const char * 7455if_exists_else_spec_function (int argc, const char **argv) 7456{ 7457 /* Must have exactly two arguments. */ 7458 if (argc != 2) 7459 return NULL; 7460 7461 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK)) 7462 return argv[0]; 7463 7464 return argv[1]; 7465}
| 1660#endif 1661 ); 1662 1663 p += 5; 1664 in_sep = 0; 1665 } 1666 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0) 1667 { 1668 /* Ug. We don't know shared library extensions. Hope that 1669 systems that use this form don't do shared libraries. */ 1670 init_gcc_specs (&obstack, 1671#ifdef NO_SHARED_LIBGCC_MULTILIB 1672 "-lgcc_s" 1673#else 1674 "-lgcc_s%M" 1675#endif 1676 , 1677 "libgcc.a%s", 1678 "libgcc_eh.a%s" 1679#ifdef USE_LIBUNWIND_EXCEPTIONS 1680 " -lunwind" 1681#endif 1682 ); 1683 p += 10; 1684 in_sep = 0; 1685 } 1686 else 1687 { 1688 obstack_1grow (&obstack, *p); 1689 in_sep = (*p == ' '); 1690 p += 1; 1691 } 1692 } 1693 1694 obstack_1grow (&obstack, '\0'); 1695 libgcc_spec = obstack_finish (&obstack); 1696 } 1697#endif 1698#ifdef USE_AS_TRADITIONAL_FORMAT 1699 /* Prepend "--traditional-format" to whatever asm_spec we had before. */ 1700 { 1701 static const char tf[] = "--traditional-format "; 1702 obstack_grow (&obstack, tf, sizeof(tf) - 1); 1703 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec)); 1704 asm_spec = obstack_finish (&obstack); 1705 } 1706#endif 1707#ifdef LINK_EH_SPEC 1708 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */ 1709 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1); 1710 obstack_grow0 (&obstack, link_spec, strlen (link_spec)); 1711 link_spec = obstack_finish (&obstack); 1712#endif 1713 1714 specs = sl; 1715} 1716 1717/* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is 1718 removed; If the spec starts with a + then SPEC is added to the end of the 1719 current spec. */ 1720 1721static void 1722set_spec (const char *name, const char *spec) 1723{ 1724 struct spec_list *sl; 1725 const char *old_spec; 1726 int name_len = strlen (name); 1727 int i; 1728 1729 /* If this is the first call, initialize the statically allocated specs. */ 1730 if (!specs) 1731 { 1732 struct spec_list *next = (struct spec_list *) 0; 1733 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--) 1734 { 1735 sl = &static_specs[i]; 1736 sl->next = next; 1737 next = sl; 1738 } 1739 specs = sl; 1740 } 1741 1742 /* See if the spec already exists. */ 1743 for (sl = specs; sl; sl = sl->next) 1744 if (name_len == sl->name_len && !strcmp (sl->name, name)) 1745 break; 1746 1747 if (!sl) 1748 { 1749 /* Not found - make it. */ 1750 sl = xmalloc (sizeof (struct spec_list)); 1751 sl->name = xstrdup (name); 1752 sl->name_len = name_len; 1753 sl->ptr_spec = &sl->ptr; 1754 sl->alloc_p = 0; 1755 *(sl->ptr_spec) = ""; 1756 sl->next = specs; 1757 specs = sl; 1758 } 1759 1760 old_spec = *(sl->ptr_spec); 1761 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1])) 1762 ? concat (old_spec, spec + 1, NULL) 1763 : xstrdup (spec)); 1764 1765#ifdef DEBUG_SPECS 1766 if (verbose_flag) 1767 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec)); 1768#endif 1769 1770 /* Free the old spec. */ 1771 if (old_spec && sl->alloc_p) 1772 free ((void *) old_spec); 1773 1774 sl->alloc_p = 1; 1775} 1776 1777/* Accumulate a command (program name and args), and run it. */ 1778 1779/* Vector of pointers to arguments in the current line of specifications. */ 1780 1781static const char **argbuf; 1782 1783/* Number of elements allocated in argbuf. */ 1784 1785static int argbuf_length; 1786 1787/* Number of elements in argbuf currently in use (containing args). */ 1788 1789static int argbuf_index; 1790 1791/* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated 1792 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for 1793 it here. */ 1794 1795static struct temp_name { 1796 const char *suffix; /* suffix associated with the code. */ 1797 int length; /* strlen (suffix). */ 1798 int unique; /* Indicates whether %g or %u/%U was used. */ 1799 const char *filename; /* associated filename. */ 1800 int filename_length; /* strlen (filename). */ 1801 struct temp_name *next; 1802} *temp_names; 1803 1804/* Number of commands executed so far. */ 1805 1806static int execution_count; 1807 1808/* Number of commands that exited with a signal. */ 1809 1810static int signal_count; 1811 1812/* Name with which this program was invoked. */ 1813 1814static const char *programname; 1815 1816/* Allocate the argument vector. */ 1817 1818static void 1819alloc_args (void) 1820{ 1821 argbuf_length = 10; 1822 argbuf = xmalloc (argbuf_length * sizeof (const char *)); 1823} 1824 1825/* Clear out the vector of arguments (after a command is executed). */ 1826 1827static void 1828clear_args (void) 1829{ 1830 argbuf_index = 0; 1831} 1832 1833/* Add one argument to the vector at the end. 1834 This is done when a space is seen or at the end of the line. 1835 If DELETE_ALWAYS is nonzero, the arg is a filename 1836 and the file should be deleted eventually. 1837 If DELETE_FAILURE is nonzero, the arg is a filename 1838 and the file should be deleted if this compilation fails. */ 1839 1840static void 1841store_arg (const char *arg, int delete_always, int delete_failure) 1842{ 1843 if (argbuf_index + 1 == argbuf_length) 1844 argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *)); 1845 1846 argbuf[argbuf_index++] = arg; 1847 argbuf[argbuf_index] = 0; 1848 1849 if (delete_always || delete_failure) 1850 record_temp_file (arg, delete_always, delete_failure); 1851} 1852 1853/* Load specs from a file name named FILENAME, replacing occurrences of 1854 various different types of line-endings, \r\n, \n\r and just \r, with 1855 a single \n. */ 1856 1857static char * 1858load_specs (const char *filename) 1859{ 1860 int desc; 1861 int readlen; 1862 struct stat statbuf; 1863 char *buffer; 1864 char *buffer_p; 1865 char *specs; 1866 char *specs_p; 1867 1868 if (verbose_flag) 1869 notice ("Reading specs from %s\n", filename); 1870 1871 /* Open and stat the file. */ 1872 desc = open (filename, O_RDONLY, 0); 1873 if (desc < 0) 1874 pfatal_with_name (filename); 1875 if (stat (filename, &statbuf) < 0) 1876 pfatal_with_name (filename); 1877 1878 /* Read contents of file into BUFFER. */ 1879 buffer = xmalloc ((unsigned) statbuf.st_size + 1); 1880 readlen = read (desc, buffer, (unsigned) statbuf.st_size); 1881 if (readlen < 0) 1882 pfatal_with_name (filename); 1883 buffer[readlen] = 0; 1884 close (desc); 1885 1886 specs = xmalloc (readlen + 1); 1887 specs_p = specs; 1888 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++) 1889 { 1890 int skip = 0; 1891 char c = *buffer_p; 1892 if (c == '\r') 1893 { 1894 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */ 1895 skip = 1; 1896 else if (*(buffer_p + 1) == '\n') /* \r\n */ 1897 skip = 1; 1898 else /* \r */ 1899 c = '\n'; 1900 } 1901 if (! skip) 1902 *specs_p++ = c; 1903 } 1904 *specs_p = '\0'; 1905 1906 free (buffer); 1907 return (specs); 1908} 1909 1910/* Read compilation specs from a file named FILENAME, 1911 replacing the default ones. 1912 1913 A suffix which starts with `*' is a definition for 1914 one of the machine-specific sub-specs. The "suffix" should be 1915 *asm, *cc1, *cpp, *link, *startfile, etc. 1916 The corresponding spec is stored in asm_spec, etc., 1917 rather than in the `compilers' vector. 1918 1919 Anything invalid in the file is a fatal error. */ 1920 1921static void 1922read_specs (const char *filename, int main_p) 1923{ 1924 char *buffer; 1925 char *p; 1926 1927 buffer = load_specs (filename); 1928 1929 /* Scan BUFFER for specs, putting them in the vector. */ 1930 p = buffer; 1931 while (1) 1932 { 1933 char *suffix; 1934 char *spec; 1935 char *in, *out, *p1, *p2, *p3; 1936 1937 /* Advance P in BUFFER to the next nonblank nocomment line. */ 1938 p = skip_whitespace (p); 1939 if (*p == 0) 1940 break; 1941 1942 /* Is this a special command that starts with '%'? */ 1943 /* Don't allow this for the main specs file, since it would 1944 encourage people to overwrite it. */ 1945 if (*p == '%' && !main_p) 1946 { 1947 p1 = p; 1948 while (*p && *p != '\n') 1949 p++; 1950 1951 /* Skip '\n'. */ 1952 p++; 1953 1954 if (!strncmp (p1, "%include", sizeof ("%include") - 1) 1955 && (p1[sizeof "%include" - 1] == ' ' 1956 || p1[sizeof "%include" - 1] == '\t')) 1957 { 1958 char *new_filename; 1959 1960 p1 += sizeof ("%include"); 1961 while (*p1 == ' ' || *p1 == '\t') 1962 p1++; 1963 1964 if (*p1++ != '<' || p[-2] != '>') 1965 fatal ("specs %%include syntax malformed after %ld characters", 1966 (long) (p1 - buffer + 1)); 1967 1968 p[-2] = '\0'; 1969 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0); 1970 read_specs (new_filename ? new_filename : p1, FALSE); 1971 continue; 1972 } 1973 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1) 1974 && (p1[sizeof "%include_noerr" - 1] == ' ' 1975 || p1[sizeof "%include_noerr" - 1] == '\t')) 1976 { 1977 char *new_filename; 1978 1979 p1 += sizeof "%include_noerr"; 1980 while (*p1 == ' ' || *p1 == '\t') 1981 p1++; 1982 1983 if (*p1++ != '<' || p[-2] != '>') 1984 fatal ("specs %%include syntax malformed after %ld characters", 1985 (long) (p1 - buffer + 1)); 1986 1987 p[-2] = '\0'; 1988 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0); 1989 if (new_filename) 1990 read_specs (new_filename, FALSE); 1991 else if (verbose_flag) 1992 notice ("could not find specs file %s\n", p1); 1993 continue; 1994 } 1995 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1) 1996 && (p1[sizeof "%rename" - 1] == ' ' 1997 || p1[sizeof "%rename" - 1] == '\t')) 1998 { 1999 int name_len; 2000 struct spec_list *sl; 2001 struct spec_list *newsl; 2002 2003 /* Get original name. */ 2004 p1 += sizeof "%rename"; 2005 while (*p1 == ' ' || *p1 == '\t') 2006 p1++; 2007 2008 if (! ISALPHA ((unsigned char) *p1)) 2009 fatal ("specs %%rename syntax malformed after %ld characters", 2010 (long) (p1 - buffer)); 2011 2012 p2 = p1; 2013 while (*p2 && !ISSPACE ((unsigned char) *p2)) 2014 p2++; 2015 2016 if (*p2 != ' ' && *p2 != '\t') 2017 fatal ("specs %%rename syntax malformed after %ld characters", 2018 (long) (p2 - buffer)); 2019 2020 name_len = p2 - p1; 2021 *p2++ = '\0'; 2022 while (*p2 == ' ' || *p2 == '\t') 2023 p2++; 2024 2025 if (! ISALPHA ((unsigned char) *p2)) 2026 fatal ("specs %%rename syntax malformed after %ld characters", 2027 (long) (p2 - buffer)); 2028 2029 /* Get new spec name. */ 2030 p3 = p2; 2031 while (*p3 && !ISSPACE ((unsigned char) *p3)) 2032 p3++; 2033 2034 if (p3 != p - 1) 2035 fatal ("specs %%rename syntax malformed after %ld characters", 2036 (long) (p3 - buffer)); 2037 *p3 = '\0'; 2038 2039 for (sl = specs; sl; sl = sl->next) 2040 if (name_len == sl->name_len && !strcmp (sl->name, p1)) 2041 break; 2042 2043 if (!sl) 2044 fatal ("specs %s spec was not found to be renamed", p1); 2045 2046 if (strcmp (p1, p2) == 0) 2047 continue; 2048 2049 for (newsl = specs; newsl; newsl = newsl->next) 2050 if (strcmp (newsl->name, p2) == 0) 2051 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'", 2052 filename, p1, p2); 2053 2054 if (verbose_flag) 2055 { 2056 notice ("rename spec %s to %s\n", p1, p2); 2057#ifdef DEBUG_SPECS 2058 notice ("spec is '%s'\n\n", *(sl->ptr_spec)); 2059#endif 2060 } 2061 2062 set_spec (p2, *(sl->ptr_spec)); 2063 if (sl->alloc_p) 2064 free ((void *) *(sl->ptr_spec)); 2065 2066 *(sl->ptr_spec) = ""; 2067 sl->alloc_p = 0; 2068 continue; 2069 } 2070 else 2071 fatal ("specs unknown %% command after %ld characters", 2072 (long) (p1 - buffer)); 2073 } 2074 2075 /* Find the colon that should end the suffix. */ 2076 p1 = p; 2077 while (*p1 && *p1 != ':' && *p1 != '\n') 2078 p1++; 2079 2080 /* The colon shouldn't be missing. */ 2081 if (*p1 != ':') 2082 fatal ("specs file malformed after %ld characters", 2083 (long) (p1 - buffer)); 2084 2085 /* Skip back over trailing whitespace. */ 2086 p2 = p1; 2087 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t')) 2088 p2--; 2089 2090 /* Copy the suffix to a string. */ 2091 suffix = save_string (p, p2 - p); 2092 /* Find the next line. */ 2093 p = skip_whitespace (p1 + 1); 2094 if (p[1] == 0) 2095 fatal ("specs file malformed after %ld characters", 2096 (long) (p - buffer)); 2097 2098 p1 = p; 2099 /* Find next blank line or end of string. */ 2100 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0'))) 2101 p1++; 2102 2103 /* Specs end at the blank line and do not include the newline. */ 2104 spec = save_string (p, p1 - p); 2105 p = p1; 2106 2107 /* Delete backslash-newline sequences from the spec. */ 2108 in = spec; 2109 out = spec; 2110 while (*in != 0) 2111 { 2112 if (in[0] == '\\' && in[1] == '\n') 2113 in += 2; 2114 else if (in[0] == '#') 2115 while (*in && *in != '\n') 2116 in++; 2117 2118 else 2119 *out++ = *in++; 2120 } 2121 *out = 0; 2122 2123 if (suffix[0] == '*') 2124 { 2125 if (! strcmp (suffix, "*link_command")) 2126 link_command_spec = spec; 2127 else 2128 set_spec (suffix + 1, spec); 2129 } 2130 else 2131 { 2132 /* Add this pair to the vector. */ 2133 compilers 2134 = xrealloc (compilers, 2135 (n_compilers + 2) * sizeof (struct compiler)); 2136 2137 compilers[n_compilers].suffix = suffix; 2138 compilers[n_compilers].spec = spec; 2139 n_compilers++; 2140 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]); 2141 } 2142 2143 if (*suffix == 0) 2144 link_command_spec = spec; 2145 } 2146 2147 if (link_command_spec == 0) 2148 fatal ("spec file has no spec for linking"); 2149} 2150 2151/* Record the names of temporary files we tell compilers to write, 2152 and delete them at the end of the run. */ 2153 2154/* This is the common prefix we use to make temp file names. 2155 It is chosen once for each run of this program. 2156 It is substituted into a spec by %g or %j. 2157 Thus, all temp file names contain this prefix. 2158 In practice, all temp file names start with this prefix. 2159 2160 This prefix comes from the envvar TMPDIR if it is defined; 2161 otherwise, from the P_tmpdir macro if that is defined; 2162 otherwise, in /usr/tmp or /tmp; 2163 or finally the current directory if all else fails. */ 2164 2165static const char *temp_filename; 2166 2167/* Length of the prefix. */ 2168 2169static int temp_filename_length; 2170 2171/* Define the list of temporary files to delete. */ 2172 2173struct temp_file 2174{ 2175 const char *name; 2176 struct temp_file *next; 2177}; 2178 2179/* Queue of files to delete on success or failure of compilation. */ 2180static struct temp_file *always_delete_queue; 2181/* Queue of files to delete on failure of compilation. */ 2182static struct temp_file *failure_delete_queue; 2183 2184/* Record FILENAME as a file to be deleted automatically. 2185 ALWAYS_DELETE nonzero means delete it if all compilation succeeds; 2186 otherwise delete it in any case. 2187 FAIL_DELETE nonzero means delete it if a compilation step fails; 2188 otherwise delete it in any case. */ 2189 2190void 2191record_temp_file (const char *filename, int always_delete, int fail_delete) 2192{ 2193 char *const name = xstrdup (filename); 2194 2195 if (always_delete) 2196 { 2197 struct temp_file *temp; 2198 for (temp = always_delete_queue; temp; temp = temp->next) 2199 if (! strcmp (name, temp->name)) 2200 goto already1; 2201 2202 temp = xmalloc (sizeof (struct temp_file)); 2203 temp->next = always_delete_queue; 2204 temp->name = name; 2205 always_delete_queue = temp; 2206 2207 already1:; 2208 } 2209 2210 if (fail_delete) 2211 { 2212 struct temp_file *temp; 2213 for (temp = failure_delete_queue; temp; temp = temp->next) 2214 if (! strcmp (name, temp->name)) 2215 goto already2; 2216 2217 temp = xmalloc (sizeof (struct temp_file)); 2218 temp->next = failure_delete_queue; 2219 temp->name = name; 2220 failure_delete_queue = temp; 2221 2222 already2:; 2223 } 2224} 2225 2226/* Delete all the temporary files whose names we previously recorded. */ 2227 2228static void 2229delete_if_ordinary (const char *name) 2230{ 2231 struct stat st; 2232#ifdef DEBUG 2233 int i, c; 2234 2235 printf ("Delete %s? (y or n) ", name); 2236 fflush (stdout); 2237 i = getchar (); 2238 if (i != '\n') 2239 while ((c = getchar ()) != '\n' && c != EOF) 2240 ; 2241 2242 if (i == 'y' || i == 'Y') 2243#endif /* DEBUG */ 2244 if (stat (name, &st) >= 0 && S_ISREG (st.st_mode)) 2245 if (unlink (name) < 0) 2246 if (verbose_flag) 2247 perror_with_name (name); 2248} 2249 2250static void 2251delete_temp_files (void) 2252{ 2253 struct temp_file *temp; 2254 2255 for (temp = always_delete_queue; temp; temp = temp->next) 2256 delete_if_ordinary (temp->name); 2257 always_delete_queue = 0; 2258} 2259 2260/* Delete all the files to be deleted on error. */ 2261 2262static void 2263delete_failure_queue (void) 2264{ 2265 struct temp_file *temp; 2266 2267 for (temp = failure_delete_queue; temp; temp = temp->next) 2268 delete_if_ordinary (temp->name); 2269} 2270 2271static void 2272clear_failure_queue (void) 2273{ 2274 failure_delete_queue = 0; 2275} 2276 2277/* Build a list of search directories from PATHS. 2278 PREFIX is a string to prepend to the list. 2279 If CHECK_DIR_P is nonzero we ensure the directory exists. 2280 This is used mostly by putenv_from_prefixes so we use `collect_obstack'. 2281 It is also used by the --print-search-dirs flag. */ 2282 2283static char * 2284build_search_list (struct path_prefix *paths, const char *prefix, 2285 int check_dir_p) 2286{ 2287 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0; 2288 int just_suffix_len 2289 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0; 2290 int first_time = TRUE; 2291 struct prefix_list *pprefix; 2292 2293 obstack_grow (&collect_obstack, prefix, strlen (prefix)); 2294 obstack_1grow (&collect_obstack, '='); 2295 2296 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next) 2297 { 2298 int len = strlen (pprefix->prefix); 2299 2300 if (machine_suffix 2301 && (! check_dir_p 2302 || is_directory (pprefix->prefix, machine_suffix, 0))) 2303 { 2304 if (!first_time) 2305 obstack_1grow (&collect_obstack, PATH_SEPARATOR); 2306 2307 first_time = FALSE; 2308 obstack_grow (&collect_obstack, pprefix->prefix, len); 2309 obstack_grow (&collect_obstack, machine_suffix, suffix_len); 2310 } 2311 2312 if (just_machine_suffix 2313 && pprefix->require_machine_suffix == 2 2314 && (! check_dir_p 2315 || is_directory (pprefix->prefix, just_machine_suffix, 0))) 2316 { 2317 if (! first_time) 2318 obstack_1grow (&collect_obstack, PATH_SEPARATOR); 2319 2320 first_time = FALSE; 2321 obstack_grow (&collect_obstack, pprefix->prefix, len); 2322 obstack_grow (&collect_obstack, just_machine_suffix, 2323 just_suffix_len); 2324 } 2325 2326 if (! pprefix->require_machine_suffix) 2327 { 2328 if (! first_time) 2329 obstack_1grow (&collect_obstack, PATH_SEPARATOR); 2330 2331 first_time = FALSE; 2332 obstack_grow (&collect_obstack, pprefix->prefix, len); 2333 } 2334 } 2335 2336 obstack_1grow (&collect_obstack, '\0'); 2337 return obstack_finish (&collect_obstack); 2338} 2339 2340/* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables 2341 for collect. */ 2342 2343static void 2344putenv_from_prefixes (struct path_prefix *paths, const char *env_var) 2345{ 2346 putenv (build_search_list (paths, env_var, 1)); 2347} 2348 2349/* Check whether NAME can be accessed in MODE. This is like access, 2350 except that it never considers directories to be executable. */ 2351 2352static int 2353access_check (const char *name, int mode) 2354{ 2355 if (mode == X_OK) 2356 { 2357 struct stat st; 2358 2359 if (stat (name, &st) < 0 2360 || S_ISDIR (st.st_mode)) 2361 return -1; 2362 } 2363 2364 return access (name, mode); 2365} 2366 2367/* Search for NAME using the prefix list PREFIXES. MODE is passed to 2368 access to check permissions. 2369 Return 0 if not found, otherwise return its name, allocated with malloc. */ 2370 2371static char * 2372find_a_file (struct path_prefix *pprefix, const char *name, int mode, 2373 int multilib) 2374{ 2375 char *temp; 2376 const char *const file_suffix = 2377 ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : ""); 2378 struct prefix_list *pl; 2379 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1; 2380 const char *multilib_name, *multilib_os_name; 2381 2382#ifdef DEFAULT_ASSEMBLER 2383 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0) 2384 return xstrdup (DEFAULT_ASSEMBLER); 2385#endif 2386 2387#ifdef DEFAULT_LINKER 2388 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0) 2389 return xstrdup (DEFAULT_LINKER); 2390#endif 2391 2392 if (machine_suffix) 2393 len += strlen (machine_suffix); 2394 2395 multilib_name = name; 2396 multilib_os_name = name; 2397 if (multilib && multilib_os_dir) 2398 { 2399 int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0; 2400 int len2 = strlen (multilib_os_dir) + 1; 2401 2402 len += len1 > len2 ? len1 : len2; 2403 if (multilib_dir) 2404 multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name, 2405 NULL)); 2406 if (strcmp (multilib_os_dir, ".") != 0) 2407 multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name, 2408 NULL)); 2409 } 2410 2411 temp = xmalloc (len); 2412 2413 /* Determine the filename to execute (special case for absolute paths). */ 2414 2415 if (IS_ABSOLUTE_PATH (name)) 2416 { 2417 if (access (name, mode) == 0) 2418 { 2419 strcpy (temp, name); 2420 return temp; 2421 } 2422 } 2423 else 2424 for (pl = pprefix->plist; pl; pl = pl->next) 2425 { 2426 const char *this_name 2427 = pl->os_multilib ? multilib_os_name : multilib_name; 2428 2429 if (machine_suffix) 2430 { 2431 /* Some systems have a suffix for executable files. 2432 So try appending that first. */ 2433 if (file_suffix[0] != 0) 2434 { 2435 strcpy (temp, pl->prefix); 2436 strcat (temp, machine_suffix); 2437 strcat (temp, multilib_name); 2438 strcat (temp, file_suffix); 2439 if (access_check (temp, mode) == 0) 2440 { 2441 if (pl->used_flag_ptr != 0) 2442 *pl->used_flag_ptr = 1; 2443 return temp; 2444 } 2445 } 2446 2447 /* Now try just the multilib_name. */ 2448 strcpy (temp, pl->prefix); 2449 strcat (temp, machine_suffix); 2450 strcat (temp, multilib_name); 2451 if (access_check (temp, mode) == 0) 2452 { 2453 if (pl->used_flag_ptr != 0) 2454 *pl->used_flag_ptr = 1; 2455 return temp; 2456 } 2457 } 2458 2459 /* Certain prefixes are tried with just the machine type, 2460 not the version. This is used for finding as, ld, etc. */ 2461 if (just_machine_suffix && pl->require_machine_suffix == 2) 2462 { 2463 /* Some systems have a suffix for executable files. 2464 So try appending that first. */ 2465 if (file_suffix[0] != 0) 2466 { 2467 strcpy (temp, pl->prefix); 2468 strcat (temp, just_machine_suffix); 2469 strcat (temp, multilib_name); 2470 strcat (temp, file_suffix); 2471 if (access_check (temp, mode) == 0) 2472 { 2473 if (pl->used_flag_ptr != 0) 2474 *pl->used_flag_ptr = 1; 2475 return temp; 2476 } 2477 } 2478 2479 strcpy (temp, pl->prefix); 2480 strcat (temp, just_machine_suffix); 2481 strcat (temp, multilib_name); 2482 if (access_check (temp, mode) == 0) 2483 { 2484 if (pl->used_flag_ptr != 0) 2485 *pl->used_flag_ptr = 1; 2486 return temp; 2487 } 2488 } 2489 2490 /* Certain prefixes can't be used without the machine suffix 2491 when the machine or version is explicitly specified. */ 2492 if (! pl->require_machine_suffix) 2493 { 2494 /* Some systems have a suffix for executable files. 2495 So try appending that first. */ 2496 if (file_suffix[0] != 0) 2497 { 2498 strcpy (temp, pl->prefix); 2499 strcat (temp, this_name); 2500 strcat (temp, file_suffix); 2501 if (access_check (temp, mode) == 0) 2502 { 2503 if (pl->used_flag_ptr != 0) 2504 *pl->used_flag_ptr = 1; 2505 return temp; 2506 } 2507 } 2508 2509 strcpy (temp, pl->prefix); 2510 strcat (temp, this_name); 2511 if (access_check (temp, mode) == 0) 2512 { 2513 if (pl->used_flag_ptr != 0) 2514 *pl->used_flag_ptr = 1; 2515 return temp; 2516 } 2517 } 2518 } 2519 2520 free (temp); 2521 return 0; 2522} 2523 2524/* Ranking of prefixes in the sort list. -B prefixes are put before 2525 all others. */ 2526 2527enum path_prefix_priority 2528{ 2529 PREFIX_PRIORITY_B_OPT, 2530 PREFIX_PRIORITY_LAST 2531}; 2532 2533/* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending 2534 order according to PRIORITY. Within each PRIORITY, new entries are 2535 appended. 2536 2537 If WARN is nonzero, we will warn if no file is found 2538 through this prefix. WARN should point to an int 2539 which will be set to 1 if this entry is used. 2540 2541 COMPONENT is the value to be passed to update_path. 2542 2543 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without 2544 the complete value of machine_suffix. 2545 2 means try both machine_suffix and just_machine_suffix. */ 2546 2547static void 2548add_prefix (struct path_prefix *pprefix, const char *prefix, 2549 const char *component, /* enum prefix_priority */ int priority, 2550 int require_machine_suffix, int *warn, int os_multilib) 2551{ 2552 struct prefix_list *pl, **prev; 2553 int len; 2554 2555 for (prev = &pprefix->plist; 2556 (*prev) != NULL && (*prev)->priority <= priority; 2557 prev = &(*prev)->next) 2558 ; 2559 2560 /* Keep track of the longest prefix. */ 2561 2562 prefix = update_path (prefix, component); 2563 len = strlen (prefix); 2564 if (len > pprefix->max_len) 2565 pprefix->max_len = len; 2566 2567 pl = xmalloc (sizeof (struct prefix_list)); 2568 pl->prefix = prefix; 2569 pl->require_machine_suffix = require_machine_suffix; 2570 pl->used_flag_ptr = warn; 2571 pl->priority = priority; 2572 pl->os_multilib = os_multilib; 2573 if (warn) 2574 *warn = 0; 2575 2576 /* Insert after PREV. */ 2577 pl->next = (*prev); 2578 (*prev) = pl; 2579} 2580 2581/* Same as add_prefix, but prepending target_system_root to prefix. */ 2582static void 2583add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix, 2584 const char *component, 2585 /* enum prefix_priority */ int priority, 2586 int require_machine_suffix, int *warn, int os_multilib) 2587{ 2588 if (!IS_ABSOLUTE_PATH (prefix)) 2589 abort (); 2590 2591 if (target_system_root) 2592 { 2593 if (target_sysroot_suffix) 2594 prefix = concat (target_sysroot_suffix, prefix, NULL); 2595 prefix = concat (target_system_root, prefix, NULL); 2596 2597 /* We have to override this because GCC's notion of sysroot 2598 moves along with GCC. */ 2599 component = "GCC"; 2600 } 2601 2602 add_prefix (pprefix, prefix, component, priority, 2603 require_machine_suffix, warn, os_multilib); 2604} 2605 2606/* Execute the command specified by the arguments on the current line of spec. 2607 When using pipes, this includes several piped-together commands 2608 with `|' between them. 2609 2610 Return 0 if successful, -1 if failed. */ 2611 2612static int 2613execute (void) 2614{ 2615 int i; 2616 int n_commands; /* # of command. */ 2617 char *string; 2618 struct command 2619 { 2620 const char *prog; /* program name. */ 2621 const char **argv; /* vector of args. */ 2622 int pid; /* pid of process for this command. */ 2623 }; 2624 2625 struct command *commands; /* each command buffer with above info. */ 2626 2627 if (processing_spec_function) 2628 abort (); 2629 2630 /* Count # of piped commands. */ 2631 for (n_commands = 1, i = 0; i < argbuf_index; i++) 2632 if (strcmp (argbuf[i], "|") == 0) 2633 n_commands++; 2634 2635 /* Get storage for each command. */ 2636 commands = alloca (n_commands * sizeof (struct command)); 2637 2638 /* Split argbuf into its separate piped processes, 2639 and record info about each one. 2640 Also search for the programs that are to be run. */ 2641 2642 commands[0].prog = argbuf[0]; /* first command. */ 2643 commands[0].argv = &argbuf[0]; 2644 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0); 2645 2646 if (string) 2647 commands[0].argv[0] = string; 2648 2649 for (n_commands = 1, i = 0; i < argbuf_index; i++) 2650 if (strcmp (argbuf[i], "|") == 0) 2651 { /* each command. */ 2652#if defined (__MSDOS__) || defined (OS2) || defined (VMS) 2653 fatal ("-pipe not supported"); 2654#endif 2655 argbuf[i] = 0; /* termination of command args. */ 2656 commands[n_commands].prog = argbuf[i + 1]; 2657 commands[n_commands].argv = &argbuf[i + 1]; 2658 string = find_a_file (&exec_prefixes, commands[n_commands].prog, 2659 X_OK, 0); 2660 if (string) 2661 commands[n_commands].argv[0] = string; 2662 n_commands++; 2663 } 2664 2665 argbuf[argbuf_index] = 0; 2666 2667 /* If -v, print what we are about to do, and maybe query. */ 2668 2669 if (verbose_flag) 2670 { 2671 /* For help listings, put a blank line between sub-processes. */ 2672 if (print_help_list) 2673 fputc ('\n', stderr); 2674 2675 /* Print each piped command as a separate line. */ 2676 for (i = 0; i < n_commands; i++) 2677 { 2678 const char *const *j; 2679 2680 if (verbose_only_flag) 2681 { 2682 for (j = commands[i].argv; *j; j++) 2683 { 2684 const char *p; 2685 fprintf (stderr, " \""); 2686 for (p = *j; *p; ++p) 2687 { 2688 if (*p == '"' || *p == '\\' || *p == '$') 2689 fputc ('\\', stderr); 2690 fputc (*p, stderr); 2691 } 2692 fputc ('"', stderr); 2693 } 2694 } 2695 else 2696 for (j = commands[i].argv; *j; j++) 2697 fprintf (stderr, " %s", *j); 2698 2699 /* Print a pipe symbol after all but the last command. */ 2700 if (i + 1 != n_commands) 2701 fprintf (stderr, " |"); 2702 fprintf (stderr, "\n"); 2703 } 2704 fflush (stderr); 2705 if (verbose_only_flag != 0) 2706 { 2707 /* verbose_only_flag should act as if the spec was 2708 executed, so increment execution_count before 2709 returning. This prevents spurious warnings about 2710 unused linker input files, etc. */ 2711 execution_count++; 2712 return 0; 2713 } 2714#ifdef DEBUG 2715 notice ("\nGo ahead? (y or n) "); 2716 fflush (stderr); 2717 i = getchar (); 2718 if (i != '\n') 2719 while (getchar () != '\n') 2720 ; 2721 2722 if (i != 'y' && i != 'Y') 2723 return 0; 2724#endif /* DEBUG */ 2725 } 2726 2727#ifdef ENABLE_VALGRIND_CHECKING 2728 /* Run the each command through valgrind. To simplify prepending the 2729 path to valgrind and the option "-q" (for quiet operation unless 2730 something triggers), we allocate a separate argv array. */ 2731 2732 for (i = 0; i < n_commands; i++) 2733 { 2734 const char **argv; 2735 int argc; 2736 int j; 2737 2738 for (argc = 0; commands[i].argv[argc] != NULL; argc++) 2739 ; 2740 2741 argv = alloca ((argc + 3) * sizeof (char *)); 2742 2743 argv[0] = VALGRIND_PATH; 2744 argv[1] = "-q"; 2745 for (j = 2; j < argc + 2; j++) 2746 argv[j] = commands[i].argv[j - 2]; 2747 argv[j] = NULL; 2748 2749 commands[i].argv = argv; 2750 commands[i].prog = argv[0]; 2751 } 2752#endif 2753 2754 /* Run each piped subprocess. */ 2755 2756 for (i = 0; i < n_commands; i++) 2757 { 2758 char *errmsg_fmt, *errmsg_arg; 2759 const char *string = commands[i].argv[0]; 2760 2761 /* For some bizarre reason, the second argument of execvp() is 2762 char *const *, not const char *const *. */ 2763 commands[i].pid = pexecute (string, (char *const *) commands[i].argv, 2764 programname, temp_filename, 2765 &errmsg_fmt, &errmsg_arg, 2766 ((i == 0 ? PEXECUTE_FIRST : 0) 2767 | (i + 1 == n_commands ? PEXECUTE_LAST : 0) 2768 | (string == commands[i].prog 2769 ? PEXECUTE_SEARCH : 0) 2770 | (verbose_flag ? PEXECUTE_VERBOSE : 0))); 2771 2772 if (commands[i].pid == -1) 2773 pfatal_pexecute (errmsg_fmt, errmsg_arg); 2774 2775 if (string != commands[i].prog) 2776 free ((void *) string); 2777 } 2778 2779 execution_count++; 2780 2781 /* Wait for all the subprocesses to finish. 2782 We don't care what order they finish in; 2783 we know that N_COMMANDS waits will get them all. 2784 Ignore subprocesses that we don't know about, 2785 since they can be spawned by the process that exec'ed us. */ 2786 2787 { 2788 int ret_code = 0; 2789#ifdef HAVE_GETRUSAGE 2790 struct timeval d; 2791 double ut = 0.0, st = 0.0; 2792#endif 2793 2794 for (i = 0; i < n_commands;) 2795 { 2796 int j; 2797 int status; 2798 int pid; 2799 2800 pid = pwait (commands[i].pid, &status, 0); 2801 if (pid < 0) 2802 abort (); 2803 2804#ifdef HAVE_GETRUSAGE 2805 if (report_times) 2806 { 2807 /* getrusage returns the total resource usage of all children 2808 up to now. Copy the previous values into prus, get the 2809 current statistics, then take the difference. */ 2810 2811 prus = rus; 2812 getrusage (RUSAGE_CHILDREN, &rus); 2813 d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec; 2814 d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec; 2815 ut = (double) d.tv_sec + (double) d.tv_usec / 1.0e6; 2816 2817 d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec; 2818 d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec; 2819 st = (double) d.tv_sec + (double) d.tv_usec / 1.0e6; 2820 } 2821#endif 2822 2823 for (j = 0; j < n_commands; j++) 2824 if (commands[j].pid == pid) 2825 { 2826 i++; 2827 if (WIFSIGNALED (status)) 2828 { 2829#ifdef SIGPIPE 2830 /* SIGPIPE is a special case. It happens in -pipe mode 2831 when the compiler dies before the preprocessor is 2832 done, or the assembler dies before the compiler is 2833 done. There's generally been an error already, and 2834 this is just fallout. So don't generate another error 2835 unless we would otherwise have succeeded. */ 2836 if (WTERMSIG (status) == SIGPIPE 2837 && (signal_count || greatest_status >= MIN_FATAL_STATUS)) 2838 ; 2839 else 2840#endif 2841 fatal ("\ 2842Internal error: %s (program %s)\n\ 2843Please submit a full bug report.\n\ 2844See %s for instructions.", 2845 strsignal (WTERMSIG (status)), commands[j].prog, 2846 bug_report_url); 2847 signal_count++; 2848 ret_code = -1; 2849 } 2850 else if (WIFEXITED (status) 2851 && WEXITSTATUS (status) >= MIN_FATAL_STATUS) 2852 { 2853 if (WEXITSTATUS (status) > greatest_status) 2854 greatest_status = WEXITSTATUS (status); 2855 ret_code = -1; 2856 } 2857#ifdef HAVE_GETRUSAGE 2858 if (report_times && ut + st != 0) 2859 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st); 2860#endif 2861 break; 2862 } 2863 } 2864 return ret_code; 2865 } 2866} 2867 2868/* Find all the switches given to us 2869 and make a vector describing them. 2870 The elements of the vector are strings, one per switch given. 2871 If a switch uses following arguments, then the `part1' field 2872 is the switch itself and the `args' field 2873 is a null-terminated vector containing the following arguments. 2874 The `live_cond' field is: 2875 0 when initialized 2876 1 if the switch is true in a conditional spec, 2877 -1 if false (overridden by a later switch) 2878 -2 if this switch should be ignored (used in %<S) 2879 The `validated' field is nonzero if any spec has looked at this switch; 2880 if it remains zero at the end of the run, it must be meaningless. */ 2881 2882#define SWITCH_OK 0 2883#define SWITCH_FALSE -1 2884#define SWITCH_IGNORE -2 2885#define SWITCH_LIVE 1 2886 2887struct switchstr 2888{ 2889 const char *part1; 2890 const char **args; 2891 int live_cond; 2892 unsigned char validated; 2893 unsigned char ordering; 2894}; 2895 2896static struct switchstr *switches; 2897 2898static int n_switches; 2899 2900struct infile 2901{ 2902 const char *name; 2903 const char *language; 2904}; 2905 2906/* Also a vector of input files specified. */ 2907 2908static struct infile *infiles; 2909 2910int n_infiles; 2911 2912/* True if multiple input files are being compiled to a single 2913 assembly file. */ 2914 2915static bool combine_inputs; 2916 2917/* This counts the number of libraries added by lang_specific_driver, so that 2918 we can tell if there were any user supplied any files or libraries. */ 2919 2920static int added_libraries; 2921 2922/* And a vector of corresponding output files is made up later. */ 2923 2924const char **outfiles; 2925 2926/* Used to track if none of the -B paths are used. */ 2927static int warn_B; 2928 2929/* Gives value to pass as "warn" to add_prefix for standard prefixes. */ 2930static int *warn_std_ptr = 0; 2931 2932#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 2933 2934/* Convert NAME to a new name if it is the standard suffix. DO_EXE 2935 is true if we should look for an executable suffix. DO_OBJ 2936 is true if we should look for an object suffix. */ 2937 2938static const char * 2939convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED, 2940 int do_obj ATTRIBUTE_UNUSED) 2941{ 2942#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 2943 int i; 2944#endif 2945 int len; 2946 2947 if (name == NULL) 2948 return NULL; 2949 2950 len = strlen (name); 2951 2952#ifdef HAVE_TARGET_OBJECT_SUFFIX 2953 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */ 2954 if (do_obj && len > 2 2955 && name[len - 2] == '.' 2956 && name[len - 1] == 'o') 2957 { 2958 obstack_grow (&obstack, name, len - 2); 2959 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX)); 2960 name = obstack_finish (&obstack); 2961 } 2962#endif 2963 2964#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 2965 /* If there is no filetype, make it the executable suffix (which includes 2966 the "."). But don't get confused if we have just "-o". */ 2967 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-')) 2968 return name; 2969 2970 for (i = len - 1; i >= 0; i--) 2971 if (IS_DIR_SEPARATOR (name[i])) 2972 break; 2973 2974 for (i++; i < len; i++) 2975 if (name[i] == '.') 2976 return name; 2977 2978 obstack_grow (&obstack, name, len); 2979 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX, 2980 strlen (TARGET_EXECUTABLE_SUFFIX)); 2981 name = obstack_finish (&obstack); 2982#endif 2983 2984 return name; 2985} 2986#endif 2987 2988/* Display the command line switches accepted by gcc. */ 2989static void 2990display_help (void) 2991{ 2992 printf (_("Usage: %s [options] file...\n"), programname); 2993 fputs (_("Options:\n"), stdout); 2994 2995 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout); 2996 fputs (_(" --help Display this information\n"), stdout); 2997 fputs (_(" --target-help Display target specific command line options\n"), stdout); 2998 if (! verbose_flag) 2999 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout); 3000 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout); 3001 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout); 3002 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout); 3003 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout); 3004 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout); 3005 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout); 3006 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout); 3007 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout); 3008 fputs (_("\ 3009 -print-multi-lib Display the mapping between command line options and\n\ 3010 multiple library search directories\n"), stdout); 3011 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout); 3012 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout); 3013 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout); 3014 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout); 3015 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout); 3016 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout); 3017 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout); 3018 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout); 3019 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout); 3020 fputs (_(" -time Time the execution of each subprocess\n"), stdout); 3021 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout); 3022 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout); 3023 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout); 3024 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout); 3025 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout); 3026 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout); 3027 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout); 3028 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout); 3029 fputs (_(" -S Compile only; do not assemble or link\n"), stdout); 3030 fputs (_(" -c Compile and assemble, but do not link\n"), stdout); 3031 fputs (_(" -o <file> Place the output into <file>\n"), stdout); 3032 fputs (_("\ 3033 -x <language> Specify the language of the following input files\n\ 3034 Permissible languages include: c c++ assembler none\n\ 3035 'none' means revert to the default behavior of\n\ 3036 guessing the language based on the file's extension\n\ 3037"), stdout); 3038 3039 printf (_("\ 3040\nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\ 3041 passed on to the various sub-processes invoked by %s. In order to pass\n\ 3042 other options on to these processes the -W<letter> options must be used.\n\ 3043"), programname); 3044 3045 /* The rest of the options are displayed by invocations of the various 3046 sub-processes. */ 3047} 3048 3049static void 3050add_preprocessor_option (const char *option, int len) 3051{ 3052 n_preprocessor_options++; 3053 3054 if (! preprocessor_options) 3055 preprocessor_options = xmalloc (n_preprocessor_options * sizeof (char *)); 3056 else 3057 preprocessor_options = xrealloc (preprocessor_options, 3058 n_preprocessor_options * sizeof (char *)); 3059 3060 preprocessor_options [n_preprocessor_options - 1] = 3061 save_string (option, len); 3062} 3063 3064static void 3065add_assembler_option (const char *option, int len) 3066{ 3067 n_assembler_options++; 3068 3069 if (! assembler_options) 3070 assembler_options = xmalloc (n_assembler_options * sizeof (char *)); 3071 else 3072 assembler_options = xrealloc (assembler_options, 3073 n_assembler_options * sizeof (char *)); 3074 3075 assembler_options [n_assembler_options - 1] = save_string (option, len); 3076} 3077 3078static void 3079add_linker_option (const char *option, int len) 3080{ 3081 n_linker_options++; 3082 3083 if (! linker_options) 3084 linker_options = xmalloc (n_linker_options * sizeof (char *)); 3085 else 3086 linker_options = xrealloc (linker_options, 3087 n_linker_options * sizeof (char *)); 3088 3089 linker_options [n_linker_options - 1] = save_string (option, len); 3090} 3091 3092/* Create the vector `switches' and its contents. 3093 Store its length in `n_switches'. */ 3094 3095static void 3096process_command (int argc, const char **argv) 3097{ 3098 int i; 3099 const char *temp; 3100 char *temp1; 3101 const char *spec_lang = 0; 3102 int last_language_n_infiles; 3103 int have_c = 0; 3104 int have_o = 0; 3105 int lang_n_infiles = 0; 3106#ifdef MODIFY_TARGET_NAME 3107 int is_modify_target_name; 3108 int j; 3109#endif 3110 3111 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX"); 3112 3113 n_switches = 0; 3114 n_infiles = 0; 3115 added_libraries = 0; 3116 3117 /* Figure compiler version from version string. */ 3118 3119 compiler_version = temp1 = xstrdup (version_string); 3120 3121 for (; *temp1; ++temp1) 3122 { 3123 if (*temp1 == ' ') 3124 { 3125 *temp1 = '\0'; 3126 break; 3127 } 3128 } 3129 3130 /* If there is a -V or -b option (or both), process it now, before 3131 trying to interpret the rest of the command line. */ 3132 if (argc > 1 && argv[1][0] == '-' 3133 && (argv[1][1] == 'V' || argv[1][1] == 'b')) 3134 { 3135 const char *new_version = DEFAULT_TARGET_VERSION; 3136 const char *new_machine = DEFAULT_TARGET_MACHINE; 3137 const char *progname = argv[0]; 3138 char **new_argv; 3139 char *new_argv0; 3140 int baselen; 3141 3142 while (argc > 1 && argv[1][0] == '-' 3143 && (argv[1][1] == 'V' || argv[1][1] == 'b')) 3144 { 3145 char opt = argv[1][1]; 3146 const char *arg; 3147 if (argv[1][2] != '\0') 3148 { 3149 arg = argv[1] + 2; 3150 argc -= 1; 3151 argv += 1; 3152 } 3153 else if (argc > 2) 3154 { 3155 arg = argv[2]; 3156 argc -= 2; 3157 argv += 2; 3158 } 3159 else 3160 fatal ("`-%c' option must have argument", opt); 3161 if (opt == 'V') 3162 new_version = arg; 3163 else 3164 new_machine = arg; 3165 } 3166 3167 for (baselen = strlen (progname); baselen > 0; baselen--) 3168 if (IS_DIR_SEPARATOR (progname[baselen-1])) 3169 break; 3170 new_argv0 = xmemdup (progname, baselen, 3171 baselen + concat_length (new_version, new_machine, 3172 "-gcc-", NULL) + 1); 3173 strcpy (new_argv0 + baselen, new_machine); 3174 strcat (new_argv0, "-gcc-"); 3175 strcat (new_argv0, new_version); 3176 3177 new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]), 3178 (argc + 1) * sizeof (argv[0])); 3179 new_argv[0] = new_argv0; 3180 3181 execvp (new_argv0, new_argv); 3182 fatal ("couldn't run `%s': %s", new_argv0, xstrerror (errno)); 3183 } 3184 3185 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX, 3186 see if we can create it from the pathname specified in argv[0]. */ 3187 3188 gcc_libexec_prefix = standard_libexec_prefix; 3189#ifndef FREEBSD_NATIVE 3190#ifndef VMS 3191 /* FIXME: make_relative_prefix doesn't yet work for VMS. */ 3192 if (!gcc_exec_prefix) 3193 { 3194 gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix, 3195 standard_exec_prefix); 3196 gcc_libexec_prefix = make_relative_prefix (argv[0], 3197 standard_bindir_prefix, 3198 standard_libexec_prefix); 3199 if (gcc_exec_prefix) 3200 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL)); 3201 } 3202 else 3203 gcc_libexec_prefix = make_relative_prefix (gcc_exec_prefix, 3204 standard_exec_prefix, 3205 standard_libexec_prefix); 3206#else 3207#endif 3208#endif /* not FREEBSD_NATIVE */ 3209 3210 if (gcc_exec_prefix) 3211 { 3212 int len = strlen (gcc_exec_prefix); 3213 3214 if (len > (int) sizeof ("/lib/gcc/") - 1 3215 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1]))) 3216 { 3217 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1; 3218 if (IS_DIR_SEPARATOR (*temp) 3219 && strncmp (temp + 1, "lib", 3) == 0 3220 && IS_DIR_SEPARATOR (temp[4]) 3221 && strncmp (temp + 5, "gcc", 3) == 0) 3222 len -= sizeof ("/lib/gcc/") - 1; 3223 } 3224 3225 set_std_prefix (gcc_exec_prefix, len); 3226 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC", 3227 PREFIX_PRIORITY_LAST, 0, NULL, 0); 3228 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC", 3229 PREFIX_PRIORITY_LAST, 0, NULL, 0); 3230 } 3231 3232 /* COMPILER_PATH and LIBRARY_PATH have values 3233 that are lists of directory names with colons. */ 3234 3235 GET_ENVIRONMENT (temp, "COMPILER_PATH"); 3236 if (temp) 3237 { 3238 const char *startp, *endp; 3239 char *nstore = alloca (strlen (temp) + 3); 3240 3241 startp = endp = temp; 3242 while (1) 3243 { 3244 if (*endp == PATH_SEPARATOR || *endp == 0) 3245 { 3246 strncpy (nstore, startp, endp - startp); 3247 if (endp == startp) 3248 strcpy (nstore, concat (".", dir_separator_str, NULL)); 3249 else if (!IS_DIR_SEPARATOR (endp[-1])) 3250 { 3251 nstore[endp - startp] = DIR_SEPARATOR; 3252 nstore[endp - startp + 1] = 0; 3253 } 3254 else 3255 nstore[endp - startp] = 0; 3256 add_prefix (&exec_prefixes, nstore, 0, 3257 PREFIX_PRIORITY_LAST, 0, NULL, 0); 3258 add_prefix (&include_prefixes, 3259 concat (nstore, "include", NULL), 3260 0, PREFIX_PRIORITY_LAST, 0, NULL, 0); 3261 if (*endp == 0) 3262 break; 3263 endp = startp = endp + 1; 3264 } 3265 else 3266 endp++; 3267 } 3268 } 3269 3270 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV); 3271 if (temp && *cross_compile == '0') 3272 { 3273 const char *startp, *endp; 3274 char *nstore = alloca (strlen (temp) + 3); 3275 3276 startp = endp = temp; 3277 while (1) 3278 { 3279 if (*endp == PATH_SEPARATOR || *endp == 0) 3280 { 3281 strncpy (nstore, startp, endp - startp); 3282 if (endp == startp) 3283 strcpy (nstore, concat (".", dir_separator_str, NULL)); 3284 else if (!IS_DIR_SEPARATOR (endp[-1])) 3285 { 3286 nstore[endp - startp] = DIR_SEPARATOR; 3287 nstore[endp - startp + 1] = 0; 3288 } 3289 else 3290 nstore[endp - startp] = 0; 3291 add_prefix (&startfile_prefixes, nstore, NULL, 3292 PREFIX_PRIORITY_LAST, 0, NULL, 1); 3293 if (*endp == 0) 3294 break; 3295 endp = startp = endp + 1; 3296 } 3297 else 3298 endp++; 3299 } 3300 } 3301 3302 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */ 3303 GET_ENVIRONMENT (temp, "LPATH"); 3304 if (temp && *cross_compile == '0') 3305 { 3306 const char *startp, *endp; 3307 char *nstore = alloca (strlen (temp) + 3); 3308 3309 startp = endp = temp; 3310 while (1) 3311 { 3312 if (*endp == PATH_SEPARATOR || *endp == 0) 3313 { 3314 strncpy (nstore, startp, endp - startp); 3315 if (endp == startp) 3316 strcpy (nstore, concat (".", dir_separator_str, NULL)); 3317 else if (!IS_DIR_SEPARATOR (endp[-1])) 3318 { 3319 nstore[endp - startp] = DIR_SEPARATOR; 3320 nstore[endp - startp + 1] = 0; 3321 } 3322 else 3323 nstore[endp - startp] = 0; 3324 add_prefix (&startfile_prefixes, nstore, NULL, 3325 PREFIX_PRIORITY_LAST, 0, NULL, 1); 3326 if (*endp == 0) 3327 break; 3328 endp = startp = endp + 1; 3329 } 3330 else 3331 endp++; 3332 } 3333 } 3334 3335 /* Options specified as if they appeared on the command line. */ 3336 temp = getenv ("GCC_OPTIONS"); 3337 if ((temp) && (strlen (temp) > 0)) 3338 { 3339 int len; 3340 int optc = 1; 3341 int new_argc; 3342 const char **new_argv; 3343 char *envopts; 3344 3345 while (isspace (*temp)) 3346 temp++; 3347 len = strlen (temp); 3348 envopts = (char *) xmalloc (len + 1); 3349 strcpy (envopts, temp); 3350 3351 for (i = 0; i < (len - 1); i++) 3352 if ((isspace (envopts[i])) && ! (isspace (envopts[i+1]))) 3353 optc++; 3354 3355 new_argv = (const char **) alloca ((optc + argc) * sizeof(char *)); 3356 3357 for (i = 0, new_argc = 1; new_argc <= optc; new_argc++) 3358 { 3359 while (isspace (envopts[i])) 3360 i++; 3361 new_argv[new_argc] = envopts + i; 3362 while (!isspace (envopts[i]) && (envopts[i] != '\0')) 3363 i++; 3364 envopts[i++] = '\0'; 3365 } 3366 for (i = 1; i < argc; i++) 3367 new_argv[new_argc++] = argv[i]; 3368 3369 argv = new_argv; 3370 argc = new_argc; 3371 } 3372 3373 /* Convert new-style -- options to old-style. */ 3374 translate_options (&argc, (const char *const **) &argv); 3375 3376 /* Do language-specific adjustment/addition of flags. */ 3377 lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries); 3378 3379 /* Scan argv twice. Here, the first time, just count how many switches 3380 there will be in their vector, and how many input files in theirs. 3381 Here we also parse the switches that cc itself uses (e.g. -v). */ 3382 3383 for (i = 1; i < argc; i++) 3384 { 3385 if (! strcmp (argv[i], "-dumpspecs")) 3386 { 3387 struct spec_list *sl; 3388 init_spec (); 3389 for (sl = specs; sl; sl = sl->next) 3390 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec)); 3391 if (link_command_spec) 3392 printf ("*link_command:\n%s\n\n", link_command_spec); 3393 exit (0); 3394 } 3395 else if (! strcmp (argv[i], "-dumpversion")) 3396 { 3397 printf ("%s\n", spec_version); 3398 exit (0); 3399 } 3400 else if (! strcmp (argv[i], "-dumpmachine")) 3401 { 3402 printf ("%s\n", spec_machine); 3403 exit (0); 3404 } 3405 else if (strcmp (argv[i], "-fversion") == 0) 3406 { 3407 /* translate_options () has turned --version into -fversion. */ 3408 printf (_("%s (GCC) %s\n"), programname, version_string); 3409 printf ("Copyright %s 2004 Free Software Foundation, Inc.\n", 3410 _("(C)")); 3411 fputs (_("This is free software; see the source for copying conditions. There is NO\n\ 3412warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"), 3413 stdout); 3414 exit (0); 3415 } 3416 else if (strcmp (argv[i], "-fhelp") == 0) 3417 { 3418 /* translate_options () has turned --help into -fhelp. */ 3419 print_help_list = 1; 3420 3421 /* We will be passing a dummy file on to the sub-processes. */ 3422 n_infiles++; 3423 n_switches++; 3424 3425 /* CPP driver cannot obtain switch from cc1_options. */ 3426 if (is_cpp_driver) 3427 add_preprocessor_option ("--help", 6); 3428 add_assembler_option ("--help", 6); 3429 add_linker_option ("--help", 6); 3430 } 3431 else if (strcmp (argv[i], "-ftarget-help") == 0) 3432 { 3433 /* translate_options() has turned --target-help into -ftarget-help. */ 3434 target_help_flag = 1; 3435 3436 /* We will be passing a dummy file on to the sub-processes. */ 3437 n_infiles++; 3438 n_switches++; 3439 3440 /* CPP driver cannot obtain switch from cc1_options. */ 3441 if (is_cpp_driver) 3442 add_preprocessor_option ("--target-help", 13); 3443 add_assembler_option ("--target-help", 13); 3444 add_linker_option ("--target-help", 13); 3445 } 3446 else if (! strcmp (argv[i], "-pass-exit-codes")) 3447 { 3448 pass_exit_codes = 1; 3449 n_switches++; 3450 } 3451 else if (! strcmp (argv[i], "-print-search-dirs")) 3452 print_search_dirs = 1; 3453 else if (! strcmp (argv[i], "-print-libgcc-file-name")) 3454 print_file_name = "libgcc.a"; 3455 else if (! strncmp (argv[i], "-print-file-name=", 17)) 3456 print_file_name = argv[i] + 17; 3457 else if (! strncmp (argv[i], "-print-prog-name=", 17)) 3458 print_prog_name = argv[i] + 17; 3459 else if (! strcmp (argv[i], "-print-multi-lib")) 3460 print_multi_lib = 1; 3461 else if (! strcmp (argv[i], "-print-multi-directory")) 3462 print_multi_directory = 1; 3463 else if (! strcmp (argv[i], "-print-multi-os-directory")) 3464 print_multi_os_directory = 1; 3465 else if (! strncmp (argv[i], "-Wa,", 4)) 3466 { 3467 int prev, j; 3468 /* Pass the rest of this option to the assembler. */ 3469 3470 /* Split the argument at commas. */ 3471 prev = 4; 3472 for (j = 4; argv[i][j]; j++) 3473 if (argv[i][j] == ',') 3474 { 3475 add_assembler_option (argv[i] + prev, j - prev); 3476 prev = j + 1; 3477 } 3478 3479 /* Record the part after the last comma. */ 3480 add_assembler_option (argv[i] + prev, j - prev); 3481 } 3482 else if (! strncmp (argv[i], "-Wp,", 4)) 3483 { 3484 int prev, j; 3485 /* Pass the rest of this option to the preprocessor. */ 3486 3487 /* Split the argument at commas. */ 3488 prev = 4; 3489 for (j = 4; argv[i][j]; j++) 3490 if (argv[i][j] == ',') 3491 { 3492 add_preprocessor_option (argv[i] + prev, j - prev); 3493 prev = j + 1; 3494 } 3495 3496 /* Record the part after the last comma. */ 3497 add_preprocessor_option (argv[i] + prev, j - prev); 3498 } 3499 else if (argv[i][0] == '+' && argv[i][1] == 'e') 3500 /* The +e options to the C++ front-end. */ 3501 n_switches++; 3502 else if (strncmp (argv[i], "-Wl,", 4) == 0) 3503 { 3504 int j; 3505 /* Split the argument at commas. */ 3506 for (j = 3; argv[i][j]; j++) 3507 n_infiles += (argv[i][j] == ','); 3508 } 3509 else if (strcmp (argv[i], "-Xlinker") == 0) 3510 { 3511 if (i + 1 == argc) 3512 fatal ("argument to `-Xlinker' is missing"); 3513 3514 n_infiles++; 3515 i++; 3516 } 3517 else if (strcmp (argv[i], "-Xpreprocessor") == 0) 3518 { 3519 if (i + 1 == argc) 3520 fatal ("argument to `-Xpreprocessor' is missing"); 3521 3522 add_preprocessor_option (argv[i+1], strlen (argv[i+1])); 3523 } 3524 else if (strcmp (argv[i], "-Xassembler") == 0) 3525 { 3526 if (i + 1 == argc) 3527 fatal ("argument to `-Xassembler' is missing"); 3528 3529 add_assembler_option (argv[i+1], strlen (argv[i+1])); 3530 } 3531 else if (strcmp (argv[i], "-l") == 0) 3532 { 3533 if (i + 1 == argc) 3534 fatal ("argument to `-l' is missing"); 3535 3536 n_infiles++; 3537 i++; 3538 } 3539 else if (strncmp (argv[i], "-l", 2) == 0) 3540 n_infiles++; 3541 else if (strcmp (argv[i], "-save-temps") == 0) 3542 { 3543 save_temps_flag = 1; 3544 n_switches++; 3545 } 3546 else if (strcmp (argv[i], "-specs") == 0) 3547 { 3548 struct user_specs *user = xmalloc (sizeof (struct user_specs)); 3549 if (++i >= argc) 3550 fatal ("argument to `-specs' is missing"); 3551 3552 user->next = (struct user_specs *) 0; 3553 user->filename = argv[i]; 3554 if (user_specs_tail) 3555 user_specs_tail->next = user; 3556 else 3557 user_specs_head = user; 3558 user_specs_tail = user; 3559 } 3560 else if (strncmp (argv[i], "-specs=", 7) == 0) 3561 { 3562 struct user_specs *user = xmalloc (sizeof (struct user_specs)); 3563 if (strlen (argv[i]) == 7) 3564 fatal ("argument to `-specs=' is missing"); 3565 3566 user->next = (struct user_specs *) 0; 3567 user->filename = argv[i] + 7; 3568 if (user_specs_tail) 3569 user_specs_tail->next = user; 3570 else 3571 user_specs_head = user; 3572 user_specs_tail = user; 3573 } 3574 else if (strcmp (argv[i], "-time") == 0) 3575 report_times = 1; 3576 else if (strcmp (argv[i], "-pipe") == 0) 3577 { 3578 /* -pipe has to go into the switches array as well as 3579 setting a flag. */ 3580 use_pipes = 1; 3581 n_switches++; 3582 } 3583 else if (strcmp (argv[i], "-###") == 0) 3584 { 3585 /* This is similar to -v except that there is no execution 3586 of the commands and the echoed arguments are quoted. It 3587 is intended for use in shell scripts to capture the 3588 driver-generated command line. */ 3589 verbose_only_flag++; 3590 verbose_flag++; 3591 } 3592 else if (argv[i][0] == '-' && argv[i][1] != 0) 3593 { 3594 const char *p = &argv[i][1]; 3595 int c = *p; 3596 3597 switch (c) 3598 { 3599 case 'b': 3600 case 'V': 3601 fatal ("`-%c' must come at the start of the command line", c); 3602 break; 3603 3604 case 'B': 3605 { 3606 const char *value; 3607 int len; 3608 3609 if (p[1] == 0 && i + 1 == argc) 3610 fatal ("argument to `-B' is missing"); 3611 if (p[1] == 0) 3612 value = argv[++i]; 3613 else 3614 value = p + 1; 3615 3616 len = strlen (value); 3617 3618 /* Catch the case where the user has forgotten to append a 3619 directory separator to the path. Note, they may be using 3620 -B to add an executable name prefix, eg "i386-elf-", in 3621 order to distinguish between multiple installations of 3622 GCC in the same directory. Hence we must check to see 3623 if appending a directory separator actually makes a 3624 valid directory name. */ 3625 if (! IS_DIR_SEPARATOR (value [len - 1]) 3626 && is_directory (value, "", 0)) 3627 { 3628 char *tmp = xmalloc (len + 2); 3629 strcpy (tmp, value); 3630 tmp[len] = DIR_SEPARATOR; 3631 tmp[++ len] = 0; 3632 value = tmp; 3633 } 3634 3635 /* As a kludge, if the arg is "[foo/]stageN/", just 3636 add "[foo/]include" to the include prefix. */ 3637 if ((len == 7 3638 || (len > 7 3639 && (IS_DIR_SEPARATOR (value[len - 8])))) 3640 && strncmp (value + len - 7, "stage", 5) == 0 3641 && ISDIGIT (value[len - 2]) 3642 && (IS_DIR_SEPARATOR (value[len - 1]))) 3643 { 3644 if (len == 7) 3645 add_prefix (&include_prefixes, "include", NULL, 3646 PREFIX_PRIORITY_B_OPT, 0, NULL, 0); 3647 else 3648 { 3649 char * string = xmalloc (len + 1); 3650 3651 strncpy (string, value, len - 7); 3652 strcpy (string + len - 7, "include"); 3653 add_prefix (&include_prefixes, string, NULL, 3654 PREFIX_PRIORITY_B_OPT, 0, NULL, 0); 3655 } 3656 } 3657 3658 add_prefix (&exec_prefixes, value, NULL, 3659 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0); 3660 add_prefix (&startfile_prefixes, value, NULL, 3661 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0); 3662 add_prefix (&include_prefixes, concat (value, "include", NULL), 3663 NULL, PREFIX_PRIORITY_B_OPT, 0, NULL, 0); 3664 n_switches++; 3665 } 3666 break; 3667 3668 case 'v': /* Print our subcommands and print versions. */ 3669 n_switches++; 3670 /* If they do anything other than exactly `-v', don't set 3671 verbose_flag; rather, continue on to give the error. */ 3672 if (p[1] != 0) 3673 break; 3674 verbose_flag++; 3675 break; 3676 3677 case 'S': 3678 case 'c': 3679 if (p[1] == 0) 3680 { 3681 have_c = 1; 3682 n_switches++; 3683 break; 3684 } 3685 goto normal_switch; 3686 3687 case 'o': 3688 have_o = 1; 3689#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) 3690 if (! have_c) 3691 { 3692 int skip; 3693 3694 /* Forward scan, just in case -S or -c is specified 3695 after -o. */ 3696 int j = i + 1; 3697 if (p[1] == 0) 3698 ++j; 3699 while (j < argc) 3700 { 3701 if (argv[j][0] == '-') 3702 { 3703 if (SWITCH_CURTAILS_COMPILATION (argv[j][1]) 3704 && argv[j][2] == 0) 3705 { 3706 have_c = 1; 3707 break; 3708 } 3709 else if ((skip = SWITCH_TAKES_ARG (argv[j][1]))) 3710 j += skip - (argv[j][2] != 0); 3711 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1))) 3712 j += skip; 3713 } 3714 j++; 3715 } 3716 } 3717#endif 3718#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX) 3719 if (p[1] == 0) 3720 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0); 3721 else 3722 argv[i] = convert_filename (argv[i], ! have_c, 0); 3723#endif 3724 goto normal_switch; 3725 3726 default: 3727 normal_switch: 3728 3729#ifdef MODIFY_TARGET_NAME 3730 is_modify_target_name = 0; 3731 3732 for (j = 0; j < ARRAY_SIZE (modify_target); j++) 3733 if (! strcmp (argv[i], modify_target[j].sw)) 3734 { 3735 char *new_name = xmalloc (strlen (modify_target[j].str) 3736 + strlen (spec_machine)); 3737 const char *p, *r; 3738 char *q; 3739 int made_addition = 0; 3740 3741 is_modify_target_name = 1; 3742 for (p = spec_machine, q = new_name; *p != 0; ) 3743 { 3744 if (modify_target[j].add_del == DELETE 3745 && (! strncmp (q, modify_target[j].str, 3746 strlen (modify_target[j].str)))) 3747 p += strlen (modify_target[j].str); 3748 else if (modify_target[j].add_del == ADD 3749 && ! made_addition && *p == '-') 3750 { 3751 for (r = modify_target[j].str; *r != 0; ) 3752 *q++ = *r++; 3753 made_addition = 1; 3754 } 3755 3756 *q++ = *p++; 3757 } 3758 3759 spec_machine = new_name; 3760 } 3761 3762 if (is_modify_target_name) 3763 break; 3764#endif 3765 3766 n_switches++; 3767 3768 if (SWITCH_TAKES_ARG (c) > (p[1] != 0)) 3769 i += SWITCH_TAKES_ARG (c) - (p[1] != 0); 3770 else if (WORD_SWITCH_TAKES_ARG (p)) 3771 i += WORD_SWITCH_TAKES_ARG (p); 3772 } 3773 } 3774 else 3775 { 3776 n_infiles++; 3777 lang_n_infiles++; 3778 } 3779 } 3780 3781 combine_inputs = (have_c && have_o && lang_n_infiles > 1); 3782 3783 if ((save_temps_flag || report_times) && use_pipes) 3784 { 3785 /* -save-temps overrides -pipe, so that temp files are produced */ 3786 if (save_temps_flag) 3787 error ("warning: -pipe ignored because -save-temps specified"); 3788 /* -time overrides -pipe because we can't get correct stats when 3789 multiple children are running at once. */ 3790 else if (report_times) 3791 error ("warning: -pipe ignored because -time specified"); 3792 3793 use_pipes = 0; 3794 } 3795 3796 /* Set up the search paths before we go looking for config files. */ 3797 3798 /* These come before the md prefixes so that we will find gcc's subcommands 3799 (such as cpp) rather than those of the host system. */ 3800 /* Use 2 as fourth arg meaning try just the machine as a suffix, 3801 as well as trying the machine and the version. */ 3802#ifdef FREEBSD_NATIVE 3803 add_prefix (&exec_prefixes, PREFIX"/bin/", "BINUTILS", 3804 PREFIX_PRIORITY_LAST, 0, warn_std_ptr, 0); 3805#endif /* FREEBSD_NATIVE */ 3806#ifndef OS2 3807 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC", 3808 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0); 3809 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS", 3810 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3811#ifndef FREEBSD_NATIVE 3812 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS", 3813 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3814 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS", 3815 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3816 add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS", 3817 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0); 3818#endif /* FREEBSD_NATIVE */ 3819#endif 3820 3821#ifndef FREEBSD_NATIVE 3822 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS", 3823 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0); 3824 add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS", 3825 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0); 3826#endif /* not FREEBSD_NATIVE */ 3827 3828 tooldir_prefix = concat (tooldir_base_prefix, spec_machine, 3829 dir_separator_str, NULL); 3830 3831 /* If tooldir is relative, base it on exec_prefixes. A relative 3832 tooldir lets us move the installed tree as a unit. 3833 3834 If GCC_EXEC_PREFIX is defined, then we want to add two relative 3835 directories, so that we can search both the user specified directory 3836 and the standard place. */ 3837 3838 if (!IS_ABSOLUTE_PATH (tooldir_prefix)) 3839 { 3840 if (gcc_exec_prefix) 3841 { 3842 char *gcc_exec_tooldir_prefix 3843 = concat (gcc_exec_prefix, spec_machine, dir_separator_str, 3844 spec_version, dir_separator_str, tooldir_prefix, NULL); 3845 3846 add_prefix (&exec_prefixes, 3847 concat (gcc_exec_tooldir_prefix, "bin", 3848 dir_separator_str, NULL), 3849 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 0); 3850 add_prefix (&startfile_prefixes, 3851 concat (gcc_exec_tooldir_prefix, "lib", 3852 dir_separator_str, NULL), 3853 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1); 3854 } 3855 3856 tooldir_prefix = concat (standard_exec_prefix, spec_machine, 3857 dir_separator_str, spec_version, 3858 dir_separator_str, tooldir_prefix, NULL); 3859 } 3860 3861#ifndef FREEBSD_NATIVE 3862 add_prefix (&exec_prefixes, 3863 concat (tooldir_prefix, "bin", dir_separator_str, NULL), 3864 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 0); 3865 add_prefix (&startfile_prefixes, 3866 concat (tooldir_prefix, "lib", dir_separator_str, NULL), 3867 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1); 3868 3869#if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS) 3870 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix, 3871 then consider it to relocate with the rest of the GCC installation 3872 if GCC_EXEC_PREFIX is set. 3873 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */ 3874 if (target_system_root && gcc_exec_prefix) 3875 { 3876 char *tmp_prefix = make_relative_prefix (argv[0], 3877 standard_bindir_prefix, 3878 target_system_root); 3879 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0) 3880 { 3881 target_system_root = tmp_prefix; 3882 target_system_root_changed = 1; 3883 } 3884 } 3885#endif 3886#endif /* FREEBSD_NATIVE */ 3887 3888 /* More prefixes are enabled in main, after we read the specs file 3889 and determine whether this is cross-compilation or not. */ 3890 3891 /* Then create the space for the vectors and scan again. */ 3892 3893 switches = xmalloc ((n_switches + 1) * sizeof (struct switchstr)); 3894 infiles = xmalloc ((n_infiles + 1) * sizeof (struct infile)); 3895 n_switches = 0; 3896 n_infiles = 0; 3897 last_language_n_infiles = -1; 3898 3899 /* This, time, copy the text of each switch and store a pointer 3900 to the copy in the vector of switches. 3901 Store all the infiles in their vector. */ 3902 3903 for (i = 1; i < argc; i++) 3904 { 3905 /* Just skip the switches that were handled by the preceding loop. */ 3906#ifdef MODIFY_TARGET_NAME 3907 is_modify_target_name = 0; 3908 3909 for (j = 0; j < ARRAY_SIZE (modify_target); j++) 3910 if (! strcmp (argv[i], modify_target[j].sw)) 3911 is_modify_target_name = 1; 3912 3913 if (is_modify_target_name) 3914 ; 3915 else 3916#endif 3917 if (! strncmp (argv[i], "-Wa,", 4)) 3918 ; 3919 else if (! strncmp (argv[i], "-Wp,", 4)) 3920 ; 3921 else if (! strcmp (argv[i], "-pass-exit-codes")) 3922 ; 3923 else if (! strcmp (argv[i], "-print-search-dirs")) 3924 ; 3925 else if (! strcmp (argv[i], "-print-libgcc-file-name")) 3926 ; 3927 else if (! strncmp (argv[i], "-print-file-name=", 17)) 3928 ; 3929 else if (! strncmp (argv[i], "-print-prog-name=", 17)) 3930 ; 3931 else if (! strcmp (argv[i], "-print-multi-lib")) 3932 ; 3933 else if (! strcmp (argv[i], "-print-multi-directory")) 3934 ; 3935 else if (! strcmp (argv[i], "-print-multi-os-directory")) 3936 ; 3937 else if (! strcmp (argv[i], "-ftarget-help")) 3938 ; 3939 else if (! strcmp (argv[i], "-fhelp")) 3940 ; 3941 else if (argv[i][0] == '+' && argv[i][1] == 'e') 3942 { 3943 /* Compensate for the +e options to the C++ front-end; 3944 they're there simply for cfront call-compatibility. We do 3945 some magic in default_compilers to pass them down properly. 3946 Note we deliberately start at the `+' here, to avoid passing 3947 -e0 or -e1 down into the linker. */ 3948 switches[n_switches].part1 = &argv[i][0]; 3949 switches[n_switches].args = 0; 3950 switches[n_switches].live_cond = SWITCH_OK; 3951 switches[n_switches].validated = 0; 3952 n_switches++; 3953 } 3954 else if (strncmp (argv[i], "-Wl,", 4) == 0) 3955 { 3956 int prev, j; 3957 /* Split the argument at commas. */ 3958 prev = 4; 3959 for (j = 4; argv[i][j]; j++) 3960 if (argv[i][j] == ',') 3961 { 3962 infiles[n_infiles].language = "*"; 3963 infiles[n_infiles++].name 3964 = save_string (argv[i] + prev, j - prev); 3965 prev = j + 1; 3966 } 3967 /* Record the part after the last comma. */ 3968 infiles[n_infiles].language = "*"; 3969 infiles[n_infiles++].name = argv[i] + prev; 3970 } 3971 else if (strcmp (argv[i], "-Xlinker") == 0) 3972 { 3973 infiles[n_infiles].language = "*"; 3974 infiles[n_infiles++].name = argv[++i]; 3975 } 3976 else if (strcmp (argv[i], "-Xassembler") == 0) 3977 { 3978 infiles[n_infiles].language = "*"; 3979 infiles[n_infiles++].name = argv[++i]; 3980 } 3981 else if (strcmp (argv[i], "-Xpreprocessor") == 0) 3982 { 3983 infiles[n_infiles].language = "*"; 3984 infiles[n_infiles++].name = argv[++i]; 3985 } 3986 else if (strcmp (argv[i], "-l") == 0) 3987 { /* POSIX allows separation of -l and the lib arg; 3988 canonicalize by concatenating -l with its arg */ 3989 infiles[n_infiles].language = "*"; 3990 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL); 3991 } 3992 else if (strncmp (argv[i], "-l", 2) == 0) 3993 { 3994 infiles[n_infiles].language = "*"; 3995 infiles[n_infiles++].name = argv[i]; 3996 } 3997 else if (strcmp (argv[i], "-specs") == 0) 3998 i++; 3999 else if (strncmp (argv[i], "-specs=", 7) == 0) 4000 ; 4001 else if (strcmp (argv[i], "-time") == 0) 4002 ; 4003 else if (strcmp (argv[i], "-###") == 0) 4004 ; 4005 else if (argv[i][0] == '-' && argv[i][1] != 0) 4006 { 4007 const char *p = &argv[i][1]; 4008 int c = *p; 4009 4010 if (c == 'x') 4011 { 4012 if (p[1] == 0 && i + 1 == argc) 4013 fatal ("argument to `-x' is missing"); 4014 if (p[1] == 0) 4015 spec_lang = argv[++i]; 4016 else 4017 spec_lang = p + 1; 4018 if (! strcmp (spec_lang, "none")) 4019 /* Suppress the warning if -xnone comes after the last input 4020 file, because alternate command interfaces like g++ might 4021 find it useful to place -xnone after each input file. */ 4022 spec_lang = 0; 4023 else 4024 last_language_n_infiles = n_infiles; 4025 continue; 4026 } 4027 switches[n_switches].part1 = p; 4028 /* Deal with option arguments in separate argv elements. */ 4029 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0)) 4030 || WORD_SWITCH_TAKES_ARG (p)) 4031 { 4032 int j = 0; 4033 int n_args = WORD_SWITCH_TAKES_ARG (p); 4034 4035 if (n_args == 0) 4036 { 4037 /* Count only the option arguments in separate argv elements. */ 4038 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0); 4039 } 4040 if (i + n_args >= argc) 4041 fatal ("argument to `-%s' is missing", p); 4042 switches[n_switches].args 4043 = xmalloc ((n_args + 1) * sizeof(const char *)); 4044 while (j < n_args) 4045 switches[n_switches].args[j++] = argv[++i]; 4046 /* Null-terminate the vector. */ 4047 switches[n_switches].args[j] = 0; 4048 } 4049 else if (strchr (switches_need_spaces, c)) 4050 { 4051 /* On some systems, ld cannot handle some options without 4052 a space. So split the option from its argument. */ 4053 char *part1 = xmalloc (2); 4054 part1[0] = c; 4055 part1[1] = '\0'; 4056 4057 switches[n_switches].part1 = part1; 4058 switches[n_switches].args = xmalloc (2 * sizeof (const char *)); 4059 switches[n_switches].args[0] = xstrdup (p+1); 4060 switches[n_switches].args[1] = 0; 4061 } 4062 else 4063 switches[n_switches].args = 0; 4064 4065 switches[n_switches].live_cond = SWITCH_OK; 4066 switches[n_switches].validated = 0; 4067 switches[n_switches].ordering = 0; 4068 /* These are always valid, since gcc.c itself understands them. */ 4069 if (!strcmp (p, "save-temps") 4070 || !strcmp (p, "static-libgcc") 4071 || !strcmp (p, "shared-libgcc") 4072 || !strcmp (p, "pipe")) 4073 switches[n_switches].validated = 1; 4074 else 4075 { 4076 char ch = switches[n_switches].part1[0]; 4077 if (ch == 'B') 4078 switches[n_switches].validated = 1; 4079 } 4080 n_switches++; 4081 } 4082 else 4083 { 4084#ifdef HAVE_TARGET_OBJECT_SUFFIX 4085 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK)); 4086#endif 4087 4088 if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0) 4089 { 4090 perror_with_name (argv[i]); 4091 error_count++; 4092 } 4093 else 4094 { 4095 infiles[n_infiles].language = spec_lang; 4096 infiles[n_infiles++].name = argv[i]; 4097 } 4098 } 4099 } 4100 4101 if (n_infiles == last_language_n_infiles && spec_lang != 0) 4102 error ("warning: `-x %s' after last input file has no effect", spec_lang); 4103 4104 /* Ensure we only invoke each subprocess once. */ 4105 if (target_help_flag || print_help_list) 4106 { 4107 n_infiles = 1; 4108 4109 /* Create a dummy input file, so that we can pass --target-help on to 4110 the various sub-processes. */ 4111 infiles[0].language = "c"; 4112 infiles[0].name = "help-dummy"; 4113 4114 if (target_help_flag) 4115 { 4116 switches[n_switches].part1 = "--target-help"; 4117 switches[n_switches].args = 0; 4118 switches[n_switches].live_cond = SWITCH_OK; 4119 switches[n_switches].validated = 0; 4120 4121 n_switches++; 4122 } 4123 4124 if (print_help_list) 4125 { 4126 switches[n_switches].part1 = "--help"; 4127 switches[n_switches].args = 0; 4128 switches[n_switches].live_cond = SWITCH_OK; 4129 switches[n_switches].validated = 0; 4130 4131 n_switches++; 4132 } 4133 } 4134 4135 switches[n_switches].part1 = 0; 4136 infiles[n_infiles].name = 0; 4137} 4138 4139/* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS 4140 and place that in the environment. */ 4141 4142static void 4143set_collect_gcc_options (void) 4144{ 4145 int i; 4146 int first_time; 4147 4148 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to 4149 the compiler. */ 4150 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=", 4151 sizeof ("COLLECT_GCC_OPTIONS=") - 1); 4152 4153 first_time = TRUE; 4154 for (i = 0; (int) i < n_switches; i++) 4155 { 4156 const char *const *args; 4157 const char *p, *q; 4158 if (!first_time) 4159 obstack_grow (&collect_obstack, " ", 1); 4160 4161 first_time = FALSE; 4162 4163 /* Ignore elided switches. */ 4164 if (switches[i].live_cond == SWITCH_IGNORE) 4165 continue; 4166 4167 obstack_grow (&collect_obstack, "'-", 2); 4168 q = switches[i].part1; 4169 while ((p = strchr (q, '\''))) 4170 { 4171 obstack_grow (&collect_obstack, q, p - q); 4172 obstack_grow (&collect_obstack, "'\\''", 4); 4173 q = ++p; 4174 } 4175 obstack_grow (&collect_obstack, q, strlen (q)); 4176 obstack_grow (&collect_obstack, "'", 1); 4177 4178 for (args = switches[i].args; args && *args; args++) 4179 { 4180 obstack_grow (&collect_obstack, " '", 2); 4181 q = *args; 4182 while ((p = strchr (q, '\''))) 4183 { 4184 obstack_grow (&collect_obstack, q, p - q); 4185 obstack_grow (&collect_obstack, "'\\''", 4); 4186 q = ++p; 4187 } 4188 obstack_grow (&collect_obstack, q, strlen (q)); 4189 obstack_grow (&collect_obstack, "'", 1); 4190 } 4191 } 4192 obstack_grow (&collect_obstack, "\0", 1); 4193 putenv (obstack_finish (&collect_obstack)); 4194} 4195 4196/* Process a spec string, accumulating and running commands. */ 4197 4198/* These variables describe the input file name. 4199 input_file_number is the index on outfiles of this file, 4200 so that the output file name can be stored for later use by %o. 4201 input_basename is the start of the part of the input file 4202 sans all directory names, and basename_length is the number 4203 of characters starting there excluding the suffix .c or whatever. */ 4204 4205static const char *input_filename; 4206static int input_file_number; 4207size_t input_filename_length; 4208static int basename_length; 4209static int suffixed_basename_length; 4210static const char *input_basename; 4211static const char *input_suffix; 4212static struct stat input_stat; 4213static int input_stat_set; 4214 4215/* The compiler used to process the current input file. */ 4216static struct compiler *input_file_compiler; 4217 4218/* These are variables used within do_spec and do_spec_1. */ 4219 4220/* Nonzero if an arg has been started and not yet terminated 4221 (with space, tab or newline). */ 4222static int arg_going; 4223 4224/* Nonzero means %d or %g has been seen; the next arg to be terminated 4225 is a temporary file name. */ 4226static int delete_this_arg; 4227 4228/* Nonzero means %w has been seen; the next arg to be terminated 4229 is the output file name of this compilation. */ 4230static int this_is_output_file; 4231 4232/* Nonzero means %s has been seen; the next arg to be terminated 4233 is the name of a library file and we should try the standard 4234 search dirs for it. */ 4235static int this_is_library_file; 4236 4237/* Nonzero means that the input of this command is coming from a pipe. */ 4238static int input_from_pipe; 4239 4240/* Nonnull means substitute this for any suffix when outputting a switches 4241 arguments. */ 4242static const char *suffix_subst; 4243 4244/* Process the spec SPEC and run the commands specified therein. 4245 Returns 0 if the spec is successfully processed; -1 if failed. */ 4246 4247int 4248do_spec (const char *spec) 4249{ 4250 int value; 4251 4252 value = do_spec_2 (spec); 4253 4254 /* Force out any unfinished command. 4255 If -pipe, this forces out the last command if it ended in `|'. */ 4256 if (value == 0) 4257 { 4258 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|")) 4259 argbuf_index--; 4260 4261 set_collect_gcc_options (); 4262 4263 if (argbuf_index > 0) 4264 value = execute (); 4265 } 4266 4267 return value; 4268} 4269 4270static int 4271do_spec_2 (const char *spec) 4272{ 4273 const char *string; 4274 int result; 4275 4276 clear_args (); 4277 arg_going = 0; 4278 delete_this_arg = 0; 4279 this_is_output_file = 0; 4280 this_is_library_file = 0; 4281 input_from_pipe = 0; 4282 suffix_subst = NULL; 4283 4284 result = do_spec_1 (spec, 0, NULL); 4285 4286 /* End any pending argument. */ 4287 if (arg_going) 4288 { 4289 obstack_1grow (&obstack, 0); 4290 string = obstack_finish (&obstack); 4291 if (this_is_library_file) 4292 string = find_file (string); 4293 store_arg (string, delete_this_arg, this_is_output_file); 4294 if (this_is_output_file) 4295 outfiles[input_file_number] = string; 4296 arg_going = 0; 4297 } 4298 4299 return result; 4300} 4301 4302 4303/* Process the given spec string and add any new options to the end 4304 of the switches/n_switches array. */ 4305 4306static void 4307do_option_spec (const char *name, const char *spec) 4308{ 4309 unsigned int i, value_count, value_len; 4310 const char *p, *q, *value; 4311 char *tmp_spec, *tmp_spec_p; 4312 4313 if (configure_default_options[0].name == NULL) 4314 return; 4315 4316 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++) 4317 if (strcmp (configure_default_options[i].name, name) == 0) 4318 break; 4319 if (i == ARRAY_SIZE (configure_default_options)) 4320 return; 4321 4322 value = configure_default_options[i].value; 4323 value_len = strlen (value); 4324 4325 /* Compute the size of the final spec. */ 4326 value_count = 0; 4327 p = spec; 4328 while ((p = strstr (p, "%(VALUE)")) != NULL) 4329 { 4330 p ++; 4331 value_count ++; 4332 } 4333 4334 /* Replace each %(VALUE) by the specified value. */ 4335 tmp_spec = alloca (strlen (spec) + 1 4336 + value_count * (value_len - strlen ("%(VALUE)"))); 4337 tmp_spec_p = tmp_spec; 4338 q = spec; 4339 while ((p = strstr (q, "%(VALUE)")) != NULL) 4340 { 4341 memcpy (tmp_spec_p, q, p - q); 4342 tmp_spec_p = tmp_spec_p + (p - q); 4343 memcpy (tmp_spec_p, value, value_len); 4344 tmp_spec_p += value_len; 4345 q = p + strlen ("%(VALUE)"); 4346 } 4347 strcpy (tmp_spec_p, q); 4348 4349 do_self_spec (tmp_spec); 4350} 4351 4352/* Process the given spec string and add any new options to the end 4353 of the switches/n_switches array. */ 4354 4355static void 4356do_self_spec (const char *spec) 4357{ 4358 do_spec_2 (spec); 4359 do_spec_1 (" ", 0, NULL); 4360 4361 if (argbuf_index > 0) 4362 { 4363 int i, first; 4364 4365 first = n_switches; 4366 n_switches += argbuf_index; 4367 switches = xrealloc (switches, 4368 sizeof (struct switchstr) * (n_switches + 1)); 4369 4370 switches[n_switches] = switches[first]; 4371 for (i = 0; i < argbuf_index; i++) 4372 { 4373 struct switchstr *sw; 4374 4375 /* Each switch should start with '-'. */ 4376 if (argbuf[i][0] != '-') 4377 abort (); 4378 4379 sw = &switches[i + first]; 4380 sw->part1 = &argbuf[i][1]; 4381 sw->args = 0; 4382 sw->live_cond = SWITCH_OK; 4383 sw->validated = 0; 4384 sw->ordering = 0; 4385 } 4386 } 4387} 4388 4389/* Process the sub-spec SPEC as a portion of a larger spec. 4390 This is like processing a whole spec except that we do 4391 not initialize at the beginning and we do not supply a 4392 newline by default at the end. 4393 INSWITCH nonzero means don't process %-sequences in SPEC; 4394 in this case, % is treated as an ordinary character. 4395 This is used while substituting switches. 4396 INSWITCH nonzero also causes SPC not to terminate an argument. 4397 4398 Value is zero unless a line was finished 4399 and the command on that line reported an error. */ 4400 4401static int 4402do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part) 4403{ 4404 const char *p = spec; 4405 int c; 4406 int i; 4407 const char *string; 4408 int value; 4409 4410 while ((c = *p++)) 4411 /* If substituting a switch, treat all chars like letters. 4412 Otherwise, NL, SPC, TAB and % are special. */ 4413 switch (inswitch ? 'a' : c) 4414 { 4415 case '\n': 4416 /* End of line: finish any pending argument, 4417 then run the pending command if one has been started. */ 4418 if (arg_going) 4419 { 4420 obstack_1grow (&obstack, 0); 4421 string = obstack_finish (&obstack); 4422 if (this_is_library_file) 4423 string = find_file (string); 4424 store_arg (string, delete_this_arg, this_is_output_file); 4425 if (this_is_output_file) 4426 outfiles[input_file_number] = string; 4427 } 4428 arg_going = 0; 4429 4430 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|")) 4431 { 4432 /* A `|' before the newline means use a pipe here, 4433 but only if -pipe was specified. 4434 Otherwise, execute now and don't pass the `|' as an arg. */ 4435 if (use_pipes) 4436 { 4437 input_from_pipe = 1; 4438 break; 4439 } 4440 else 4441 argbuf_index--; 4442 } 4443 4444 set_collect_gcc_options (); 4445 4446 if (argbuf_index > 0) 4447 { 4448 value = execute (); 4449 if (value) 4450 return value; 4451 } 4452 /* Reinitialize for a new command, and for a new argument. */ 4453 clear_args (); 4454 arg_going = 0; 4455 delete_this_arg = 0; 4456 this_is_output_file = 0; 4457 this_is_library_file = 0; 4458 input_from_pipe = 0; 4459 break; 4460 4461 case '|': 4462 /* End any pending argument. */ 4463 if (arg_going) 4464 { 4465 obstack_1grow (&obstack, 0); 4466 string = obstack_finish (&obstack); 4467 if (this_is_library_file) 4468 string = find_file (string); 4469 store_arg (string, delete_this_arg, this_is_output_file); 4470 if (this_is_output_file) 4471 outfiles[input_file_number] = string; 4472 } 4473 4474 /* Use pipe */ 4475 obstack_1grow (&obstack, c); 4476 arg_going = 1; 4477 break; 4478 4479 case '\t': 4480 case ' ': 4481 /* Space or tab ends an argument if one is pending. */ 4482 if (arg_going) 4483 { 4484 obstack_1grow (&obstack, 0); 4485 string = obstack_finish (&obstack); 4486 if (this_is_library_file) 4487 string = find_file (string); 4488 store_arg (string, delete_this_arg, this_is_output_file); 4489 if (this_is_output_file) 4490 outfiles[input_file_number] = string; 4491 } 4492 /* Reinitialize for a new argument. */ 4493 arg_going = 0; 4494 delete_this_arg = 0; 4495 this_is_output_file = 0; 4496 this_is_library_file = 0; 4497 break; 4498 4499 case '%': 4500 switch (c = *p++) 4501 { 4502 case 0: 4503 fatal ("invalid specification! Bug in cc"); 4504 4505 case 'b': 4506 obstack_grow (&obstack, input_basename, basename_length); 4507 arg_going = 1; 4508 break; 4509 4510 case 'B': 4511 obstack_grow (&obstack, input_basename, suffixed_basename_length); 4512 arg_going = 1; 4513 break; 4514 4515 case 'd': 4516 delete_this_arg = 2; 4517 break; 4518 4519 /* Dump out the directories specified with LIBRARY_PATH, 4520 followed by the absolute directories 4521 that we search for startfiles. */ 4522 case 'D': 4523 { 4524 struct prefix_list *pl = startfile_prefixes.plist; 4525 size_t bufsize = 100; 4526 char *buffer = xmalloc (bufsize); 4527 int idx; 4528 4529 for (; pl; pl = pl->next) 4530 { 4531#ifdef RELATIVE_PREFIX_NOT_LINKDIR 4532 /* Used on systems which record the specified -L dirs 4533 and use them to search for dynamic linking. */ 4534 /* Relative directories always come from -B, 4535 and it is better not to use them for searching 4536 at run time. In particular, stage1 loses. */ 4537 if (!IS_ABSOLUTE_PATH (pl->prefix)) 4538 continue; 4539#endif 4540 /* Try subdirectory if there is one. */ 4541 if (multilib_dir != NULL 4542 || (pl->os_multilib && multilib_os_dir != NULL)) 4543 { 4544 const char *multi_dir; 4545 4546 multi_dir = pl->os_multilib ? multilib_os_dir 4547 : multilib_dir; 4548 if (machine_suffix && multilib_dir) 4549 { 4550 if (strlen (pl->prefix) + strlen (machine_suffix) 4551 >= bufsize) 4552 bufsize = (strlen (pl->prefix) 4553 + strlen (machine_suffix)) * 2 + 1; 4554 buffer = xrealloc (buffer, bufsize); 4555 strcpy (buffer, pl->prefix); 4556 strcat (buffer, machine_suffix); 4557 if (is_directory (buffer, multilib_dir, 1)) 4558 { 4559 do_spec_1 ("-L", 0, NULL); 4560#ifdef SPACE_AFTER_L_OPTION 4561 do_spec_1 (" ", 0, NULL); 4562#endif 4563 do_spec_1 (buffer, 1, NULL); 4564 do_spec_1 (multilib_dir, 1, NULL); 4565 /* Make this a separate argument. */ 4566 do_spec_1 (" ", 0, NULL); 4567 } 4568 } 4569 if (!pl->require_machine_suffix) 4570 { 4571 if (is_directory (pl->prefix, multi_dir, 1)) 4572 { 4573 do_spec_1 ("-L", 0, NULL); 4574#ifdef SPACE_AFTER_L_OPTION 4575 do_spec_1 (" ", 0, NULL); 4576#endif 4577 do_spec_1 (pl->prefix, 1, NULL); 4578 do_spec_1 (multi_dir, 1, NULL); 4579 /* Make this a separate argument. */ 4580 do_spec_1 (" ", 0, NULL); 4581 } 4582 } 4583 } 4584 if (machine_suffix) 4585 { 4586 if (is_directory (pl->prefix, machine_suffix, 1)) 4587 { 4588 do_spec_1 ("-L", 0, NULL); 4589#ifdef SPACE_AFTER_L_OPTION 4590 do_spec_1 (" ", 0, NULL); 4591#endif 4592 do_spec_1 (pl->prefix, 1, NULL); 4593 /* Remove slash from machine_suffix. */ 4594 if (strlen (machine_suffix) >= bufsize) 4595 bufsize = strlen (machine_suffix) * 2 + 1; 4596 buffer = xrealloc (buffer, bufsize); 4597 strcpy (buffer, machine_suffix); 4598 idx = strlen (buffer); 4599 if (IS_DIR_SEPARATOR (buffer[idx - 1])) 4600 buffer[idx - 1] = 0; 4601 do_spec_1 (buffer, 1, NULL); 4602 /* Make this a separate argument. */ 4603 do_spec_1 (" ", 0, NULL); 4604 } 4605 } 4606 if (!pl->require_machine_suffix) 4607 { 4608 if (is_directory (pl->prefix, "", 1)) 4609 { 4610 do_spec_1 ("-L", 0, NULL); 4611#ifdef SPACE_AFTER_L_OPTION 4612 do_spec_1 (" ", 0, NULL); 4613#endif 4614 /* Remove slash from pl->prefix. */ 4615 if (strlen (pl->prefix) >= bufsize) 4616 bufsize = strlen (pl->prefix) * 2 + 1; 4617 buffer = xrealloc (buffer, bufsize); 4618 strcpy (buffer, pl->prefix); 4619 idx = strlen (buffer); 4620 if (IS_DIR_SEPARATOR (buffer[idx - 1])) 4621 buffer[idx - 1] = 0; 4622 do_spec_1 (buffer, 1, NULL); 4623 /* Make this a separate argument. */ 4624 do_spec_1 (" ", 0, NULL); 4625 } 4626 } 4627 } 4628 free (buffer); 4629 } 4630 break; 4631 4632 case 'e': 4633 /* %efoo means report an error with `foo' as error message 4634 and don't execute any more commands for this file. */ 4635 { 4636 const char *q = p; 4637 char *buf; 4638 while (*p != 0 && *p != '\n') 4639 p++; 4640 buf = alloca (p - q + 1); 4641 strncpy (buf, q, p - q); 4642 buf[p - q] = 0; 4643 error ("%s", buf); 4644 return -1; 4645 } 4646 break; 4647 case 'n': 4648 /* %nfoo means report a notice with `foo' on stderr. */ 4649 { 4650 const char *q = p; 4651 char *buf; 4652 while (*p != 0 && *p != '\n') 4653 p++; 4654 buf = alloca (p - q + 1); 4655 strncpy (buf, q, p - q); 4656 buf[p - q] = 0; 4657 notice ("%s\n", buf); 4658 if (*p) 4659 p++; 4660 } 4661 break; 4662 4663 case 'j': 4664 { 4665 struct stat st; 4666 4667 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is 4668 defined, and it is not a directory, and it is 4669 writable, use it. Otherwise, treat this like any 4670 other temporary file. */ 4671 4672 if ((!save_temps_flag) 4673 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode)) 4674 && (access (HOST_BIT_BUCKET, W_OK) == 0)) 4675 { 4676 obstack_grow (&obstack, HOST_BIT_BUCKET, 4677 strlen (HOST_BIT_BUCKET)); 4678 delete_this_arg = 0; 4679 arg_going = 1; 4680 break; 4681 } 4682 } 4683 goto create_temp_file; 4684 case '|': 4685 if (use_pipes) 4686 { 4687 obstack_1grow (&obstack, '-'); 4688 delete_this_arg = 0; 4689 arg_going = 1; 4690 4691 /* consume suffix */ 4692 while (*p == '.' || ISALPHA ((unsigned char) *p)) 4693 p++; 4694 if (p[0] == '%' && p[1] == 'O') 4695 p += 2; 4696 4697 break; 4698 } 4699 goto create_temp_file; 4700 case 'm': 4701 if (use_pipes) 4702 { 4703 /* consume suffix */ 4704 while (*p == '.' || ISALPHA ((unsigned char) *p)) 4705 p++; 4706 if (p[0] == '%' && p[1] == 'O') 4707 p += 2; 4708 4709 break; 4710 } 4711 goto create_temp_file; 4712 case 'g': 4713 case 'u': 4714 case 'U': 4715 create_temp_file: 4716 { 4717 struct temp_name *t; 4718 int suffix_length; 4719 const char *suffix = p; 4720 char *saved_suffix = NULL; 4721 4722 while (*p == '.' || ISALPHA ((unsigned char) *p)) 4723 p++; 4724 suffix_length = p - suffix; 4725 if (p[0] == '%' && p[1] == 'O') 4726 { 4727 p += 2; 4728 /* We don't support extra suffix characters after %O. */ 4729 if (*p == '.' || ISALPHA ((unsigned char) *p)) 4730 abort (); 4731 if (suffix_length == 0) 4732 suffix = TARGET_OBJECT_SUFFIX; 4733 else 4734 { 4735 saved_suffix 4736 = xmalloc (suffix_length 4737 + strlen (TARGET_OBJECT_SUFFIX)); 4738 strncpy (saved_suffix, suffix, suffix_length); 4739 strcpy (saved_suffix + suffix_length, 4740 TARGET_OBJECT_SUFFIX); 4741 } 4742 suffix_length += strlen (TARGET_OBJECT_SUFFIX); 4743 } 4744 4745 /* If the input_filename has the same suffix specified 4746 for the %g, %u, or %U, and -save-temps is specified, 4747 we could end up using that file as an intermediate 4748 thus clobbering the user's source file (.e.g., 4749 gcc -save-temps foo.s would clobber foo.s with the 4750 output of cpp0). So check for this condition and 4751 generate a temp file as the intermediate. */ 4752 4753 if (save_temps_flag) 4754 { 4755 temp_filename_length = basename_length + suffix_length; 4756 temp_filename = alloca (temp_filename_length + 1); 4757 strncpy ((char *) temp_filename, input_basename, basename_length); 4758 strncpy ((char *) temp_filename + basename_length, suffix, 4759 suffix_length); 4760 *((char *) temp_filename + temp_filename_length) = '\0'; 4761 if (strcmp (temp_filename, input_filename) != 0) 4762 { 4763 struct stat st_temp; 4764 4765 /* Note, set_input() resets input_stat_set to 0. */ 4766 if (input_stat_set == 0) 4767 { 4768 input_stat_set = stat (input_filename, &input_stat); 4769 if (input_stat_set >= 0) 4770 input_stat_set = 1; 4771 } 4772 4773 /* If we have the stat for the input_filename 4774 and we can do the stat for the temp_filename 4775 then the they could still refer to the same 4776 file if st_dev/st_ino's are the same. */ 4777 4778 if (input_stat_set != 1 4779 || stat (temp_filename, &st_temp) < 0 4780 || input_stat.st_dev != st_temp.st_dev 4781 || input_stat.st_ino != st_temp.st_ino) 4782 { 4783 temp_filename = save_string (temp_filename, 4784 temp_filename_length + 1); 4785 obstack_grow (&obstack, temp_filename, 4786 temp_filename_length); 4787 arg_going = 1; 4788 delete_this_arg = 0; 4789 break; 4790 } 4791 } 4792 } 4793 4794 /* See if we already have an association of %g/%u/%U and 4795 suffix. */ 4796 for (t = temp_names; t; t = t->next) 4797 if (t->length == suffix_length 4798 && strncmp (t->suffix, suffix, suffix_length) == 0 4799 && t->unique == (c == 'u' || c == 'U' || c == 'j')) 4800 break; 4801 4802 /* Make a new association if needed. %u and %j 4803 require one. */ 4804 if (t == 0 || c == 'u' || c == 'j') 4805 { 4806 if (t == 0) 4807 { 4808 t = xmalloc (sizeof (struct temp_name)); 4809 t->next = temp_names; 4810 temp_names = t; 4811 } 4812 t->length = suffix_length; 4813 if (saved_suffix) 4814 { 4815 t->suffix = saved_suffix; 4816 saved_suffix = NULL; 4817 } 4818 else 4819 t->suffix = save_string (suffix, suffix_length); 4820 t->unique = (c == 'u' || c == 'U' || c == 'j'); 4821 temp_filename = make_temp_file (t->suffix); 4822 temp_filename_length = strlen (temp_filename); 4823 t->filename = temp_filename; 4824 t->filename_length = temp_filename_length; 4825 } 4826 4827 if (saved_suffix) 4828 free (saved_suffix); 4829 4830 obstack_grow (&obstack, t->filename, t->filename_length); 4831 delete_this_arg = 1; 4832 } 4833 arg_going = 1; 4834 break; 4835 4836 case 'i': 4837 if (combine_inputs) 4838 { 4839 for (i = 0; (int) i < n_infiles; i++) 4840 store_arg (infiles[i].name, 0, 0); 4841 } 4842 else 4843 { 4844 obstack_grow (&obstack, input_filename, input_filename_length); 4845 arg_going = 1; 4846 } 4847 break; 4848 4849 case 'I': 4850 { 4851 struct prefix_list *pl = include_prefixes.plist; 4852 4853 if (gcc_exec_prefix) 4854 { 4855 do_spec_1 ("-iprefix", 1, NULL); 4856 /* Make this a separate argument. */ 4857 do_spec_1 (" ", 0, NULL); 4858 do_spec_1 (gcc_exec_prefix, 1, NULL); 4859 do_spec_1 (" ", 0, NULL); 4860 } 4861 4862 if (target_system_root_changed || 4863 (target_system_root && target_sysroot_hdrs_suffix)) 4864 { 4865 do_spec_1 ("-isysroot", 1, NULL); 4866 /* Make this a separate argument. */ 4867 do_spec_1 (" ", 0, NULL); 4868 do_spec_1 (target_system_root, 1, NULL); 4869 if (target_sysroot_hdrs_suffix) 4870 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL); 4871 do_spec_1 (" ", 0, NULL); 4872 } 4873 4874 for (; pl; pl = pl->next) 4875 { 4876 do_spec_1 ("-isystem", 1, NULL); 4877 /* Make this a separate argument. */ 4878 do_spec_1 (" ", 0, NULL); 4879 do_spec_1 (pl->prefix, 1, NULL); 4880 do_spec_1 (" ", 0, NULL); 4881 } 4882 } 4883 break; 4884 4885 case 'o': 4886 { 4887 int max = n_infiles; 4888 max += lang_specific_extra_outfiles; 4889 4890 for (i = 0; i < max; i++) 4891 if (outfiles[i]) 4892 store_arg (outfiles[i], 0, 0); 4893 break; 4894 } 4895 4896 case 'O': 4897 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX)); 4898 arg_going = 1; 4899 break; 4900 4901 case 's': 4902 this_is_library_file = 1; 4903 break; 4904 4905 case 'V': 4906 outfiles[input_file_number] = NULL; 4907 break; 4908 4909 case 'w': 4910 this_is_output_file = 1; 4911 break; 4912 4913 case 'W': 4914 { 4915 int cur_index = argbuf_index; 4916 /* Handle the {...} following the %W. */ 4917 if (*p != '{') 4918 abort (); 4919 p = handle_braces (p + 1); 4920 if (p == 0) 4921 return -1; 4922 /* End any pending argument. */ 4923 if (arg_going) 4924 { 4925 obstack_1grow (&obstack, 0); 4926 string = obstack_finish (&obstack); 4927 if (this_is_library_file) 4928 string = find_file (string); 4929 store_arg (string, delete_this_arg, this_is_output_file); 4930 if (this_is_output_file) 4931 outfiles[input_file_number] = string; 4932 arg_going = 0; 4933 } 4934 /* If any args were output, mark the last one for deletion 4935 on failure. */ 4936 if (argbuf_index != cur_index) 4937 record_temp_file (argbuf[argbuf_index - 1], 0, 1); 4938 break; 4939 } 4940 4941 /* %x{OPTION} records OPTION for %X to output. */ 4942 case 'x': 4943 { 4944 const char *p1 = p; 4945 char *string; 4946 4947 /* Skip past the option value and make a copy. */ 4948 if (*p != '{') 4949 abort (); 4950 while (*p++ != '}') 4951 ; 4952 string = save_string (p1 + 1, p - p1 - 2); 4953 4954 /* See if we already recorded this option. */ 4955 for (i = 0; i < n_linker_options; i++) 4956 if (! strcmp (string, linker_options[i])) 4957 { 4958 free (string); 4959 return 0; 4960 } 4961 4962 /* This option is new; add it. */ 4963 add_linker_option (string, strlen (string)); 4964 } 4965 break; 4966 4967 /* Dump out the options accumulated previously using %x. */ 4968 case 'X': 4969 for (i = 0; i < n_linker_options; i++) 4970 { 4971 do_spec_1 (linker_options[i], 1, NULL); 4972 /* Make each accumulated option a separate argument. */ 4973 do_spec_1 (" ", 0, NULL); 4974 } 4975 break; 4976 4977 /* Dump out the options accumulated previously using -Wa,. */ 4978 case 'Y': 4979 for (i = 0; i < n_assembler_options; i++) 4980 { 4981 do_spec_1 (assembler_options[i], 1, NULL); 4982 /* Make each accumulated option a separate argument. */ 4983 do_spec_1 (" ", 0, NULL); 4984 } 4985 break; 4986 4987 /* Dump out the options accumulated previously using -Wp,. */ 4988 case 'Z': 4989 for (i = 0; i < n_preprocessor_options; i++) 4990 { 4991 do_spec_1 (preprocessor_options[i], 1, NULL); 4992 /* Make each accumulated option a separate argument. */ 4993 do_spec_1 (" ", 0, NULL); 4994 } 4995 break; 4996 4997 /* Here are digits and numbers that just process 4998 a certain constant string as a spec. */ 4999 5000 case '1': 5001 value = do_spec_1 (cc1_spec, 0, NULL); 5002 if (value != 0) 5003 return value; 5004 break; 5005 5006 case '2': 5007 value = do_spec_1 (cc1plus_spec, 0, NULL); 5008 if (value != 0) 5009 return value; 5010 break; 5011 5012 case 'a': 5013 value = do_spec_1 (asm_spec, 0, NULL); 5014 if (value != 0) 5015 return value; 5016 break; 5017 5018 case 'A': 5019 value = do_spec_1 (asm_final_spec, 0, NULL); 5020 if (value != 0) 5021 return value; 5022 break; 5023 5024 case 'C': 5025 { 5026 const char *const spec 5027 = (input_file_compiler->cpp_spec 5028 ? input_file_compiler->cpp_spec 5029 : cpp_spec); 5030 value = do_spec_1 (spec, 0, NULL); 5031 if (value != 0) 5032 return value; 5033 } 5034 break; 5035 5036 case 'E': 5037 value = do_spec_1 (endfile_spec, 0, NULL); 5038 if (value != 0) 5039 return value; 5040 break; 5041 5042 case 'l': 5043 value = do_spec_1 (link_spec, 0, NULL); 5044 if (value != 0) 5045 return value; 5046 break; 5047 5048 case 'L': 5049 value = do_spec_1 (lib_spec, 0, NULL); 5050 if (value != 0) 5051 return value; 5052 break; 5053 5054 case 'G': 5055 value = do_spec_1 (libgcc_spec, 0, NULL); 5056 if (value != 0) 5057 return value; 5058 break; 5059 5060 case 'M': 5061 if (multilib_dir && strcmp (multilib_dir, ".") != 0) 5062 { 5063 char *p; 5064 const char *q; 5065 size_t len; 5066 5067 len = strlen (multilib_dir); 5068 obstack_blank (&obstack, len + 1); 5069 p = obstack_next_free (&obstack) - (len + 1); 5070 5071 *p++ = '_'; 5072 for (q = multilib_dir; *q ; ++q, ++p) 5073 *p = (IS_DIR_SEPARATOR (*q) ? '_' : *q); 5074 } 5075 break; 5076 5077 case 'R': 5078 /* We assume there is a directory 5079 separator at the end of this string. */ 5080 if (target_system_root) 5081 { 5082 obstack_grow (&obstack, target_system_root, 5083 strlen (target_system_root)); 5084 if (target_sysroot_suffix) 5085 obstack_grow (&obstack, target_sysroot_suffix, 5086 strlen (target_sysroot_suffix)); 5087 } 5088 break; 5089 5090 case 'S': 5091 value = do_spec_1 (startfile_spec, 0, NULL); 5092 if (value != 0) 5093 return value; 5094 break; 5095 5096 /* Here we define characters other than letters and digits. */ 5097 5098 case '{': 5099 p = handle_braces (p); 5100 if (p == 0) 5101 return -1; 5102 break; 5103 5104 case ':': 5105 p = handle_spec_function (p); 5106 if (p == 0) 5107 return -1; 5108 break; 5109 5110 case '%': 5111 obstack_1grow (&obstack, '%'); 5112 break; 5113 5114 case '.': 5115 { 5116 unsigned len = 0; 5117 5118 while (p[len] && p[len] != ' ' && p[len] != '%') 5119 len++; 5120 suffix_subst = save_string (p - 1, len + 1); 5121 p += len; 5122 } 5123 break; 5124 5125 /* Henceforth ignore the option(s) matching the pattern 5126 after the %<. */ 5127 case '<': 5128 { 5129 unsigned len = 0; 5130 int have_wildcard = 0; 5131 int i; 5132 5133 while (p[len] && p[len] != ' ' && p[len] != '\t') 5134 len++; 5135 5136 if (p[len-1] == '*') 5137 have_wildcard = 1; 5138 5139 for (i = 0; i < n_switches; i++) 5140 if (!strncmp (switches[i].part1, p, len - have_wildcard) 5141 && (have_wildcard || switches[i].part1[len] == '\0')) 5142 { 5143 switches[i].live_cond = SWITCH_IGNORE; 5144 switches[i].validated = 1; 5145 } 5146 5147 p += len; 5148 } 5149 break; 5150 5151 case '*': 5152 if (soft_matched_part) 5153 { 5154 do_spec_1 (soft_matched_part, 1, NULL); 5155 do_spec_1 (" ", 0, NULL); 5156 } 5157 else 5158 /* Catch the case where a spec string contains something like 5159 '%{foo:%*}'. ie there is no * in the pattern on the left 5160 hand side of the :. */ 5161 error ("spec failure: '%%*' has not been initialized by pattern match"); 5162 break; 5163 5164 /* Process a string found as the value of a spec given by name. 5165 This feature allows individual machine descriptions 5166 to add and use their own specs. 5167 %[...] modifies -D options the way %P does; 5168 %(...) uses the spec unmodified. */ 5169 case '[': 5170 error ("warning: use of obsolete %%[ operator in specs"); 5171 case '(': 5172 { 5173 const char *name = p; 5174 struct spec_list *sl; 5175 int len; 5176 5177 /* The string after the S/P is the name of a spec that is to be 5178 processed. */ 5179 while (*p && *p != ')' && *p != ']') 5180 p++; 5181 5182 /* See if it's in the list. */ 5183 for (len = p - name, sl = specs; sl; sl = sl->next) 5184 if (sl->name_len == len && !strncmp (sl->name, name, len)) 5185 { 5186 name = *(sl->ptr_spec); 5187#ifdef DEBUG_SPECS 5188 notice ("Processing spec %c%s%c, which is '%s'\n", 5189 c, sl->name, (c == '(') ? ')' : ']', name); 5190#endif 5191 break; 5192 } 5193 5194 if (sl) 5195 { 5196 if (c == '(') 5197 { 5198 value = do_spec_1 (name, 0, NULL); 5199 if (value != 0) 5200 return value; 5201 } 5202 else 5203 { 5204 char *x = alloca (strlen (name) * 2 + 1); 5205 char *buf = x; 5206 const char *y = name; 5207 int flag = 0; 5208 5209 /* Copy all of NAME into BUF, but put __ after 5210 every -D and at the end of each arg. */ 5211 while (1) 5212 { 5213 if (! strncmp (y, "-D", 2)) 5214 { 5215 *x++ = '-'; 5216 *x++ = 'D'; 5217 *x++ = '_'; 5218 *x++ = '_'; 5219 y += 2; 5220 flag = 1; 5221 continue; 5222 } 5223 else if (flag 5224 && (*y == ' ' || *y == '\t' || *y == '=' 5225 || *y == '}' || *y == 0)) 5226 { 5227 *x++ = '_'; 5228 *x++ = '_'; 5229 flag = 0; 5230 } 5231 if (*y == 0) 5232 break; 5233 else 5234 *x++ = *y++; 5235 } 5236 *x = 0; 5237 5238 value = do_spec_1 (buf, 0, NULL); 5239 if (value != 0) 5240 return value; 5241 } 5242 } 5243 5244 /* Discard the closing paren or bracket. */ 5245 if (*p) 5246 p++; 5247 } 5248 break; 5249 5250 default: 5251 error ("spec failure: unrecognized spec option '%c'", c); 5252 break; 5253 } 5254 break; 5255 5256 case '\\': 5257 /* Backslash: treat next character as ordinary. */ 5258 c = *p++; 5259 5260 /* Fall through. */ 5261 default: 5262 /* Ordinary character: put it into the current argument. */ 5263 obstack_1grow (&obstack, c); 5264 arg_going = 1; 5265 } 5266 5267 /* End of string. If we are processing a spec function, we need to 5268 end any pending argument. */ 5269 if (processing_spec_function && arg_going) 5270 { 5271 obstack_1grow (&obstack, 0); 5272 string = obstack_finish (&obstack); 5273 if (this_is_library_file) 5274 string = find_file (string); 5275 store_arg (string, delete_this_arg, this_is_output_file); 5276 if (this_is_output_file) 5277 outfiles[input_file_number] = string; 5278 arg_going = 0; 5279 } 5280 5281 return 0; 5282} 5283 5284/* Look up a spec function. */ 5285 5286static const struct spec_function * 5287lookup_spec_function (const char *name) 5288{ 5289 static const struct spec_function * const spec_function_tables[] = 5290 { 5291 static_spec_functions, 5292 lang_specific_spec_functions, 5293 }; 5294 const struct spec_function *sf; 5295 unsigned int i; 5296 5297 for (i = 0; i < ARRAY_SIZE (spec_function_tables); i++) 5298 { 5299 for (sf = spec_function_tables[i]; sf->name != NULL; sf++) 5300 if (strcmp (sf->name, name) == 0) 5301 return sf; 5302 } 5303 5304 return NULL; 5305} 5306 5307/* Evaluate a spec function. */ 5308 5309static const char * 5310eval_spec_function (const char *func, const char *args) 5311{ 5312 const struct spec_function *sf; 5313 const char *funcval; 5314 5315 /* Saved spec processing context. */ 5316 int save_argbuf_index; 5317 int save_argbuf_length; 5318 const char **save_argbuf; 5319 5320 int save_arg_going; 5321 int save_delete_this_arg; 5322 int save_this_is_output_file; 5323 int save_this_is_library_file; 5324 int save_input_from_pipe; 5325 const char *save_suffix_subst; 5326 5327 5328 sf = lookup_spec_function (func); 5329 if (sf == NULL) 5330 fatal ("unknown spec function `%s'", func); 5331 5332 /* Push the spec processing context. */ 5333 save_argbuf_index = argbuf_index; 5334 save_argbuf_length = argbuf_length; 5335 save_argbuf = argbuf; 5336 5337 save_arg_going = arg_going; 5338 save_delete_this_arg = delete_this_arg; 5339 save_this_is_output_file = this_is_output_file; 5340 save_this_is_library_file = this_is_library_file; 5341 save_input_from_pipe = input_from_pipe; 5342 save_suffix_subst = suffix_subst; 5343 5344 /* Create a new spec processing context, and build the function 5345 arguments. */ 5346 5347 alloc_args (); 5348 if (do_spec_2 (args) < 0) 5349 fatal ("error in args to spec function `%s'", func); 5350 5351 /* argbuf_index is an index for the next argument to be inserted, and 5352 so contains the count of the args already inserted. */ 5353 5354 funcval = (*sf->func) (argbuf_index, argbuf); 5355 5356 /* Pop the spec processing context. */ 5357 argbuf_index = save_argbuf_index; 5358 argbuf_length = save_argbuf_length; 5359 free (argbuf); 5360 argbuf = save_argbuf; 5361 5362 arg_going = save_arg_going; 5363 delete_this_arg = save_delete_this_arg; 5364 this_is_output_file = save_this_is_output_file; 5365 this_is_library_file = save_this_is_library_file; 5366 input_from_pipe = save_input_from_pipe; 5367 suffix_subst = save_suffix_subst; 5368 5369 return funcval; 5370} 5371 5372/* Handle a spec function call of the form: 5373 5374 %:function(args) 5375 5376 ARGS is processed as a spec in a separate context and split into an 5377 argument vector in the normal fashion. The function returns a string 5378 containing a spec which we then process in the caller's context, or 5379 NULL if no processing is required. */ 5380 5381static const char * 5382handle_spec_function (const char *p) 5383{ 5384 char *func, *args; 5385 const char *endp, *funcval; 5386 int count; 5387 5388 processing_spec_function++; 5389 5390 /* Get the function name. */ 5391 for (endp = p; *endp != '\0'; endp++) 5392 { 5393 if (*endp == '(') /* ) */ 5394 break; 5395 /* Only allow [A-Za-z0-9], -, and _ in function names. */ 5396 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_')) 5397 fatal ("malformed spec function name"); 5398 } 5399 if (*endp != '(') /* ) */ 5400 fatal ("no arguments for spec function"); 5401 func = save_string (p, endp - p); 5402 p = ++endp; 5403 5404 /* Get the arguments. */ 5405 for (count = 0; *endp != '\0'; endp++) 5406 { 5407 /* ( */ 5408 if (*endp == ')') 5409 { 5410 if (count == 0) 5411 break; 5412 count--; 5413 } 5414 else if (*endp == '(') /* ) */ 5415 count++; 5416 } 5417 /* ( */ 5418 if (*endp != ')') 5419 fatal ("malformed spec function arguments"); 5420 args = save_string (p, endp - p); 5421 p = ++endp; 5422 5423 /* p now points to just past the end of the spec function expression. */ 5424 5425 funcval = eval_spec_function (func, args); 5426 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0) 5427 p = NULL; 5428 5429 free (func); 5430 free (args); 5431 5432 processing_spec_function--; 5433 5434 return p; 5435} 5436 5437/* Inline subroutine of handle_braces. Returns true if the current 5438 input suffix matches the atom bracketed by ATOM and END_ATOM. */ 5439static inline bool 5440input_suffix_matches (const char *atom, const char *end_atom) 5441{ 5442 return (input_suffix 5443 && !strncmp (input_suffix, atom, end_atom - atom) 5444 && input_suffix[end_atom - atom] == '\0'); 5445} 5446 5447/* Inline subroutine of handle_braces. Returns true if a switch 5448 matching the atom bracketed by ATOM and END_ATOM appeared on the 5449 command line. */ 5450static inline bool 5451switch_matches (const char *atom, const char *end_atom, int starred) 5452{ 5453 int i; 5454 int len = end_atom - atom; 5455 int plen = starred ? len : -1; 5456 5457 for (i = 0; i < n_switches; i++) 5458 if (!strncmp (switches[i].part1, atom, len) 5459 && (starred || switches[i].part1[len] == '\0') 5460 && check_live_switch (i, plen)) 5461 return true; 5462 5463 return false; 5464} 5465 5466/* Inline subroutine of handle_braces. Mark all of the switches which 5467 match ATOM (extends to END_ATOM; STARRED indicates whether there 5468 was a star after the atom) for later processing. */ 5469static inline void 5470mark_matching_switches (const char *atom, const char *end_atom, int starred) 5471{ 5472 int i; 5473 int len = end_atom - atom; 5474 int plen = starred ? len : -1; 5475 5476 for (i = 0; i < n_switches; i++) 5477 if (!strncmp (switches[i].part1, atom, len) 5478 && (starred || switches[i].part1[len] == '\0') 5479 && check_live_switch (i, plen)) 5480 switches[i].ordering = 1; 5481} 5482 5483/* Inline subroutine of handle_braces. Process all the currently 5484 marked switches through give_switch, and clear the marks. */ 5485static inline void 5486process_marked_switches (void) 5487{ 5488 int i; 5489 5490 for (i = 0; i < n_switches; i++) 5491 if (switches[i].ordering == 1) 5492 { 5493 switches[i].ordering = 0; 5494 give_switch (i, 0); 5495 } 5496} 5497 5498/* Handle a %{ ... } construct. P points just inside the leading {. 5499 Returns a pointer one past the end of the brace block, or 0 5500 if we call do_spec_1 and that returns -1. */ 5501 5502static const char * 5503handle_braces (const char *p) 5504{ 5505 const char *atom, *end_atom; 5506 const char *d_atom = NULL, *d_end_atom = NULL; 5507 5508 bool a_is_suffix; 5509 bool a_is_starred; 5510 bool a_is_negated; 5511 bool a_matched; 5512 5513 bool a_must_be_last = false; 5514 bool ordered_set = false; 5515 bool disjunct_set = false; 5516 bool disj_matched = false; 5517 bool disj_starred = true; 5518 bool n_way_choice = false; 5519 bool n_way_matched = false; 5520 5521#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0) 5522 5523 do 5524 { 5525 if (a_must_be_last) 5526 abort (); 5527 5528 /* Scan one "atom" (S in the description above of %{}, possibly 5529 with !, ., or * modifiers). */ 5530 a_matched = a_is_suffix = a_is_starred = a_is_negated = false; 5531 5532 SKIP_WHITE(); 5533 if (*p == '!') 5534 p++, a_is_negated = true; 5535 5536 SKIP_WHITE(); 5537 if (*p == '.') 5538 p++, a_is_suffix = true; 5539 5540 atom = p; 5541 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '=' 5542 || *p == ',' || *p == '.' || *p == '@') 5543 p++; 5544 end_atom = p; 5545 5546 if (*p == '*') 5547 p++, a_is_starred = 1; 5548 5549 SKIP_WHITE(); 5550 if (*p == '&' || *p == '}') 5551 { 5552 /* Substitute the switch(es) indicated by the current atom. */ 5553 ordered_set = true; 5554 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix 5555 || atom == end_atom) 5556 abort (); 5557 5558 mark_matching_switches (atom, end_atom, a_is_starred); 5559 5560 if (*p == '}') 5561 process_marked_switches (); 5562 } 5563 else if (*p == '|' || *p == ':') 5564 { 5565 /* Substitute some text if the current atom appears as a switch 5566 or suffix. */ 5567 disjunct_set = true; 5568 if (ordered_set) 5569 abort (); 5570 5571 if (atom == end_atom) 5572 { 5573 if (!n_way_choice || disj_matched || *p == '|' 5574 || a_is_negated || a_is_suffix || a_is_starred) 5575 abort (); 5576 5577 /* An empty term may appear as the last choice of an 5578 N-way choice set; it means "otherwise". */ 5579 a_must_be_last = true; 5580 disj_matched = !n_way_matched; 5581 disj_starred = false; 5582 } 5583 else 5584 { 5585 if (a_is_suffix && a_is_starred) 5586 abort (); 5587 5588 if (!a_is_starred) 5589 disj_starred = false; 5590 5591 /* Don't bother testing this atom if we already have a 5592 match. */ 5593 if (!disj_matched && !n_way_matched) 5594 { 5595 if (a_is_suffix) 5596 a_matched = input_suffix_matches (atom, end_atom); 5597 else 5598 a_matched = switch_matches (atom, end_atom, a_is_starred); 5599 5600 if (a_matched != a_is_negated) 5601 { 5602 disj_matched = true; 5603 d_atom = atom; 5604 d_end_atom = end_atom; 5605 } 5606 } 5607 } 5608 5609 if (*p == ':') 5610 { 5611 /* Found the body, that is, the text to substitute if the 5612 current disjunction matches. */ 5613 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred, 5614 disj_matched && !n_way_matched); 5615 if (p == 0) 5616 return 0; 5617 5618 /* If we have an N-way choice, reset state for the next 5619 disjunction. */ 5620 if (*p == ';') 5621 { 5622 n_way_choice = true; 5623 n_way_matched |= disj_matched; 5624 disj_matched = false; 5625 disj_starred = true; 5626 d_atom = d_end_atom = NULL; 5627 } 5628 } 5629 } 5630 else 5631 abort (); 5632 } 5633 while (*p++ != '}'); 5634 5635 return p; 5636 5637#undef SKIP_WHITE 5638} 5639 5640/* Subroutine of handle_braces. Scan and process a brace substitution body 5641 (X in the description of %{} syntax). P points one past the colon; 5642 ATOM and END_ATOM bracket the first atom which was found to be true 5643 (present) in the current disjunction; STARRED indicates whether all 5644 the atoms in the current disjunction were starred (for syntax validation); 5645 MATCHED indicates whether the disjunction matched or not, and therefore 5646 whether or not the body is to be processed through do_spec_1 or just 5647 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1 5648 returns -1. */ 5649 5650static const char * 5651process_brace_body (const char *p, const char *atom, const char *end_atom, 5652 int starred, int matched) 5653{ 5654 const char *body, *end_body; 5655 unsigned int nesting_level; 5656 bool have_subst = false; 5657 5658 /* Locate the closing } or ;, honoring nested braces. 5659 Trim trailing whitespace. */ 5660 body = p; 5661 nesting_level = 1; 5662 for (;;) 5663 { 5664 if (*p == '{') 5665 nesting_level++; 5666 else if (*p == '}') 5667 { 5668 if (!--nesting_level) 5669 break; 5670 } 5671 else if (*p == ';' && nesting_level == 1) 5672 break; 5673 else if (*p == '%' && p[1] == '*' && nesting_level == 1) 5674 have_subst = true; 5675 else if (*p == '\0') 5676 abort (); 5677 p++; 5678 } 5679 5680 end_body = p; 5681 while (end_body[-1] == ' ' || end_body[-1] == '\t') 5682 end_body--; 5683 5684 if (have_subst && !starred) 5685 abort (); 5686 5687 if (matched) 5688 { 5689 /* Copy the substitution body to permanent storage and execute it. 5690 If have_subst is false, this is a simple matter of running the 5691 body through do_spec_1... */ 5692 char *string = save_string (body, end_body - body); 5693 if (!have_subst) 5694 { 5695 if (do_spec_1 (string, 0, NULL) < 0) 5696 return 0; 5697 } 5698 else 5699 { 5700 /* ... but if have_subst is true, we have to process the 5701 body once for each matching switch, with %* set to the 5702 variant part of the switch. */ 5703 unsigned int hard_match_len = end_atom - atom; 5704 int i; 5705 5706 for (i = 0; i < n_switches; i++) 5707 if (!strncmp (switches[i].part1, atom, hard_match_len) 5708 && check_live_switch (i, hard_match_len)) 5709 { 5710 if (do_spec_1 (string, 0, 5711 &switches[i].part1[hard_match_len]) < 0) 5712 return 0; 5713 /* Pass any arguments this switch has. */ 5714 give_switch (i, 1); 5715 suffix_subst = NULL; 5716 } 5717 } 5718 } 5719 5720 return p; 5721} 5722 5723/* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch 5724 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*} 5725 spec, or -1 if either exact match or %* is used. 5726 5727 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch 5728 whose value does not begin with "no-" is obsoleted by the same value 5729 with the "no-", similarly for a switch with the "no-" prefix. */ 5730 5731static int 5732check_live_switch (int switchnum, int prefix_length) 5733{ 5734 const char *name = switches[switchnum].part1; 5735 int i; 5736 5737 /* In the common case of {<at-most-one-letter>*}, a negating 5738 switch would always match, so ignore that case. We will just 5739 send the conflicting switches to the compiler phase. */ 5740 if (prefix_length >= 0 && prefix_length <= 1) 5741 return 1; 5742 5743 /* If we already processed this switch and determined if it was 5744 live or not, return our past determination. */ 5745 if (switches[switchnum].live_cond != 0) 5746 return switches[switchnum].live_cond > 0; 5747 5748 /* Now search for duplicate in a manner that depends on the name. */ 5749 switch (*name) 5750 { 5751 case 'O': 5752 for (i = switchnum + 1; i < n_switches; i++) 5753 if (switches[i].part1[0] == 'O') 5754 { 5755 switches[switchnum].validated = 1; 5756 switches[switchnum].live_cond = SWITCH_FALSE; 5757 return 0; 5758 } 5759 break; 5760 5761 case 'W': case 'f': case 'm': 5762 if (! strncmp (name + 1, "no-", 3)) 5763 { 5764 /* We have Xno-YYY, search for XYYY. */ 5765 for (i = switchnum + 1; i < n_switches; i++) 5766 if (switches[i].part1[0] == name[0] 5767 && ! strcmp (&switches[i].part1[1], &name[4])) 5768 { 5769 switches[switchnum].validated = 1; 5770 switches[switchnum].live_cond = SWITCH_FALSE; 5771 return 0; 5772 } 5773 } 5774 else 5775 { 5776 /* We have XYYY, search for Xno-YYY. */ 5777 for (i = switchnum + 1; i < n_switches; i++) 5778 if (switches[i].part1[0] == name[0] 5779 && switches[i].part1[1] == 'n' 5780 && switches[i].part1[2] == 'o' 5781 && switches[i].part1[3] == '-' 5782 && !strcmp (&switches[i].part1[4], &name[1])) 5783 { 5784 switches[switchnum].validated = 1; 5785 switches[switchnum].live_cond = SWITCH_FALSE; 5786 return 0; 5787 } 5788 } 5789 break; 5790 } 5791 5792 /* Otherwise the switch is live. */ 5793 switches[switchnum].live_cond = SWITCH_LIVE; 5794 return 1; 5795} 5796 5797/* Pass a switch to the current accumulating command 5798 in the same form that we received it. 5799 SWITCHNUM identifies the switch; it is an index into 5800 the vector of switches gcc received, which is `switches'. 5801 This cannot fail since it never finishes a command line. 5802 5803 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */ 5804 5805static void 5806give_switch (int switchnum, int omit_first_word) 5807{ 5808 if (switches[switchnum].live_cond == SWITCH_IGNORE) 5809 return; 5810 5811 if (!omit_first_word) 5812 { 5813 do_spec_1 ("-", 0, NULL); 5814 do_spec_1 (switches[switchnum].part1, 1, NULL); 5815 } 5816 5817 if (switches[switchnum].args != 0) 5818 { 5819 const char **p; 5820 for (p = switches[switchnum].args; *p; p++) 5821 { 5822 const char *arg = *p; 5823 5824 do_spec_1 (" ", 0, NULL); 5825 if (suffix_subst) 5826 { 5827 unsigned length = strlen (arg); 5828 int dot = 0; 5829 5830 while (length-- && !IS_DIR_SEPARATOR (arg[length])) 5831 if (arg[length] == '.') 5832 { 5833 ((char *)arg)[length] = 0; 5834 dot = 1; 5835 break; 5836 } 5837 do_spec_1 (arg, 1, NULL); 5838 if (dot) 5839 ((char *)arg)[length] = '.'; 5840 do_spec_1 (suffix_subst, 1, NULL); 5841 } 5842 else 5843 do_spec_1 (arg, 1, NULL); 5844 } 5845 } 5846 5847 do_spec_1 (" ", 0, NULL); 5848 switches[switchnum].validated = 1; 5849} 5850 5851/* Search for a file named NAME trying various prefixes including the 5852 user's -B prefix and some standard ones. 5853 Return the absolute file name found. If nothing is found, return NAME. */ 5854 5855static const char * 5856find_file (const char *name) 5857{ 5858 char *newname; 5859 5860 /* Try multilib_dir if it is defined. */ 5861 if (multilib_os_dir != NULL) 5862 { 5863 newname = find_a_file (&startfile_prefixes, name, R_OK, 1); 5864 5865 /* If we don't find it in the multi library dir, then fall 5866 through and look for it in the normal places. */ 5867 if (newname != NULL) 5868 return newname; 5869 } 5870 5871 newname = find_a_file (&startfile_prefixes, name, R_OK, 0); 5872 return newname ? newname : name; 5873} 5874 5875/* Determine whether a directory exists. If LINKER, return 0 for 5876 certain fixed names not needed by the linker. If not LINKER, it is 5877 only important to return 0 if the host machine has a small ARG_MAX 5878 limit. */ 5879 5880static int 5881is_directory (const char *path1, const char *path2, int linker) 5882{ 5883 int len1 = strlen (path1); 5884 int len2 = strlen (path2); 5885 char *path = alloca (3 + len1 + len2); 5886 char *cp; 5887 struct stat st; 5888 5889#ifndef SMALL_ARG_MAX 5890 if (! linker) 5891 return 1; 5892#endif 5893 5894 /* Construct the path from the two parts. Ensure the string ends with "/.". 5895 The resulting path will be a directory even if the given path is a 5896 symbolic link. */ 5897 memcpy (path, path1, len1); 5898 memcpy (path + len1, path2, len2); 5899 cp = path + len1 + len2; 5900 if (!IS_DIR_SEPARATOR (cp[-1])) 5901 *cp++ = DIR_SEPARATOR; 5902 *cp++ = '.'; 5903 *cp = '\0'; 5904 5905#ifndef FREEBSD_NATIVE 5906 /* Exclude directories that the linker is known to search. */ 5907 if (linker 5908 && ((cp - path == 6 5909 && strcmp (path, concat (dir_separator_str, "lib", 5910 dir_separator_str, ".", NULL)) == 0) 5911 || (cp - path == 10 5912 && strcmp (path, concat (dir_separator_str, "usr", 5913 dir_separator_str, "lib", 5914 dir_separator_str, ".", NULL)) == 0))) 5915 return 0; 5916#endif /* FREEBSD_NATIVE */ 5917 5918 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode)); 5919} 5920 5921/* Set up the various global variables to indicate that we're processing 5922 the input file named FILENAME. */ 5923 5924void 5925set_input (const char *filename) 5926{ 5927 const char *p; 5928 5929 input_filename = filename; 5930 input_filename_length = strlen (input_filename); 5931 5932 input_basename = input_filename; 5933#ifdef HAVE_DOS_BASED_FILE_SYSTEM 5934 /* Skip drive name so 'x:foo' is handled properly. */ 5935 if (input_basename[1] == ':') 5936 input_basename += 2; 5937#endif 5938 for (p = input_basename; *p; p++) 5939 if (IS_DIR_SEPARATOR (*p)) 5940 input_basename = p + 1; 5941 5942 /* Find a suffix starting with the last period, 5943 and set basename_length to exclude that suffix. */ 5944 basename_length = strlen (input_basename); 5945 suffixed_basename_length = basename_length; 5946 p = input_basename + basename_length; 5947 while (p != input_basename && *p != '.') 5948 --p; 5949 if (*p == '.' && p != input_basename) 5950 { 5951 basename_length = p - input_basename; 5952 input_suffix = p + 1; 5953 } 5954 else 5955 input_suffix = ""; 5956 5957 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then 5958 we will need to do a stat on the input_filename. The 5959 INPUT_STAT_SET signals that the stat is needed. */ 5960 input_stat_set = 0; 5961} 5962 5963/* On fatal signals, delete all the temporary files. */ 5964 5965static void 5966fatal_error (int signum) 5967{ 5968 signal (signum, SIG_DFL); 5969 delete_failure_queue (); 5970 delete_temp_files (); 5971 /* Get the same signal again, this time not handled, 5972 so its normal effect occurs. */ 5973 kill (getpid (), signum); 5974} 5975 5976extern int main (int, const char **); 5977 5978int 5979main (int argc, const char **argv) 5980{ 5981 size_t i; 5982 int value; 5983 int linker_was_run = 0; 5984 int num_linker_inputs = 0; 5985 char *explicit_link_files; 5986 char *specs_file; 5987 const char *p; 5988 struct user_specs *uptr; 5989 5990 p = argv[0] + strlen (argv[0]); 5991 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1])) 5992 --p; 5993 programname = p; 5994 5995 xmalloc_set_program_name (programname); 5996 5997#ifdef GCC_DRIVER_HOST_INITIALIZATION 5998 /* Perform host dependent initialization when needed. */ 5999 GCC_DRIVER_HOST_INITIALIZATION; 6000#endif 6001 6002 gcc_init_libintl (); 6003 6004 if (signal (SIGINT, SIG_IGN) != SIG_IGN) 6005 signal (SIGINT, fatal_error); 6006#ifdef SIGHUP 6007 if (signal (SIGHUP, SIG_IGN) != SIG_IGN) 6008 signal (SIGHUP, fatal_error); 6009#endif 6010 if (signal (SIGTERM, SIG_IGN) != SIG_IGN) 6011 signal (SIGTERM, fatal_error); 6012#ifdef SIGPIPE 6013 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN) 6014 signal (SIGPIPE, fatal_error); 6015#endif 6016#ifdef SIGCHLD 6017 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will 6018 receive the signal. A different setting is inheritable */ 6019 signal (SIGCHLD, SIG_DFL); 6020#endif 6021 6022 /* Allocate the argument vector. */ 6023 alloc_args (); 6024 6025 obstack_init (&obstack); 6026 6027 /* Build multilib_select, et. al from the separate lines that make up each 6028 multilib selection. */ 6029 { 6030 const char *const *q = multilib_raw; 6031 int need_space; 6032 6033 obstack_init (&multilib_obstack); 6034 while ((p = *q++) != (char *) 0) 6035 obstack_grow (&multilib_obstack, p, strlen (p)); 6036 6037 obstack_1grow (&multilib_obstack, 0); 6038 multilib_select = obstack_finish (&multilib_obstack); 6039 6040 q = multilib_matches_raw; 6041 while ((p = *q++) != (char *) 0) 6042 obstack_grow (&multilib_obstack, p, strlen (p)); 6043 6044 obstack_1grow (&multilib_obstack, 0); 6045 multilib_matches = obstack_finish (&multilib_obstack); 6046 6047 q = multilib_exclusions_raw; 6048 while ((p = *q++) != (char *) 0) 6049 obstack_grow (&multilib_obstack, p, strlen (p)); 6050 6051 obstack_1grow (&multilib_obstack, 0); 6052 multilib_exclusions = obstack_finish (&multilib_obstack); 6053 6054 need_space = FALSE; 6055 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++) 6056 { 6057 if (need_space) 6058 obstack_1grow (&multilib_obstack, ' '); 6059 obstack_grow (&multilib_obstack, 6060 multilib_defaults_raw[i], 6061 strlen (multilib_defaults_raw[i])); 6062 need_space = TRUE; 6063 } 6064 6065 obstack_1grow (&multilib_obstack, 0); 6066 multilib_defaults = obstack_finish (&multilib_obstack); 6067 } 6068 6069 /* Set up to remember the pathname of gcc and any options 6070 needed for collect. We use argv[0] instead of programname because 6071 we need the complete pathname. */ 6072 obstack_init (&collect_obstack); 6073 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1); 6074 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1); 6075 putenv (obstack_finish (&collect_obstack)); 6076 6077#ifdef INIT_ENVIRONMENT 6078 /* Set up any other necessary machine specific environment variables. */ 6079 putenv (INIT_ENVIRONMENT); 6080#endif 6081 6082 /* Make a table of what switches there are (switches, n_switches). 6083 Make a table of specified input files (infiles, n_infiles). 6084 Decode switches that are handled locally. */ 6085 6086 process_command (argc, argv); 6087 6088 /* Initialize the vector of specs to just the default. 6089 This means one element containing 0s, as a terminator. */ 6090 6091 compilers = xmalloc (sizeof default_compilers); 6092 memcpy (compilers, default_compilers, sizeof default_compilers); 6093 n_compilers = n_default_compilers; 6094 6095 /* Read specs from a file if there is one. */ 6096 6097#ifdef FREEBSD_NATIVE 6098 just_machine_suffix = ""; 6099#else /* FREEBSD_NATIVE */ 6100 machine_suffix = concat (spec_machine, dir_separator_str, 6101 spec_version, dir_separator_str, NULL); 6102 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL); 6103#endif /* FREEBSD_NATIVE */ 6104 6105 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, 0); 6106 /* Read the specs file unless it is a default one. */ 6107 if (specs_file != 0 && strcmp (specs_file, "specs")) 6108 read_specs (specs_file, TRUE); 6109 else 6110 init_spec (); 6111 6112 /* We need to check standard_exec_prefix/just_machine_suffix/specs 6113 for any override of as, ld and libraries. */ 6114 specs_file = (char *) alloca (strlen (FBSD_DATA_PREFIX) 6115 + strlen (just_machine_suffix) 6116 + sizeof ("specs")); 6117 6118 strcpy (specs_file, FBSD_DATA_PREFIX); 6119 strcat (specs_file, just_machine_suffix); 6120 strcat (specs_file, "specs"); 6121 if (access (specs_file, R_OK) == 0) 6122 read_specs (specs_file, TRUE); 6123 6124 /* Process any configure-time defaults specified for the command line 6125 options, via OPTION_DEFAULT_SPECS. */ 6126 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++) 6127 do_option_spec (option_default_specs[i].name, 6128 option_default_specs[i].spec); 6129 6130 /* Process DRIVER_SELF_SPECS, adding any new options to the end 6131 of the command line. */ 6132 6133 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++) 6134 do_self_spec (driver_self_specs[i]); 6135 6136 /* If not cross-compiling, look for executables in the standard 6137 places. */ 6138 if (*cross_compile == '0') 6139 { 6140 if (*md_exec_prefix) 6141 { 6142 add_prefix (&exec_prefixes, md_exec_prefix, "GCC", 6143 PREFIX_PRIORITY_LAST, 0, NULL, 0); 6144 } 6145 } 6146 6147 /* Process sysroot_suffix_spec. */ 6148 if (*sysroot_suffix_spec != 0 6149 && do_spec_2 (sysroot_suffix_spec) == 0) 6150 { 6151 if (argbuf_index > 1) 6152 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC."); 6153 else if (argbuf_index == 1) 6154 target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]); 6155 } 6156 6157 /* Process sysroot_hdrs_suffix_spec. */ 6158 if (*sysroot_hdrs_suffix_spec != 0 6159 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0) 6160 { 6161 if (argbuf_index > 1) 6162 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC."); 6163 else if (argbuf_index == 1) 6164 target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]); 6165 } 6166 6167 /* Look for startfiles in the standard places. */ 6168 if (*startfile_prefix_spec != 0 6169 && do_spec_2 (startfile_prefix_spec) == 0 6170 && do_spec_1 (" ", 0, NULL) == 0) 6171 { 6172 int ndx; 6173 for (ndx = 0; ndx < argbuf_index; ndx++) 6174 add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS", 6175 PREFIX_PRIORITY_LAST, 0, NULL, 1); 6176 } 6177 /* We should eventually get rid of all these and stick to 6178 startfile_prefix_spec exclusively. */ 6179 else if (*cross_compile == '0' || target_system_root) 6180 { 6181 if (*md_exec_prefix) 6182 add_sysrooted_prefix (&startfile_prefixes, md_exec_prefix, "GCC", 6183 PREFIX_PRIORITY_LAST, 0, NULL, 1); 6184 6185 if (*md_startfile_prefix) 6186 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix, 6187 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6188 6189 if (*md_startfile_prefix_1) 6190 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1, 6191 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6192 6193 /* If standard_startfile_prefix is relative, base it on 6194 standard_exec_prefix. This lets us move the installed tree 6195 as a unit. If GCC_EXEC_PREFIX is defined, base 6196 standard_startfile_prefix on that as well. 6197 6198 If the prefix is relative, only search it for native compilers; 6199 otherwise we will search a directory containing host libraries. */ 6200 if (IS_ABSOLUTE_PATH (standard_startfile_prefix)) 6201 add_sysrooted_prefix (&startfile_prefixes, 6202 standard_startfile_prefix, "BINUTILS", 6203 PREFIX_PRIORITY_LAST, 0, NULL, 1); 6204 else if (*cross_compile == '0') 6205 { 6206 if (gcc_exec_prefix) 6207 add_prefix (&startfile_prefixes, 6208 concat (gcc_exec_prefix, machine_suffix, 6209 standard_startfile_prefix, NULL), 6210 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1); 6211 add_prefix (&startfile_prefixes, 6212 concat (standard_exec_prefix, 6213 machine_suffix, 6214 standard_startfile_prefix, NULL), 6215 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1); 6216 } 6217 6218#ifndef FREEBSD_NATIVE 6219 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_1, 6220 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6221 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_2, 6222 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1); 6223#endif /* not FREEBSD_NATIVE */ 6224#if 0 /* Can cause surprises, and one can use -B./ instead. */ 6225 add_prefix (&startfile_prefixes, "./", NULL, 6226 PREFIX_PRIORITY_LAST, 1, NULL, 0); 6227#endif 6228 } 6229 6230 /* Process any user specified specs in the order given on the command 6231 line. */ 6232 for (uptr = user_specs_head; uptr; uptr = uptr->next) 6233 { 6234 char *filename = find_a_file (&startfile_prefixes, uptr->filename, 6235 R_OK, 0); 6236 read_specs (filename ? filename : uptr->filename, FALSE); 6237 } 6238 6239 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */ 6240 if (gcc_exec_prefix) 6241 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str, 6242 spec_version, dir_separator_str, NULL); 6243 6244 /* Now we have the specs. 6245 Set the `valid' bits for switches that match anything in any spec. */ 6246 6247 validate_all_switches (); 6248 6249 /* Now that we have the switches and the specs, set 6250 the subdirectory based on the options. */ 6251 set_multilib_dir (); 6252 6253 /* Warn about any switches that no pass was interested in. */ 6254 6255 for (i = 0; (int) i < n_switches; i++) 6256 if (! switches[i].validated) 6257 error ("unrecognized option `-%s'", switches[i].part1); 6258 6259 /* Obey some of the options. */ 6260 6261 if (print_search_dirs) 6262 { 6263 printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix); 6264 printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0)); 6265 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0)); 6266 return (0); 6267 } 6268 6269 if (print_file_name) 6270 { 6271 printf ("%s\n", find_file (print_file_name)); 6272 return (0); 6273 } 6274 6275 if (print_prog_name) 6276 { 6277 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0); 6278 printf ("%s\n", (newname ? newname : print_prog_name)); 6279 return (0); 6280 } 6281 6282 if (print_multi_lib) 6283 { 6284 print_multilib_info (); 6285 return (0); 6286 } 6287 6288 if (print_multi_directory) 6289 { 6290 if (multilib_dir == NULL) 6291 printf (".\n"); 6292 else 6293 printf ("%s\n", multilib_dir); 6294 return (0); 6295 } 6296 6297 if (print_multi_os_directory) 6298 { 6299 if (multilib_os_dir == NULL) 6300 printf (".\n"); 6301 else 6302 printf ("%s\n", multilib_os_dir); 6303 return (0); 6304 } 6305 6306 if (target_help_flag) 6307 { 6308 /* Print if any target specific options. */ 6309 6310 /* We do not exit here. Instead we have created a fake input file 6311 called 'target-dummy' which needs to be compiled, and we pass this 6312 on to the various sub-processes, along with the --target-help 6313 switch. */ 6314 } 6315 6316 if (print_help_list) 6317 { 6318 display_help (); 6319 6320 if (! verbose_flag) 6321 { 6322 printf (_("\nFor bug reporting instructions, please see:\n")); 6323 printf ("%s.\n", bug_report_url); 6324 6325 return (0); 6326 } 6327 6328 /* We do not exit here. Instead we have created a fake input file 6329 called 'help-dummy' which needs to be compiled, and we pass this 6330 on the various sub-processes, along with the --help switch. */ 6331 } 6332 6333 if (verbose_flag) 6334 { 6335 int n; 6336 const char *thrmod; 6337 6338 notice ("Configured with: %s\n", configuration_arguments); 6339 6340#ifdef THREAD_MODEL_SPEC 6341 /* We could have defined THREAD_MODEL_SPEC to "%*" by default, 6342 but there's no point in doing all this processing just to get 6343 thread_model back. */ 6344 obstack_init (&obstack); 6345 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model); 6346 obstack_1grow (&obstack, '\0'); 6347 thrmod = obstack_finish (&obstack); 6348#else 6349 thrmod = thread_model; 6350#endif 6351 6352 notice ("Thread model: %s\n", thrmod); 6353 6354 /* compiler_version is truncated at the first space when initialized 6355 from version string, so truncate version_string at the first space 6356 before comparing. */ 6357 for (n = 0; version_string[n]; n++) 6358 if (version_string[n] == ' ') 6359 break; 6360 6361 if (! strncmp (version_string, compiler_version, n) 6362 && compiler_version[n] == 0) 6363 notice ("gcc version %s\n", version_string); 6364 else 6365 notice ("gcc driver version %s executing gcc version %s\n", 6366 version_string, compiler_version); 6367 6368 if (n_infiles == 0) 6369 return (0); 6370 } 6371 6372 if (n_infiles == added_libraries) 6373 fatal ("No input files specified"); 6374 6375 /* Make a place to record the compiler output file names 6376 that correspond to the input files. */ 6377 6378 i = n_infiles; 6379 i += lang_specific_extra_outfiles; 6380 outfiles = xcalloc (i, sizeof (char *)); 6381 6382 /* Record which files were specified explicitly as link input. */ 6383 6384 explicit_link_files = xcalloc (1, n_infiles); 6385 6386 if (combine_inputs) 6387 { 6388 int lang_n_infiles = 0; 6389 for (i = 0; (int) i < n_infiles; i++) 6390 { 6391 const char *name = infiles[i].name; 6392 struct compiler *compiler 6393 = lookup_compiler (name, strlen (name), infiles[i].language); 6394 if (compiler == NULL) 6395 error ("%s: linker input file unused because linking not done", 6396 name); 6397 else if (lang_n_infiles > 0 && compiler != input_file_compiler) 6398 fatal ("cannot specify -o with -c or -S and multiple languages"); 6399 else 6400 { 6401 lang_n_infiles++; 6402 input_file_compiler = compiler; 6403 } 6404 } 6405 } 6406 6407 for (i = 0; (int) i < (combine_inputs ? 1 : n_infiles); i++) 6408 { 6409 int this_file_error = 0; 6410 6411 /* Tell do_spec what to substitute for %i. */ 6412 6413 input_file_number = i; 6414 set_input (infiles[i].name); 6415 6416 /* Use the same thing in %o, unless cp->spec says otherwise. */ 6417 6418 outfiles[i] = input_filename; 6419 6420 /* Figure out which compiler from the file's suffix. */ 6421 6422 if (! combine_inputs) 6423 input_file_compiler 6424 = lookup_compiler (infiles[i].name, input_filename_length, 6425 infiles[i].language); 6426 6427 if (input_file_compiler) 6428 { 6429 /* Ok, we found an applicable compiler. Run its spec. */ 6430 6431 if (input_file_compiler->spec[0] == '#') 6432 { 6433 error ("%s: %s compiler not installed on this system", 6434 input_filename, &input_file_compiler->spec[1]); 6435 this_file_error = 1; 6436 } 6437 else 6438 { 6439 value = do_spec (input_file_compiler->spec); 6440 if (value < 0) 6441 this_file_error = 1; 6442 } 6443 } 6444 6445 /* If this file's name does not contain a recognized suffix, 6446 record it as explicit linker input. */ 6447 6448 else 6449 explicit_link_files[i] = 1; 6450 6451 /* Clear the delete-on-failure queue, deleting the files in it 6452 if this compilation failed. */ 6453 6454 if (this_file_error) 6455 { 6456 delete_failure_queue (); 6457 error_count++; 6458 } 6459 /* If this compilation succeeded, don't delete those files later. */ 6460 clear_failure_queue (); 6461 } 6462 6463 /* Reset the output file name to the first input file name, for use 6464 with %b in LINK_SPEC on a target that prefers not to emit a.out 6465 by default. */ 6466 if (n_infiles > 0) 6467 set_input (infiles[0].name); 6468 6469 if (error_count == 0) 6470 { 6471 /* Make sure INPUT_FILE_NUMBER points to first available open 6472 slot. */ 6473 input_file_number = n_infiles; 6474 if (lang_specific_pre_link ()) 6475 error_count++; 6476 } 6477 6478 /* Determine if there are any linker input files. */ 6479 num_linker_inputs = 0; 6480 for (i = 0; (int) i < n_infiles; i++) 6481 if (explicit_link_files[i] || outfiles[i] != NULL) 6482 num_linker_inputs++; 6483 6484 /* Run ld to link all the compiler output files. */ 6485 6486 if (num_linker_inputs > 0 && error_count == 0) 6487 { 6488 int tmp = execution_count; 6489 6490 /* We'll use ld if we can't find collect2. */ 6491 if (! strcmp (linker_name_spec, "collect2")) 6492 { 6493 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, 0); 6494 if (s == NULL) 6495 linker_name_spec = "ld"; 6496 } 6497 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables 6498 for collect. */ 6499 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH"); 6500 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV); 6501 6502 value = do_spec (link_command_spec); 6503 if (value < 0) 6504 error_count = 1; 6505 linker_was_run = (tmp != execution_count); 6506 } 6507 6508 /* If options said don't run linker, 6509 complain about input files to be given to the linker. */ 6510 6511 if (! linker_was_run && error_count == 0) 6512 for (i = 0; (int) i < n_infiles; i++) 6513 if (explicit_link_files[i]) 6514 error ("%s: linker input file unused because linking not done", 6515 outfiles[i]); 6516 6517 /* Delete some or all of the temporary files we made. */ 6518 6519 if (error_count) 6520 delete_failure_queue (); 6521 delete_temp_files (); 6522 6523 if (print_help_list) 6524 { 6525 printf (("\nFor bug reporting instructions, please see:\n")); 6526 printf ("%s\n", bug_report_url); 6527 } 6528 6529 return (signal_count != 0 ? 2 6530 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1) 6531 : 0); 6532} 6533 6534/* Find the proper compilation spec for the file name NAME, 6535 whose length is LENGTH. LANGUAGE is the specified language, 6536 or 0 if this file is to be passed to the linker. */ 6537 6538static struct compiler * 6539lookup_compiler (const char *name, size_t length, const char *language) 6540{ 6541 struct compiler *cp; 6542 6543 /* If this was specified by the user to be a linker input, indicate that. */ 6544 if (language != 0 && language[0] == '*') 6545 return 0; 6546 6547 /* Otherwise, look for the language, if one is spec'd. */ 6548 if (language != 0) 6549 { 6550 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 6551 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language)) 6552 return cp; 6553 6554 error ("language %s not recognized", language); 6555 return 0; 6556 } 6557 6558 /* Look for a suffix. */ 6559 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 6560 { 6561 if (/* The suffix `-' matches only the file name `-'. */ 6562 (!strcmp (cp->suffix, "-") && !strcmp (name, "-")) 6563 || (strlen (cp->suffix) < length 6564 /* See if the suffix matches the end of NAME. */ 6565 && !strcmp (cp->suffix, 6566 name + length - strlen (cp->suffix)) 6567 )) 6568 break; 6569 } 6570 6571#if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM) 6572 /* look again, but case-insensitively this time. */ 6573 if (cp < compilers) 6574 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--) 6575 { 6576 if (/* The suffix `-' matches only the file name `-'. */ 6577 (!strcmp (cp->suffix, "-") && !strcmp (name, "-")) 6578 || (strlen (cp->suffix) < length 6579 /* See if the suffix matches the end of NAME. */ 6580 && ((!strcmp (cp->suffix, 6581 name + length - strlen (cp->suffix)) 6582 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ")) 6583 && !strcasecmp (cp->suffix, 6584 name + length - strlen (cp->suffix))) 6585 )) 6586 break; 6587 } 6588#endif 6589 6590 if (cp >= compilers) 6591 { 6592 if (cp->spec[0] != '@') 6593 /* A non-alias entry: return it. */ 6594 return cp; 6595 6596 /* An alias entry maps a suffix to a language. 6597 Search for the language; pass 0 for NAME and LENGTH 6598 to avoid infinite recursion if language not found. */ 6599 return lookup_compiler (NULL, 0, cp->spec + 1); 6600 } 6601 return 0; 6602} 6603 6604static char * 6605save_string (const char *s, int len) 6606{ 6607 char *result = xmalloc (len + 1); 6608 6609 memcpy (result, s, len); 6610 result[len] = 0; 6611 return result; 6612} 6613 6614void 6615pfatal_with_name (const char *name) 6616{ 6617 perror_with_name (name); 6618 delete_temp_files (); 6619 exit (1); 6620} 6621 6622static void 6623perror_with_name (const char *name) 6624{ 6625 error ("%s: %s", name, xstrerror (errno)); 6626} 6627 6628static void 6629pfatal_pexecute (const char *errmsg_fmt, const char *errmsg_arg) 6630{ 6631 if (errmsg_arg) 6632 { 6633 int save_errno = errno; 6634 6635 /* Space for trailing '\0' is in %s. */ 6636 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg)); 6637 sprintf (msg, errmsg_fmt, errmsg_arg); 6638 errmsg_fmt = msg; 6639 6640 errno = save_errno; 6641 } 6642 6643 pfatal_with_name (errmsg_fmt); 6644} 6645 6646/* Output an error message and exit. */ 6647 6648void 6649fancy_abort (void) 6650{ 6651 fatal ("internal gcc abort"); 6652} 6653 6654/* Output an error message and exit. */ 6655 6656void 6657fatal (const char *msgid, ...) 6658{ 6659 va_list ap; 6660 6661 va_start (ap, msgid); 6662 6663 fprintf (stderr, "%s: ", programname); 6664 vfprintf (stderr, _(msgid), ap); 6665 va_end (ap); 6666 fprintf (stderr, "\n"); 6667 delete_temp_files (); 6668 exit (1); 6669} 6670 6671void 6672error (const char *msgid, ...) 6673{ 6674 va_list ap; 6675 6676 va_start (ap, msgid); 6677 fprintf (stderr, "%s: ", programname); 6678 vfprintf (stderr, _(msgid), ap); 6679 va_end (ap); 6680 6681 fprintf (stderr, "\n"); 6682} 6683 6684static void 6685notice (const char *msgid, ...) 6686{ 6687 va_list ap; 6688 6689 va_start (ap, msgid); 6690 vfprintf (stderr, _(msgid), ap); 6691 va_end (ap); 6692} 6693 6694static inline void 6695validate_switches_from_spec (const char *spec) 6696{ 6697 const char *p = spec; 6698 char c; 6699 while ((c = *p++)) 6700 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{'))) 6701 /* We have a switch spec. */ 6702 p = validate_switches (p + 1); 6703} 6704 6705static void 6706validate_all_switches (void) 6707{ 6708 struct compiler *comp; 6709 struct spec_list *spec; 6710 6711 for (comp = compilers; comp->spec; comp++) 6712 validate_switches_from_spec (comp->spec); 6713 6714 /* Look through the linked list of specs read from the specs file. */ 6715 for (spec = specs; spec; spec = spec->next) 6716 validate_switches_from_spec (*spec->ptr_spec); 6717 6718 validate_switches_from_spec (link_command_spec); 6719} 6720 6721/* Look at the switch-name that comes after START 6722 and mark as valid all supplied switches that match it. */ 6723 6724static const char * 6725validate_switches (const char *start) 6726{ 6727 const char *p = start; 6728 const char *atom; 6729 size_t len; 6730 int i; 6731 bool suffix = false; 6732 bool starred = false; 6733 6734#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0) 6735 6736next_member: 6737 SKIP_WHITE (); 6738 6739 if (*p == '!') 6740 p++; 6741 6742 SKIP_WHITE (); 6743 if (*p == '.') 6744 suffix = true, p++; 6745 6746 atom = p; 6747 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '=' 6748 || *p == ',' || *p == '.' || *p == '@') 6749 p++; 6750 len = p - atom; 6751 6752 if (*p == '*') 6753 starred = true, p++; 6754 6755 SKIP_WHITE (); 6756 6757 if (!suffix) 6758 { 6759 /* Mark all matching switches as valid. */ 6760 for (i = 0; i < n_switches; i++) 6761 if (!strncmp (switches[i].part1, atom, len) 6762 && (starred || switches[i].part1[len] == 0)) 6763 switches[i].validated = 1; 6764 } 6765 6766 if (*p) p++; 6767 if (*p && (p[-1] == '|' || p[-1] == '&')) 6768 goto next_member; 6769 6770 if (*p && p[-1] == ':') 6771 { 6772 while (*p && *p != ';' && *p != '}') 6773 { 6774 if (*p == '%') 6775 { 6776 p++; 6777 if (*p == '{' || *p == '<') 6778 p = validate_switches (p+1); 6779 else if (p[0] == 'W' && p[1] == '{') 6780 p = validate_switches (p+2); 6781 } 6782 else 6783 p++; 6784 } 6785 6786 if (*p) p++; 6787 if (*p && p[-1] == ';') 6788 goto next_member; 6789 } 6790 6791 return p; 6792#undef SKIP_WHITE 6793} 6794 6795struct mdswitchstr 6796{ 6797 const char *str; 6798 int len; 6799}; 6800 6801static struct mdswitchstr *mdswitches; 6802static int n_mdswitches; 6803 6804/* Check whether a particular argument was used. The first time we 6805 canonicalize the switches to keep only the ones we care about. */ 6806 6807static int 6808used_arg (const char *p, int len) 6809{ 6810 struct mswitchstr 6811 { 6812 const char *str; 6813 const char *replace; 6814 int len; 6815 int rep_len; 6816 }; 6817 6818 static struct mswitchstr *mswitches; 6819 static int n_mswitches; 6820 int i, j; 6821 6822 if (!mswitches) 6823 { 6824 struct mswitchstr *matches; 6825 const char *q; 6826 int cnt = 0; 6827 6828 /* Break multilib_matches into the component strings of string 6829 and replacement string. */ 6830 for (q = multilib_matches; *q != '\0'; q++) 6831 if (*q == ';') 6832 cnt++; 6833 6834 matches = alloca ((sizeof (struct mswitchstr)) * cnt); 6835 i = 0; 6836 q = multilib_matches; 6837 while (*q != '\0') 6838 { 6839 matches[i].str = q; 6840 while (*q != ' ') 6841 { 6842 if (*q == '\0') 6843 abort (); 6844 q++; 6845 } 6846 matches[i].len = q - matches[i].str; 6847 6848 matches[i].replace = ++q; 6849 while (*q != ';' && *q != '\0') 6850 { 6851 if (*q == ' ') 6852 abort (); 6853 q++; 6854 } 6855 matches[i].rep_len = q - matches[i].replace; 6856 i++; 6857 if (*q == ';') 6858 q++; 6859 } 6860 6861 /* Now build a list of the replacement string for switches that we care 6862 about. Make sure we allocate at least one entry. This prevents 6863 xmalloc from calling fatal, and prevents us from re-executing this 6864 block of code. */ 6865 mswitches 6866 = xmalloc (sizeof (struct mswitchstr) 6867 * (n_mdswitches + (n_switches ? n_switches : 1))); 6868 for (i = 0; i < n_switches; i++) 6869 { 6870 int xlen = strlen (switches[i].part1); 6871 for (j = 0; j < cnt; j++) 6872 if (xlen == matches[j].len 6873 && ! strncmp (switches[i].part1, matches[j].str, xlen)) 6874 { 6875 mswitches[n_mswitches].str = matches[j].replace; 6876 mswitches[n_mswitches].len = matches[j].rep_len; 6877 mswitches[n_mswitches].replace = (char *) 0; 6878 mswitches[n_mswitches].rep_len = 0; 6879 n_mswitches++; 6880 break; 6881 } 6882 } 6883 6884 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present 6885 on the command line nor any options mutually incompatible with 6886 them. */ 6887 for (i = 0; i < n_mdswitches; i++) 6888 { 6889 const char *r; 6890 6891 for (q = multilib_options; *q != '\0'; q++) 6892 { 6893 while (*q == ' ') 6894 q++; 6895 6896 r = q; 6897 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0 6898 || strchr (" /", q[mdswitches[i].len]) == NULL) 6899 { 6900 while (*q != ' ' && *q != '/' && *q != '\0') 6901 q++; 6902 if (*q != '/') 6903 break; 6904 q++; 6905 } 6906 6907 if (*q != ' ' && *q != '\0') 6908 { 6909 while (*r != ' ' && *r != '\0') 6910 { 6911 q = r; 6912 while (*q != ' ' && *q != '/' && *q != '\0') 6913 q++; 6914 6915 if (used_arg (r, q - r)) 6916 break; 6917 6918 if (*q != '/') 6919 { 6920 mswitches[n_mswitches].str = mdswitches[i].str; 6921 mswitches[n_mswitches].len = mdswitches[i].len; 6922 mswitches[n_mswitches].replace = (char *) 0; 6923 mswitches[n_mswitches].rep_len = 0; 6924 n_mswitches++; 6925 break; 6926 } 6927 6928 r = q + 1; 6929 } 6930 break; 6931 } 6932 } 6933 } 6934 } 6935 6936 for (i = 0; i < n_mswitches; i++) 6937 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len)) 6938 return 1; 6939 6940 return 0; 6941} 6942 6943static int 6944default_arg (const char *p, int len) 6945{ 6946 int i; 6947 6948 for (i = 0; i < n_mdswitches; i++) 6949 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len)) 6950 return 1; 6951 6952 return 0; 6953} 6954 6955/* Work out the subdirectory to use based on the options. The format of 6956 multilib_select is a list of elements. Each element is a subdirectory 6957 name followed by a list of options followed by a semicolon. The format 6958 of multilib_exclusions is the same, but without the preceding 6959 directory. First gcc will check the exclusions, if none of the options 6960 beginning with an exclamation point are present, and all of the other 6961 options are present, then we will ignore this completely. Passing 6962 that, gcc will consider each multilib_select in turn using the same 6963 rules for matching the options. If a match is found, that subdirectory 6964 will be used. */ 6965 6966static void 6967set_multilib_dir (void) 6968{ 6969 const char *p; 6970 unsigned int this_path_len; 6971 const char *this_path, *this_arg; 6972 const char *start, *end; 6973 int not_arg; 6974 int ok, ndfltok, first; 6975 6976 n_mdswitches = 0; 6977 start = multilib_defaults; 6978 while (*start == ' ' || *start == '\t') 6979 start++; 6980 while (*start != '\0') 6981 { 6982 n_mdswitches++; 6983 while (*start != ' ' && *start != '\t' && *start != '\0') 6984 start++; 6985 while (*start == ' ' || *start == '\t') 6986 start++; 6987 } 6988 6989 if (n_mdswitches) 6990 { 6991 int i = 0; 6992 6993 mdswitches = xmalloc (sizeof (struct mdswitchstr) * n_mdswitches); 6994 for (start = multilib_defaults; *start != '\0'; start = end + 1) 6995 { 6996 while (*start == ' ' || *start == '\t') 6997 start++; 6998 6999 if (*start == '\0') 7000 break; 7001 7002 for (end = start + 1; 7003 *end != ' ' && *end != '\t' && *end != '\0'; end++) 7004 ; 7005 7006 obstack_grow (&multilib_obstack, start, end - start); 7007 obstack_1grow (&multilib_obstack, 0); 7008 mdswitches[i].str = obstack_finish (&multilib_obstack); 7009 mdswitches[i++].len = end - start; 7010 7011 if (*end == '\0') 7012 break; 7013 } 7014 } 7015 7016 p = multilib_exclusions; 7017 while (*p != '\0') 7018 { 7019 /* Ignore newlines. */ 7020 if (*p == '\n') 7021 { 7022 ++p; 7023 continue; 7024 } 7025 7026 /* Check the arguments. */ 7027 ok = 1; 7028 while (*p != ';') 7029 { 7030 if (*p == '\0') 7031 abort (); 7032 7033 if (! ok) 7034 { 7035 ++p; 7036 continue; 7037 } 7038 7039 this_arg = p; 7040 while (*p != ' ' && *p != ';') 7041 { 7042 if (*p == '\0') 7043 abort (); 7044 ++p; 7045 } 7046 7047 if (*this_arg != '!') 7048 not_arg = 0; 7049 else 7050 { 7051 not_arg = 1; 7052 ++this_arg; 7053 } 7054 7055 ok = used_arg (this_arg, p - this_arg); 7056 if (not_arg) 7057 ok = ! ok; 7058 7059 if (*p == ' ') 7060 ++p; 7061 } 7062 7063 if (ok) 7064 return; 7065 7066 ++p; 7067 } 7068 7069 first = 1; 7070 p = multilib_select; 7071 while (*p != '\0') 7072 { 7073 /* Ignore newlines. */ 7074 if (*p == '\n') 7075 { 7076 ++p; 7077 continue; 7078 } 7079 7080 /* Get the initial path. */ 7081 this_path = p; 7082 while (*p != ' ') 7083 { 7084 if (*p == '\0') 7085 abort (); 7086 ++p; 7087 } 7088 this_path_len = p - this_path; 7089 7090 /* Check the arguments. */ 7091 ok = 1; 7092 ndfltok = 1; 7093 ++p; 7094 while (*p != ';') 7095 { 7096 if (*p == '\0') 7097 abort (); 7098 7099 if (! ok) 7100 { 7101 ++p; 7102 continue; 7103 } 7104 7105 this_arg = p; 7106 while (*p != ' ' && *p != ';') 7107 { 7108 if (*p == '\0') 7109 abort (); 7110 ++p; 7111 } 7112 7113 if (*this_arg != '!') 7114 not_arg = 0; 7115 else 7116 { 7117 not_arg = 1; 7118 ++this_arg; 7119 } 7120 7121 /* If this is a default argument, we can just ignore it. 7122 This is true even if this_arg begins with '!'. Beginning 7123 with '!' does not mean that this argument is necessarily 7124 inappropriate for this library: it merely means that 7125 there is a more specific library which uses this 7126 argument. If this argument is a default, we need not 7127 consider that more specific library. */ 7128 ok = used_arg (this_arg, p - this_arg); 7129 if (not_arg) 7130 ok = ! ok; 7131 7132 if (! ok) 7133 ndfltok = 0; 7134 7135 if (default_arg (this_arg, p - this_arg)) 7136 ok = 1; 7137 7138 if (*p == ' ') 7139 ++p; 7140 } 7141 7142 if (ok && first) 7143 { 7144 if (this_path_len != 1 7145 || this_path[0] != '.') 7146 { 7147 char *new_multilib_dir = xmalloc (this_path_len + 1); 7148 char *q; 7149 7150 strncpy (new_multilib_dir, this_path, this_path_len); 7151 new_multilib_dir[this_path_len] = '\0'; 7152 q = strchr (new_multilib_dir, ':'); 7153 if (q != NULL) 7154 *q = '\0'; 7155 multilib_dir = new_multilib_dir; 7156 } 7157 first = 0; 7158 } 7159 7160 if (ndfltok) 7161 { 7162 const char *q = this_path, *end = this_path + this_path_len; 7163 7164 while (q < end && *q != ':') 7165 q++; 7166 if (q < end) 7167 { 7168 char *new_multilib_os_dir = xmalloc (end - q); 7169 memcpy (new_multilib_os_dir, q + 1, end - q - 1); 7170 new_multilib_os_dir[end - q - 1] = '\0'; 7171 multilib_os_dir = new_multilib_os_dir; 7172 break; 7173 } 7174 } 7175 7176 ++p; 7177 } 7178 7179 if (multilib_dir == NULL && multilib_os_dir != NULL 7180 && strcmp (multilib_os_dir, ".") == 0) 7181 { 7182 free ((char *) multilib_os_dir); 7183 multilib_os_dir = NULL; 7184 } 7185 else if (multilib_dir != NULL && multilib_os_dir == NULL) 7186 multilib_os_dir = multilib_dir; 7187} 7188 7189/* Print out the multiple library subdirectory selection 7190 information. This prints out a series of lines. Each line looks 7191 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is 7192 required. Only the desired options are printed out, the negative 7193 matches. The options are print without a leading dash. There are 7194 no spaces to make it easy to use the information in the shell. 7195 Each subdirectory is printed only once. This assumes the ordering 7196 generated by the genmultilib script. Also, we leave out ones that match 7197 the exclusions. */ 7198 7199static void 7200print_multilib_info (void) 7201{ 7202 const char *p = multilib_select; 7203 const char *last_path = 0, *this_path; 7204 int skip; 7205 unsigned int last_path_len = 0; 7206 7207 while (*p != '\0') 7208 { 7209 skip = 0; 7210 /* Ignore newlines. */ 7211 if (*p == '\n') 7212 { 7213 ++p; 7214 continue; 7215 } 7216 7217 /* Get the initial path. */ 7218 this_path = p; 7219 while (*p != ' ') 7220 { 7221 if (*p == '\0') 7222 abort (); 7223 ++p; 7224 } 7225 7226 /* When --disable-multilib was used but target defines 7227 MULTILIB_OSDIRNAMES, entries starting with .: are there just 7228 to find multilib_os_dir, so skip them from output. */ 7229 if (this_path[0] == '.' && this_path[1] == ':') 7230 skip = 1; 7231 7232 /* Check for matches with the multilib_exclusions. We don't bother 7233 with the '!' in either list. If any of the exclusion rules match 7234 all of its options with the select rule, we skip it. */ 7235 { 7236 const char *e = multilib_exclusions; 7237 const char *this_arg; 7238 7239 while (*e != '\0') 7240 { 7241 int m = 1; 7242 /* Ignore newlines. */ 7243 if (*e == '\n') 7244 { 7245 ++e; 7246 continue; 7247 } 7248 7249 /* Check the arguments. */ 7250 while (*e != ';') 7251 { 7252 const char *q; 7253 int mp = 0; 7254 7255 if (*e == '\0') 7256 abort (); 7257 7258 if (! m) 7259 { 7260 ++e; 7261 continue; 7262 } 7263 7264 this_arg = e; 7265 7266 while (*e != ' ' && *e != ';') 7267 { 7268 if (*e == '\0') 7269 abort (); 7270 ++e; 7271 } 7272 7273 q = p + 1; 7274 while (*q != ';') 7275 { 7276 const char *arg; 7277 int len = e - this_arg; 7278 7279 if (*q == '\0') 7280 abort (); 7281 7282 arg = q; 7283 7284 while (*q != ' ' && *q != ';') 7285 { 7286 if (*q == '\0') 7287 abort (); 7288 ++q; 7289 } 7290 7291 if (! strncmp (arg, this_arg, (len < q - arg) ? q - arg : len) || 7292 default_arg (this_arg, e - this_arg)) 7293 { 7294 mp = 1; 7295 break; 7296 } 7297 7298 if (*q == ' ') 7299 ++q; 7300 } 7301 7302 if (! mp) 7303 m = 0; 7304 7305 if (*e == ' ') 7306 ++e; 7307 } 7308 7309 if (m) 7310 { 7311 skip = 1; 7312 break; 7313 } 7314 7315 if (*e != '\0') 7316 ++e; 7317 } 7318 } 7319 7320 if (! skip) 7321 { 7322 /* If this is a duplicate, skip it. */ 7323 skip = (last_path != 0 && (unsigned int) (p - this_path) == last_path_len 7324 && ! strncmp (last_path, this_path, last_path_len)); 7325 7326 last_path = this_path; 7327 last_path_len = p - this_path; 7328 } 7329 7330 /* If this directory requires any default arguments, we can skip 7331 it. We will already have printed a directory identical to 7332 this one which does not require that default argument. */ 7333 if (! skip) 7334 { 7335 const char *q; 7336 7337 q = p + 1; 7338 while (*q != ';') 7339 { 7340 const char *arg; 7341 7342 if (*q == '\0') 7343 abort (); 7344 7345 if (*q == '!') 7346 arg = NULL; 7347 else 7348 arg = q; 7349 7350 while (*q != ' ' && *q != ';') 7351 { 7352 if (*q == '\0') 7353 abort (); 7354 ++q; 7355 } 7356 7357 if (arg != NULL 7358 && default_arg (arg, q - arg)) 7359 { 7360 skip = 1; 7361 break; 7362 } 7363 7364 if (*q == ' ') 7365 ++q; 7366 } 7367 } 7368 7369 if (! skip) 7370 { 7371 const char *p1; 7372 7373 for (p1 = last_path; p1 < p && *p1 != ':'; p1++) 7374 putchar (*p1); 7375 putchar (';'); 7376 } 7377 7378 ++p; 7379 while (*p != ';') 7380 { 7381 int use_arg; 7382 7383 if (*p == '\0') 7384 abort (); 7385 7386 if (skip) 7387 { 7388 ++p; 7389 continue; 7390 } 7391 7392 use_arg = *p != '!'; 7393 7394 if (use_arg) 7395 putchar ('@'); 7396 7397 while (*p != ' ' && *p != ';') 7398 { 7399 if (*p == '\0') 7400 abort (); 7401 if (use_arg) 7402 putchar (*p); 7403 ++p; 7404 } 7405 7406 if (*p == ' ') 7407 ++p; 7408 } 7409 7410 if (! skip) 7411 { 7412 /* If there are extra options, print them now. */ 7413 if (multilib_extra && *multilib_extra) 7414 { 7415 int print_at = TRUE; 7416 const char *q; 7417 7418 for (q = multilib_extra; *q != '\0'; q++) 7419 { 7420 if (*q == ' ') 7421 print_at = TRUE; 7422 else 7423 { 7424 if (print_at) 7425 putchar ('@'); 7426 putchar (*q); 7427 print_at = FALSE; 7428 } 7429 } 7430 } 7431 7432 putchar ('\n'); 7433 } 7434 7435 ++p; 7436 } 7437} 7438 7439/* if-exists built-in spec function. 7440 7441 Checks to see if the file specified by the absolute pathname in 7442 ARGS exists. Returns that pathname if found. 7443 7444 The usual use for this function is to check for a library file 7445 (whose name has been expanded with %s). */ 7446 7447static const char * 7448if_exists_spec_function (int argc, const char **argv) 7449{ 7450 /* Must have only one argument. */ 7451 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK)) 7452 return argv[0]; 7453 7454 return NULL; 7455} 7456 7457/* if-exists-else built-in spec function. 7458 7459 This is like if-exists, but takes an additional argument which 7460 is returned if the first argument does not exist. */ 7461 7462static const char * 7463if_exists_else_spec_function (int argc, const char **argv) 7464{ 7465 /* Must have exactly two arguments. */ 7466 if (argc != 2) 7467 return NULL; 7468 7469 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK)) 7470 return argv[0]; 7471 7472 return argv[1]; 7473}
|