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