gcc/incpath.c

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