sdcc/support/cpp/gcc/incpath.cc

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