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