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