gcc-4_8-branch/gcc/incpath.c

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