/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/files.c

Bug Summary

File:	build/libcpp/files.c
Warning:	line 849, column 48 Use of memory after it is freed
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name files.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -fdeprecated-macro -fdebug-compilation-dir /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/build-x86_64-pc-linux-gnu/libcpp -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-Jvnagp.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/files.c
1/* Part of CPP library.  File handling.
 Copyright (C) 1986-2021 Free Software Foundation, Inc.
 Written by Per Bothner, 1994.
 Based on CCCP program by Paul Rubin, June 1986
 Adapted to ANSI C, Richard Stallman, Jan 1987
 Split out of cpplib.c, Zack Weinberg, Oct 1998
 Reimplemented, Neil Booth, Jul 2003

9This program is free software; you can redistribute it and/or modify it
10under the terms of the GNU General Public License as published by the
11Free Software Foundation; either version 3, or (at your option) any
12later version.

14This program is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17GNU General Public License for more details.

19You should have received a copy of the GNU General Public License
20along with this program; see the file COPYING3.  If not see
21<http://www.gnu.org/licenses/>.  */

23#include "config.h"
24#include "system.h"
25#include "cpplib.h"
26#include "internal.h"
27#include "mkdeps.h"
28#include "obstack.h"
29#include "hashtab.h"
30#include "md5.h"
31#include <dirent.h>

33/* Variable length record files on VMS will have a stat size that includes
 record control characters that won't be included in the read size.  */
35#ifdef VMS
36# define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
37# define STAT_SIZE_RELIABLE(ST)true ((ST).st_fab_rfm != FAB_C_VAR)
38#else
39# define STAT_SIZE_RELIABLE(ST)true true
40#endif

42#ifdef __DJGPP__
43#include <io.h>
/* For DJGPP redirected input is opened in text mode.  */
45#  define set_stdin_to_binary_mode() \
   if (! isatty (0)) setmode (0, O_BINARY0)
47#else
48#  define set_stdin_to_binary_mode() /* Nothing */
49#endif

51/* This structure represents a file searched for by CPP, whether it
 exists or not.  An instance may be pointed to by more than one
 cpp_file_hash_entry; at present no reference count is kept.  */
54struct _cpp_file
55{
/* Filename as given to #include or command line switch.  */
const char *name;

/* The full path used to find the file.  */
const char *path;

/* The full path of the pch file.  */
const char *pchname;

/* The file's path with the basename stripped.  NULL if it hasn't
   been calculated yet.  */
const char *dir_name;

/* Chain through all files.  */
struct _cpp_file *next_file;

/* The contents of NAME after calling read_file().  */
const uchar *buffer;

/* Pointer to the real start of BUFFER.  read_file() might increment
   BUFFER; when freeing, this this pointer must be used instead.  */
const uchar *buffer_start;

/* The macro, if any, preventing re-inclusion.  */
const cpp_hashnode *cmacro;

/* The directory in the search path where FILE was found.  Used for
   #include_next and determining whether a header is a system
   header.  */
cpp_dir *dir;

/* As filled in by stat(2) for the file.  */
struct stat st;

/* File descriptor.  Invalid if -1, otherwise open.  */
int fd;

/* Zero if this file was successfully opened and stat()-ed,
   otherwise errno obtained from failure.  */
int err_no;

/* Number of times the file has been stacked for preprocessing.  */
unsigned short stack_count;

/* If opened with #import or contains #pragma once.  */
bool once_only : 1;

/* If read() failed before.  */
bool dont_read : 1;

/* If BUFFER above contains the true contents of the file.  */
bool buffer_valid : 1;

/* If this file is implicitly preincluded.  */
bool implicit_preinclude : 1;

/* > 0: Known C++ Module header unit, <0: known not.  ==0, unknown  */
int header_unit : 2;
114};

116/* A singly-linked list for all searches for a given file name, with
 its head pointed to by a slot in FILE_HASH.  The file name is what
 appeared between the quotes in a #include directive; it can be
 determined implicitly from the hash table location or explicitly
 from FILE->name.

 FILE is a structure containing details about the file that was
 found with that search, or details of how the search failed.

 START_DIR is the starting location of the search in the include
 chain.  The current directories for "" includes are also hashed in
 the hash table and therefore unique.  Files that are looked up
 without using a search path, such as absolute filenames and file
 names from the command line share a special starting directory so
 they don't cause cache hits with normal include-chain lookups.

 If START_DIR is NULL then the entry is for a directory, not a file,
 and the directory is in DIR.  Since the starting point in a file
 lookup chain is never NULL, this means that simple pointer
 comparisons against START_DIR can be made to determine cache hits
 in file lookups.

 If a cache lookup fails because of e.g. an extra "./" in the path,
 then nothing will break.  It is just less efficient as CPP will
 have to do more work re-preprocessing the file, and/or comparing
 its contents against earlier once-only files.
142*/
143struct cpp_file_hash_entry
144{
struct cpp_file_hash_entry *next;
cpp_dir *start_dir;
location_t location;
union
{
  _cpp_file *file;
  cpp_dir *dir;
} u;
153};

155/* Number of entries to put in a cpp_file_hash_entry pool.  */
156#define FILE_HASH_POOL_SIZE127 127

158/* A file hash entry pool.  We allocate cpp_file_hash_entry object from
 one of these.  */
160struct file_hash_entry_pool
161{
/* Number of entries used from this pool.  */
unsigned int file_hash_entries_used;
/* Next pool in the chain; used when freeing.  */
struct file_hash_entry_pool *next;
/* The memory pool.  */
struct cpp_file_hash_entry pool[FILE_HASH_POOL_SIZE127];
168};

170static bool open_file (_cpp_file *file);
171static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
	   bool *invalid_pch);
173static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
	      bool *invalid_pch, location_t loc);
175static bool read_file_guts (cpp_reader *pfile, _cpp_file *file,
	    location_t loc);
177static bool read_file (cpp_reader *pfile, _cpp_file *file,
       location_t loc);
179static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
		 int angle_brackets, enum include_type);
181static const char *dir_name_of_file (_cpp_file *file);
182static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int,
	      location_t);
184static struct cpp_file_hash_entry *search_cache (struct cpp_file_hash_entry *head,
			     const cpp_dir *start_dir);
186static _cpp_file *make_cpp_file (cpp_dir *, const char *fname);
187static void destroy_cpp_file (_cpp_file *);
188static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
189static void allocate_file_hash_entries (cpp_reader *pfile);
190static struct cpp_file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
191static int report_missing_guard (void **slot, void *b);
192static hashval_t file_hash_hash (const void *p);
193static int file_hash_eq (const void *p, const void *q);
194static char *read_filename_string (int ch, FILE *f);
195static void read_name_map (cpp_dir *dir);
196static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
197static char *append_file_to_dir (const char *fname, cpp_dir *dir);
198static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
199static int pchf_save_compare (const void *e1, const void *e2);
200static int pchf_compare (const void *d_p, const void *e_p);
201static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);

203/* Given a filename in FILE->PATH, with the empty string interpreted
 as <stdin>, open it.

 On success FILE contains an open file descriptor and stat
 information for the file.  On failure the file descriptor is -1 and
 the appropriate errno is also stored in FILE.  Returns TRUE iff
 successful.

 We used to open files in nonblocking mode, but that caused more
 problems than it solved.  Do take care not to acquire a controlling
 terminal by mistake (this can't happen on sane systems, but
 paranoia is a virtue).

 Use the three-argument form of open even though we aren't
 specifying O_CREAT, to defend against broken system headers.

 O_BINARY tells some runtime libraries (notably DJGPP) not to do
 newline translation; we can handle DOS line breaks just fine
 ourselves.  */
222static bool
223open_file (_cpp_file *file)
224{
if (file->path[0] == '\0')
  {
    file->fd = 0;
    set_stdin_to_binary_mode ();
  }
else
  file->fd = open (file->path, O_RDONLY00 | O_NOCTTY0400 | O_BINARY0, 0666);

if (file->fd != -1)
  {
    if (fstat (file->fd, &file->st) == 0)
{
 if (!S_ISDIR (file->st.st_mode)((((file->st.st_mode)) & 0170000) == (0040000)))
   {
     file->err_no = 0;
     return true;
   }

 /* Ignore a directory and continue the search.  The file we're
    looking for may be elsewhere in the search path.  */
 errno(*__errno_location ()) = ENOENT2;
}

    close (file->fd);
    file->fd = -1;
  }
251#if defined(_WIN32) && !defined(__CYGWIN__)
else if (errno(*__errno_location ()) == EACCES13)
  {
    /* On most UNIX systems, open succeeds on a directory.  Above,
       we check if we have opened a directory and if so, set errno
       to ENOENT.  However, on Windows, opening a directory
       fails with EACCES.  We want to return ENOENT in that
       case too.  */
    if (stat (file->path, &file->st) == 0
        && S_ISDIR (file->st.st_mode)((((file->st.st_mode)) & 0170000) == (0040000)))
      errno(*__errno_location ()) = ENOENT2;
    else
/* The call to stat may have reset errno.  */
errno(*__errno_location ()) = EACCES13;
  }
266#endif    
else if (errno(*__errno_location ()) == ENOTDIR20)
  errno(*__errno_location ()) = ENOENT2;

file->err_no = errno(*__errno_location ());

return false;
273}

275/* Temporary PCH intercept of opening a file.  Try to find a PCH file
 based on FILE->name and FILE->dir, and test those found for
 validity using PFILE->cb.valid_pch.  Return true iff a valid file is
 found.  Set *INVALID_PCH if a PCH file is found but wasn't valid.  */

280static bool
281pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
282{
static const char extension[] = ".gch";
const char *path = file->path;
size_t len, flen;
char *pchname;
struct stat st;
bool valid = false;

/* No PCH on <stdin> or if not requested.  */
if (file->name[0] == '\0' || !pfile->cb.valid_pch)
  return false;

/* If the file is not included as first include from either the toplevel
   file or the command-line it is not a valid use of PCH.  */
for (_cpp_file *f = pfile->all_files; f; f = f->next_file)
  if (f->implicit_preinclude)
    continue;
  else if (pfile->main_file == f)
    break;
  else
    return false;

flen = strlen (path);
len = flen + sizeof (extension);
pchname = XNEWVEC (char, len)((char *) xmalloc (sizeof (char) * (len)));
memcpy (pchname, path, flen);
memcpy (pchname + flen, extension, sizeof (extension));

if (stat (pchname, &st) == 0)
  {
    DIR *pchdir;
    struct dirent *d;
    size_t dlen, plen = len;

    if (!S_ISDIR (st.st_mode)((((st.st_mode)) & 0170000) == (0040000)))
valid = validate_pch (pfile, file, pchname);
    else if ((pchdir = opendir (pchname)) != NULL__null)
{
 pchname[plen - 1] = '/';
 while ((d = readdir (pchdir)) != NULL__null)
   {
     dlen = strlen (d->d_name) + 1;
     if ((strcmp (d->d_name, ".") == 0)
  || (strcmp (d->d_name, "..") == 0))
continue;
     if (dlen + plen > len)
{
  len += dlen + 64;
  pchname = XRESIZEVEC (char, pchname, len)((char *) xrealloc ((void *) (pchname), sizeof (char) * (len)
));
}
     memcpy (pchname + plen, d->d_name, dlen);
     valid = validate_pch (pfile, file, pchname);
     if (valid)
break;
   }
 closedir (pchdir);
}
    if (!valid)
*invalid_pch = true;
  }

if (valid)
  file->pchname = pchname;
else
  free (pchname);

return valid;
349}

351/* Canonicalize the path to FILE.  Return the canonical form if it is
 shorter, otherwise return NULL.  This function does NOT free the
 memory pointed by FILE.  */

355static char *
356maybe_shorter_path (const char * file)
357{
char * file2 = lrealpath (file);
if (file2 && strlen (file2) < strlen (file))
  {
    return file2;
  }
else 
  {
    free (file2);
    return NULL__null;
  }
368}

370/* Try to open the path FILE->name appended to FILE->dir.  This is
 where remap and PCH intercept the file lookup process.  Return true
 if the file was found, whether or not the open was successful.
 Set *INVALID_PCH to true if a PCH file is found but wasn't valid.
 Use LOC when emitting any diagnostics.  */

376static bool
377find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch,
  location_t loc)
379{
char *path;

if (CPP_OPTION (pfile, remap)((pfile)->opts.remap) && (path = remap_filename (pfile, file)))
  ;
else
  if (file->dir->construct)
    path = file->dir->construct (file->name, file->dir);
  else
    path = append_file_to_dir (file->name, file->dir);

if (path)
  {
    hashval_t hv;
    char *copy;
    void **pp;

    /* We try to canonicalize system headers.  For DOS based file
     * system, we always try to shorten non-system headers, as DOS
     * has a tighter constraint on max path length.  */
    if ((CPP_OPTION (pfile, canonical_system_headers)((pfile)->opts.canonical_system_headers) && file->dir->sysp)
400#ifdef HAVE_DOS_BASED_FILE_SYSTEM
 || !file->dir->sysp
402#endif
)
{
 char * canonical_path = maybe_shorter_path (path);
 if (canonical_path)
   {
     /* The canonical path was newly allocated.  Let's free the
 non-canonical one.  */
     free (path);
     path = canonical_path;
   }
}

    hv = htab_hash_string (path);
    if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL__null)
{
 file->err_no = ENOENT2;
 return false;
}

    file->path = path;
    if (pch_open_file (pfile, file, invalid_pch))
return true;

    if (open_file (file))
return true;

    if (file->err_no != ENOENT2)
{
 open_file_failed (pfile, file, 0, loc);
 return true;
}

    /* We copy the path name onto an obstack partly so that we don't
leak the memory, but mostly so that we don't fragment the
heap.  */
    copy = (char *) obstack_copy0 (&pfile->nonexistent_file_ob, path,__extension__ ({ struct obstack *__h = (&pfile->nonexistent_file_ob
); __extension__ ({ struct obstack *__o = (__h); size_t __len
 = ((strlen (path))); if (__extension__ ({ struct obstack const
 *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len + 1) _obstack_newchunk (__o, __len + 1); memcpy
 (__o->next_free, (path), __len); __o->next_free += __len
; *(__o->next_free)++ = 0; (void) 0; }); __extension__ ({ struct
 obstack *__o1 = (__h); void *__value = (void *) __o1->object_base
; if (__o1->next_free == __value) __o1->maybe_empty_object
 = 1; __o1->next_free = ((sizeof (ptrdiff_t) < sizeof (
void *) ? (__o1->object_base) : (char *) 0) + (((__o1->
next_free) - (sizeof (ptrdiff_t) < sizeof (void *) ? (__o1
->object_base) : (char *) 0) + (__o1->alignment_mask)) &
 ~(__o1->alignment_mask))); if ((size_t) (__o1->next_free
 - (char *) __o1->chunk) > (size_t) (__o1->chunk_limit
 - (char *) __o1->chunk)) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; __value; }); })
		     strlen (path))__extension__ ({ struct obstack *__h = (&pfile->nonexistent_file_ob
); __extension__ ({ struct obstack *__o = (__h); size_t __len
 = ((strlen (path))); if (__extension__ ({ struct obstack const
 *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len + 1) _obstack_newchunk (__o, __len + 1); memcpy
 (__o->next_free, (path), __len); __o->next_free += __len
; *(__o->next_free)++ = 0; (void) 0; }); __extension__ ({ struct
 obstack *__o1 = (__h); void *__value = (void *) __o1->object_base
; if (__o1->next_free == __value) __o1->maybe_empty_object
 = 1; __o1->next_free = ((sizeof (ptrdiff_t) < sizeof (
void *) ? (__o1->object_base) : (char *) 0) + (((__o1->
next_free) - (sizeof (ptrdiff_t) < sizeof (void *) ? (__o1
->object_base) : (char *) 0) + (__o1->alignment_mask)) &
 ~(__o1->alignment_mask))); if ((size_t) (__o1->next_free
 - (char *) __o1->chunk) > (size_t) (__o1->chunk_limit
 - (char *) __o1->chunk)) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; __value; }); });
    free (path);
    pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
		     copy, hv, INSERT);
    *pp = copy;

    file->path = file->name;
  }
else
  {
    file->err_no = ENOENT2; 
    file->path = NULL__null;
  }

return false;
454}

456/* Return true iff the missing_header callback found the given HEADER.  */
457static bool
458search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
459{
missing_header_cb func = pfile->cb.missing_header;

/* When the regular search path doesn't work, try context dependent
   headers search paths.  */
if (func
    && file->dir == NULL__null)
  {
    if ((file->path = func (pfile, header, &file->dir)) != NULL__null)
{
 if (open_file (file))
   return true;
 free ((void *)file->path);
}
    file->path = file->name;
  }

return false;
477}

479bool
480_cpp_find_failed (_cpp_file *file)
481{
return file->err_no != 0;
483}

485/* Given a filename FNAME search for such a file in the include path
 starting from START_DIR.  If FNAME is the empty string it is
 interpreted as STDIN if START_DIR is PFILE->no_search_path.

 If the file is not found in the file cache fall back to the O/S and
 add the result to our cache.

 If the file was not found in the filesystem, or there was an error
 opening it, then ERR_NO is nonzero and FD is -1.  If the file was
 found, then ERR_NO is zero and FD could be -1 or an open file
 descriptor.  FD can be -1 if the file was found in the cache and
 had previously been closed.  To open it again pass the return value
 to open_file().

 If KIND is _cpp_FFK_PRE_INCLUDE then it is OK for the file to be
 missing.  If present, it is OK for a precompiled header to be
 included after it.

 Use LOC as the location for any errors.  */

505_cpp_file *
506_cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir,
int angle_brackets, _cpp_find_file_kind kind, location_t loc)
508{
bool invalid_pch = false;
bool saw_bracket_include = false;
bool saw_quote_include = false;
struct cpp_dir *found_in_cache = NULL__null;

/* Ensure we get no confusion between cached files and directories.  */
if (start_dir == NULL__null)
  cpp_error_at (pfile, CPP_DL_ICE, loc, "NULL directory in find_file");

void **hash_slot
  = htab_find_slot_with_hash (pfile->file_hash, fname,
		htab_hash_string (fname), INSERT);

/* First check the cache before we resort to memory allocation.  */
cpp_file_hash_entry *entry
  = search_cache ((struct cpp_file_hash_entry *) *hash_slot, start_dir);
if (entry)
  return entry->u.file;

_cpp_file *file = make_cpp_file (start_dir, fname);
file->implicit_preinclude
  = (kind == _cpp_FFK_PRE_INCLUDE
     || (pfile->buffer && pfile->buffer->file->implicit_preinclude));

if (kind != _cpp_FFK_FAKE)
  /* Try each path in the include chain.  */
  for (;;)
    {
if (find_file_in_dir (pfile, file, &invalid_pch, loc))
 break;

file->dir = file->dir->next;
if (file->dir == NULL__null)
 {
   if (search_path_exhausted (pfile, fname, file))
     {
/* Although this file must not go in the cache,
   because the file found might depend on things (like
   the current file) that aren't represented in the
   cache, it still has to go in the list of all files
   so that #import works.  */
file->next_file = pfile->all_files;
pfile->all_files = file;
if (*hash_slot == NULL__null)
  {
    /* If *hash_slot is NULL, the above
       htab_find_slot_with_hash call just created the
       slot, but we aren't going to store there
       anything, so need to remove the newly created
       entry.  htab_clear_slot requires that it is
       non-NULL, so store there some non-NULL pointer,
       htab_clear_slot will overwrite it
       immediately.  */
    *hash_slot = file;
    htab_clear_slot (pfile->file_hash, hash_slot);
  }
return file;
     }

   if (invalid_pch)
     {
cpp_error (pfile, CPP_DL_ERROR,
	   "one or more PCH files were found,"
	   " but they were invalid");
if (!cpp_get_options (pfile)->warn_invalid_pch)
  cpp_error (pfile, CPP_DL_NOTE,
	     "use -Winvalid-pch for more information");
     }

   if (kind == _cpp_FFK_PRE_INCLUDE)
     {
free ((char *) file->name);
free (file);
if (*hash_slot == NULL__null)
  {
    /* See comment on the above htab_clear_slot call.  */
    *hash_slot = file;
    htab_clear_slot (pfile->file_hash, hash_slot);
  }
return NULL__null;
     }

   if (kind != _cpp_FFK_HAS_INCLUDE)
     open_file_failed (pfile, file, angle_brackets, loc);
   break;
 }

/* Only check the cache for the starting location (done above)
  and the quote and bracket chain heads because there are no
  other possible starting points for searches.  */
if (file->dir == pfile->bracket_include)
 saw_bracket_include = true;
else if (file->dir == pfile->quote_include)
 saw_quote_include = true;
else
 continue;

entry
 = search_cache ((struct cpp_file_hash_entry *) *hash_slot, file->dir);
if (entry)
 {
   found_in_cache = file->dir;
   break;
 }
    }

if (entry)
  {
    /* Cache for START_DIR too, sharing the _cpp_file structure.  */
    free ((char *) file->name);
    free (file);
    file = entry->u.file;
  }
else
  {
    /* This is a new file; put it in the list.  */
    file->next_file = pfile->all_files;
    pfile->all_files = file;
  }

/* Store this new result in the hash table.  */
entry = new_file_hash_entry (pfile);
entry->next = (struct cpp_file_hash_entry *) *hash_slot;
entry->start_dir = start_dir;
entry->location = loc;
entry->u.file = file;
*hash_slot = (void *) entry;

/* If we passed the quote or bracket chain heads, cache them also.
   This speeds up processing if there are lots of -I options.  */
if (saw_bracket_include
    && pfile->bracket_include != start_dir
    && found_in_cache != pfile->bracket_include)
  {
    entry = new_file_hash_entry (pfile);
    entry->next = (struct cpp_file_hash_entry *) *hash_slot;
    entry->start_dir = pfile->bracket_include;
    entry->location = loc;
    entry->u.file = file;
    *hash_slot = (void *) entry;
  }
if (saw_quote_include
    && pfile->quote_include != start_dir
    && found_in_cache != pfile->quote_include)
  {
    entry = new_file_hash_entry (pfile);
    entry->next = (struct cpp_file_hash_entry *) *hash_slot;
    entry->start_dir = pfile->quote_include;
    entry->location = loc;
    entry->u.file = file;
    *hash_slot = (void *) entry;
  }

return file;
663}

665/* Read a file into FILE->buffer, returning true on success.

 If FILE->fd is something weird, like a block device, we don't want
 to read it at all.  Don't even try to figure out what something is,
 except for plain files and block devices, since there is no
 reliable portable way of doing this.

 Use LOC for any diagnostics.

 FIXME: Flush file cache and try again if we run out of memory.  */
675static bool
676read_file_guts (cpp_reader *pfile, _cpp_file *file, location_t loc)
677{
ssize_t size, total, count;
uchar *buf;
bool regular;

if (S_ISBLK (file->st.st_mode)((((file->st.st_mode)) & 0170000) == (0060000)))
  {
    cpp_error_at (pfile, CPP_DL_ERROR, loc,
    "%s is a block device", file->path);
    return false;
  }

regular = S_ISREG (file->st.st_mode)((((file->st.st_mode)) & 0170000) == (0100000)) != 0;
if (regular)
  {
    /* off_t might have a wider range than ssize_t - in other words,
the max size of a file might be bigger than the address
space.  We can't handle a file that large.  (Anyone with
a single source file bigger than 2GB needs to rethink
their coding style.)  Some systems (e.g. AIX 4.1) define
SSIZE_MAX to be much smaller than the actual range of the
type.  Use INTTYPE_MAXIMUM unconditionally to ensure this
does not bite us.  */
    if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t)((ssize_t) (~ (ssize_t) 0 - ((ssize_t) ((! ((ssize_t) 0 < (
ssize_t) -1)) ? (ssize_t) 1 << (sizeof (ssize_t) * 8 - 1
) : (ssize_t) 0)))))
{
 cpp_error_at (pfile, CPP_DL_ERROR, loc,
	"%s is too large", file->path);
 return false;
}

    size = file->st.st_size;
  }
else
  /* 8 kilobytes is a sensible starting size.  It ought to be bigger
     than the kernel pipe buffer, and it's definitely bigger than
     the majority of C source files.  */
  size = 8 * 1024;

/* The + 16 here is space for the final '\n' and 15 bytes of padding,
   used to quiet warnings from valgrind or Address Sanitizer, when the
   optimized lexer accesses aligned 16-byte memory chunks, including
   the bytes after the malloced, area, and stops lexing on '\n'.  */
buf = XNEWVEC (uchar, size + 16)((uchar *) xmalloc (sizeof (uchar) * (size + 16)));
total = 0;
while ((count = read (file->fd, buf + total, size - total)) > 0)
  {
    total += count;

    if (total == size)
{
 if (regular)
   break;
 size *= 2;
 buf = XRESIZEVEC (uchar, buf, size + 16)((uchar *) xrealloc ((void *) (buf), sizeof (uchar) * (size +
 16)));
}
  }

if (count < 0)
  {
    cpp_errno_filename (pfile, CPP_DL_ERROR, file->path, loc);
    free (buf);
    return false;
  }

if (regular && total != size && STAT_SIZE_RELIABLE (file->st)true)
  cpp_error_at (pfile, CPP_DL_WARNING, loc,
      "%s is shorter than expected", file->path);

file->buffer = _cpp_convert_input (pfile,
		     CPP_OPTION (pfile, input_charset)((pfile)->opts.input_charset),
		     buf, size + 16, total,
		     &file->buffer_start,
		     &file->st.st_size);
file->buffer_valid = true;

return true;
753}

755/* Convenience wrapper around read_file_guts that opens the file if
 necessary and closes the file descriptor after reading.  FILE must
 have been passed through find_file() at some stage.  Use LOC for
 any diagnostics.  */
759static bool
760read_file (cpp_reader *pfile, _cpp_file *file, location_t loc)
761{
/* If we already have its contents in memory, succeed immediately.  */
if (file->buffer_valid)
  return true;

/* If an earlier read failed for some reason don't try again.  */
if (file->dont_read || file->err_no)
  return false;

if (file->fd == -1 && !open_file (file))
  {
    open_file_failed (pfile, file, 0, loc);
    return false;
  }

file->dont_read = !read_file_guts (pfile, file, loc);
close (file->fd);
file->fd = -1;

return !file->dont_read;
781}

783/* Returns TRUE if FILE is already known to be idempotent, and should
 therefore not be read again.  */
785static bool
786is_known_idempotent_file (cpp_reader *pfile, _cpp_file *file, bool import)
787{
/* Skip once-only files.  */
if (file->once_only)
  return true;

/* We must mark the file once-only if #import now, before header
   guard checks.  Otherwise, undefining the header guard might
   cause the file to be re-stacked.  */
if (import)
  {
    _cpp_mark_file_once_only (pfile, file);

    /* Don't stack files that have been stacked before.  */
    if (file->stack_count)
return true;
  }

/* Skip if the file had a header guard and the macro is defined.
   PCH relies on this appearing before the PCH handler below.  */
if (file->cmacro && cpp_macro_p (file->cmacro))
  return true;

/* Handle PCH files immediately; don't stack them.  */
if (file->pchname)
  {
    pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
    file->fd = -1;
    free ((void *) file->pchname);
    file->pchname = NULL__null;
    return true;
  }

return false;
820}

822/* Return TRUE if file has unique contents, so we should read process
 it.  The file's contents must already have been read.  */

825static bool
826has_unique_contents (cpp_reader *pfile, _cpp_file *file, bool import,
     location_t loc)
828{
/* Check the file against the PCH file.  This is done before
   checking against files we've already seen, since it may save on
   I/O.  */
if (check_file_against_entries (pfile, file, import))
12
←
Taking false branch→
  {
    /* If this isn't a #import, but yet we can't include the file,
that means that it was #import-ed in the PCH file,
so we can never include it again.  */
    if (! import)
_cpp_mark_file_once_only (pfile, file);
    return false;
  }

/* Now we've read the file's contents, we can stack it if there
   are no once-only files.  */
if (!pfile->seen_once_only)
13
←
Assuming field 'seen_once_only' is true→
14
←
Taking false branch→
  return true;

/* We may have read the file under a different name.  Look
   for likely candidates and compare file contents to be sure.  */
for (_cpp_file *f = pfile->all_files; f; f = f->next_file)
15
←
Loop condition is true.  Entering loop body→
31
←
Use of memory after it is freed
  {
    if (f == file)
16
←
Assuming 'f' is not equal to 'file'→
17
←
Taking false branch→
continue; /* It'sa me!  */

    if ((import17.1
'import' is false
 || f->once_only)
18
←
Assuming field 'once_only' is true→
22
←
Taking true branch→
 && f->err_no == 0
19
←
Assuming field 'err_no' is equal to 0→
 && f->st.st_mtimest_mtim.tv_sec == file->st.st_mtimest_mtim.tv_sec
20
←
Assuming 'f->st.st_mtime' is equal to 'file->st.st_mtime'→
 && f->st.st_size == file->st.st_size)
21
←
Assuming 'f->st.st_size' is equal to 'file->st.st_size'→
{
 _cpp_file *ref_file;

 if (f->buffer && !f->buffer_valid)
23
←
Assuming field 'buffer' is null→
   {
     /* We already have a buffer but it is not valid, because
 the file is still stacked.  Make a new one.  */
     ref_file = make_cpp_file (f->dir, f->name);
     ref_file->path = f->path;
   }
 else
   /* The file is not stacked anymore.  We can reuse it.  */
   ref_file = f;

 bool same_file_p = (read_file (pfile, ref_file, loc)
	      /* Size might have changed in read_file().  */
	      && ref_file->st.st_size == file->st.st_size
	      && !memcmp (ref_file->buffer, file->buffer,
			  file->st.st_size));

 if (f->buffer && !f->buffer_valid)
24
←
Assuming field 'buffer' is non-null→
25
←
Assuming field 'buffer_valid' is false→
26
←
Taking true branch→
   {
     ref_file->path = 0;
     destroy_cpp_file (ref_file);
27
←
Calling 'destroy_cpp_file'→
29
←
Returning; memory was released via 1st parameter→
   }

 if (same_file_p29.1
'same_file_p' is false
)
30
←
Taking false branch→
   /* Already seen under a different name.  */
   return false;
}
  }

return true;
891}

893/* Place the file referenced by FILE into a new buffer on the buffer
 stack if possible.  Returns true if a buffer is stacked.  Use LOC
 for any diagnostics.  */

897bool
898_cpp_stack_file (cpp_reader *pfile, _cpp_file *file, include_type type,
 location_t loc)
900{
if (is_known_idempotent_file (pfile, file, type == IT_IMPORT))
7
←
Taking false branch→
  return false;

int sysp = 0;
char *buf = nullptr;

/* Check C++ module include translation.  */
if (!file->header_unit && type < IT_HEADER_HWM
8
←
Assuming field 'header_unit' is not equal to 0→
    /* Do not include translate include-next.  */
    && type != IT_INCLUDE_NEXT
    && pfile->cb.translate_include)
  buf = (pfile->cb.translate_include
  (pfile, pfile->line_table, loc, file->path));

if (buf8.1
'buf' is null
)
9
←
Taking false branch→
  {
    /* We don't increment the line number at the end of a buffer,
because we don't usually need that location (we're popping an
include file).  However in this case we do want to do the
increment.  So push a writable buffer of two newlines to acheive
that.  */
    static uchar newlines[] = "\n\n";
    cpp_push_buffer (pfile, newlines, 2, true);

    cpp_buffer *buffer
= cpp_push_buffer (pfile, reinterpret_cast<unsigned char *> (buf),
	   strlen (buf), true);
    buffer->to_free = buffer->buf;

    file->header_unit = +1;
    _cpp_mark_file_once_only (pfile, file);
  }
else
  {
    /* Not a header unit, and we know it.  */
    file->header_unit = -1;

    if (!read_file (pfile, file, loc))
10
←
Taking false branch→
return false;

    if (!has_unique_contents (pfile, file, type == IT_IMPORT, loc))
11
←
Calling 'has_unique_contents'→
return false;

    if (pfile->buffer && file->dir)
sysp = MAX (pfile->buffer->sysp, file->dir->sysp)((pfile->buffer->sysp) > (file->dir->sysp) ? (
pfile->buffer->sysp) : (file->dir->sysp));

    /* Add the file to the dependencies on its first inclusion.  */
    if (CPP_OPTION (pfile, deps.style)((pfile)->opts.deps.style) > (sysp != 0)
 && !file->stack_count
 && file->path[0]
 && !(pfile->main_file == file
      && CPP_OPTION (pfile, deps.ignore_main_file)((pfile)->opts.deps.ignore_main_file)))
deps_add_dep (pfile->deps, file->path);

    /* Clear buffer_valid since _cpp_clean_line messes it up.  */
    file->buffer_valid = false;
    file->stack_count++;

    /* Stack the buffer.  */
    cpp_buffer *buffer
= cpp_push_buffer (pfile, file->buffer, file->st.st_size,
	   CPP_OPTION (pfile, preprocessed)((pfile)->opts.preprocessed)
	   && !CPP_OPTION (pfile, directives_only)((pfile)->opts.directives_only));
    buffer->file = file;
    buffer->sysp = sysp;
    buffer->to_free = file->buffer_start;

    /* Initialize controlling macro state.  */
    pfile->mi_valid = true;
    pfile->mi_cmacro = 0;
  }

/* In the case of a normal #include, we're now at the start of the
   line *following* the #include.  A separate location_t for this
   location makes no sense, until we do the LC_LEAVE.

   This does not apply if we found a PCH file, we're not a regular
   include, or we ran out of locations.  */
bool decrement = (file->pchname == NULL__null
    && type < IT_DIRECTIVE_HWM
    && (pfile->line_table->highest_location
	!= LINE_MAP_MAX_LOCATION - 1));
if (decrement)
  pfile->line_table->highest_location--;

if (file->header_unit <= 0)
  /* Add line map and do callbacks.  */
  _cpp_do_file_change (pfile, LC_ENTER, file->path,
       /* With preamble injection, start on line zero,
	  so the preamble doesn't appear to have been
	  included from line 1.  Likewise when
	  starting preprocessed, we expect an initial
	  locating line.  */
	 type == IT_PRE_MAIN ? 0 : 1, sysp);
else if (decrement)
  {
    /* Adjust the line back one so we appear on the #include line itself.  */
    const line_map_ordinary *map
= LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table);
    linenum_type line = SOURCE_LINE (map, pfile->line_table->highest_line);
    linemap_line_start (pfile->line_table, line - 1, 0);
  }

return true;
1005}

1007/* Mark FILE to be included once only.  */
1008void
1009_cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
1010{
pfile->seen_once_only = true;
file->once_only = true;
1013}

1015/* Return the directory from which searching for FNAME should start,
 considering the directive TYPE and ANGLE_BRACKETS.  If there is
 nothing left in the path, returns NULL.  */
1018static struct cpp_dir *
1019search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
  enum include_type type)
1021{
cpp_dir *dir;
_cpp_file *file;

if (IS_ABSOLUTE_PATH (fname)(((((fname)[0]) == '/') || ((((fname)[0]) == '\\') &&
 (0))) || ((fname)[0] && ((fname)[1] == ':') &&
 (0))))
  return &pfile->no_search_path;

/* pfile->buffer is NULL when processing an -include command-line flag.  */
file = pfile->buffer == NULL__null ? pfile->main_file : pfile->buffer->file;

/* For #include_next, skip in the search path past the dir in which
   the current file was found, but if it was found via an absolute
   path use the normal search logic.  */
if (type == IT_INCLUDE_NEXT && file->dir
    && file->dir != &pfile->no_search_path)
  dir = file->dir->next;
else if (angle_brackets)
  dir = pfile->bracket_include;
else if (type == IT_CMDLINE)
  /* -include and -imacros use the #include "" chain with the
     preprocessor's cwd prepended.  */
  return make_cpp_dir (pfile, "./", false);
else if (pfile->quote_ignores_source_dir)
  dir = pfile->quote_include;
else
  return make_cpp_dir (pfile, dir_name_of_file (file),
	 pfile->buffer ? pfile->buffer->sysp : 0);

if (dir == NULL__null)
  cpp_error (pfile, CPP_DL_ERROR,
      "no include path in which to search for %s", fname);

return dir;
1054}

1056/* Strip the basename from the file's path.  It ends with a slash if
 of nonzero length.  Note that this procedure also works for
 <stdin>, which is represented by the empty string.  */
1059static const char *
1060dir_name_of_file (_cpp_file *file)
1061{
if (!file->dir_name)
  {
    size_t len = lbasename (file->path) - file->path;
    char *dir_name = XNEWVEC (char, len + 1)((char *) xmalloc (sizeof (char) * (len + 1)));

    memcpy (dir_name, file->path, len);
    dir_name[len] = '\0';
    file->dir_name = dir_name;
  }

return file->dir_name;
1073}

1075/* Handles #include-family directives (distinguished by TYPE),
 including HEADER, and the command line -imacros and -include.
 Returns true if a buffer was stacked.  */
1078bool
1079_cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
    enum include_type type, location_t loc)
1081{
/* For -include command-line flags we have type == IT_CMDLINE.
   When the first -include file is processed we have the case, where
   pfile->cur_token == pfile->cur_run->base, we are directly called up
   by the front end.  However in the case of the second -include file,
   we are called from _cpp_lex_token -> _cpp_get_fresh_line ->
   cpp_push_include, with pfile->cur_token != pfile->cur_run->base,
   and pfile->cur_token[-1].src_loc not (yet) initialized.
   However, when the include file cannot be found, we need src_loc to
   be initialized to some safe value: 0 means UNKNOWN_LOCATION.  */
if (type1.1
'type' is not equal to IT_CMDLINE
 == IT_CMDLINE && pfile->cur_token != pfile->cur_run->base)
  pfile->cur_token[-1].src_loc = 0;

cpp_dir *dir = search_path_head (pfile, fname, angle_brackets, type);
if (!dir1.2
'dir' is non-null
)
2
←
Taking false branch→
  return false;

_cpp_file *file = _cpp_find_file (pfile, fname, dir, angle_brackets,
		    type2.1
'type' is equal to IT_DEFAULT
 == IT_DEFAULT ? _cpp_FFK_PRE_INCLUDE
3
←
'?' condition is true→
		    : _cpp_FFK_NORMAL, loc);
if (type3.1
'type' is equal to IT_DEFAULT
 == IT_DEFAULT && file == NULL__null)
4
←
Assuming 'file' is not equal to NULL→
5
←
Taking false branch→
  return false;

return _cpp_stack_file (pfile, file, type, loc);
6
←
Calling '_cpp_stack_file'→
1105}

1107/* NAME is a header file name, find the path we'll use to open it.  */

1109const char *
1110cpp_find_header_unit (cpp_reader *pfile, const char *name, bool angle,
      location_t loc)
1112{
cpp_dir *dir = search_path_head (pfile, name, angle, IT_INCLUDE);
if (!dir)
  return NULL__null;

_cpp_file *file = _cpp_find_file (pfile, name, dir, angle,
		    _cpp_FFK_NORMAL, loc);
if (!file)
  return NULL__null;

if (file->fd > 0)
  {
    /* Don't leave it open.  */
    close (file->fd);
    file->fd = 0;
  }

file->header_unit = +1;
_cpp_mark_file_once_only (pfile, file);
return file->path;
1132}

1134/* Retrofit the just-entered main file asif it was an include.  This
 will permit correct include_next use, and mark it as a system
 header if that's where it resides.  We use filesystem-appropriate
 prefix matching of the include path to locate the main file.  */
1138void
1139cpp_retrofit_as_include (cpp_reader *pfile)
1140{
/* We should be the outermost.  */
gcc_assert (!pfile->buffer->prev)((void)(!(!pfile->buffer->prev) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/files.c"
, 1142, __FUNCTION__), 0 : 0));

if (const char *name = pfile->main_file->name)
  {
    /* Locate name on the include dir path, using a prefix match.  */
    size_t name_len = strlen (name);
    for (cpp_dir *dir = pfile->quote_include; dir; dir = dir->next)
if (dir->len < name_len
   && IS_DIR_SEPARATOR (name[dir->len])(((name[dir->len]) == '/') || (((name[dir->len]) == '\\'
) && (0)))
   && !filename_ncmp (name, dir->name, dir->len))
 {
   pfile->main_file->dir = dir;
   if (dir->sysp)
     cpp_make_system_header (pfile, 1, 0);
   break;
 }
  }

/* Initialize controlling macro state.  */
pfile->mi_valid = true;
pfile->mi_cmacro = 0;
1163}

1165/* Could not open FILE.  The complication is dependency output.  */
1166static void
1167open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets,
  location_t loc)
1169{
int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
bool print_dep = CPP_OPTION (pfile, deps.style)((pfile)->opts.deps.style) > (angle_brackets || !!sysp);

errno(*__errno_location ()) = file->err_no;
if (print_dep && CPP_OPTION (pfile, deps.missing_files)((pfile)->opts.deps.missing_files) && errno(*__errno_location ()) == ENOENT2)
  {
    deps_add_dep (pfile->deps, file->name);
    /* If the preprocessor output (other than dependency information) is
       being used, we must also flag an error.  */
    if (CPP_OPTION (pfile, deps.need_preprocessor_output)((pfile)->opts.deps.need_preprocessor_output))
cpp_errno_filename (pfile, CPP_DL_FATAL,
	    file->path ? file->path : file->name,
	    loc);
  }
else
  {
    /* If we are not outputting dependencies, or if we are and dependencies
       were requested for this file, or if preprocessor output is needed
       in addition to dependency information, this is an error.

       Otherwise (outputting dependencies but not for this file, and not
       using the preprocessor output), we can still produce correct output
       so it's only a warning.  */
    if (CPP_OPTION (pfile, deps.style)((pfile)->opts.deps.style) == DEPS_NONE
        || print_dep
        || CPP_OPTION (pfile, deps.need_preprocessor_output)((pfile)->opts.deps.need_preprocessor_output))
cpp_errno_filename (pfile, CPP_DL_FATAL,
	    file->path ? file->path : file->name,
	    loc);
    else
cpp_errno_filename (pfile, CPP_DL_WARNING,
	    file->path ? file->path : file->name,
	    loc);
  }
1204}

1206/* Search in the chain beginning at HEAD for a file whose search path
 started at START_DIR != NULL.  */
1208static struct cpp_file_hash_entry *
1209search_cache (struct cpp_file_hash_entry *head, const cpp_dir *start_dir)
1210{
while (head && head->start_dir != start_dir)
  head = head->next;

return head;
1215}

1217/* Allocate a new _cpp_file structure.  */
1218static _cpp_file *
1219make_cpp_file (cpp_dir *dir, const char *fname)
1220{
_cpp_file *file = XCNEW (_cpp_file)((_cpp_file *) xcalloc (1, sizeof (_cpp_file)));
file->fd = -1;
file->dir = dir;
file->name = xstrdup (fname);

return file;
1227}

1229/* Release a _cpp_file structure.  */
1230static void
1231destroy_cpp_file (_cpp_file *file)
1232{
free ((void *) file->buffer_start);
free ((void *) file->name);
free ((void *) file->path);
free (file);
28
←
Memory is released→
1237}

1239/* Release all the files allocated by this reader.  */
1240static void
1241destroy_all_cpp_files (cpp_reader *pfile)
1242{
_cpp_file *iter = pfile->all_files;
while (iter)
  {
    _cpp_file *next = iter->next_file;
    destroy_cpp_file (iter);
    iter = next;
  }
1250}

1252/* A hash of directory names.  The directory names are the path names
 of files which contain a #include "", the included file name is
 appended to this directories.

 To avoid duplicate entries we follow the convention that all
 non-empty directory names should end in a '/'.  DIR_NAME must be
 stored in permanently allocated memory.  */
1259static cpp_dir *
1260make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1261{
struct cpp_file_hash_entry *entry, **hash_slot;
cpp_dir *dir;

hash_slot = (struct cpp_file_hash_entry **)
  htab_find_slot_with_hash (pfile->dir_hash, dir_name,
	      htab_hash_string (dir_name),
	      INSERT);

/* Have we already hashed this directory?  */
for (entry = *hash_slot; entry; entry = entry->next)
  if (entry->start_dir == NULL__null)
    return entry->u.dir;

dir = XCNEW (cpp_dir)((cpp_dir *) xcalloc (1, sizeof (cpp_dir)));
dir->next = pfile->quote_include;
dir->name = (char *) dir_name;
dir->len = strlen (dir_name);
dir->sysp = sysp;
dir->construct = 0;

/* Store this new result in the hash table.  */
entry = new_file_hash_entry (pfile);
entry->next = *hash_slot;
entry->start_dir = NULL__null;
entry->location = pfile->line_table->highest_location;
entry->u.dir = dir;
*hash_slot = entry;

return dir;
1291}

1293/* Create a new block of memory for file hash entries.  */
1294static void
1295allocate_file_hash_entries (cpp_reader *pfile)
1296{
struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool)((struct file_hash_entry_pool *) xmalloc (sizeof (struct file_hash_entry_pool
)));
pool->file_hash_entries_used = 0;
pool->next = pfile->file_hash_entries;
pfile->file_hash_entries = pool;
1301}

1303/* Return a new file hash entry.  */
1304static struct cpp_file_hash_entry *
1305new_file_hash_entry (cpp_reader *pfile)
1306{
unsigned int idx;
if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE127)
  allocate_file_hash_entries (pfile);

idx = pfile->file_hash_entries->file_hash_entries_used++;
return &pfile->file_hash_entries->pool[idx];
1313}

1315/* Free the file hash entry pools.  */
1316static void
1317free_file_hash_entries (cpp_reader *pfile)
1318{
struct file_hash_entry_pool *iter = pfile->file_hash_entries;
while (iter)
  {
    struct file_hash_entry_pool *next = iter->next;
    free (iter);
    iter = next;
  }
1326}

1328/* Returns TRUE if a file FNAME has ever been successfully opened.
 This routine is not intended to correctly handle filenames aliased
 by links or redundant . or .. traversals etc.  */
1331bool
1332cpp_included (cpp_reader *pfile, const char *fname)
1333{
struct cpp_file_hash_entry *entry;

entry = (struct cpp_file_hash_entry *)
   htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));

while (entry && (entry->start_dir == NULL__null || entry->u.file->err_no))
  entry = entry->next;

return entry != NULL__null;
1343}

1345/* Returns TRUE if a file FNAME has ever been successfully opened
 before LOCATION.  This routine is not intended to correctly handle
 filenames aliased by links or redundant . or .. traversals etc.  */
1348bool
1349cpp_included_before (cpp_reader *pfile, const char *fname,
     location_t location)
1351{
struct cpp_file_hash_entry *entry
  = (struct cpp_file_hash_entry *)
    htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));

if (IS_ADHOC_LOC (location))
  location = get_location_from_adhoc_loc (pfile->line_table, location);

while (entry && (entry->start_dir == NULL__null || entry->u.file->err_no
   || entry->location > location))
  entry = entry->next;

return entry != NULL__null;
1364}

1366/* Calculate the hash value of a file hash entry P.  */

1368static hashval_t
1369file_hash_hash (const void *p)
1370{
struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p;
const char *hname;
if (entry->start_dir)
  hname = entry->u.file->name;
else
  hname = entry->u.dir->name;

return htab_hash_string (hname);
1379}

1381/* Compare a string Q against a file hash entry P.  */
1382static int
1383file_hash_eq (const void *p, const void *q)
1384{
struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p;
const char *fname = (const char *) q;
const char *hname;

if (entry->start_dir)
  hname = entry->u.file->name;
else
  hname = entry->u.dir->name;

return filename_cmp (hname, fname) == 0;
1395}

1397/* Compare entries in the nonexistent file hash table.  These are just
 strings.  */
1399static int
1400nonexistent_file_hash_eq (const void *p, const void *q)
1401{
return filename_cmp ((const char *) p, (const char *) q) == 0;
1403}

1405/* Initialize everything in this source file.  */
1406void
1407_cpp_init_files (cpp_reader *pfile)
1408{
pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
			NULL__null, xcalloc, free);
pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
			NULL__null, xcalloc, free);
allocate_file_hash_entries (pfile);
pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
				    nonexistent_file_hash_eq,
				    NULL__null, xcalloc, free);
obstack_specify_allocation (&pfile->nonexistent_file_ob, 0, 0,_obstack_begin ((&pfile->nonexistent_file_ob), (0), (0
), (xmalloc), (free))
	      xmalloc, free)_obstack_begin ((&pfile->nonexistent_file_ob), (0), (0
), (xmalloc), (free));
1419}

1421/* Finalize everything in this source file.  */
1422void
1423_cpp_cleanup_files (cpp_reader *pfile)
1424{
htab_delete (pfile->file_hash);
htab_delete (pfile->dir_hash);
htab_delete (pfile->nonexistent_file_hash);
obstack_free (&pfile->nonexistent_file_ob, 0)__extension__ ({ struct obstack *__o = (&pfile->nonexistent_file_ob
); void *__obj = (void *) (0); if (__obj > (void *) __o->
chunk && __obj < (void *) __o->chunk_limit) __o
->next_free = __o->object_base = (char *) __obj; else _obstack_free
 (__o, __obj); });
free_file_hash_entries (pfile);
destroy_all_cpp_files (pfile);
1431}

1433/* Make the parser forget about files it has seen.  This can be useful
 for resetting the parser to start another run.  */
1435void
1436cpp_clear_file_cache (cpp_reader *pfile)
1437{
_cpp_cleanup_files (pfile);
pfile->file_hash_entries = NULL__null;
pfile->all_files = NULL__null;
_cpp_init_files (pfile);
1442}

1444/* Enter a file name in the hash for the sake of cpp_included.  */
1445void
1446_cpp_fake_include (cpp_reader *pfile, const char *fname)
1447{
_cpp_find_file (pfile, fname, pfile->buffer->file->dir, 0, _cpp_FFK_FAKE, 0);
1449}

1451/* Not everyone who wants to set system-header-ness on a buffer can
 see the details of a buffer.  This is an exported interface because
 fix-header needs it.  */
1454void
1455cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1456{
int flags = 0;
const class line_maps *line_table = pfile->line_table;
const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
/* 1 = system header, 2 = system header to be treated as C.  */
if (syshdr)
  flags = 1 + (externc != 0);
pfile->buffer->sysp = flags;
_cpp_do_file_change (pfile, LC_RENAME, ORDINARY_MAP_FILE_NAME (map),
       SOURCE_LINE (map, pfile->line_table->highest_line),
       flags);
1467}

1469/* Allow the client to change the current file.  Used by the front end
 to achieve pseudo-file names like <built-in>.
 If REASON is LC_LEAVE, then NEW_NAME must be NULL.  */
1472void
1473cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
 const char *new_name)
1475{
_cpp_do_file_change (pfile, reason, new_name, 1, 0);
1477}

1479struct report_missing_guard_data
1480{
cpp_reader *pfile;
const char **paths;
size_t count;
1484};

1486/* Callback function for htab_traverse.  */
1487static int
1488report_missing_guard (void **slot, void *d)
1489{
struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) *slot;
struct report_missing_guard_data *data
  = (struct report_missing_guard_data *) d;

/* Skip directories.  */
if (entry->start_dir != NULL__null)
  {
    _cpp_file *file = entry->u.file;

    /* We don't want MI guard advice for the main file.  */
    if (!file->once_only
 && file->cmacro == NULL__null
 && file->stack_count == 1
 && data->pfile->main_file != file)
{
 if (data->paths == NULL__null)
   {
     data->paths = XCNEWVEC (const char *, data->count)((const char * *) xcalloc ((data->count), sizeof (const char
 *)));
     data->count = 0;
   }

 data->paths[data->count++] = file->path;
}
  }

/* Keep traversing the hash table.  */
return 1;
1517}

1519/* Comparison function for qsort.  */
1520static int
1521report_missing_guard_cmp (const void *p1, const void *p2)
1522{
return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1524}

1526/* Report on all files that might benefit from a multiple include guard.
 Triggered by -H.  */
1528void
1529_cpp_report_missing_guards (cpp_reader *pfile)
1530{
struct report_missing_guard_data data;

data.pfile = pfile;
data.paths = NULL__null;
data.count = htab_elements (pfile->file_hash);
htab_traverse (pfile->file_hash, report_missing_guard, &data);

if (data.paths != NULL__null)
  {
    size_t i;

    /* Sort the paths to avoid outputting them in hash table
order.  */
    qsort (data.paths, data.count, sizeof (const char *),
    report_missing_guard_cmp);
    fputs (_("Multiple include guards may be useful for:\n"),fputs_unlocked (("Multiple include guards may be useful for:\n"
), stderr)
    stderr)fputs_unlocked (("Multiple include guards may be useful for:\n"
), stderr);
    for (i = 0; i < data.count; i++)
{
 fputs (data.paths[i], stderr)fputs_unlocked (data.paths[i], stderr);
 putc ('\n', stderr)putc_unlocked ('\n', stderr);
}
    free (data.paths);
  }
1555}

1557/* Locate HEADER, and determine whether it is newer than the current
 file.  If it cannot be located or dated, return -1, if it is
 newer, return 1, otherwise 0.  */
1560int
1561_cpp_compare_file_date (cpp_reader *pfile, const char *fname,
	int angle_brackets)
1563{
_cpp_file *file;
struct cpp_dir *dir;

dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
if (!dir)
  return -1;

file = _cpp_find_file (pfile, fname, dir, angle_brackets, _cpp_FFK_NORMAL, 0);
if (file->err_no)
  return -1;

if (file->fd != -1)
  {
    close (file->fd);
    file->fd = -1;
  }

return file->st.st_mtimest_mtim.tv_sec > pfile->buffer->file->st.st_mtimest_mtim.tv_sec;
1582}

1584/* Pushes the given file onto the buffer stack.  Returns nonzero if
 successful.  */
1586bool
1587cpp_push_include (cpp_reader *pfile, const char *fname)
1588{
return _cpp_stack_include (pfile, fname, false, IT_CMDLINE,
	     pfile->line_table->highest_line);
1591}

1593/* Pushes the given file, implicitly included at the start of a
 compilation, onto the buffer stack but without any errors if the
 file is not found.  Returns nonzero if successful.  */
1596bool
1597cpp_push_default_include (cpp_reader *pfile, const char *fname)
1598{
return _cpp_stack_include (pfile, fname, true, IT_DEFAULT,
1
Calling '_cpp_stack_include'→
	     pfile->line_table->highest_line);
1601}

1603/* Do appropriate cleanup when a file INC's buffer is popped off the
 input stack.  */
1605void
1606_cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file,
      const unsigned char *to_free)
1608{
/* Record the inclusion-preventing macro, which could be NULL
   meaning no controlling macro.  */
if (pfile->mi_valid && file->cmacro == NULL__null)
  file->cmacro = pfile->mi_cmacro;

/* Invalidate control macros in the #including file.  */
pfile->mi_valid = false;

if (to_free)
  {
    if (to_free == file->buffer_start)
{
 file->buffer_start = NULL__null;
 file->buffer = NULL__null;
 file->buffer_valid = false;
}
    free ((void *) to_free);
  }
1627}

1629/* Return the file name associated with FILE.  */
1630const char *
1631_cpp_get_file_name (_cpp_file *file)
1632{
return file->name;
1634}

1636/* Inteface to file statistics record in _cpp_file structure. */
1637struct stat *
1638_cpp_get_file_stat (_cpp_file *file)
1639{
  return &file->st;
1641}

1643/* Set the include chain for "" to QUOTE, for <> to BRACKET.  If
 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
 directory of the including file.

 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE.  */
1648void
1649cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
	int quote_ignores_source_dir)
1651{
pfile->quote_include = quote;
pfile->bracket_include = quote;
pfile->quote_ignores_source_dir = quote_ignores_source_dir;

for (; quote; quote = quote->next)
  {
    quote->name_map = NULL__null;
    quote->len = strlen (quote->name);
    if (quote == bracket)
pfile->bracket_include = bracket;
  }
1663}

1665/* Append the file name to the directory to create the path, but don't
 turn / into // or // into ///; // may be a namespace escape.  */
1667static char *
1668append_file_to_dir (const char *fname, cpp_dir *dir)
1669{
size_t dlen, flen;
char *path;

dlen = dir->len;
flen = strlen (fname);
path = XNEWVEC (char, dlen + 1 + flen + 1)((char *) xmalloc (sizeof (char) * (dlen + 1 + flen + 1)));
memcpy (path, dir->name, dlen);
if (dlen && !IS_DIR_SEPARATOR (path[dlen - 1])(((path[dlen - 1]) == '/') || (((path[dlen - 1]) == '\\') &&
 (0))))
  path[dlen++] = '/';
memcpy (&path[dlen], fname, flen + 1);

return path;
1682}

1684/* Read a space delimited string of unlimited length from a stdio
 file F.  */
1686static char *
1687read_filename_string (int ch, FILE *f)
1688{
char *alloc, *set;
int len;

len = 20;
set = alloc = XNEWVEC (char, len + 1)((char *) xmalloc (sizeof (char) * (len + 1)));
if (! is_space (ch)(_sch_istable[(ch) & 0xff] & (unsigned short)(_sch_iscppsp
)))
  {
    *set++ = ch;
    while ((ch = getc (f)getc_unlocked (f)) != EOF(-1) && ! is_space (ch)(_sch_istable[(ch) & 0xff] & (unsigned short)(_sch_iscppsp
)))
{
 if (set - alloc == len)
   {
     len *= 2;
     alloc = XRESIZEVEC (char, alloc, len + 1)((char *) xrealloc ((void *) (alloc), sizeof (char) * (len + 1
)));
     set = alloc + len / 2;
   }
 *set++ = ch;
}
  }
*set = '\0';
ungetc (ch, f);
return alloc;
1711}

1713/* Read the file name map file for DIR.  */
1714static void
1715read_name_map (cpp_dir *dir)
1716{
static const char FILE_NAME_MAP_FILE[] = "header.gcc";
char *name;
FILE *f;
size_t len, count = 0, room = 9;

len = dir->len;
name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1)__builtin_alloca(len + sizeof (FILE_NAME_MAP_FILE) + 1);
memcpy (name, dir->name, len);
if (len && !IS_DIR_SEPARATOR (name[len - 1])(((name[len - 1]) == '/') || (((name[len - 1]) == '\\') &&
 (0))))
  name[len++] = '/';
strcpy (name + len, FILE_NAME_MAP_FILE);
f = fopen (name, "r")fopen_unlocked(name,"r");

dir->name_map = XNEWVEC (const char *, room)((const char * *) xmalloc (sizeof (const char *) * (room)));

/* Silently return NULL if we cannot open.  */
if (f)
  {
    int ch;

    while ((ch = getc (f)getc_unlocked (f)) != EOF(-1))
{
 char *to;

 if (is_space (ch)(_sch_istable[(ch) & 0xff] & (unsigned short)(_sch_iscppsp
)))
   continue;

 if (count + 2 > room)
   {
     room += 8;
     dir->name_map = XRESIZEVEC (const char *, dir->name_map, room)((const char * *) xrealloc ((void *) (dir->name_map), sizeof
 (const char *) * (room)));
   }

 dir->name_map[count] = read_filename_string (ch, f);
 while ((ch = getc (f)getc_unlocked (f)) != EOF(-1) && is_hspace (ch)(_sch_istable[(ch) & 0xff] & (unsigned short)(_sch_isblank
)))
   ;

 to = read_filename_string (ch, f);
 if (IS_ABSOLUTE_PATH (to)(((((to)[0]) == '/') || ((((to)[0]) == '\\') && (0)))
 || ((to)[0] && ((to)[1] == ':') && (0))))
   dir->name_map[count + 1] = to;
 else
   {
     dir->name_map[count + 1] = append_file_to_dir (to, dir);
     free (to);
   }

 count += 2;
 while ((ch = getc (f)getc_unlocked (f)) != '\n')
   if (ch == EOF(-1))
     break;
}

    fclose (f);
  }

/* Terminate the list of maps.  */
dir->name_map[count] = NULL__null;
1774}

1776/* Remap a FILE's name based on the file_name_map, if any, for
 FILE->dir.  If the file name has any directory separators,
 recursively check those directories too.  */
1779static char *
1780remap_filename (cpp_reader *pfile, _cpp_file *file)
1781{
const char *fname, *p;
char *new_dir, *p3;
cpp_dir *dir;
size_t index, len;

dir = file->dir;
fname = file->name;

for (;;)
  {
    if (!dir->name_map)
read_name_map (dir);

    for (index = 0; dir->name_map[index]; index += 2)
if (!filename_cmp (dir->name_map[index], fname))
   return xstrdup (dir->name_map[index + 1]);
    if (IS_ABSOLUTE_PATH (fname)(((((fname)[0]) == '/') || ((((fname)[0]) == '\\') &&
 (0))) || ((fname)[0] && ((fname)[1] == ':') &&
 (0))))
return NULL__null;
    p = strchr (fname, '/');
1801#ifdef HAVE_DOS_BASED_FILE_SYSTEM
    {
const char *p2 = strchr (fname, '\\');
if (!p || (p > p2))
 p = p2;
    }
1807#endif
    if (!p || p == fname)
return NULL__null;

    len = dir->len + (p - fname + 1);
    new_dir = XNEWVEC (char, len + 2)((char *) xmalloc (sizeof (char) * (len + 2)));
    p3 = new_dir + dir->len;
    memcpy (new_dir, dir->name, dir->len);
    if (dir->len && !IS_DIR_SEPARATOR (dir->name[dir->len - 1])(((dir->name[dir->len - 1]) == '/') || (((dir->name[
dir->len - 1]) == '\\') && (0))))
{
 *p3++ = '/';
 len++;
}
    memcpy (p3, fname, p - fname + 1);
    new_dir[len] = '\0';

    dir = make_cpp_dir (pfile, new_dir, dir->sysp);
    fname = p + 1;
  }
1826}

1828/* Returns true if PCHNAME is a valid PCH file for FILE.  */
1829static bool
1830validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1831{
const char *saved_path = file->path;
bool valid = false;

file->path = pchname;
if (open_file (file))
  {
    valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);

    if (!valid)
{
 close (file->fd);
 file->fd = -1;
}

    if (CPP_OPTION (pfile, print_include_names)((pfile)->opts.print_include_names))
{
 unsigned int i;
 for (i = 1; i < pfile->line_table->depth; i++)
   putc ('.', stderr)putc_unlocked ('.', stderr);
 fprintf (stderrstderr, "%c %s\n",
   valid ? '!' : 'x', pchname);
}
  }

file->path = saved_path;
return valid;
1858}

1860/* Get the path associated with the _cpp_file F.  The path includes
 the base name from the include directive and the directory it was
 found in via the search path.  */

1864const char *
1865cpp_get_path (struct _cpp_file *f)
1866{
return f->path;
1868}

1870/* Get the directory associated with the _cpp_file F.  */

1872cpp_dir *
1873cpp_get_dir (struct _cpp_file *f)
1874{
return f->dir;
1876}

1878/* Get the cpp_buffer currently associated with the cpp_reader
 PFILE.  */

1881cpp_buffer *
1882cpp_get_buffer (cpp_reader *pfile)
1883{
return pfile->buffer;
1885}

1887/* Get the _cpp_file associated with the cpp_buffer B.  */

1889_cpp_file *
1890cpp_get_file (cpp_buffer *b)
1891{
return b->file;
1893}

1895/* Get the previous cpp_buffer given a cpp_buffer B.  The previous
 buffer is the buffer that included the given buffer.  */

1898cpp_buffer *
1899cpp_get_prev (cpp_buffer *b)
1900{
return b->prev;
1902}
1903
1904/* This data structure holds the list of header files that were seen
 while the PCH was being built.  The 'entries' field is kept sorted
 in memcmp() order; yes, this means that on little-endian systems,
 it's sorted initially by the least-significant byte of 'size', but
 that's OK.  The code does rely on having entries with the same size
 next to each other.  */

1911struct pchf_entry {
/* The size of this file.  This is used to save running a MD5 checksum
   if the sizes don't match.  */
off_t size;
/* The MD5 checksum of this file.  */
unsigned char sum[16];
/* Is this file to be included only once?  */
bool once_only;
1919};

1921struct pchf_data {
/* Number of pchf_entry structures.  */
size_t count;

/* Are there any values with once_only set?
   This is used as an optimisation, it means we don't have to search
   the structure if we're processing a regular #include.  */
bool have_once_only;

struct pchf_entry entries[1];
1931};

1933static struct pchf_data *pchf;

1935/* A qsort ordering function for pchf_entry structures.  */

1937static int
1938pchf_save_compare (const void *e1, const void *e2)
1939{
return memcmp (e1, e2, sizeof (struct pchf_entry));
1941}

1943/* Create and write to F a pchf_data structure.  */

1945bool
1946_cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1947{
size_t count = 0;
struct pchf_data *result;
size_t result_size;
_cpp_file *f;
bool ret;

for (f = pfile->all_files; f; f = f->next_file)
  ++count;

result_size = (sizeof (struct pchf_data)
 + sizeof (struct pchf_entry) * (count - 1));
result = XCNEWVAR (struct pchf_data, result_size)((struct pchf_data *) xcalloc (1, (result_size)));

result->count = 0;
result->have_once_only = false;

for (f = pfile->all_files; f; f = f->next_file)
  {
    size_t count;

    /* This should probably never happen, since if a read error occurred
the PCH file shouldn't be written...  */
    if (f->dont_read || f->err_no)
continue;

    if (f->stack_count == 0)
continue;

    count = result->count++;

    result->entries[count].once_only = f->once_only;
    /* |= is avoided in the next line because of an HP C compiler bug */
    result->have_once_only = result->have_once_only | f->once_only;
    if (f->buffer_valid)
md5_buffer ((const char *)f->buffer,
    f->st.st_size, result->entries[count].sum);
    else
{
 FILE *ff;
 int oldfd = f->fd;

 if (!open_file (f))
   {
     open_file_failed (pfile, f, 0, 0);
     free (result);
     return false;
   }
 ff = fdopen (f->fd, "rb")fdopen_unlocked(f->fd,"rb");
 md5_stream (ff, result->entries[count].sum);
 fclose (ff);
 f->fd = oldfd;
}
    result->entries[count].size = f->st.st_size;
  }

result_size = (sizeof (struct pchf_data)
               + sizeof (struct pchf_entry) * (result->count - 1));

qsort (result->entries, result->count, sizeof (struct pchf_entry),
pchf_save_compare);

ret = fwrite (result, result_size, 1, fp)fwrite_unlocked (result, result_size, 1, fp) == 1;
free (result);
return ret;
2012}

2014/* Read the pchf_data structure from F.  */

2016bool
2017_cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED__attribute__ ((__unused__)), FILE *f)
2018{
struct pchf_data d;

if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)fread_unlocked (&d, sizeof (struct pchf_data) - sizeof (struct
 pchf_entry), 1, f)
     != 1)
  return false;

pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)((struct pchf_data *) xmalloc ((sizeof (struct pchf_data) + sizeof
 (struct pchf_entry) * (d.count - 1))))
  + sizeof (struct pchf_entry) * (d.count - 1))((struct pchf_data *) xmalloc ((sizeof (struct pchf_data) + sizeof
 (struct pchf_entry) * (d.count - 1))));
memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)fread_unlocked (pchf->entries, sizeof (struct pchf_entry),
 d.count, f)
    != d.count)
  return false;
return true;
2032}

2034/* The parameters for pchf_compare.  */

2036struct pchf_compare_data
2037{
/* The size of the file we're looking for.  */
off_t size;

/* The MD5 checksum of the file, if it's been computed.  */
unsigned char sum[16];

/* Is SUM valid?  */
bool sum_computed;

/* Do we need to worry about entries that don't have ONCE_ONLY set?  */
bool check_included;

/* The file that we're searching for.  */
_cpp_file *f;
2052};

2054/* bsearch comparison function; look for D_P in E_P.  */

2056static int
2057pchf_compare (const void *d_p, const void *e_p)
2058{
const struct pchf_entry *e = (const struct pchf_entry *)e_p;
struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
int result;

result = memcmp (&d->size, &e->size, sizeof (off_t));
if (result != 0)
  return result;

if (! d->sum_computed)
  {
    _cpp_file *const f = d->f;

    md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
    d->sum_computed = true;
  }

result = memcmp (d->sum, e->sum, 16);
if (result != 0)
  return result;

if (d->check_included || e->once_only)
  return 0;
else
  return 1;
2083}

2085/* Check that F is not in a list read from a PCH file (if any).
 Assumes that f->buffer_valid is true.  Return TRUE if the file
 should not be read.  */

2089static bool
2090check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
	    _cpp_file *f,
	    bool check_included)
2093{
struct pchf_compare_data d;

if (pchf == NULL__null
    || (! check_included && ! pchf->have_once_only))
  return false;

d.size = f->st.st_size;
d.sum_computed = false;
d.f = f;
d.check_included = check_included;
return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
  pchf_compare) != NULL__null;
2106}

2108/* Return true if the file FNAME is found in the appropriate include file path
 as indicated by ANGLE_BRACKETS.  */

2111bool
2112_cpp_has_header (cpp_reader *pfile, const char *fname, int angle_brackets,
 enum include_type type)
2114{
cpp_dir *start_dir = search_path_head (pfile, fname, angle_brackets, type);
_cpp_file *file = _cpp_find_file (pfile, fname, start_dir, angle_brackets,
		    _cpp_FFK_HAS_INCLUDE, 0);
return file->err_no != ENOENT2;
2119}
