1 /* Set up combined include path chain for the preprocessor. 2 Copyright (C) 1986-2015 Free Software Foundation, Inc. 3 4 Broken out of cppinit.c and cppfiles.c and rewritten Mar 2003. 5 6 This program is free software; you can redistribute it and/or modify it 7 under the terms of the GNU General Public License as published by the 8 Free Software Foundation; either version 3, or (at your option) any 9 later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #include "config.h" 21 #include "system.h" 22 #include "coretypes.h" 23 #include "machmode.h" 24 #include "target.h" 25 #include "tm.h" 26 #include "cpplib.h" 27 #include "prefix.h" 28 #include "intl.h" 29 #include "incpath.h" 30 #include "cppdefault.h" 31 32 /* Microsoft Windows does not natively support inodes. 33 VMS has non-numeric inodes. */ 34 #ifdef VMS 35 # define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A))) 36 # define INO_T_COPY(DEST, SRC) memcpy (&(DEST), &(SRC), sizeof (SRC)) 37 #elif !defined (HOST_LACKS_INODE_NUMBERS) 38 # define INO_T_EQ(A, B) ((A) == (B)) 39 # define INO_T_COPY(DEST, SRC) (DEST) = (SRC) 40 #endif 41 42 #if defined INO_T_EQ 43 #define DIRS_EQ(A, B) ((A)->dev == (B)->dev \ 44 && INO_T_EQ ((A)->ino, (B)->ino)) 45 #else 46 #define DIRS_EQ(A, B) (!filename_cmp ((A)->canonical_name, (B)->canonical_name)) 47 #endif 48 49 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 }; 50 51 static void add_env_var_paths (const char *, int); 52 static void add_standard_paths (const char *, const char *, const char *, int); 53 static void free_path (struct cpp_dir *, int); 54 static void merge_include_chains (const char *, cpp_reader *, int); 55 static void add_sysroot_to_chain (const char *, int); 56 static struct cpp_dir *remove_duplicates (cpp_reader *, struct cpp_dir *, 57 struct cpp_dir *, 58 struct cpp_dir *, int); 59 60 /* Include chains heads and tails. */ 61 static struct cpp_dir *heads[4]; 62 static struct cpp_dir *tails[4]; 63 static bool quote_ignores_source_dir; 64 enum { REASON_QUIET = 0, REASON_NOENT, REASON_DUP, REASON_DUP_SYS }; 65 66 /* Free an element of the include chain, possibly giving a reason. */ 67 static void 68 free_path (struct cpp_dir *path, int reason) 69 { 70 switch (reason) 71 { 72 case REASON_DUP: 73 case REASON_DUP_SYS: 74 fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), path->name); 75 if (reason == REASON_DUP_SYS) 76 fprintf (stderr, 77 _(" as it is a non-system directory that duplicates a system directory\n")); 78 break; 79 80 case REASON_NOENT: 81 fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"), 82 path->name); 83 break; 84 85 case REASON_QUIET: 86 default: 87 break; 88 } 89 90 free (path->name); 91 free (path); 92 } 93 94 /* Read ENV_VAR for a PATH_SEPARATOR-separated list of file names; and 95 append all the names to the search path CHAIN. */ 96 static void 97 add_env_var_paths (const char *env_var, int chain) 98 { 99 char *p, *q, *path; 100 101 q = getenv (env_var); 102 103 if (!q) 104 return; 105 106 for (p = q; *q; p = q + 1) 107 { 108 q = p; 109 while (*q != 0 && *q != PATH_SEPARATOR) 110 q++; 111 112 if (p == q) 113 path = xstrdup ("."); 114 else 115 { 116 path = XNEWVEC (char, q - p + 1); 117 memcpy (path, p, q - p); 118 path[q - p] = '\0'; 119 } 120 121 add_path (path, chain, chain == SYSTEM, false); 122 } 123 } 124 125 /* Append the standard include chain defined in cppdefault.c. */ 126 static void 127 add_standard_paths (const char *sysroot, const char *iprefix, 128 const char *imultilib, int cxx_stdinc) 129 { 130 const struct default_include *p; 131 int relocated = cpp_relocated (); 132 size_t len; 133 134 if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0) 135 { 136 /* Look for directories that start with the standard prefix. 137 "Translate" them, i.e. replace /usr/local/lib/gcc... with 138 IPREFIX and search them first. */ 139 for (p = cpp_include_defaults; p->fname; p++) 140 { 141 if (!p->cplusplus || cxx_stdinc) 142 { 143 /* Should we be translating sysrooted dirs too? Assume 144 that iprefix and sysroot are mutually exclusive, for 145 now. */ 146 if (sysroot && p->add_sysroot) 147 continue; 148 if (!filename_ncmp (p->fname, cpp_GCC_INCLUDE_DIR, len)) 149 { 150 char *str = concat (iprefix, p->fname + len, NULL); 151 if (p->multilib == 1 && imultilib) 152 str = reconcat (str, str, dir_separator_str, 153 imultilib, NULL); 154 else if (p->multilib == 2) 155 { 156 if (!imultiarch) 157 { 158 free (str); 159 continue; 160 } 161 str = reconcat (str, str, dir_separator_str, 162 imultiarch, NULL); 163 } 164 add_path (str, SYSTEM, p->cxx_aware, false); 165 } 166 } 167 } 168 } 169 170 for (p = cpp_include_defaults; p->fname; p++) 171 { 172 if (!p->cplusplus || cxx_stdinc) 173 { 174 char *str; 175 176 /* Should this directory start with the sysroot? */ 177 if (sysroot && p->add_sysroot) 178 { 179 char *sysroot_no_trailing_dir_separator = xstrdup (sysroot); 180 size_t sysroot_len = strlen (sysroot); 181 182 if (sysroot_len > 0 && sysroot[sysroot_len - 1] == DIR_SEPARATOR) 183 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0'; 184 str = concat (sysroot_no_trailing_dir_separator, p->fname, NULL); 185 free (sysroot_no_trailing_dir_separator); 186 } 187 else if (!p->add_sysroot && relocated 188 && !filename_ncmp (p->fname, cpp_PREFIX, cpp_PREFIX_len)) 189 { 190 static const char *relocated_prefix; 191 char *ostr; 192 /* If this path starts with the configure-time prefix, 193 but the compiler has been relocated, replace it 194 with the run-time prefix. The run-time exec prefix 195 is GCC_EXEC_PREFIX. Compute the path from there back 196 to the toplevel prefix. */ 197 if (!relocated_prefix) 198 { 199 char *dummy; 200 /* Make relative prefix expects the first argument 201 to be a program, not a directory. */ 202 dummy = concat (gcc_exec_prefix, "dummy", NULL); 203 relocated_prefix 204 = make_relative_prefix (dummy, 205 cpp_EXEC_PREFIX, 206 cpp_PREFIX); 207 free (dummy); 208 } 209 ostr = concat (relocated_prefix, 210 p->fname + cpp_PREFIX_len, 211 NULL); 212 str = update_path (ostr, p->component); 213 free (ostr); 214 } 215 else 216 str = update_path (p->fname, p->component); 217 218 if (p->multilib == 1 && imultilib) 219 str = reconcat (str, str, dir_separator_str, imultilib, NULL); 220 else if (p->multilib == 2) 221 { 222 if (!imultiarch) 223 { 224 free (str); 225 continue; 226 } 227 str = reconcat (str, str, dir_separator_str, imultiarch, NULL); 228 } 229 230 add_path (str, SYSTEM, p->cxx_aware, false); 231 } 232 } 233 } 234 235 /* For each duplicate path in chain HEAD, keep just the first one. 236 Remove each path in chain HEAD that also exists in chain SYSTEM. 237 Set the NEXT pointer of the last path in the resulting chain to 238 JOIN, unless it duplicates JOIN in which case the last path is 239 removed. Return the head of the resulting chain. Any of HEAD, 240 JOIN and SYSTEM can be NULL. */ 241 242 static struct cpp_dir * 243 remove_duplicates (cpp_reader *pfile, struct cpp_dir *head, 244 struct cpp_dir *system, struct cpp_dir *join, 245 int verbose) 246 { 247 struct cpp_dir **pcur, *tmp, *cur; 248 struct stat st; 249 250 for (pcur = &head; *pcur; ) 251 { 252 int reason = REASON_QUIET; 253 254 cur = *pcur; 255 256 if (stat (cur->name, &st)) 257 { 258 /* Dirs that don't exist or have denied permissions are 259 silently ignored, unless verbose. */ 260 if ((errno != ENOENT) && (errno != EPERM)) 261 cpp_errno (pfile, CPP_DL_ERROR, cur->name); 262 else 263 { 264 /* If -Wmissing-include-dirs is given, warn. */ 265 cpp_options *opts = cpp_get_options (pfile); 266 if (opts->warn_missing_include_dirs && cur->user_supplied_p) 267 cpp_warning (pfile, CPP_W_MISSING_INCLUDE_DIRS, "%s: %s", 268 cur->name, xstrerror (errno)); 269 reason = REASON_NOENT; 270 } 271 } 272 else if (!S_ISDIR (st.st_mode)) 273 cpp_error_with_line (pfile, CPP_DL_WARNING, 0, 0, 274 "%s: not a directory", cur->name); 275 else 276 { 277 #if defined (INO_T_COPY) 278 INO_T_COPY (cur->ino, st.st_ino); 279 cur->dev = st.st_dev; 280 #endif 281 282 /* Remove this one if it is in the system chain. */ 283 reason = REASON_DUP_SYS; 284 for (tmp = system; tmp; tmp = tmp->next) 285 if (DIRS_EQ (tmp, cur) && cur->construct == tmp->construct) 286 break; 287 288 if (!tmp) 289 { 290 /* Duplicate of something earlier in the same chain? */ 291 reason = REASON_DUP; 292 for (tmp = head; tmp != cur; tmp = tmp->next) 293 if (DIRS_EQ (cur, tmp) && cur->construct == tmp->construct) 294 break; 295 296 if (tmp == cur 297 /* Last in the chain and duplicate of JOIN? */ 298 && !(cur->next == NULL && join 299 && DIRS_EQ (cur, join) 300 && cur->construct == join->construct)) 301 { 302 /* Unique, so keep this directory. */ 303 pcur = &cur->next; 304 continue; 305 } 306 } 307 } 308 309 /* Remove this entry from the chain. */ 310 *pcur = cur->next; 311 free_path (cur, verbose ? reason: REASON_QUIET); 312 } 313 314 *pcur = join; 315 return head; 316 } 317 318 /* Add SYSROOT to any user-supplied paths in CHAIN starting with 319 "=". */ 320 321 static void 322 add_sysroot_to_chain (const char *sysroot, int chain) 323 { 324 struct cpp_dir *p; 325 326 for (p = heads[chain]; p != NULL; p = p->next) 327 if (p->name[0] == '=' && p->user_supplied_p) 328 p->name = concat (sysroot, p->name + 1, NULL); 329 } 330 331 /* Merge the four include chains together in the order quote, bracket, 332 system, after. Remove duplicate dirs (determined in 333 system-specific manner). 334 335 We can't just merge the lists and then uniquify them because then 336 we may lose directories from the <> search path that should be 337 there; consider -iquote foo -iquote bar -Ifoo -Iquux. It is 338 however safe to treat -iquote bar -iquote foo -Ifoo -Iquux as if 339 written -iquote bar -Ifoo -Iquux. */ 340 341 static void 342 merge_include_chains (const char *sysroot, cpp_reader *pfile, int verbose) 343 { 344 /* Add the sysroot to user-supplied paths starting with "=". */ 345 if (sysroot) 346 { 347 add_sysroot_to_chain (sysroot, QUOTE); 348 add_sysroot_to_chain (sysroot, BRACKET); 349 add_sysroot_to_chain (sysroot, SYSTEM); 350 add_sysroot_to_chain (sysroot, AFTER); 351 } 352 353 /* Join the SYSTEM and AFTER chains. Remove duplicates in the 354 resulting SYSTEM chain. */ 355 if (heads[SYSTEM]) 356 tails[SYSTEM]->next = heads[AFTER]; 357 else 358 heads[SYSTEM] = heads[AFTER]; 359 heads[SYSTEM] = remove_duplicates (pfile, heads[SYSTEM], 0, 0, verbose); 360 361 /* Remove duplicates from BRACKET that are in itself or SYSTEM, and 362 join it to SYSTEM. */ 363 heads[BRACKET] = remove_duplicates (pfile, heads[BRACKET], heads[SYSTEM], 364 heads[SYSTEM], verbose); 365 366 /* Remove duplicates from QUOTE that are in itself or SYSTEM, and 367 join it to BRACKET. */ 368 heads[QUOTE] = remove_duplicates (pfile, heads[QUOTE], heads[SYSTEM], 369 heads[BRACKET], verbose); 370 371 /* If verbose, print the list of dirs to search. */ 372 if (verbose) 373 { 374 struct cpp_dir *p; 375 376 fprintf (stderr, _("#include \"...\" search starts here:\n")); 377 for (p = heads[QUOTE];; p = p->next) 378 { 379 if (p == heads[BRACKET]) 380 fprintf (stderr, _("#include <...> search starts here:\n")); 381 if (!p) 382 break; 383 fprintf (stderr, " %s\n", p->name); 384 } 385 fprintf (stderr, _("End of search list.\n")); 386 } 387 } 388 389 /* Use given -I paths for #include "..." but not #include <...>, and 390 don't search the directory of the present file for #include "...". 391 (Note that -I. -I- is not the same as the default setup; -I. uses 392 the compiler's working dir.) */ 393 void 394 split_quote_chain (void) 395 { 396 if (heads[QUOTE]) 397 free_path (heads[QUOTE], REASON_QUIET); 398 if (tails[QUOTE]) 399 free_path (tails[QUOTE], REASON_QUIET); 400 heads[QUOTE] = heads[BRACKET]; 401 tails[QUOTE] = tails[BRACKET]; 402 heads[BRACKET] = NULL; 403 tails[BRACKET] = NULL; 404 /* This is NOT redundant. */ 405 quote_ignores_source_dir = true; 406 } 407 408 /* Add P to the chain specified by CHAIN. */ 409 410 void 411 add_cpp_dir_path (cpp_dir *p, int chain) 412 { 413 if (tails[chain]) 414 tails[chain]->next = p; 415 else 416 heads[chain] = p; 417 tails[chain] = p; 418 } 419 420 /* Add PATH to the include chain CHAIN. PATH must be malloc-ed and 421 NUL-terminated. */ 422 void 423 add_path (char *path, int chain, int cxx_aware, bool user_supplied_p) 424 { 425 cpp_dir *p; 426 427 #if defined (HAVE_DOS_BASED_FILE_SYSTEM) 428 /* Remove unnecessary trailing slashes. On some versions of MS 429 Windows, trailing _forward_ slashes cause no problems for stat(). 430 On newer versions, stat() does not recognize a directory that ends 431 in a '\\' or '/', unless it is a drive root dir, such as "c:/", 432 where it is obligatory. */ 433 int pathlen = strlen (path); 434 char* end = path + pathlen - 1; 435 /* Preserve the lead '/' or lead "c:/". */ 436 char* start = path + (pathlen > 2 && path[1] == ':' ? 3 : 1); 437 438 for (; end > start && IS_DIR_SEPARATOR (*end); end--) 439 *end = 0; 440 #endif 441 442 p = XNEW (cpp_dir); 443 p->next = NULL; 444 p->name = path; 445 #ifndef INO_T_EQ 446 p->canonical_name = lrealpath (path); 447 #endif 448 if (chain == SYSTEM || chain == AFTER) 449 p->sysp = 1 + !cxx_aware; 450 else 451 p->sysp = 0; 452 p->construct = 0; 453 p->user_supplied_p = user_supplied_p; 454 455 add_cpp_dir_path (p, chain); 456 } 457 458 /* Exported function to handle include chain merging, duplicate 459 removal, and registration with cpplib. */ 460 void 461 register_include_chains (cpp_reader *pfile, const char *sysroot, 462 const char *iprefix, const char *imultilib, 463 int stdinc, int cxx_stdinc, int verbose) 464 { 465 static const char *const lang_env_vars[] = 466 { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH", 467 "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" }; 468 cpp_options *cpp_opts = cpp_get_options (pfile); 469 size_t idx = (cpp_opts->objc ? 2: 0); 470 471 if (cpp_opts->cplusplus) 472 idx++; 473 else 474 cxx_stdinc = false; 475 476 /* CPATH and language-dependent environment variables may add to the 477 include chain. */ 478 add_env_var_paths ("CPATH", BRACKET); 479 add_env_var_paths (lang_env_vars[idx], SYSTEM); 480 481 target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc); 482 483 /* Finally chain on the standard directories. */ 484 if (stdinc) 485 add_standard_paths (sysroot, iprefix, imultilib, cxx_stdinc); 486 487 target_c_incpath.extra_includes (sysroot, iprefix, stdinc); 488 489 merge_include_chains (sysroot, pfile, verbose); 490 491 cpp_set_include_chains (pfile, heads[QUOTE], heads[BRACKET], 492 quote_ignores_source_dir); 493 } 494 495 /* Return the current chain of cpp dirs. */ 496 497 struct cpp_dir * 498 get_added_cpp_dirs (int chain) 499 { 500 return heads[chain]; 501 } 502 503 #if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES) 504 static void hook_void_charptr_charptr_int (const char *sysroot ATTRIBUTE_UNUSED, 505 const char *iprefix ATTRIBUTE_UNUSED, 506 int stdinc ATTRIBUTE_UNUSED) 507 { 508 } 509 #endif 510 511 #ifndef TARGET_EXTRA_INCLUDES 512 #define TARGET_EXTRA_INCLUDES hook_void_charptr_charptr_int 513 #endif 514 #ifndef TARGET_EXTRA_PRE_INCLUDES 515 #define TARGET_EXTRA_PRE_INCLUDES hook_void_charptr_charptr_int 516 #endif 517 518 struct target_c_incpath_s target_c_incpath = { TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES }; 519 520