gcc/incpath.c

   1 /* Set up combined include path chain for the preprocessor.
   2    Copyright (C) 1986-2013 Free Software Foundation, Inc.
   3
   4    Broken out of cppinit.c and cppfiles.c and rewritten Mar 2003.
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 3, or (at your option) any
   9    later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; see the file COPYING3.  If not see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "machmode.h"
  24 #include "target.h"
  25 #include "tm.h"
  26 #include "cpplib.h"
  27 #include "prefix.h"
  28 #include "intl.h"
  29 #include "incpath.h"
  30 #include "cppdefault.h"
  31
  32 /* Microsoft Windows does not natively support inodes.
  33    VMS has non-numeric inodes.  */
  34 #ifdef VMS
  35 # define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A)))
  36 # define INO_T_COPY(DEST, SRC) memcpy(&(DEST), &(SRC), sizeof (SRC))
  37 #elif !defined (HOST_LACKS_INODE_NUMBERS)
  38 # define INO_T_EQ(A, B) ((A) == (B))
  39 # define INO_T_COPY(DEST, SRC) (DEST) = (SRC)
  40 #endif
  41
  42 #if defined INO_T_EQ
  43 #define DIRS_EQ(A, B) ((A)->dev == (B)->dev \
  44         && INO_T_EQ((A)->ino, (B)->ino))
  45 #else
  46 #define DIRS_EQ(A, B) (!filename_cmp ((A)->canonical_name, (B)->canonical_name))
  47 #endif
  48
  49 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
  50
  51 static void add_env_var_paths (const char *, int);
  52 static void add_standard_paths (const char *, const char *, const char *, int);
  53 static void free_path (struct cpp_dir *, int);
  54 static void merge_include_chains (const char *, cpp_reader *, int);
  55 static void add_sysroot_to_chain (const char *, int);
  56 static struct cpp_dir *remove_duplicates (cpp_reader *, struct cpp_dir *,
  57                                            struct cpp_dir *,
  58                                            struct cpp_dir *, int);
  59
  60 /* Include chains heads and tails.  */
  61 static struct cpp_dir *heads[4];
  62 static struct cpp_dir *tails[4];
  63 static bool quote_ignores_source_dir;
  64 enum { REASON_QUIET = 0, REASON_NOENT, REASON_DUP, REASON_DUP_SYS };
  65
  66 /* Free an element of the include chain, possibly giving a reason.  */
  67 static void
  68 free_path (struct cpp_dir *path, int reason)
  69 {
  70   switch (reason)
  71     {
  72     case REASON_DUP:
  73     case REASON_DUP_SYS:
  74       fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), path->name);
  75       if (reason == REASON_DUP_SYS)
  76         fprintf (stderr,
  77  _("  as it is a non-system directory that duplicates a system directory\n"));
  78       break;
  79
  80     case REASON_NOENT:
  81       fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"),
  82                path->name);
  83       break;
  84
  85     case REASON_QUIET:
  86     default:
  87       break;
  88     }
  89
  90   free (path->name);
  91   free (path);
  92 }
  93
  94 /* Read ENV_VAR for a PATH_SEPARATOR-separated list of file names; and
  95    append all the names to the search path CHAIN.  */
  96 static void
  97 add_env_var_paths (const char *env_var, int chain)
  98 {
  99   char *p, *q, *path;
 100
 101   q = getenv (env_var);
 102
 103   if (!q)
 104     return;
 105
 106   for (p = q; *q; p = q + 1)
 107     {
 108       q = p;
 109       while (*q != 0 && *q != PATH_SEPARATOR)
 110         q++;
 111
 112       if (p == q)
 113         path = xstrdup (".");
 114       else
 115         {
 116           path = XNEWVEC (char, q - p + 1);
 117           memcpy (path, p, q - p);
 118           path[q - p] = '\0';
 119         }
 120
 121       add_path (path, chain, chain == SYSTEM, false);
 122     }
 123 }
 124
 125 /* Append the standard include chain defined in cppdefault.c.  */
 126 static void
 127 add_standard_paths (const char *sysroot, const char *iprefix,
 128                     const char *imultilib, int cxx_stdinc)
 129 {
 130   const struct default_include *p;
 131   int relocated = cpp_relocated();
 132   size_t len;
 133
 134   if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0)
 135     {
 136       /* Look for directories that start with the standard prefix.
 137          "Translate" them, i.e. replace /usr/local/lib/gcc... with
 138          IPREFIX and search them first.  */
 139       for (p = cpp_include_defaults; p->fname; p++)
 140         {
 141           if (!p->cplusplus || cxx_stdinc)
 142             {
 143               /* Should we be translating sysrooted dirs too?  Assume
 144                  that iprefix and sysroot are mutually exclusive, for
 145                  now.  */
 146               if (sysroot && p->add_sysroot)
 147                 continue;
 148               if (!filename_ncmp (p->fname, cpp_GCC_INCLUDE_DIR, len))
 149                 {
 150                   char *str = concat (iprefix, p->fname + len, NULL);
 151                   if (p->multilib == 1 && imultilib)
 152                     str = concat (str, dir_separator_str, imultilib, NULL);
 153                   else if (p->multilib == 2)
 154                     {
 155                       if (!imultiarch)
 156                         continue;
 157                       str = concat (str, dir_separator_str, imultiarch, NULL);
 158                     }
 159                   add_path (str, SYSTEM, p->cxx_aware, false);
 160                 }
 161             }
 162         }
 163     }
 164
 165   for (p = cpp_include_defaults; p->fname; p++)
 166     {
 167       if (!p->cplusplus || cxx_stdinc)
 168         {
 169           char *str;
 170
 171           /* Should this directory start with the sysroot?  */
 172           if (sysroot && p->add_sysroot)
 173             {
 174               char *sysroot_no_trailing_dir_separator = xstrdup (sysroot);
 175               size_t sysroot_len = strlen (sysroot);
 176
 177               if (sysroot_len > 0 && sysroot[sysroot_len - 1] == DIR_SEPARATOR)
 178                 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
 179               str = concat (sysroot_no_trailing_dir_separator, p->fname, NULL);
 180               free (sysroot_no_trailing_dir_separator);
 181             }
 182           else if (!p->add_sysroot && relocated
 183                    && !filename_ncmp (p->fname, cpp_PREFIX, cpp_PREFIX_len))
 184             {
 185               static const char *relocated_prefix;
 186               /* If this path starts with the configure-time prefix,
 187                  but the compiler has been relocated, replace it
 188                  with the run-time prefix.  The run-time exec prefix
 189                  is GCC_EXEC_PREFIX.  Compute the path from there back
 190                  to the toplevel prefix.  */
 191               if (!relocated_prefix)
 192                 {
 193                   char *dummy;
 194                   /* Make relative prefix expects the first argument
 195                      to be a program, not a directory.  */
 196                   dummy = concat (gcc_exec_prefix, "dummy", NULL);
 197                   relocated_prefix
 198                     = make_relative_prefix (dummy,
 199                                             cpp_EXEC_PREFIX,
 200                                             cpp_PREFIX);
 201                 }
 202               str = concat (relocated_prefix,
 203                             p->fname + cpp_PREFIX_len,
 204                             NULL);
 205               str = update_path (str, p->component);
 206             }
 207           else
 208             str = update_path (p->fname, p->component);
 209
 210           if (p->multilib == 1 && imultilib)
 211             str = concat (str, dir_separator_str, imultilib, NULL);
 212           else if (p->multilib == 2)
 213             {
 214               if (!imultiarch)
 215                 continue;
 216               str = concat (str, dir_separator_str, imultiarch, NULL);
 217             }
 218
 219           add_path (str, SYSTEM, p->cxx_aware, false);
 220         }
 221     }
 222 }
 223
 224 /* For each duplicate path in chain HEAD, keep just the first one.
 225    Remove each path in chain HEAD that also exists in chain SYSTEM.
 226    Set the NEXT pointer of the last path in the resulting chain to
 227    JOIN, unless it duplicates JOIN in which case the last path is
 228    removed.  Return the head of the resulting chain.  Any of HEAD,
 229    JOIN and SYSTEM can be NULL.  */
 230
 231 static struct cpp_dir *
 232 remove_duplicates (cpp_reader *pfile, struct cpp_dir *head,
 233                    struct cpp_dir *system, struct cpp_dir *join,
 234                    int verbose)
 235 {
 236   struct cpp_dir **pcur, *tmp, *cur;
 237   struct stat st;
 238
 239   for (pcur = &head; *pcur; )
 240     {
 241       int reason = REASON_QUIET;
 242
 243       cur = *pcur;
 244
 245       if (stat (cur->name, &st))
 246         {
 247           /* Dirs that don't exist are silently ignored, unless verbose.  */
 248           if (errno != ENOENT)
 249             cpp_errno (pfile, CPP_DL_ERROR, cur->name);
 250           else
 251             {
 252               /* If -Wmissing-include-dirs is given, warn.  */
 253               cpp_options *opts = cpp_get_options (pfile);
 254               if (opts->warn_missing_include_dirs && cur->user_supplied_p)
 255                 cpp_errno (pfile, CPP_DL_WARNING, cur->name);
 256               reason = REASON_NOENT;
 257             }
 258         }
 259       else if (!S_ISDIR (st.st_mode))
 260         cpp_error_with_line (pfile, CPP_DL_WARNING, 0, 0,
 261                              "%s: not a directory", cur->name);
 262       else
 263         {
 264 #if defined (INO_T_COPY)
 265           INO_T_COPY (cur->ino, st.st_ino);
 266           cur->dev  = st.st_dev;
 267 #endif
 268
 269           /* Remove this one if it is in the system chain.  */
 270           reason = REASON_DUP_SYS;
 271           for (tmp = system; tmp; tmp = tmp->next)
 272            if (DIRS_EQ (tmp, cur) && cur->construct == tmp->construct)
 273               break;
 274
 275           if (!tmp)
 276             {
 277               /* Duplicate of something earlier in the same chain?  */
 278               reason = REASON_DUP;
 279               for (tmp = head; tmp != cur; tmp = tmp->next)
 280                if (DIRS_EQ (cur, tmp) && cur->construct == tmp->construct)
 281                   break;
 282
 283               if (tmp == cur
 284                   /* Last in the chain and duplicate of JOIN?  */
 285                   && !(cur->next == NULL && join
 286                        && DIRS_EQ (cur, join)
 287                        && cur->construct == join->construct))
 288                 {
 289                   /* Unique, so keep this directory.  */
 290                   pcur = &cur->next;
 291                   continue;
 292                 }
 293             }
 294         }
 295
 296       /* Remove this entry from the chain.  */
 297       *pcur = cur->next;
 298       free_path (cur, verbose ? reason: REASON_QUIET);
 299     }
 300
 301   *pcur = join;
 302   return head;
 303 }
 304
 305 /* Add SYSROOT to any user-supplied paths in CHAIN starting with
 306    "=".  */
 307
 308 static void
 309 add_sysroot_to_chain (const char *sysroot, int chain)
 310 {
 311   struct cpp_dir *p;
 312
 313   for (p = heads[chain]; p != NULL; p = p->next)
 314     if (p->name[0] == '=' && p->user_supplied_p)
 315       p->name = concat (sysroot, p->name + 1, NULL);
 316 }
 317
 318 /* Merge the four include chains together in the order quote, bracket,
 319    system, after.  Remove duplicate dirs (determined in
 320    system-specific manner).
 321
 322    We can't just merge the lists and then uniquify them because then
 323    we may lose directories from the <> search path that should be
 324    there; consider -iquote foo -iquote bar -Ifoo -Iquux.  It is
 325    however safe to treat -iquote bar -iquote foo -Ifoo -Iquux as if
 326    written -iquote bar -Ifoo -Iquux.  */
 327
 328 static void
 329 merge_include_chains (const char *sysroot, cpp_reader *pfile, int verbose)
 330 {
 331   /* Add the sysroot to user-supplied paths starting with "=".  */
 332   if (sysroot)
 333     {
 334       add_sysroot_to_chain (sysroot, QUOTE);
 335       add_sysroot_to_chain (sysroot, BRACKET);
 336       add_sysroot_to_chain (sysroot, SYSTEM);
 337       add_sysroot_to_chain (sysroot, AFTER);
 338     }
 339
 340   /* Join the SYSTEM and AFTER chains.  Remove duplicates in the
 341      resulting SYSTEM chain.  */
 342   if (heads[SYSTEM])
 343     tails[SYSTEM]->next = heads[AFTER];
 344   else
 345     heads[SYSTEM] = heads[AFTER];
 346   heads[SYSTEM] = remove_duplicates (pfile, heads[SYSTEM], 0, 0, verbose);
 347
 348   /* Remove duplicates from BRACKET that are in itself or SYSTEM, and
 349      join it to SYSTEM.  */
 350   heads[BRACKET] = remove_duplicates (pfile, heads[BRACKET], heads[SYSTEM],
 351                                       heads[SYSTEM], verbose);
 352
 353   /* Remove duplicates from QUOTE that are in itself or SYSTEM, and
 354      join it to BRACKET.  */
 355   heads[QUOTE] = remove_duplicates (pfile, heads[QUOTE], heads[SYSTEM],
 356                                     heads[BRACKET], verbose);
 357
 358   /* If verbose, print the list of dirs to search.  */
 359   if (verbose)
 360     {
 361       struct cpp_dir *p;
 362
 363       fprintf (stderr, _("#include \"...\" search starts here:\n"));
 364       for (p = heads[QUOTE];; p = p->next)
 365         {
 366           if (p == heads[BRACKET])
 367             fprintf (stderr, _("#include <...> search starts here:\n"));
 368           if (!p)
 369             break;
 370           fprintf (stderr, " %s\n", p->name);
 371         }
 372       fprintf (stderr, _("End of search list.\n"));
 373     }
 374 }
 375
 376 /* Use given -I paths for #include "..." but not #include <...>, and
 377    don't search the directory of the present file for #include "...".
 378    (Note that -I. -I- is not the same as the default setup; -I. uses
 379    the compiler's working dir.)  */
 380 void
 381 split_quote_chain (void)
 382 {
 383   if (heads[QUOTE])
 384     free_path (heads[QUOTE], REASON_QUIET);
 385   if (tails[QUOTE])
 386     free_path (tails[QUOTE], REASON_QUIET);
 387   heads[QUOTE] = heads[BRACKET];
 388   tails[QUOTE] = tails[BRACKET];
 389   heads[BRACKET] = NULL;
 390   tails[BRACKET] = NULL;
 391   /* This is NOT redundant.  */
 392   quote_ignores_source_dir = true;
 393 }
 394
 395 /* Add P to the chain specified by CHAIN.  */
 396
 397 void
 398 add_cpp_dir_path (cpp_dir *p, int chain)
 399 {
 400   if (tails[chain])
 401     tails[chain]->next = p;
 402   else
 403     heads[chain] = p;
 404   tails[chain] = p;
 405 }
 406
 407 /* Add PATH to the include chain CHAIN. PATH must be malloc-ed and
 408    NUL-terminated.  */
 409 void
 410 add_path (char *path, int chain, int cxx_aware, bool user_supplied_p)
 411 {
 412   cpp_dir *p;
 413
 414 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 415   /* Remove unnecessary trailing slashes.  On some versions of MS
 416      Windows, trailing  _forward_ slashes cause no problems for stat().
 417      On newer versions, stat() does not recognize a directory that ends
 418      in a '\\' or '/', unless it is a drive root dir, such as "c:/",
 419      where it is obligatory.  */
 420   int pathlen = strlen (path);
 421   char* end = path + pathlen - 1;
 422   /* Preserve the lead '/' or lead "c:/".  */
 423   char* start = path + (pathlen > 2 && path[1] == ':' ? 3 : 1);
 424
 425   for (; end > start && IS_DIR_SEPARATOR (*end); end--)
 426     *end = 0;
 427 #endif
 428
 429   p = XNEW (cpp_dir);
 430   p->next = NULL;
 431   p->name = path;
 432 #ifndef INO_T_EQ
 433   p->canonical_name = lrealpath (path);
 434 #endif
 435   if (chain == SYSTEM || chain == AFTER)
 436     p->sysp = 1 + !cxx_aware;
 437   else
 438     p->sysp = 0;
 439   p->construct = 0;
 440   p->user_supplied_p = user_supplied_p;
 441
 442   add_cpp_dir_path (p, chain);
 443 }
 444
 445 /* Exported function to handle include chain merging, duplicate
 446    removal, and registration with cpplib.  */
 447 void
 448 register_include_chains (cpp_reader *pfile, const char *sysroot,
 449                          const char *iprefix, const char *imultilib,
 450                          int stdinc, int cxx_stdinc, int verbose)
 451 {
 452   static const char *const lang_env_vars[] =
 453     { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH",
 454       "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" };
 455   cpp_options *cpp_opts = cpp_get_options (pfile);
 456   size_t idx = (cpp_opts->objc ? 2: 0);
 457
 458   if (cpp_opts->cplusplus)
 459     idx++;
 460   else
 461     cxx_stdinc = false;
 462
 463   /* CPATH and language-dependent environment variables may add to the
 464      include chain.  */
 465   add_env_var_paths ("CPATH", BRACKET);
 466   add_env_var_paths (lang_env_vars[idx], SYSTEM);
 467
 468   target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc);
 469
 470   /* Finally chain on the standard directories.  */
 471   if (stdinc)
 472     add_standard_paths (sysroot, iprefix, imultilib, cxx_stdinc);
 473
 474   target_c_incpath.extra_includes (sysroot, iprefix, stdinc);
 475
 476   merge_include_chains (sysroot, pfile, verbose);
 477
 478   cpp_set_include_chains (pfile, heads[QUOTE], heads[BRACKET],
 479                           quote_ignores_source_dir);
 480 }
 481
 482 /* Return the current chain of cpp dirs.  */
 483
 484 struct cpp_dir *
 485 get_added_cpp_dirs (int chain)
 486 {
 487   return heads[chain];
 488 }
 489
 490 #if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES)
 491 static void hook_void_charptr_charptr_int (const char *sysroot ATTRIBUTE_UNUSED,
 492                                            const char *iprefix ATTRIBUTE_UNUSED,
 493                                            int stdinc ATTRIBUTE_UNUSED)
 494 {
 495 }
 496 #endif
 497
 498 #ifndef TARGET_EXTRA_INCLUDES
 499 #define TARGET_EXTRA_INCLUDES hook_void_charptr_charptr_int
 500 #endif
 501 #ifndef TARGET_EXTRA_PRE_INCLUDES
 502 #define TARGET_EXTRA_PRE_INCLUDES hook_void_charptr_charptr_int
 503 #endif
 504
 505 struct target_c_incpath_s target_c_incpath = { TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES };
 506