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