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