gcc/incpath.c

   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, 2010
   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             str = concat (sysroot, p->fname, NULL);
 170           else if (!p->add_sysroot && relocated
 171                    && !filename_ncmp (p->fname, cpp_PREFIX, cpp_PREFIX_len))
 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_WARNING, 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   if (heads[QUOTE])
 366     free_path (heads[QUOTE], REASON_QUIET);
 367   if (tails[QUOTE])
 368     free_path (tails[QUOTE], REASON_QUIET);
 369   heads[QUOTE] = heads[BRACKET];
 370   tails[QUOTE] = tails[BRACKET];
 371   heads[BRACKET] = NULL;
 372   tails[BRACKET] = NULL;
 373   /* This is NOT redundant.  */
 374   quote_ignores_source_dir = true;
 375 }
 376
 377 /* Add P to the chain specified by CHAIN.  */
 378
 379 void
 380 add_cpp_dir_path (cpp_dir *p, int chain)
 381 {
 382   if (tails[chain])
 383     tails[chain]->next = p;
 384   else
 385     heads[chain] = p;
 386   tails[chain] = p;
 387 }
 388
 389 /* Add PATH to the include chain CHAIN. PATH must be malloc-ed and
 390    NUL-terminated.  */
 391 void
 392 add_path (char *path, int chain, int cxx_aware, bool user_supplied_p)
 393 {
 394   cpp_dir *p;
 395
 396 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 397   /* Remove unnecessary trailing slashes.  On some versions of MS
 398      Windows, trailing  _forward_ slashes cause no problems for stat().
 399      On newer versions, stat() does not recognize a directory that ends
 400      in a '\\' or '/', unless it is a drive root dir, such as "c:/",
 401      where it is obligatory.  */
 402   int pathlen = strlen (path);
 403   char* end = path + pathlen - 1;
 404   /* Preserve the lead '/' or lead "c:/".  */
 405   char* start = path + (pathlen > 2 && path[1] == ':' ? 3 : 1);
 406
 407   for (; end > start && IS_DIR_SEPARATOR (*end); end--)
 408     *end = 0;
 409 #endif
 410
 411   p = XNEW (cpp_dir);
 412   p->next = NULL;
 413   p->name = path;
 414 #ifndef INO_T_EQ
 415   p->canonical_name = lrealpath (path);
 416 #endif
 417   if (chain == SYSTEM || chain == AFTER)
 418     p->sysp = 1 + !cxx_aware;
 419   else
 420     p->sysp = 0;
 421   p->construct = 0;
 422   p->user_supplied_p = user_supplied_p;
 423
 424   add_cpp_dir_path (p, chain);
 425 }
 426
 427 /* Exported function to handle include chain merging, duplicate
 428    removal, and registration with cpplib.  */
 429 void
 430 register_include_chains (cpp_reader *pfile, const char *sysroot,
 431                          const char *iprefix, const char *imultilib,
 432                          int stdinc, int cxx_stdinc, int verbose)
 433 {
 434   static const char *const lang_env_vars[] =
 435     { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH",
 436       "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" };
 437   cpp_options *cpp_opts = cpp_get_options (pfile);
 438   size_t idx = (cpp_opts->objc ? 2: 0);
 439
 440   if (cpp_opts->cplusplus)
 441     idx++;
 442   else
 443     cxx_stdinc = false;
 444
 445   /* CPATH and language-dependent environment variables may add to the
 446      include chain.  */
 447   add_env_var_paths ("CPATH", BRACKET);
 448   add_env_var_paths (lang_env_vars[idx], SYSTEM);
 449
 450   target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc);
 451
 452   /* Finally chain on the standard directories.  */
 453   if (stdinc)
 454     add_standard_paths (sysroot, iprefix, imultilib, cxx_stdinc);
 455
 456   target_c_incpath.extra_includes (sysroot, iprefix, stdinc);
 457
 458   merge_include_chains (sysroot, pfile, verbose);
 459
 460   cpp_set_include_chains (pfile, heads[QUOTE], heads[BRACKET],
 461                           quote_ignores_source_dir);
 462 }
 463
 464 /* Return the current chain of cpp dirs.  */
 465
 466 struct cpp_dir *
 467 get_added_cpp_dirs (int chain)
 468 {
 469   return heads[chain];
 470 }
 471
 472 #if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES)
 473 static void hook_void_charptr_charptr_int (const char *sysroot ATTRIBUTE_UNUSED,
 474                                            const char *iprefix ATTRIBUTE_UNUSED,
 475                                            int stdinc ATTRIBUTE_UNUSED)
 476 {
 477 }
 478 #endif
 479
 480 #ifndef TARGET_EXTRA_INCLUDES
 481 #define TARGET_EXTRA_INCLUDES hook_void_charptr_charptr_int
 482 #endif
 483 #ifndef TARGET_EXTRA_PRE_INCLUDES
 484 #define TARGET_EXTRA_PRE_INCLUDES hook_void_charptr_charptr_int
 485 #endif
 486
 487 struct target_c_incpath_s target_c_incpath = { TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES };
 488