LCOV - code coverage report
Current view: top level - gcc - incpath.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 137 195 70.3 %
Date: 2020-04-04 11:58:09 Functions: 9 12 75.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       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                 :     995060 : free_path (struct cpp_dir *path, int reason)
      68                 :            : {
      69                 :     995060 :   switch (reason)
      70                 :            :     {
      71                 :          0 :     case REASON_DUP:
      72                 :          0 :     case REASON_DUP_SYS:
      73                 :          0 :       fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), path->name);
      74                 :          0 :       if (reason == REASON_DUP_SYS)
      75                 :          0 :         fprintf (stderr,
      76                 :          0 :  _("  as it is a non-system directory that duplicates a system directory\n"));
      77                 :            :       break;
      78                 :            : 
      79                 :        654 :     case REASON_NOENT:
      80                 :        654 :       fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"),
      81                 :            :                path->name);
      82                 :        654 :       break;
      83                 :            : 
      84                 :            :     case REASON_QUIET:
      85                 :            :     default:
      86                 :            :       break;
      87                 :            :     }
      88                 :            : 
      89                 :     995060 :   free (path->name);
      90                 :     995060 :   free (path);
      91                 :     995060 : }
      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                 :     316374 : add_env_var_paths (const char *env_var, incpath_kind chain)
      97                 :            : {
      98                 :     316374 :   char *p, *q, *path;
      99                 :            : 
     100                 :     316374 :   q = getenv (env_var);
     101                 :            : 
     102                 :     316374 :   if (!q)
     103                 :            :     return;
     104                 :            : 
     105                 :          0 :   for (p = q; *q; p = q + 1)
     106                 :            :     {
     107                 :            :       q = p;
     108                 :          0 :       while (*q != 0 && *q != PATH_SEPARATOR)
     109                 :          0 :         q++;
     110                 :            : 
     111                 :          0 :       if (p == q)
     112                 :          0 :         path = xstrdup (".");
     113                 :            :       else
     114                 :            :         {
     115                 :          0 :           path = XNEWVEC (char, q - p + 1);
     116                 :          0 :           memcpy (path, p, q - p);
     117                 :          0 :           path[q - p] = '\0';
     118                 :            :         }
     119                 :            : 
     120                 :          0 :       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                 :     158156 : add_standard_paths (const char *sysroot, const char *iprefix,
     127                 :            :                     const char *imultilib, int cxx_stdinc)
     128                 :            : {
     129                 :     158156 :   const struct default_include *p;
     130                 :     158156 :   int relocated = cpp_relocated ();
     131                 :     158156 :   size_t len;
     132                 :            : 
     133                 :     158156 :   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                 :    1738230 :       for (p = cpp_include_defaults; p->fname; p++)
     139                 :            :         {
     140                 :    1580210 :           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                 :    1106270 :               if (sysroot && p->add_sysroot)
     146                 :          0 :                 continue;
     147                 :    1106270 :               if (!filename_ncmp (p->fname, cpp_GCC_INCLUDE_DIR, len))
     148                 :            :                 {
     149                 :     474183 :                   char *str = concat (iprefix, p->fname + len, NULL);
     150                 :     474183 :                   if (p->multilib == 1 && imultilib)
     151                 :          0 :                     str = reconcat (str, str, dir_separator_str,
     152                 :            :                                     imultilib, NULL);
     153                 :     474183 :                   else if (p->multilib == 2)
     154                 :            :                     {
     155                 :          0 :                       if (!imultiarch)
     156                 :            :                         {
     157                 :          0 :                           free (str);
     158                 :          0 :                           continue;
     159                 :            :                         }
     160                 :          0 :                       str = reconcat (str, str, dir_separator_str,
     161                 :            :                                       imultiarch, NULL);
     162                 :            :                     }
     163                 :     474183 :                   add_path (str, INC_SYSTEM, p->cxx_aware, false);
     164                 :            :                 }
     165                 :            :             }
     166                 :            :         }
     167                 :            :     }
     168                 :            : 
     169                 :    1739720 :   for (p = cpp_include_defaults; p->fname; p++)
     170                 :            :     {
     171                 :    1581560 :       if (!p->cplusplus || cxx_stdinc)
     172                 :            :         {
     173                 :    1107370 :           char *str;
     174                 :            : 
     175                 :            :           /* Should this directory start with the sysroot?  */
     176                 :    1107370 :           if (sysroot && p->add_sysroot)
     177                 :            :             {
     178                 :          0 :               char *sysroot_no_trailing_dir_separator = xstrdup (sysroot);
     179                 :          0 :               size_t sysroot_len = strlen (sysroot);
     180                 :            : 
     181                 :          0 :               if (sysroot_len > 0 && sysroot[sysroot_len - 1] == DIR_SEPARATOR)
     182                 :          0 :                 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
     183                 :          0 :               str = concat (sysroot_no_trailing_dir_separator, p->fname, NULL);
     184                 :          0 :               free (sysroot_no_trailing_dir_separator);
     185                 :            :             }
     186                 :     474747 :           else if (!p->add_sysroot && relocated
     187                 :    1582120 :                    && !filename_ncmp (p->fname, cpp_PREFIX, cpp_PREFIX_len))
     188                 :            :             {
     189                 :     474747 :               static const char *relocated_prefix;
     190                 :     474747 :               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                 :     474747 :               if (!relocated_prefix)
     197                 :            :                 {
     198                 :     448516 :                   char *dummy;
     199                 :            :                   /* Make relative prefix expects the first argument
     200                 :            :                      to be a program, not a directory.  */
     201                 :     448516 :                   dummy = concat (gcc_exec_prefix, "dummy", NULL);
     202                 :     448516 :                   relocated_prefix
     203                 :     448516 :                     = make_relative_prefix (dummy,
     204                 :            :                                             cpp_EXEC_PREFIX,
     205                 :            :                                             cpp_PREFIX);
     206                 :     448516 :                   free (dummy);
     207                 :            :                 }
     208                 :     949494 :               ostr = concat (relocated_prefix,
     209                 :     474747 :                              p->fname + cpp_PREFIX_len,
     210                 :            :                              NULL);
     211                 :     474747 :               str = update_path (ostr, p->component);
     212                 :     474747 :               free (ostr);
     213                 :            :             }
     214                 :            :           else
     215                 :     632624 :             str = update_path (p->fname, p->component);
     216                 :            : 
     217                 :    1107370 :           if (p->multilib == 1 && imultilib)
     218                 :          0 :             str = reconcat (str, str, dir_separator_str, imultilib, NULL);
     219                 :    1107370 :           else if (p->multilib == 2)
     220                 :            :             {
     221                 :     316312 :               if (!imultiarch)
     222                 :            :                 {
     223                 :     316312 :                   free (str);
     224                 :     316312 :                   continue;
     225                 :            :                 }
     226                 :          0 :               str = reconcat (str, str, dir_separator_str, imultiarch, NULL);
     227                 :            :             }
     228                 :            : 
     229                 :     791059 :           add_path (str, INC_SYSTEM, p->cxx_aware, false);
     230                 :            :         }
     231                 :            :     }
     232                 :     158156 : }
     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                 :     474561 : remove_duplicates (cpp_reader *pfile, struct cpp_dir *head,
     243                 :            :                    struct cpp_dir *system, struct cpp_dir *join,
     244                 :            :                    int verbose)
     245                 :            : {
     246                 :     474561 :   struct cpp_dir **pcur, *tmp, *cur;
     247                 :     474561 :   struct stat st;
     248                 :            : 
     249                 :    2550010 :   for (pcur = &head; *pcur; )
     250                 :            :     {
     251                 :    2075450 :       int reason = REASON_QUIET;
     252                 :            : 
     253                 :    2075450 :       cur = *pcur;
     254                 :            : 
     255                 :    2075450 :       if (stat (cur->name, &st))
     256                 :            :         {
     257                 :            :           /* Dirs that don't exist or have denied permissions are 
     258                 :            :              silently ignored, unless verbose.  */
     259                 :     990644 :           if ((errno != ENOENT) && (errno != EPERM))
     260                 :          0 :             cpp_errno (pfile, CPP_DL_ERROR, cur->name);
     261                 :            :           else
     262                 :            :             {
     263                 :            :               /* If -Wmissing-include-dirs is given, warn.  */
     264                 :     990644 :               cpp_options *opts = cpp_get_options (pfile);
     265                 :     990644 :               if (opts->warn_missing_include_dirs && cur->user_supplied_p)
     266                 :          1 :                 cpp_warning (pfile, CPP_W_MISSING_INCLUDE_DIRS, "%s: %s",
     267                 :            :                              cur->name, xstrerror (errno));
     268                 :            :               reason = REASON_NOENT;
     269                 :            :             }
     270                 :            :         }
     271                 :    1084800 :       else if (!S_ISDIR (st.st_mode))
     272                 :          0 :         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                 :    1084800 :           INO_T_COPY (cur->ino, st.st_ino);
     278                 :    1084800 :           cur->dev  = st.st_dev;
     279                 :            : #endif
     280                 :            : 
     281                 :            :           /* Remove this one if it is in the system chain.  */
     282                 :    1084800 :           reason = REASON_DUP_SYS;
     283                 :    2883430 :           for (tmp = system; tmp; tmp = tmp->next)
     284                 :    1798800 :            if (DIRS_EQ (tmp, cur) && cur->construct == tmp->construct)
     285                 :            :               break;
     286                 :            : 
     287                 :    1084800 :           if (!tmp)
     288                 :            :             {
     289                 :            :               /* Duplicate of something earlier in the same chain?  */
     290                 :    1084640 :               reason = REASON_DUP;
     291                 :    3051680 :               for (tmp = head; tmp != cur; tmp = tmp->next)
     292                 :    1971290 :                if (DIRS_EQ (cur, tmp) && cur->construct == tmp->construct)
     293                 :            :                   break;
     294                 :            : 
     295                 :    1084640 :               if (tmp == cur
     296                 :            :                   /* Last in the chain and duplicate of JOIN?  */
     297                 :    1080390 :                   && !(cur->next == NULL && join
     298                 :      87469 :                        && DIRS_EQ (cur, join)
     299                 :          0 :                        && cur->construct == join->construct))
     300                 :            :                 {
     301                 :            :                   /* Unique, so keep this directory.  */
     302                 :    1080390 :                   pcur = &cur->next;
     303                 :    1080390 :                   continue;
     304                 :            :                 }
     305                 :            :             }
     306                 :            :         }
     307                 :            : 
     308                 :            :       /* Remove this entry from the chain.  */
     309                 :     995060 :       *pcur = cur->next;
     310                 :     995714 :       free_path (cur, verbose ? reason: REASON_QUIET);
     311                 :            :     }
     312                 :            : 
     313                 :     474561 :   *pcur = join;
     314                 :     474561 :   return head;
     315                 :            : }
     316                 :            : 
     317                 :            : /* Add SYSROOT to any user-supplied paths in CHAIN starting with
     318                 :            :    "=" or "$SYSROOT".  */
     319                 :            : 
     320                 :            : static void
     321                 :          0 : add_sysroot_to_chain (const char *sysroot, int chain)
     322                 :            : {
     323                 :          0 :   struct cpp_dir *p;
     324                 :            : 
     325                 :          0 :   for (p = heads[chain]; p != NULL; p = p->next)
     326                 :            :     {
     327                 :          0 :       if (p->user_supplied_p)
     328                 :            :         {
     329                 :          0 :           if (p->name[0] == '=')
     330                 :          0 :             p->name = concat (sysroot, p->name + 1, NULL);
     331                 :          0 :           if (strncmp (p->name, "$SYSROOT", strlen ("$SYSROOT")) == 0)
     332                 :          0 :             p->name = concat (sysroot, p->name + strlen ("$SYSROOT"), NULL);
     333                 :            :         }
     334                 :            :     }
     335                 :          0 : }
     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                 :     158187 : merge_include_chains (const char *sysroot, cpp_reader *pfile, int verbose)
     349                 :            : {
     350                 :            :   /* Add the sysroot to user-supplied paths starting with "=".  */
     351                 :     158187 :   if (sysroot)
     352                 :            :     {
     353                 :          0 :       add_sysroot_to_chain (sysroot, INC_QUOTE);
     354                 :          0 :       add_sysroot_to_chain (sysroot, INC_BRACKET);
     355                 :          0 :       add_sysroot_to_chain (sysroot, INC_SYSTEM);
     356                 :          0 :       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                 :     158187 :   if (heads[INC_SYSTEM])
     362                 :     158186 :     tails[INC_SYSTEM]->next = heads[INC_AFTER];
     363                 :            :   else
     364                 :          1 :     heads[INC_SYSTEM] = heads[INC_AFTER];
     365                 :     158187 :   heads[INC_SYSTEM]
     366                 :     158187 :     = 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                 :     158187 :   heads[INC_BRACKET]
     371                 :     158187 :     = 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                 :     158187 :   heads[INC_QUOTE]
     377                 :     158187 :     = 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                 :     158187 :   if (verbose)
     382                 :            :     {
     383                 :        109 :       struct cpp_dir *p;
     384                 :            : 
     385                 :        109 :       fprintf (stderr, _("#include \"...\" search starts here:\n"));
     386                 :        545 :       for (p = heads[INC_QUOTE];; p = p->next)
     387                 :            :         {
     388                 :        545 :           if (p == heads[INC_BRACKET])
     389                 :        109 :             fprintf (stderr, _("#include <...> search starts here:\n"));
     390                 :        545 :           if (!p)
     391                 :            :             break;
     392                 :        436 :           fprintf (stderr, " %s\n", p->name);
     393                 :            :         }
     394                 :        109 :       fprintf (stderr, _("End of search list.\n"));
     395                 :            :     }
     396                 :     158187 : }
     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                 :          0 : split_quote_chain (void)
     404                 :            : {
     405                 :          0 :   if (heads[INC_QUOTE])
     406                 :          0 :     free_path (heads[INC_QUOTE], REASON_QUIET);
     407                 :          0 :   if (tails[INC_QUOTE])
     408                 :          0 :     free_path (tails[INC_QUOTE], REASON_QUIET);
     409                 :          0 :   heads[INC_QUOTE] = heads[INC_BRACKET];
     410                 :          0 :   tails[INC_QUOTE] = tails[INC_BRACKET];
     411                 :          0 :   heads[INC_BRACKET] = NULL;
     412                 :          0 :   tails[INC_BRACKET] = NULL;
     413                 :            :   /* This is NOT redundant.  */
     414                 :          0 :   quote_ignores_source_dir = true;
     415                 :          0 : }
     416                 :            : 
     417                 :            : /* Add P to the chain specified by CHAIN.  */
     418                 :            : 
     419                 :            : void
     420                 :    2114630 : add_cpp_dir_path (cpp_dir *p, incpath_kind chain)
     421                 :            : {
     422                 :    2114630 :   if (tails[chain])
     423                 :    1842190 :     tails[chain]->next = p;
     424                 :            :   else
     425                 :     272440 :     heads[chain] = p;
     426                 :    2114630 :   tails[chain] = p;
     427                 :    2114630 : }
     428                 :            : 
     429                 :            : /* Add PATH to the include chain CHAIN. PATH must be malloc-ed and
     430                 :            :    NUL-terminated.  */
     431                 :            : void
     432                 :    2114630 : add_path (char *path, incpath_kind chain, int cxx_aware, bool user_supplied_p)
     433                 :            : {
     434                 :    2114630 :   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                 :    2114630 :   p = XNEW (cpp_dir);
     452                 :    2114630 :   p->next = NULL;
     453                 :    2114630 :   p->name = path;
     454                 :            : #ifndef INO_T_EQ
     455                 :            :   p->canonical_name = lrealpath (path);
     456                 :            : #endif
     457                 :    2114630 :   if (chain == INC_SYSTEM || chain == INC_AFTER)
     458                 :    2094000 :     p->sysp = 1 + !cxx_aware;
     459                 :            :   else
     460                 :     495361 :     p->sysp = 0;
     461                 :    2114630 :   p->construct = 0;
     462                 :    2114630 :   p->user_supplied_p = user_supplied_p;
     463                 :            : 
     464                 :    2114630 :   add_cpp_dir_path (p, chain);
     465                 :    2114630 : }
     466                 :            : 
     467                 :            : /* Exported function to handle include chain merging, duplicate
     468                 :            :    removal, and registration with cpplib.  */
     469                 :            : void
     470                 :     158187 : 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                 :     158187 :   static const char *const lang_env_vars[] =
     475                 :            :     { "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH",
     476                 :            :       "OBJC_INCLUDE_PATH", "OBJCPLUS_INCLUDE_PATH" };
     477                 :     158187 :   cpp_options *cpp_opts = cpp_get_options (pfile);
     478                 :     158187 :   size_t idx = (cpp_opts->objc ? 2: 0);
     479                 :            : 
     480                 :     158187 :   if (cpp_opts->cplusplus)
     481                 :      78519 :     idx++;
     482                 :            :   else
     483                 :            :     cxx_stdinc = false;
     484                 :            : 
     485                 :            :   /* CPATH and language-dependent environment variables may add to the
     486                 :            :      include chain.  */
     487                 :     158187 :   add_env_var_paths ("CPATH", INC_BRACKET);
     488                 :     158187 :   add_env_var_paths (lang_env_vars[idx], INC_SYSTEM);
     489                 :            : 
     490                 :     158187 :   target_c_incpath.extra_pre_includes (sysroot, iprefix, stdinc);
     491                 :            : 
     492                 :            :   /* Finally chain on the standard directories.  */
     493                 :     158187 :   if (stdinc)
     494                 :     158156 :     add_standard_paths (sysroot, iprefix, imultilib, cxx_stdinc);
     495                 :            : 
     496                 :     158187 :   target_c_incpath.extra_includes (sysroot, iprefix, stdinc);
     497                 :            : 
     498                 :     158187 :   merge_include_chains (sysroot, pfile, verbose);
     499                 :            : 
     500                 :     158187 :   cpp_set_include_chains (pfile, heads[INC_QUOTE], heads[INC_BRACKET],
     501                 :            :                           quote_ignores_source_dir);
     502                 :     158187 : }
     503                 :            : 
     504                 :            : /* Return the current chain of cpp dirs.  */
     505                 :            : 
     506                 :            : struct cpp_dir *
     507                 :          0 : get_added_cpp_dirs (incpath_kind chain)
     508                 :            : {
     509                 :          0 :   return heads[chain];
     510                 :            : }
     511                 :            : 
     512                 :            : #if !(defined TARGET_EXTRA_INCLUDES) || !(defined TARGET_EXTRA_PRE_INCLUDES)
     513                 :     316374 : 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                 :     316374 : }
     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                 :            : 

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.