gcc/incpath.cc

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