OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [incpath.c] - Blame information for rev 707

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 684 jeremybenn
/* 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
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.