gcc/incpath.c

   1 /* Set up combined include path chain for the preprocessor.
   2    Copyright (C) 1986-2017 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 or have denied permissions are
 257              silently ignored, unless verbose.  */
 258           if ((errno != ENOENT) && (errno != EPERM))
 259             cpp_errno (pfile, CPP_DL_ERROR, cur->name);
 260           else
 261             {
 262               /* If -Wmissing-include-dirs is given, warn.  */
 263               cpp_options *opts = cpp_get_options (pfile);
 264               if (opts->warn_missing_include_dirs && cur->user_supplied_p)
 265                 cpp_warning (pfile, CPP_W_MISSING_INCLUDE_DIRS, "%s: %s",
 266                              cur->name, xstrerror (errno));
 267               reason = REASON_NOENT;
 268             }
 269         }
 270       else if (!S_ISDIR (st.st_mode))
 271         cpp_error_with_line (pfile, CPP_DL_WARNING, 0, 0,
 272                              "%s: not a directory", cur->name);
 273       else
 274         {
 275 #if defined (INO_T_COPY)
 276           INO_T_COPY (cur->ino, st.st_ino);
 277           cur->dev  = st.st_dev;
 278 #endif
 279
 280           /* Remove this one if it is in the system chain.  */
 281           reason = REASON_DUP_SYS;
 282           for (tmp = system; tmp; tmp = tmp->next)
 283            if (DIRS_EQ (tmp, cur) && cur->construct == tmp->construct)
 284               break;
 285
 286           if (!tmp)
 287             {
 288               /* Duplicate of something earlier in the same chain?  */
 289               reason = REASON_DUP;
 290               for (tmp = head; tmp != cur; tmp = tmp->next)
 291                if (DIRS_EQ (cur, tmp) && cur->construct == tmp->construct)
 292                   break;
 293
 294               if (tmp == cur
 295                   /* Last in the chain and duplicate of JOIN?  */
 296                   && !(cur->next == NULL && join
 297                        && DIRS_EQ (cur, join)
 298                        && cur->construct == join->construct))
 299                 {
 300                   /* Unique, so keep this directory.  */
 301                   pcur = &cur->next;
 302                   continue;
 303                 }
 304             }
 305         }
 306
 307       /* Remove this entry from the chain.  */
 308       *pcur = cur->next;
 309       free_path (cur, verbose ? reason: REASON_QUIET);
 310     }
 311
 312   *pcur = join;
 313   return head;
 314 }
 315
 316 /* Add SYSROOT to any user-supplied paths in CHAIN starting with
 317    "=" or "$SYSROOT".  */
 318
 319 static void
 320 add_sysroot_to_chain (const char *sysroot, int chain)
 321 {
 322   struct cpp_dir *p;
 323
 324   for (p = heads[chain]; p != NULL; p = p->next)
 325     {
 326       if (p->user_supplied_p)
 327         {
 328           if (p->name[0] == '=')
 329             p->name = concat (sysroot, p->name + 1, NULL);
 330           if (strncmp (p->name, "$SYSROOT", strlen ("$SYSROOT")) == 0)
 331             p->name = concat (sysroot, p->name + strlen ("$SYSROOT"), NULL);
 332         }
 333     }
 334 }
 335
 336 /* Merge the four include chains together in the order quote, bracket,
 337    system, after.  Remove duplicate dirs (determined in
 338    system-specific manner).
 339
 340    We can't just merge the lists and then uniquify them because then
 341    we may lose directories from the <> search path that should be
 342    there; consider -iquote foo -iquote bar -Ifoo -Iquux.  It is
 343    however safe to treat -iquote bar -iquote foo -Ifoo -Iquux as if
 344    written -iquote bar -Ifoo -Iquux.  */
 345
 346 static void
 347 merge_include_chains (const char *sysroot, cpp_reader *pfile, int verbose)
 348 {
 349   /* Add the sysroot to user-supplied paths starting with "=".  */
 350   if (sysroot)
 351     {
 352       add_sysroot_to_chain (sysroot, QUOTE);
 353       add_sysroot_to_chain (sysroot, BRACKET);
 354       add_sysroot_to_chain (sysroot, SYSTEM);
 355       add_sysroot_to_chain (sysroot, AFTER);
 356     }
 357
 358   /* Join the SYSTEM and AFTER chains.  Remove duplicates in the
 359      resulting SYSTEM chain.  */
 360   if (heads[SYSTEM])
 361     tails[SYSTEM]->next = heads[AFTER];
 362   else
 363     heads[SYSTEM] = heads[AFTER];
 364   heads[SYSTEM] = remove_duplicates (pfile, heads[SYSTEM], 0, 0, verbose);
 365
 366   /* Remove duplicates from BRACKET that are in itself or SYSTEM, and
 367      join it to SYSTEM.  */
 368   heads[BRACKET] = remove_duplicates (pfile, heads[BRACKET], heads[SYSTEM],
 369                                       heads[SYSTEM], verbose);
 370
 371   /* Remove duplicates from QUOTE that are in itself or SYSTEM, and
 372      join it to BRACKET.  */
 373   heads[QUOTE] = remove_duplicates (pfile, heads[QUOTE], heads[SYSTEM],
 374                                     heads[BRACKET], verbose);
 375
 376   /* If verbose, print the list of dirs to search.  */
 377   if (verbose)
 378     {
 379       struct cpp_dir *p;
 380
 381       fprintf (stderr, _("#include \"...\" search starts here:\n"));
 382       for (p = heads[QUOTE];; p = p->next)
 383         {
 384           if (p == heads[BRACKET])
 385             fprintf (stderr, _("#include <...> search starts here:\n"));
 386           if (!p)
 387             break;
 388           fprintf (stderr, " %s\n", p->name);
 389         }
 390       fprintf (stderr, _("End of search list.\n"));
 391     }
 392 }
 393
 394 /* Use given -I paths for #include "..." but not #include <...>, and
 395    don't search the directory of the present file for #include "...".
 396    (Note that -I. -I- is not the same as the default setup; -I. uses
 397    the compiler's working dir.)  */
 398 void
 399 split_quote_chain (void)
 400 {
 401   if (heads[QUOTE])
 402     free_path (heads[QUOTE], REASON_QUIET);
 403   if (tails[QUOTE])
 404     free_path (tails[QUOTE], REASON_QUIET);
 405   heads[QUOTE] = heads[BRACKET];
 406   tails[QUOTE] = tails[BRACKET];
 407   heads[BRACKET] = NULL;
 408   tails[BRACKET] = NULL;
 409   /* This is NOT redundant.  */
 410   quote_ignores_source_dir = true;
 411 }
 412
 413 /* Add P to the chain specified by CHAIN.  */
 414
 415 void
 416 add_cpp_dir_path (cpp_dir *p, int chain)
 417 {
 418   if (tails[chain])
 419     tails[chain]->next = p;
 420   else
 421     heads[chain] = p;
 422   tails[chain] = p;
 423 }
 424
 425 /* Add PATH to the include chain CHAIN. PATH must be malloc-ed and
 426    NUL-terminated.  */
 427 void
 428 add_path (char *path, int chain, int cxx_aware, bool user_supplied_p)
 429 {
 430   cpp_dir *p;
 431
 432 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 433   /* Remove unnecessary trailing slashes.  On some versions of MS
 434      Windows, trailing  _forward_ slashes cause no problems for stat().
 435      On newer versions, stat() does not recognize a directory that ends
 436      in a '\\' or '/', unless it is a drive root dir, such as "c:/",
 437      where it is obligatory.  */
 438   int pathlen = strlen (path);
 439   char* end = path + pathlen - 1;
 440   /* Preserve the lead '/' or lead "c:/".  */
 441   char* start = path + (pathlen > 2 && path[1] == ':' ? 3 : 1);
 442
 443   for (; end > start && IS_DIR_SEPARATOR (*end); end--)
 444     *end = 0;
 445 #endif
 446
 447   p = XNEW (cpp_dir);
 448   p->next = NULL;
 449   p->name = path;
 450 #ifndef INO_T_EQ
 451   p->canonical_name = lrealpath (path);
 452 #endif
 453   if (chain == SYSTEM || chain == AFTER)
 454     p->sysp = 1 + !cxx_aware;
 455   else
 456     p->sysp = 0;
 457   p->construct = 0;
 458   p->user_supplied_p = user_supplied_p;
 459
 460   add_cpp_dir_path (p, chain);
 461 }
 462
 463 /* Exported function to handle include chain merging, duplicate
 464    removal, and registration with cpplib.  */
 465 void
 466 register_include_chains (cpp_reader *pfile, const char *sysroot,
 467                          const char *iprefix, const char *imultilib,
 468                          int stdinc, int cxx_stdinc, int verbose)
 469 {
 470   static const char *const lang_env_vars[] =
 471     { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH",
 472       "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" };
 473   cpp_options *cpp_opts = cpp_get_options (pfile);
 474   size_t idx = (cpp_opts->objc ? 2: 0);
 475
 476   if (cpp_opts->cplusplus)
 477     idx++;
 478   else
 479     cxx_stdinc = false;
 480
 481   /* CPATH and language-dependent environment variables may add to the
 482      include chain.  */
 483   add_env_var_paths ("CPATH", BRACKET);
 484   add_env_var_paths (lang_env_vars[idx], SYSTEM);
 485
 486   target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc);
 487
 488   /* Finally chain on the standard directories.  */
 489   if (stdinc)
 490     add_standard_paths (sysroot, iprefix, imultilib, cxx_stdinc);
 491
 492   target_c_incpath.extra_includes (sysroot, iprefix, stdinc);
 493
 494   merge_include_chains (sysroot, pfile, verbose);
 495
 496   cpp_set_include_chains (pfile, heads[QUOTE], heads[BRACKET],
 497                           quote_ignores_source_dir);
 498 }
 499
 500 /* Return the current chain of cpp dirs.  */
 501
 502 struct cpp_dir *
 503 get_added_cpp_dirs (int chain)
 504 {
 505   return heads[chain];
 506 }
 507
 508 #if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES)
 509 static void hook_void_charptr_charptr_int (const char *sysroot ATTRIBUTE_UNUSED,
 510                                            const char *iprefix ATTRIBUTE_UNUSED,
 511                                            int stdinc ATTRIBUTE_UNUSED)
 512 {
 513 }
 514 #endif
 515
 516 #ifndef TARGET_EXTRA_INCLUDES
 517 #define TARGET_EXTRA_INCLUDES hook_void_charptr_charptr_int
 518 #endif
 519 #ifndef TARGET_EXTRA_PRE_INCLUDES
 520 #define TARGET_EXTRA_PRE_INCLUDES hook_void_charptr_charptr_int
 521 #endif
 522
 523 struct target_c_incpath_s target_c_incpath = { TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES };
 524