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