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