gcc/incpath.c

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