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