gcc/incpath.c

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