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 && imultilib) 154 str = concat (str, dir_separator_str, imultilib, NULL); 155 add_path (str, SYSTEM, p->cxx_aware, false); 156 } 157 } 158 } 159 } 160 161 for (p = cpp_include_defaults; p->fname; p++) 162 { 163 if (!p->cplusplus || cxx_stdinc) 164 { 165 char *str; 166 167 /* Should this directory start with the sysroot? */ 168 if (sysroot && p->add_sysroot) 169 { 170 char *sysroot_no_trailing_dir_separator = xstrdup (sysroot); 171 size_t sysroot_len = strlen (sysroot); 172 173 if (sysroot_len > 0 && sysroot[sysroot_len - 1] == DIR_SEPARATOR) 174 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0'; 175 str = concat (sysroot_no_trailing_dir_separator, p->fname, NULL); 176 free (sysroot_no_trailing_dir_separator); 177 } 178 else if (!p->add_sysroot && relocated 179 && !filename_ncmp (p->fname, cpp_PREFIX, cpp_PREFIX_len)) 180 { 181 static const char *relocated_prefix; 182 /* If this path starts with the configure-time prefix, 183 but the compiler has been relocated, replace it 184 with the run-time prefix. The run-time exec prefix 185 is GCC_EXEC_PREFIX. Compute the path from there back 186 to the toplevel prefix. */ 187 if (!relocated_prefix) 188 { 189 char *dummy; 190 /* Make relative prefix expects the first argument 191 to be a program, not a directory. */ 192 dummy = concat (gcc_exec_prefix, "dummy", NULL); 193 relocated_prefix 194 = make_relative_prefix (dummy, 195 cpp_EXEC_PREFIX, 196 cpp_PREFIX); 197 } 198 str = concat (relocated_prefix, 199 p->fname + cpp_PREFIX_len, 200 NULL); 201 str = update_path (str, p->component); 202 } 203 else 204 str = update_path (p->fname, p->component); 205 206 if (p->multilib && imultilib) 207 str = concat (str, dir_separator_str, imultilib, NULL); 208 209 add_path (str, SYSTEM, p->cxx_aware, false); 210 } 211 } 212 } 213 214 /* For each duplicate path in chain HEAD, keep just the first one. 215 Remove each path in chain HEAD that also exists in chain SYSTEM. 216 Set the NEXT pointer of the last path in the resulting chain to 217 JOIN, unless it duplicates JOIN in which case the last path is 218 removed. Return the head of the resulting chain. Any of HEAD, 219 JOIN and SYSTEM can be NULL. */ 220 221 static struct cpp_dir * 222 remove_duplicates (cpp_reader *pfile, struct cpp_dir *head, 223 struct cpp_dir *system, struct cpp_dir *join, 224 int verbose) 225 { 226 struct cpp_dir **pcur, *tmp, *cur; 227 struct stat st; 228 229 for (pcur = &head; *pcur; ) 230 { 231 int reason = REASON_QUIET; 232 233 cur = *pcur; 234 235 if (stat (cur->name, &st)) 236 { 237 /* Dirs that don't exist are silently ignored, unless verbose. */ 238 if (errno != ENOENT) 239 cpp_errno (pfile, CPP_DL_ERROR, cur->name); 240 else 241 { 242 /* If -Wmissing-include-dirs is given, warn. */ 243 cpp_options *opts = cpp_get_options (pfile); 244 if (opts->warn_missing_include_dirs && cur->user_supplied_p) 245 cpp_errno (pfile, CPP_DL_WARNING, cur->name); 246 reason = REASON_NOENT; 247 } 248 } 249 else if (!S_ISDIR (st.st_mode)) 250 cpp_error_with_line (pfile, CPP_DL_WARNING, 0, 0, 251 "%s: not a directory", cur->name); 252 else 253 { 254 #if defined (INO_T_COPY) 255 INO_T_COPY (cur->ino, st.st_ino); 256 cur->dev = st.st_dev; 257 #endif 258 259 /* Remove this one if it is in the system chain. */ 260 reason = REASON_DUP_SYS; 261 for (tmp = system; tmp; tmp = tmp->next) 262 if (DIRS_EQ (tmp, cur) && cur->construct == tmp->construct) 263 break; 264 265 if (!tmp) 266 { 267 /* Duplicate of something earlier in the same chain? */ 268 reason = REASON_DUP; 269 for (tmp = head; tmp != cur; tmp = tmp->next) 270 if (DIRS_EQ (cur, tmp) && cur->construct == tmp->construct) 271 break; 272 273 if (tmp == cur 274 /* Last in the chain and duplicate of JOIN? */ 275 && !(cur->next == NULL && join 276 && DIRS_EQ (cur, join) 277 && cur->construct == join->construct)) 278 { 279 /* Unique, so keep this directory. */ 280 pcur = &cur->next; 281 continue; 282 } 283 } 284 } 285 286 /* Remove this entry from the chain. */ 287 *pcur = cur->next; 288 free_path (cur, verbose ? reason: REASON_QUIET); 289 } 290 291 *pcur = join; 292 return head; 293 } 294 295 /* Add SYSROOT to any user-supplied paths in CHAIN starting with 296 "=". */ 297 298 static void 299 add_sysroot_to_chain (const char *sysroot, int chain) 300 { 301 struct cpp_dir *p; 302 303 for (p = heads[chain]; p != NULL; p = p->next) 304 if (p->name[0] == '=' && p->user_supplied_p) 305 p->name = concat (sysroot, p->name + 1, NULL); 306 } 307 308 /* Merge the four include chains together in the order quote, bracket, 309 system, after. Remove duplicate dirs (determined in 310 system-specific manner). 311 312 We can't just merge the lists and then uniquify them because then 313 we may lose directories from the <> search path that should be 314 there; consider -iquote foo -iquote bar -Ifoo -Iquux. It is 315 however safe to treat -iquote bar -iquote foo -Ifoo -Iquux as if 316 written -iquote bar -Ifoo -Iquux. */ 317 318 static void 319 merge_include_chains (const char *sysroot, cpp_reader *pfile, int verbose) 320 { 321 /* Add the sysroot to user-supplied paths starting with "=". */ 322 if (sysroot) 323 { 324 add_sysroot_to_chain (sysroot, QUOTE); 325 add_sysroot_to_chain (sysroot, BRACKET); 326 add_sysroot_to_chain (sysroot, SYSTEM); 327 add_sysroot_to_chain (sysroot, AFTER); 328 } 329 330 /* Join the SYSTEM and AFTER chains. Remove duplicates in the 331 resulting SYSTEM chain. */ 332 if (heads[SYSTEM]) 333 tails[SYSTEM]->next = heads[AFTER]; 334 else 335 heads[SYSTEM] = heads[AFTER]; 336 heads[SYSTEM] = remove_duplicates (pfile, heads[SYSTEM], 0, 0, verbose); 337 338 /* Remove duplicates from BRACKET that are in itself or SYSTEM, and 339 join it to SYSTEM. */ 340 heads[BRACKET] = remove_duplicates (pfile, heads[BRACKET], heads[SYSTEM], 341 heads[SYSTEM], verbose); 342 343 /* Remove duplicates from QUOTE that are in itself or SYSTEM, and 344 join it to BRACKET. */ 345 heads[QUOTE] = remove_duplicates (pfile, heads[QUOTE], heads[SYSTEM], 346 heads[BRACKET], verbose); 347 348 /* If verbose, print the list of dirs to search. */ 349 if (verbose) 350 { 351 struct cpp_dir *p; 352 353 fprintf (stderr, _("#include \"...\" search starts here:\n")); 354 for (p = heads[QUOTE];; p = p->next) 355 { 356 if (p == heads[BRACKET]) 357 fprintf (stderr, _("#include <...> search starts here:\n")); 358 if (!p) 359 break; 360 fprintf (stderr, " %s\n", p->name); 361 } 362 fprintf (stderr, _("End of search list.\n")); 363 } 364 } 365 366 /* Use given -I paths for #include "..." but not #include <...>, and 367 don't search the directory of the present file for #include "...". 368 (Note that -I. -I- is not the same as the default setup; -I. uses 369 the compiler's working dir.) */ 370 void 371 split_quote_chain (void) 372 { 373 if (heads[QUOTE]) 374 free_path (heads[QUOTE], REASON_QUIET); 375 if (tails[QUOTE]) 376 free_path (tails[QUOTE], REASON_QUIET); 377 heads[QUOTE] = heads[BRACKET]; 378 tails[QUOTE] = tails[BRACKET]; 379 heads[BRACKET] = NULL; 380 tails[BRACKET] = NULL; 381 /* This is NOT redundant. */ 382 quote_ignores_source_dir = true; 383 } 384 385 /* Add P to the chain specified by CHAIN. */ 386 387 void 388 add_cpp_dir_path (cpp_dir *p, int chain) 389 { 390 if (tails[chain]) 391 tails[chain]->next = p; 392 else 393 heads[chain] = p; 394 tails[chain] = p; 395 } 396 397 /* Add PATH to the include chain CHAIN. PATH must be malloc-ed and 398 NUL-terminated. */ 399 void 400 add_path (char *path, int chain, int cxx_aware, bool user_supplied_p) 401 { 402 cpp_dir *p; 403 404 #if defined (HAVE_DOS_BASED_FILE_SYSTEM) 405 /* Remove unnecessary trailing slashes. On some versions of MS 406 Windows, trailing _forward_ slashes cause no problems for stat(). 407 On newer versions, stat() does not recognize a directory that ends 408 in a '\\' or '/', unless it is a drive root dir, such as "c:/", 409 where it is obligatory. */ 410 int pathlen = strlen (path); 411 char* end = path + pathlen - 1; 412 /* Preserve the lead '/' or lead "c:/". */ 413 char* start = path + (pathlen > 2 && path[1] == ':' ? 3 : 1); 414 415 for (; end > start && IS_DIR_SEPARATOR (*end); end--) 416 *end = 0; 417 #endif 418 419 p = XNEW (cpp_dir); 420 p->next = NULL; 421 p->name = path; 422 #ifndef INO_T_EQ 423 p->canonical_name = lrealpath (path); 424 #endif 425 if (chain == SYSTEM || chain == AFTER) 426 p->sysp = 1 + !cxx_aware; 427 else 428 p->sysp = 0; 429 p->construct = 0; 430 p->user_supplied_p = user_supplied_p; 431 432 add_cpp_dir_path (p, chain); 433 } 434 435 /* Exported function to handle include chain merging, duplicate 436 removal, and registration with cpplib. */ 437 void 438 register_include_chains (cpp_reader *pfile, const char *sysroot, 439 const char *iprefix, const char *imultilib, 440 int stdinc, int cxx_stdinc, int verbose) 441 { 442 static const char *const lang_env_vars[] = 443 { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH", 444 "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" }; 445 cpp_options *cpp_opts = cpp_get_options (pfile); 446 size_t idx = (cpp_opts->objc ? 2: 0); 447 448 if (cpp_opts->cplusplus) 449 idx++; 450 else 451 cxx_stdinc = false; 452 453 /* CPATH and language-dependent environment variables may add to the 454 include chain. */ 455 add_env_var_paths ("CPATH", BRACKET); 456 add_env_var_paths (lang_env_vars[idx], SYSTEM); 457 458 target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc); 459 460 /* Finally chain on the standard directories. */ 461 if (stdinc) 462 add_standard_paths (sysroot, iprefix, imultilib, cxx_stdinc); 463 464 target_c_incpath.extra_includes (sysroot, iprefix, stdinc); 465 466 merge_include_chains (sysroot, pfile, verbose); 467 468 cpp_set_include_chains (pfile, heads[QUOTE], heads[BRACKET], 469 quote_ignores_source_dir); 470 } 471 472 /* Return the current chain of cpp dirs. */ 473 474 struct cpp_dir * 475 get_added_cpp_dirs (int chain) 476 { 477 return heads[chain]; 478 } 479 480 #if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES) 481 static void hook_void_charptr_charptr_int (const char *sysroot ATTRIBUTE_UNUSED, 482 const char *iprefix ATTRIBUTE_UNUSED, 483 int stdinc ATTRIBUTE_UNUSED) 484 { 485 } 486 #endif 487 488 #ifndef TARGET_EXTRA_INCLUDES 489 #define TARGET_EXTRA_INCLUDES hook_void_charptr_charptr_int 490 #endif 491 #ifndef TARGET_EXTRA_PRE_INCLUDES 492 #define TARGET_EXTRA_PRE_INCLUDES hook_void_charptr_charptr_int 493 #endif 494 495 struct target_c_incpath_s target_c_incpath = { TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES }; 496 497