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, 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