Bug Summary

File:build/libcpp/files.c
Warning:line 875, column 14
Null pointer passed to 1st parameter expecting 'nonnull'

Annotated Source Code

Press '?' to see keyboard shortcuts

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/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-n9qmFq.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/files.c
1/* Part of CPP library. File handling.
2 Copyright (C) 1986-2021 Free Software Foundation, Inc.
3 Written by Per Bothner, 1994.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
6 Split out of cpplib.c, Zack Weinberg, Oct 1998
7 Reimplemented, Neil Booth, Jul 2003
8
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.
13
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.
18
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/>. */
22
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>
32
33/* Variable length record files on VMS will have a stat size that includes
34 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
41
42#ifdef __DJGPP__
43#include <io.h>
44 /* For DJGPP redirected input is opened in text mode. */
45# define set_stdin_to_binary_mode() \
46 if (! isatty (0)) setmode (0, O_BINARY0)
47#else
48# define set_stdin_to_binary_mode() /* Nothing */
49#endif
50
51/* This structure represents a file searched for by CPP, whether it
52 exists or not. An instance may be pointed to by more than one
53 cpp_file_hash_entry; at present no reference count is kept. */
54struct _cpp_file
55{
56 /* Filename as given to #include or command line switch. */
57 const char *name;
58
59 /* The full path used to find the file. */
60 const char *path;
61
62 /* The full path of the pch file. */
63 const char *pchname;
64
65 /* The file's path with the basename stripped. NULL if it hasn't
66 been calculated yet. */
67 const char *dir_name;
68
69 /* Chain through all files. */
70 struct _cpp_file *next_file;
71
72 /* The contents of NAME after calling read_file(). */
73 const uchar *buffer;
74
75 /* Pointer to the real start of BUFFER. read_file() might increment
76 BUFFER; when freeing, this this pointer must be used instead. */
77 const uchar *buffer_start;
78
79 /* The macro, if any, preventing re-inclusion. */
80 const cpp_hashnode *cmacro;
81
82 /* The directory in the search path where FILE was found. Used for
83 #include_next and determining whether a header is a system
84 header. */
85 cpp_dir *dir;
86
87 /* As filled in by stat(2) for the file. */
88 struct stat st;
89
90 /* File descriptor. Invalid if -1, otherwise open. */
91 int fd;
92
93 /* Zero if this file was successfully opened and stat()-ed,
94 otherwise errno obtained from failure. */
95 int err_no;
96
97 /* Number of times the file has been stacked for preprocessing. */
98 unsigned short stack_count;
99
100 /* If opened with #import or contains #pragma once. */
101 bool once_only : 1;
102
103 /* If read() failed before. */
104 bool dont_read : 1;
105
106 /* If BUFFER above contains the true contents of the file. */
107 bool buffer_valid : 1;
108
109 /* If this file is implicitly preincluded. */
110 bool implicit_preinclude : 1;
111
112 /* > 0: Known C++ Module header unit, <0: known not. ==0, unknown */
113 int header_unit : 2;
114};
115
116/* A singly-linked list for all searches for a given file name, with
117 its head pointed to by a slot in FILE_HASH. The file name is what
118 appeared between the quotes in a #include directive; it can be
119 determined implicitly from the hash table location or explicitly
120 from FILE->name.
121
122 FILE is a structure containing details about the file that was
123 found with that search, or details of how the search failed.
124
125 START_DIR is the starting location of the search in the include
126 chain. The current directories for "" includes are also hashed in
127 the hash table and therefore unique. Files that are looked up
128 without using a search path, such as absolute filenames and file
129 names from the command line share a special starting directory so
130 they don't cause cache hits with normal include-chain lookups.
131
132 If START_DIR is NULL then the entry is for a directory, not a file,
133 and the directory is in DIR. Since the starting point in a file
134 lookup chain is never NULL, this means that simple pointer
135 comparisons against START_DIR can be made to determine cache hits
136 in file lookups.
137
138 If a cache lookup fails because of e.g. an extra "./" in the path,
139 then nothing will break. It is just less efficient as CPP will
140 have to do more work re-preprocessing the file, and/or comparing
141 its contents against earlier once-only files.
142*/
143struct cpp_file_hash_entry
144{
145 struct cpp_file_hash_entry *next;
146 cpp_dir *start_dir;
147 location_t location;
148 union
149 {
150 _cpp_file *file;
151 cpp_dir *dir;
152 } u;
153};
154
155/* Number of entries to put in a cpp_file_hash_entry pool. */
156#define FILE_HASH_POOL_SIZE127 127
157
158/* A file hash entry pool. We allocate cpp_file_hash_entry object from
159 one of these. */
160struct file_hash_entry_pool
161{
162 /* Number of entries used from this pool. */
163 unsigned int file_hash_entries_used;
164 /* Next pool in the chain; used when freeing. */
165 struct file_hash_entry_pool *next;
166 /* The memory pool. */
167 struct cpp_file_hash_entry pool[FILE_HASH_POOL_SIZE127];
168};
169
170static bool open_file (_cpp_file *file);
171static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
172 bool *invalid_pch);
173static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
174 bool *invalid_pch, location_t loc);
175static bool read_file_guts (cpp_reader *pfile, _cpp_file *file,
176 location_t loc);
177static bool read_file (cpp_reader *pfile, _cpp_file *file,
178 location_t loc);
179static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
180 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,
183 location_t);
184static struct cpp_file_hash_entry *search_cache (struct cpp_file_hash_entry *head,
185 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);
202
203/* Given a filename in FILE->PATH, with the empty string interpreted
204 as <stdin>, open it.
205
206 On success FILE contains an open file descriptor and stat
207 information for the file. On failure the file descriptor is -1 and
208 the appropriate errno is also stored in FILE. Returns TRUE iff
209 successful.
210
211 We used to open files in nonblocking mode, but that caused more
212 problems than it solved. Do take care not to acquire a controlling
213 terminal by mistake (this can't happen on sane systems, but
214 paranoia is a virtue).
215
216 Use the three-argument form of open even though we aren't
217 specifying O_CREAT, to defend against broken system headers.
218
219 O_BINARY tells some runtime libraries (notably DJGPP) not to do
220 newline translation; we can handle DOS line breaks just fine
221 ourselves. */
222static bool
223open_file (_cpp_file *file)
224{
225 if (file->path[0] == '\0')
226 {
227 file->fd = 0;
228 set_stdin_to_binary_mode ();
229 }
230 else
231 file->fd = open (file->path, O_RDONLY00 | O_NOCTTY0400 | O_BINARY0, 0666);
232
233 if (file->fd != -1)
234 {
235 if (fstat (file->fd, &file->st) == 0)
236 {
237 if (!S_ISDIR (file->st.st_mode)((((file->st.st_mode)) & 0170000) == (0040000)))
238 {
239 file->err_no = 0;
240 return true;
241 }
242
243 /* Ignore a directory and continue the search. The file we're
244 looking for may be elsewhere in the search path. */
245 errno(*__errno_location ()) = ENOENT2;
246 }
247
248 close (file->fd);
249 file->fd = -1;
250 }
251#if defined(_WIN32) && !defined(__CYGWIN__)
252 else if (errno(*__errno_location ()) == EACCES13)
253 {
254 /* On most UNIX systems, open succeeds on a directory. Above,
255 we check if we have opened a directory and if so, set errno
256 to ENOENT. However, on Windows, opening a directory
257 fails with EACCES. We want to return ENOENT in that
258 case too. */
259 if (stat (file->path, &file->st) == 0
260 && S_ISDIR (file->st.st_mode)((((file->st.st_mode)) & 0170000) == (0040000)))
261 errno(*__errno_location ()) = ENOENT2;
262 else
263 /* The call to stat may have reset errno. */
264 errno(*__errno_location ()) = EACCES13;
265 }
266#endif
267 else if (errno(*__errno_location ()) == ENOTDIR20)
268 errno(*__errno_location ()) = ENOENT2;
269
270 file->err_no = errno(*__errno_location ());
271
272 return false;
273}
274
275/* Temporary PCH intercept of opening a file. Try to find a PCH file
276 based on FILE->name and FILE->dir, and test those found for
277 validity using PFILE->cb.valid_pch. Return true iff a valid file is
278 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
279
280static bool
281pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
282{
283 static const char extension[] = ".gch";
284 const char *path = file->path;
285 size_t len, flen;
286 char *pchname;
287 struct stat st;
288 bool valid = false;
289
290 /* No PCH on <stdin> or if not requested. */
291 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
292 return false;
293
294 /* If the file is not included as first include from either the toplevel
295 file or the command-line it is not a valid use of PCH. */
296 for (_cpp_file *f = pfile->all_files; f; f = f->next_file)
297 if (f->implicit_preinclude)
298 continue;
299 else if (pfile->main_file == f)
300 break;
301 else
302 return false;
303
304 flen = strlen (path);
305 len = flen + sizeof (extension);
306 pchname = XNEWVEC (char, len)((char *) xmalloc (sizeof (char) * (len)));
307 memcpy (pchname, path, flen);
308 memcpy (pchname + flen, extension, sizeof (extension));
309
310 if (stat (pchname, &st) == 0)
311 {
312 DIR *pchdir;
313 struct dirent *d;
314 size_t dlen, plen = len;
315
316 if (!S_ISDIR (st.st_mode)((((st.st_mode)) & 0170000) == (0040000)))
317 valid = validate_pch (pfile, file, pchname);
318 else if ((pchdir = opendir (pchname)) != NULL__null)
319 {
320 pchname[plen - 1] = '/';
321 while ((d = readdir (pchdir)) != NULL__null)
322 {
323 dlen = strlen (d->d_name) + 1;
324 if ((strcmp (d->d_name, ".") == 0)
325 || (strcmp (d->d_name, "..") == 0))
326 continue;
327 if (dlen + plen > len)
328 {
329 len += dlen + 64;
330 pchname = XRESIZEVEC (char, pchname, len)((char *) xrealloc ((void *) (pchname), sizeof (char) * (len)
))
;
331 }
332 memcpy (pchname + plen, d->d_name, dlen);
333 valid = validate_pch (pfile, file, pchname);
334 if (valid)
335 break;
336 }
337 closedir (pchdir);
338 }
339 if (!valid)
340 *invalid_pch = true;
341 }
342
343 if (valid)
344 file->pchname = pchname;
345 else
346 free (pchname);
347
348 return valid;
349}
350
351/* Canonicalize the path to FILE. Return the canonical form if it is
352 shorter, otherwise return NULL. This function does NOT free the
353 memory pointed by FILE. */
354
355static char *
356maybe_shorter_path (const char * file)
357{
358 char * file2 = lrealpath (file);
359 if (file2 && strlen (file2) < strlen (file))
360 {
361 return file2;
362 }
363 else
364 {
365 free (file2);
366 return NULL__null;
367 }
368}
369
370/* Try to open the path FILE->name appended to FILE->dir. This is
371 where remap and PCH intercept the file lookup process. Return true
372 if the file was found, whether or not the open was successful.
373 Set *INVALID_PCH to true if a PCH file is found but wasn't valid.
374 Use LOC when emitting any diagnostics. */
375
376static bool
377find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch,
378 location_t loc)
379{
380 char *path;
381
382 if (CPP_OPTION (pfile, remap)((pfile)->opts.remap) && (path = remap_filename (pfile, file)))
383 ;
384 else
385 if (file->dir->construct)
386 path = file->dir->construct (file->name, file->dir);
387 else
388 path = append_file_to_dir (file->name, file->dir);
389
390 if (path)
391 {
392 hashval_t hv;
393 char *copy;
394 void **pp;
395
396 /* We try to canonicalize system headers. For DOS based file
397 * system, we always try to shorten non-system headers, as DOS
398 * has a tighter constraint on max path length. */
399 if ((CPP_OPTION (pfile, canonical_system_headers)((pfile)->opts.canonical_system_headers) && file->dir->sysp)
400#ifdef HAVE_DOS_BASED_FILE_SYSTEM
401 || !file->dir->sysp
402#endif
403 )
404 {
405 char * canonical_path = maybe_shorter_path (path);
406 if (canonical_path)
407 {
408 /* The canonical path was newly allocated. Let's free the
409 non-canonical one. */
410 free (path);
411 path = canonical_path;
412 }
413 }
414
415 hv = htab_hash_string (path);
416 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL__null)
417 {
418 file->err_no = ENOENT2;
419 return false;
420 }
421
422 file->path = path;
423 if (pch_open_file (pfile, file, invalid_pch))
424 return true;
425
426 if (open_file (file))
427 return true;
428
429 if (file->err_no != ENOENT2)
430 {
431 open_file_failed (pfile, file, 0, loc);
432 return true;
433 }
434
435 /* We copy the path name onto an obstack partly so that we don't
436 leak the memory, but mostly so that we don't fragment the
437 heap. */
438 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; }); })
439 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; }); })
;
440 free (path);
441 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
442 copy, hv, INSERT);
443 *pp = copy;
444
445 file->path = file->name;
446 }
447 else
448 {
449 file->err_no = ENOENT2;
450 file->path = NULL__null;
451 }
452
453 return false;
454}
455
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{
460 missing_header_cb func = pfile->cb.missing_header;
461
462 /* When the regular search path doesn't work, try context dependent
463 headers search paths. */
464 if (func
465 && file->dir == NULL__null)
466 {
467 if ((file->path = func (pfile, header, &file->dir)) != NULL__null)
468 {
469 if (open_file (file))
470 return true;
471 free ((void *)file->path);
472 }
473 file->path = file->name;
474 }
475
476 return false;
477}
478
479bool
480_cpp_find_failed (_cpp_file *file)
481{
482 return file->err_no != 0;
483}
484
485/* Given a filename FNAME search for such a file in the include path
486 starting from START_DIR. If FNAME is the empty string it is
487 interpreted as STDIN if START_DIR is PFILE->no_search_path.
488
489 If the file is not found in the file cache fall back to the O/S and
490 add the result to our cache.
491
492 If the file was not found in the filesystem, or there was an error
493 opening it, then ERR_NO is nonzero and FD is -1. If the file was
494 found, then ERR_NO is zero and FD could be -1 or an open file
495 descriptor. FD can be -1 if the file was found in the cache and
496 had previously been closed. To open it again pass the return value
497 to open_file().
498
499 If KIND is _cpp_FFK_PRE_INCLUDE then it is OK for the file to be
500 missing. If present, it is OK for a precompiled header to be
501 included after it.
502
503 Use LOC as the location for any errors. */
504
505_cpp_file *
506_cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir,
507 int angle_brackets, _cpp_find_file_kind kind, location_t loc)
508{
509 bool invalid_pch = false;
510 bool saw_bracket_include = false;
511 bool saw_quote_include = false;
512 struct cpp_dir *found_in_cache = NULL__null;
513
514 /* Ensure we get no confusion between cached files and directories. */
515 if (start_dir == NULL__null)
516 cpp_error_at (pfile, CPP_DL_ICE, loc, "NULL directory in find_file");
517
518 void **hash_slot
519 = htab_find_slot_with_hash (pfile->file_hash, fname,
520 htab_hash_string (fname), INSERT);
521
522 /* First check the cache before we resort to memory allocation. */
523 cpp_file_hash_entry *entry
524 = search_cache ((struct cpp_file_hash_entry *) *hash_slot, start_dir);
525 if (entry)
526 return entry->u.file;
527
528 _cpp_file *file = make_cpp_file (start_dir, fname);
529 file->implicit_preinclude
530 = (kind == _cpp_FFK_PRE_INCLUDE
531 || (pfile->buffer && pfile->buffer->file->implicit_preinclude));
532
533 if (kind != _cpp_FFK_FAKE)
534 /* Try each path in the include chain. */
535 for (;;)
536 {
537 if (find_file_in_dir (pfile, file, &invalid_pch, loc))
538 break;
539
540 file->dir = file->dir->next;
541 if (file->dir == NULL__null)
542 {
543 if (search_path_exhausted (pfile, fname, file))
544 {
545 /* Although this file must not go in the cache,
546 because the file found might depend on things (like
547 the current file) that aren't represented in the
548 cache, it still has to go in the list of all files
549 so that #import works. */
550 file->next_file = pfile->all_files;
551 pfile->all_files = file;
552 if (*hash_slot == NULL__null)
553 {
554 /* If *hash_slot is NULL, the above
555 htab_find_slot_with_hash call just created the
556 slot, but we aren't going to store there
557 anything, so need to remove the newly created
558 entry. htab_clear_slot requires that it is
559 non-NULL, so store there some non-NULL pointer,
560 htab_clear_slot will overwrite it
561 immediately. */
562 *hash_slot = file;
563 htab_clear_slot (pfile->file_hash, hash_slot);
564 }
565 return file;
566 }
567
568 if (invalid_pch)
569 {
570 cpp_error (pfile, CPP_DL_ERROR,
571 "one or more PCH files were found,"
572 " but they were invalid");
573 if (!cpp_get_options (pfile)->warn_invalid_pch)
574 cpp_error (pfile, CPP_DL_NOTE,
575 "use -Winvalid-pch for more information");
576 }
577
578 if (kind == _cpp_FFK_PRE_INCLUDE)
579 {
580 free ((char *) file->name);
581 free (file);
582 if (*hash_slot == NULL__null)
583 {
584 /* See comment on the above htab_clear_slot call. */
585 *hash_slot = file;
586 htab_clear_slot (pfile->file_hash, hash_slot);
587 }
588 return NULL__null;
589 }
590
591 if (kind != _cpp_FFK_HAS_INCLUDE)
592 open_file_failed (pfile, file, angle_brackets, loc);
593 break;
594 }
595
596 /* Only check the cache for the starting location (done above)
597 and the quote and bracket chain heads because there are no
598 other possible starting points for searches. */
599 if (file->dir == pfile->bracket_include)
600 saw_bracket_include = true;
601 else if (file->dir == pfile->quote_include)
602 saw_quote_include = true;
603 else
604 continue;
605
606 entry
607 = search_cache ((struct cpp_file_hash_entry *) *hash_slot, file->dir);
608 if (entry)
609 {
610 found_in_cache = file->dir;
611 break;
612 }
613 }
614
615 if (entry)
616 {
617 /* Cache for START_DIR too, sharing the _cpp_file structure. */
618 free ((char *) file->name);
619 free (file);
620 file = entry->u.file;
621 }
622 else
623 {
624 /* This is a new file; put it in the list. */
625 file->next_file = pfile->all_files;
626 pfile->all_files = file;
627 }
628
629 /* Store this new result in the hash table. */
630 entry = new_file_hash_entry (pfile);
631 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
632 entry->start_dir = start_dir;
633 entry->location = loc;
634 entry->u.file = file;
635 *hash_slot = (void *) entry;
636
637 /* If we passed the quote or bracket chain heads, cache them also.
638 This speeds up processing if there are lots of -I options. */
639 if (saw_bracket_include
640 && pfile->bracket_include != start_dir
641 && found_in_cache != pfile->bracket_include)
642 {
643 entry = new_file_hash_entry (pfile);
644 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
645 entry->start_dir = pfile->bracket_include;
646 entry->location = loc;
647 entry->u.file = file;
648 *hash_slot = (void *) entry;
649 }
650 if (saw_quote_include
651 && pfile->quote_include != start_dir
652 && found_in_cache != pfile->quote_include)
653 {
654 entry = new_file_hash_entry (pfile);
655 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
656 entry->start_dir = pfile->quote_include;
657 entry->location = loc;
658 entry->u.file = file;
659 *hash_slot = (void *) entry;
660 }
661
662 return file;
663}
664
665/* Read a file into FILE->buffer, returning true on success.
666
667 If FILE->fd is something weird, like a block device, we don't want
668 to read it at all. Don't even try to figure out what something is,
669 except for plain files and block devices, since there is no
670 reliable portable way of doing this.
671
672 Use LOC for any diagnostics.
673
674 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{
678 ssize_t size, total, count;
679 uchar *buf;
680 bool regular;
681
682 if (S_ISBLK (file->st.st_mode)((((file->st.st_mode)) & 0170000) == (0060000)))
683 {
684 cpp_error_at (pfile, CPP_DL_ERROR, loc,
685 "%s is a block device", file->path);
686 return false;
687 }
688
689 regular = S_ISREG (file->st.st_mode)((((file->st.st_mode)) & 0170000) == (0100000)) != 0;
690 if (regular)
691 {
692 /* off_t might have a wider range than ssize_t - in other words,
693 the max size of a file might be bigger than the address
694 space. We can't handle a file that large. (Anyone with
695 a single source file bigger than 2GB needs to rethink
696 their coding style.) Some systems (e.g. AIX 4.1) define
697 SSIZE_MAX to be much smaller than the actual range of the
698 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
699 does not bite us. */
700 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))))
)
701 {
702 cpp_error_at (pfile, CPP_DL_ERROR, loc,
703 "%s is too large", file->path);
704 return false;
705 }
706
707 size = file->st.st_size;
708 }
709 else
710 /* 8 kilobytes is a sensible starting size. It ought to be bigger
711 than the kernel pipe buffer, and it's definitely bigger than
712 the majority of C source files. */
713 size = 8 * 1024;
714
715 /* The + 16 here is space for the final '\n' and 15 bytes of padding,
716 used to quiet warnings from valgrind or Address Sanitizer, when the
717 optimized lexer accesses aligned 16-byte memory chunks, including
718 the bytes after the malloced, area, and stops lexing on '\n'. */
719 buf = XNEWVEC (uchar, size + 16)((uchar *) xmalloc (sizeof (uchar) * (size + 16)));
720 total = 0;
721 while ((count = read (file->fd, buf + total, size - total)) > 0)
722 {
723 total += count;
724
725 if (total == size)
726 {
727 if (regular)
728 break;
729 size *= 2;
730 buf = XRESIZEVEC (uchar, buf, size + 16)((uchar *) xrealloc ((void *) (buf), sizeof (uchar) * (size +
16)))
;
731 }
732 }
733
734 if (count < 0)
735 {
736 cpp_errno_filename (pfile, CPP_DL_ERROR, file->path, loc);
737 free (buf);
738 return false;
739 }
740
741 if (regular && total != size && STAT_SIZE_RELIABLE (file->st)true)
742 cpp_error_at (pfile, CPP_DL_WARNING, loc,
743 "%s is shorter than expected", file->path);
744
745 file->buffer = _cpp_convert_input (pfile,
746 CPP_OPTION (pfile, input_charset)((pfile)->opts.input_charset),
747 buf, size + 16, total,
748 &file->buffer_start,
749 &file->st.st_size);
750 file->buffer_valid = true;
751
752 return true;
753}
754
755/* Convenience wrapper around read_file_guts that opens the file if
756 necessary and closes the file descriptor after reading. FILE must
757 have been passed through find_file() at some stage. Use LOC for
758 any diagnostics. */
759static bool
760read_file (cpp_reader *pfile, _cpp_file *file, location_t loc)
761{
762 /* If we already have its contents in memory, succeed immediately. */
763 if (file->buffer_valid)
33
Assuming field 'buffer_valid' is true
34
Taking true branch
60
Assuming field 'buffer_valid' is true
61
Taking true branch
764 return true;
35
Returning without writing to 'pfile->seen_once_only', which participates in a condition later
36
Returning without writing to 'pfile->all_files', which participates in a condition later
62
Returning without writing to 'file->buffer'
63
Returning the value 1, which participates in a condition later
765
766 /* If an earlier read failed for some reason don't try again. */
767 if (file->dont_read || file->err_no)
768 return false;
769
770 if (file->fd == -1 && !open_file (file))
771 {
772 open_file_failed (pfile, file, 0, loc);
773 return false;
774 }
775
776 file->dont_read = !read_file_guts (pfile, file, loc);
777 close (file->fd);
778 file->fd = -1;
779
780 return !file->dont_read;
781}
782
783/* Returns TRUE if FILE is already known to be idempotent, and should
784 therefore not be read again. */
785static bool
786is_known_idempotent_file (cpp_reader *pfile, _cpp_file *file, bool import)
787{
788 /* Skip once-only files. */
789 if (file->once_only)
20
Assuming field 'once_only' is false
21
Taking false branch
790 return true;
791
792 /* We must mark the file once-only if #import now, before header
793 guard checks. Otherwise, undefining the header guard might
794 cause the file to be re-stacked. */
795 if (import
21.1
'import' is false
)
22
Taking false branch
796 {
797 _cpp_mark_file_once_only (pfile, file);
798
799 /* Don't stack files that have been stacked before. */
800 if (file->stack_count)
801 return true;
802 }
803
804 /* Skip if the file had a header guard and the macro is defined.
805 PCH relies on this appearing before the PCH handler below. */
806 if (file->cmacro && cpp_macro_p (file->cmacro))
23
Assuming field 'cmacro' is null
807 return true;
808
809 /* Handle PCH files immediately; don't stack them. */
810 if (file->pchname)
24
Assuming field 'pchname' is null
25
Taking false branch
811 {
812 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
813 file->fd = -1;
814 free ((void *) file->pchname);
815 file->pchname = NULL__null;
816 return true;
817 }
818
819 return false;
26
Returning without writing to 'pfile->seen_once_only', which participates in a condition later
27
Returning without writing to 'pfile->all_files', which participates in a condition later
820}
821
822/* Return TRUE if file has unique contents, so we should read process
823 it. The file's contents must already have been read. */
824
825static bool
826has_unique_contents (cpp_reader *pfile, _cpp_file *file, bool import,
827 location_t loc)
828{
829 /* Check the file against the PCH file. This is done before
830 checking against files we've already seen, since it may save on
831 I/O. */
832 if (check_file_against_entries (pfile, file, import))
40
Calling 'check_file_against_entries'
45
Returning from 'check_file_against_entries'
46
Taking false branch
833 {
834 /* If this isn't a #import, but yet we can't include the file,
835 that means that it was #import-ed in the PCH file,
836 so we can never include it again. */
837 if (! import)
838 _cpp_mark_file_once_only (pfile, file);
839 return false;
840 }
841
842 /* Now we've read the file's contents, we can stack it if there
843 are no once-only files. */
844 if (!pfile->seen_once_only)
47
Assuming field 'seen_once_only' is true
48
Taking false branch
845 return true;
846
847 /* We may have read the file under a different name. Look
848 for likely candidates and compare file contents to be sure. */
849 for (_cpp_file *f = pfile->all_files; f; f = f->next_file)
49
Loop condition is true. Entering loop body
850 {
851 if (f == file)
50
Assuming 'f' is not equal to 'file'
51
Taking false branch
852 continue; /* It'sa me! */
853
854 if ((import
51.1
'import' is false
|| f->once_only)
52
Assuming field 'once_only' is true
56
Taking true branch
855 && f->err_no == 0
53
Assuming field 'err_no' is equal to 0
856 && f->st.st_mtimest_mtim.tv_sec == file->st.st_mtimest_mtim.tv_sec
54
Assuming 'f->st.st_mtime' is equal to 'file->st.st_mtime'
857 && f->st.st_size == file->st.st_size)
55
Assuming 'f->st.st_size' is equal to 'file->st.st_size'
858 {
859 _cpp_file *ref_file;
860
861 if (f->buffer && !f->buffer_valid)
57
Assuming field 'buffer' is null
58
Assuming pointer value is null
862 {
863 /* We already have a buffer but it is not valid, because
864 the file is still stacked. Make a new one. */
865 ref_file = make_cpp_file (f->dir, f->name);
866 ref_file->path = f->path;
867 }
868 else
869 /* The file is not stacked anymore. We can reuse it. */
870 ref_file = f;
871
872 bool same_file_p = (read_file (pfile, ref_file, loc)
59
Calling 'read_file'
64
Returning from 'read_file'
873 /* Size might have changed in read_file(). */
874 && ref_file->st.st_size
64.1
'ref_file->st.st_size' is equal to 'file->st.st_size'
== file->st.st_size
875 && !memcmp (ref_file->buffer, file->buffer,
65
Null pointer passed to 1st parameter expecting 'nonnull'
876 file->st.st_size));
877
878 if (f->buffer && !f->buffer_valid)
879 {
880 ref_file->path = 0;
881 destroy_cpp_file (ref_file);
882 }
883
884 if (same_file_p)
885 /* Already seen under a different name. */
886 return false;
887 }
888 }
889
890 return true;
891}
892
893/* Place the file referenced by FILE into a new buffer on the buffer
894 stack if possible. Returns true if a buffer is stacked. Use LOC
895 for any diagnostics. */
896
897bool
898_cpp_stack_file (cpp_reader *pfile, _cpp_file *file, include_type type,
899 location_t loc)
900{
901 if (is_known_idempotent_file (pfile, file, type == IT_IMPORT))
19
Calling 'is_known_idempotent_file'
28
Returning from 'is_known_idempotent_file'
29
Taking false branch
902 return false;
903
904 int sysp = 0;
905 char *buf = nullptr;
906
907 /* Check C++ module include translation. */
908 if (!file->header_unit && type < IT_HEADER_HWM
30
Assuming field 'header_unit' is not equal to 0
909 /* Do not include translate include-next. */
910 && type != IT_INCLUDE_NEXT
911 && pfile->cb.translate_include)
912 buf = (pfile->cb.translate_include
913 (pfile, pfile->line_table, loc, file->path));
914
915 if (buf
30.1
'buf' is null
)
31
Taking false branch
916 {
917 /* We don't increment the line number at the end of a buffer,
918 because we don't usually need that location (we're popping an
919 include file). However in this case we do want to do the
920 increment. So push a writable buffer of two newlines to acheive
921 that. */
922 static uchar newlines[] = "\n\n";
923 cpp_push_buffer (pfile, newlines, 2, true);
924
925 cpp_buffer *buffer
926 = cpp_push_buffer (pfile, reinterpret_cast<unsigned char *> (buf),
927 strlen (buf), true);
928 buffer->to_free = buffer->buf;
929
930 file->header_unit = +1;
931 _cpp_mark_file_once_only (pfile, file);
932 }
933 else
934 {
935 /* Not a header unit, and we know it. */
936 file->header_unit = -1;
937
938 if (!read_file (pfile, file, loc))
32
Calling 'read_file'
37
Returning from 'read_file'
38
Taking false branch
939 return false;
940
941 if (!has_unique_contents (pfile, file, type == IT_IMPORT, loc))
39
Calling 'has_unique_contents'
942 return false;
943
944 if (pfile->buffer && file->dir)
945 sysp = MAX (pfile->buffer->sysp, file->dir->sysp)((pfile->buffer->sysp) > (file->dir->sysp) ? (
pfile->buffer->sysp) : (file->dir->sysp))
;
946
947 /* Add the file to the dependencies on its first inclusion. */
948 if (CPP_OPTION (pfile, deps.style)((pfile)->opts.deps.style) > (sysp != 0)
949 && !file->stack_count
950 && file->path[0]
951 && !(pfile->main_file == file
952 && CPP_OPTION (pfile, deps.ignore_main_file)((pfile)->opts.deps.ignore_main_file)))
953 deps_add_dep (pfile->deps, file->path);
954
955 /* Clear buffer_valid since _cpp_clean_line messes it up. */
956 file->buffer_valid = false;
957 file->stack_count++;
958
959 /* Stack the buffer. */
960 cpp_buffer *buffer
961 = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
962 CPP_OPTION (pfile, preprocessed)((pfile)->opts.preprocessed)
963 && !CPP_OPTION (pfile, directives_only)((pfile)->opts.directives_only));
964 buffer->file = file;
965 buffer->sysp = sysp;
966 buffer->to_free = file->buffer_start;
967
968 /* Initialize controlling macro state. */
969 pfile->mi_valid = true;
970 pfile->mi_cmacro = 0;
971 }
972
973 /* In the case of a normal #include, we're now at the start of the
974 line *following* the #include. A separate location_t for this
975 location makes no sense, until we do the LC_LEAVE.
976
977 This does not apply if we found a PCH file, we're not a regular
978 include, or we ran out of locations. */
979 bool decrement = (file->pchname == NULL__null
980 && type < IT_DIRECTIVE_HWM
981 && (pfile->line_table->highest_location
982 != LINE_MAP_MAX_LOCATION - 1));
983 if (decrement)
984 pfile->line_table->highest_location--;
985
986 if (file->header_unit <= 0)
987 /* Add line map and do callbacks. */
988 _cpp_do_file_change (pfile, LC_ENTER, file->path,
989 /* With preamble injection, start on line zero,
990 so the preamble doesn't appear to have been
991 included from line 1. Likewise when
992 starting preprocessed, we expect an initial
993 locating line. */
994 type == IT_PRE_MAIN ? 0 : 1, sysp);
995 else if (decrement)
996 {
997 /* Adjust the line back one so we appear on the #include line itself. */
998 const line_map_ordinary *map
999 = LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table);
1000 linenum_type line = SOURCE_LINE (map, pfile->line_table->highest_line);
1001 linemap_line_start (pfile->line_table, line - 1, 0);
1002 }
1003
1004 return true;
1005}
1006
1007/* Mark FILE to be included once only. */
1008void
1009_cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
1010{
1011 pfile->seen_once_only = true;
1012 file->once_only = true;
1013}
1014
1015/* Return the directory from which searching for FNAME should start,
1016 considering the directive TYPE and ANGLE_BRACKETS. If there is
1017 nothing left in the path, returns NULL. */
1018static struct cpp_dir *
1019search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
1020 enum include_type type)
1021{
1022 cpp_dir *dir;
1023 _cpp_file *file;
1024
1025 if (IS_ABSOLUTE_PATH (fname)(((((fname)[0]) == '/') || ((((fname)[0]) == '\\') &&
(0))) || ((fname)[0] && ((fname)[1] == ':') &&
(0)))
)
3
Assuming the condition is false
4
Assuming the condition is false
5
Assuming the condition is false
1026 return &pfile->no_search_path;
1027
1028 /* pfile->buffer is NULL when processing an -include command-line flag. */
1029 file = pfile->buffer == NULL__null ? pfile->main_file : pfile->buffer->file;
6
Assuming field 'buffer' is not equal to NULL
7
'?' condition is false
1030
1031 /* For #include_next, skip in the search path past the dir in which
1032 the current file was found, but if it was found via an absolute
1033 path use the normal search logic. */
1034 if (type
7.1
'type' is not equal to IT_INCLUDE_NEXT
== IT_INCLUDE_NEXT && file->dir
1035 && file->dir != &pfile->no_search_path)
1036 dir = file->dir->next;
1037 else if (angle_brackets
7.2
'angle_brackets' is 1
)
8
Taking true branch
1038 dir = pfile->bracket_include;
1039 else if (type == IT_CMDLINE)
1040 /* -include and -imacros use the #include "" chain with the
1041 preprocessor's cwd prepended. */
1042 return make_cpp_dir (pfile, "./", false);
1043 else if (pfile->quote_ignores_source_dir)
1044 dir = pfile->quote_include;
1045 else
1046 return make_cpp_dir (pfile, dir_name_of_file (file),
1047 pfile->buffer ? pfile->buffer->sysp : 0);
1048
1049 if (dir == NULL__null)
9
Assuming 'dir' is not equal to NULL
10
Taking false branch
1050 cpp_error (pfile, CPP_DL_ERROR,
1051 "no include path in which to search for %s", fname);
1052
1053 return dir;
11
Returning without writing to 'pfile->seen_once_only', which participates in a condition later
12
Returning without writing to 'pfile->all_files', which participates in a condition later
1054}
1055
1056/* Strip the basename from the file's path. It ends with a slash if
1057 of nonzero length. Note that this procedure also works for
1058 <stdin>, which is represented by the empty string. */
1059static const char *
1060dir_name_of_file (_cpp_file *file)
1061{
1062 if (!file->dir_name)
1063 {
1064 size_t len = lbasename (file->path) - file->path;
1065 char *dir_name = XNEWVEC (char, len + 1)((char *) xmalloc (sizeof (char) * (len + 1)));
1066
1067 memcpy (dir_name, file->path, len);
1068 dir_name[len] = '\0';
1069 file->dir_name = dir_name;
1070 }
1071
1072 return file->dir_name;
1073}
1074
1075/* Handles #include-family directives (distinguished by TYPE),
1076 including HEADER, and the command line -imacros and -include.
1077 Returns true if a buffer was stacked. */
1078bool
1079_cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
1080 enum include_type type, location_t loc)
1081{
1082 /* For -include command-line flags we have type == IT_CMDLINE.
1083 When the first -include file is processed we have the case, where
1084 pfile->cur_token == pfile->cur_run->base, we are directly called up
1085 by the front end. However in the case of the second -include file,
1086 we are called from _cpp_lex_token -> _cpp_get_fresh_line ->
1087 cpp_push_include, with pfile->cur_token != pfile->cur_run->base,
1088 and pfile->cur_token[-1].src_loc not (yet) initialized.
1089 However, when the include file cannot be found, we need src_loc to
1090 be initialized to some safe value: 0 means UNKNOWN_LOCATION. */
1091 if (type
1.1
'type' is not equal to IT_CMDLINE
== IT_CMDLINE && pfile->cur_token != pfile->cur_run->base)
1092 pfile->cur_token[-1].src_loc = 0;
1093
1094 cpp_dir *dir = search_path_head (pfile, fname, angle_brackets, type);
2
Calling 'search_path_head'
13
Returning from 'search_path_head'
1095 if (!dir
13.1
'dir' is non-null
)
14
Taking false branch
1096 return false;
1097
1098 _cpp_file *file = _cpp_find_file (pfile, fname, dir, angle_brackets,
1099 type
14.1
'type' is equal to IT_DEFAULT
== IT_DEFAULT ? _cpp_FFK_PRE_INCLUDE
15
'?' condition is true
1100 : _cpp_FFK_NORMAL, loc);
1101 if (type
15.1
'type' is equal to IT_DEFAULT
== IT_DEFAULT && file == NULL__null)
16
Assuming 'file' is not equal to NULL
17
Taking false branch
1102 return false;
1103
1104 return _cpp_stack_file (pfile, file, type, loc);
18
Calling '_cpp_stack_file'
1105}
1106
1107/* NAME is a header file name, find the path we'll use to open it. */
1108
1109const char *
1110cpp_find_header_unit (cpp_reader *pfile, const char *name, bool angle,
1111 location_t loc)
1112{
1113 cpp_dir *dir = search_path_head (pfile, name, angle, IT_INCLUDE);
1114 if (!dir)
1115 return NULL__null;
1116
1117 _cpp_file *file = _cpp_find_file (pfile, name, dir, angle,
1118 _cpp_FFK_NORMAL, loc);
1119 if (!file)
1120 return NULL__null;
1121
1122 if (file->fd > 0)
1123 {
1124 /* Don't leave it open. */
1125 close (file->fd);
1126 file->fd = 0;
1127 }
1128
1129 file->header_unit = +1;
1130 _cpp_mark_file_once_only (pfile, file);
1131 return file->path;
1132}
1133
1134/* Retrofit the just-entered main file asif it was an include. This
1135 will permit correct include_next use, and mark it as a system
1136 header if that's where it resides. We use filesystem-appropriate
1137 prefix matching of the include path to locate the main file. */
1138void
1139cpp_retrofit_as_include (cpp_reader *pfile)
1140{
1141 /* We should be the outermost. */
1142 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))
;
1143
1144 if (const char *name = pfile->main_file->name)
1145 {
1146 /* Locate name on the include dir path, using a prefix match. */
1147 size_t name_len = strlen (name);
1148 for (cpp_dir *dir = pfile->quote_include; dir; dir = dir->next)
1149 if (dir->len < name_len
1150 && IS_DIR_SEPARATOR (name[dir->len])(((name[dir->len]) == '/') || (((name[dir->len]) == '\\'
) && (0)))
1151 && !filename_ncmp (name, dir->name, dir->len))
1152 {
1153 pfile->main_file->dir = dir;
1154 if (dir->sysp)
1155 cpp_make_system_header (pfile, 1, 0);
1156 break;
1157 }
1158 }
1159
1160 /* Initialize controlling macro state. */
1161 pfile->mi_valid = true;
1162 pfile->mi_cmacro = 0;
1163}
1164
1165/* Could not open FILE. The complication is dependency output. */
1166static void
1167open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets,
1168 location_t loc)
1169{
1170 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
1171 bool print_dep = CPP_OPTION (pfile, deps.style)((pfile)->opts.deps.style) > (angle_brackets || !!sysp);
1172
1173 errno(*__errno_location ()) = file->err_no;
1174 if (print_dep && CPP_OPTION (pfile, deps.missing_files)((pfile)->opts.deps.missing_files) && errno(*__errno_location ()) == ENOENT2)
1175 {
1176 deps_add_dep (pfile->deps, file->name);
1177 /* If the preprocessor output (other than dependency information) is
1178 being used, we must also flag an error. */
1179 if (CPP_OPTION (pfile, deps.need_preprocessor_output)((pfile)->opts.deps.need_preprocessor_output))
1180 cpp_errno_filename (pfile, CPP_DL_FATAL,
1181 file->path ? file->path : file->name,
1182 loc);
1183 }
1184 else
1185 {
1186 /* If we are not outputting dependencies, or if we are and dependencies
1187 were requested for this file, or if preprocessor output is needed
1188 in addition to dependency information, this is an error.
1189
1190 Otherwise (outputting dependencies but not for this file, and not
1191 using the preprocessor output), we can still produce correct output
1192 so it's only a warning. */
1193 if (CPP_OPTION (pfile, deps.style)((pfile)->opts.deps.style) == DEPS_NONE
1194 || print_dep
1195 || CPP_OPTION (pfile, deps.need_preprocessor_output)((pfile)->opts.deps.need_preprocessor_output))
1196 cpp_errno_filename (pfile, CPP_DL_FATAL,
1197 file->path ? file->path : file->name,
1198 loc);
1199 else
1200 cpp_errno_filename (pfile, CPP_DL_WARNING,
1201 file->path ? file->path : file->name,
1202 loc);
1203 }
1204}
1205
1206/* Search in the chain beginning at HEAD for a file whose search path
1207 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{
1211 while (head && head->start_dir != start_dir)
1212 head = head->next;
1213
1214 return head;
1215}
1216
1217/* Allocate a new _cpp_file structure. */
1218static _cpp_file *
1219make_cpp_file (cpp_dir *dir, const char *fname)
1220{
1221 _cpp_file *file = XCNEW (_cpp_file)((_cpp_file *) xcalloc (1, sizeof (_cpp_file)));
1222 file->fd = -1;
1223 file->dir = dir;
1224 file->name = xstrdup (fname);
1225
1226 return file;
1227}
1228
1229/* Release a _cpp_file structure. */
1230static void
1231destroy_cpp_file (_cpp_file *file)
1232{
1233 free ((void *) file->buffer_start);
1234 free ((void *) file->name);
1235 free ((void *) file->path);
1236 free (file);
1237}
1238
1239/* Release all the files allocated by this reader. */
1240static void
1241destroy_all_cpp_files (cpp_reader *pfile)
1242{
1243 _cpp_file *iter = pfile->all_files;
1244 while (iter)
1245 {
1246 _cpp_file *next = iter->next_file;
1247 destroy_cpp_file (iter);
1248 iter = next;
1249 }
1250}
1251
1252/* A hash of directory names. The directory names are the path names
1253 of files which contain a #include "", the included file name is
1254 appended to this directories.
1255
1256 To avoid duplicate entries we follow the convention that all
1257 non-empty directory names should end in a '/'. DIR_NAME must be
1258 stored in permanently allocated memory. */
1259static cpp_dir *
1260make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1261{
1262 struct cpp_file_hash_entry *entry, **hash_slot;
1263 cpp_dir *dir;
1264
1265 hash_slot = (struct cpp_file_hash_entry **)
1266 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1267 htab_hash_string (dir_name),
1268 INSERT);
1269
1270 /* Have we already hashed this directory? */
1271 for (entry = *hash_slot; entry; entry = entry->next)
1272 if (entry->start_dir == NULL__null)
1273 return entry->u.dir;
1274
1275 dir = XCNEW (cpp_dir)((cpp_dir *) xcalloc (1, sizeof (cpp_dir)));
1276 dir->next = pfile->quote_include;
1277 dir->name = (char *) dir_name;
1278 dir->len = strlen (dir_name);
1279 dir->sysp = sysp;
1280 dir->construct = 0;
1281
1282 /* Store this new result in the hash table. */
1283 entry = new_file_hash_entry (pfile);
1284 entry->next = *hash_slot;
1285 entry->start_dir = NULL__null;
1286 entry->location = pfile->line_table->highest_location;
1287 entry->u.dir = dir;
1288 *hash_slot = entry;
1289
1290 return dir;
1291}
1292
1293/* Create a new block of memory for file hash entries. */
1294static void
1295allocate_file_hash_entries (cpp_reader *pfile)
1296{
1297 struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool)((struct file_hash_entry_pool *) xmalloc (sizeof (struct file_hash_entry_pool
)))
;
1298 pool->file_hash_entries_used = 0;
1299 pool->next = pfile->file_hash_entries;
1300 pfile->file_hash_entries = pool;
1301}
1302
1303/* Return a new file hash entry. */
1304static struct cpp_file_hash_entry *
1305new_file_hash_entry (cpp_reader *pfile)
1306{
1307 unsigned int idx;
1308 if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE127)
1309 allocate_file_hash_entries (pfile);
1310
1311 idx = pfile->file_hash_entries->file_hash_entries_used++;
1312 return &pfile->file_hash_entries->pool[idx];
1313}
1314
1315/* Free the file hash entry pools. */
1316static void
1317free_file_hash_entries (cpp_reader *pfile)
1318{
1319 struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1320 while (iter)
1321 {
1322 struct file_hash_entry_pool *next = iter->next;
1323 free (iter);
1324 iter = next;
1325 }
1326}
1327
1328/* Returns TRUE if a file FNAME has ever been successfully opened.
1329 This routine is not intended to correctly handle filenames aliased
1330 by links or redundant . or .. traversals etc. */
1331bool
1332cpp_included (cpp_reader *pfile, const char *fname)
1333{
1334 struct cpp_file_hash_entry *entry;
1335
1336 entry = (struct cpp_file_hash_entry *)
1337 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1338
1339 while (entry && (entry->start_dir == NULL__null || entry->u.file->err_no))
1340 entry = entry->next;
1341
1342 return entry != NULL__null;
1343}
1344
1345/* Returns TRUE if a file FNAME has ever been successfully opened
1346 before LOCATION. This routine is not intended to correctly handle
1347 filenames aliased by links or redundant . or .. traversals etc. */
1348bool
1349cpp_included_before (cpp_reader *pfile, const char *fname,
1350 location_t location)
1351{
1352 struct cpp_file_hash_entry *entry
1353 = (struct cpp_file_hash_entry *)
1354 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1355
1356 if (IS_ADHOC_LOC (location))
1357 location = get_location_from_adhoc_loc (pfile->line_table, location);
1358
1359 while (entry && (entry->start_dir == NULL__null || entry->u.file->err_no
1360 || entry->location > location))
1361 entry = entry->next;
1362
1363 return entry != NULL__null;
1364}
1365
1366/* Calculate the hash value of a file hash entry P. */
1367
1368static hashval_t
1369file_hash_hash (const void *p)
1370{
1371 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p;
1372 const char *hname;
1373 if (entry->start_dir)
1374 hname = entry->u.file->name;
1375 else
1376 hname = entry->u.dir->name;
1377
1378 return htab_hash_string (hname);
1379}
1380
1381/* Compare a string Q against a file hash entry P. */
1382static int
1383file_hash_eq (const void *p, const void *q)
1384{
1385 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p;
1386 const char *fname = (const char *) q;
1387 const char *hname;
1388
1389 if (entry->start_dir)
1390 hname = entry->u.file->name;
1391 else
1392 hname = entry->u.dir->name;
1393
1394 return filename_cmp (hname, fname) == 0;
1395}
1396
1397/* Compare entries in the nonexistent file hash table. These are just
1398 strings. */
1399static int
1400nonexistent_file_hash_eq (const void *p, const void *q)
1401{
1402 return filename_cmp ((const char *) p, (const char *) q) == 0;
1403}
1404
1405/* Initialize everything in this source file. */
1406void
1407_cpp_init_files (cpp_reader *pfile)
1408{
1409 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1410 NULL__null, xcalloc, free);
1411 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1412 NULL__null, xcalloc, free);
1413 allocate_file_hash_entries (pfile);
1414 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1415 nonexistent_file_hash_eq,
1416 NULL__null, xcalloc, free);
1417 obstack_specify_allocation (&pfile->nonexistent_file_ob, 0, 0,_obstack_begin ((&pfile->nonexistent_file_ob), (0), (0
), (xmalloc), (free))
1418 xmalloc, free)_obstack_begin ((&pfile->nonexistent_file_ob), (0), (0
), (xmalloc), (free))
;
1419}
1420
1421/* Finalize everything in this source file. */
1422void
1423_cpp_cleanup_files (cpp_reader *pfile)
1424{
1425 htab_delete (pfile->file_hash);
1426 htab_delete (pfile->dir_hash);
1427 htab_delete (pfile->nonexistent_file_hash);
1428 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); })
;
1429 free_file_hash_entries (pfile);
1430 destroy_all_cpp_files (pfile);
1431}
1432
1433/* Make the parser forget about files it has seen. This can be useful
1434 for resetting the parser to start another run. */
1435void
1436cpp_clear_file_cache (cpp_reader *pfile)
1437{
1438 _cpp_cleanup_files (pfile);
1439 pfile->file_hash_entries = NULL__null;
1440 pfile->all_files = NULL__null;
1441 _cpp_init_files (pfile);
1442}
1443
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{
1448 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, 0, _cpp_FFK_FAKE, 0);
1449}
1450
1451/* Not everyone who wants to set system-header-ness on a buffer can
1452 see the details of a buffer. This is an exported interface because
1453 fix-header needs it. */
1454void
1455cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1456{
1457 int flags = 0;
1458 const class line_maps *line_table = pfile->line_table;
1459 const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1460 /* 1 = system header, 2 = system header to be treated as C. */
1461 if (syshdr)
1462 flags = 1 + (externc != 0);
1463 pfile->buffer->sysp = flags;
1464 _cpp_do_file_change (pfile, LC_RENAME, ORDINARY_MAP_FILE_NAME (map),
1465 SOURCE_LINE (map, pfile->line_table->highest_line),
1466 flags);
1467}
1468
1469/* Allow the client to change the current file. Used by the front end
1470 to achieve pseudo-file names like <built-in>.
1471 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1472void
1473cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1474 const char *new_name)
1475{
1476 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1477}
1478
1479struct report_missing_guard_data
1480{
1481 cpp_reader *pfile;
1482 const char **paths;
1483 size_t count;
1484};
1485
1486/* Callback function for htab_traverse. */
1487static int
1488report_missing_guard (void **slot, void *d)
1489{
1490 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) *slot;
1491 struct report_missing_guard_data *data
1492 = (struct report_missing_guard_data *) d;
1493
1494 /* Skip directories. */
1495 if (entry->start_dir != NULL__null)
1496 {
1497 _cpp_file *file = entry->u.file;
1498
1499 /* We don't want MI guard advice for the main file. */
1500 if (!file->once_only
1501 && file->cmacro == NULL__null
1502 && file->stack_count == 1
1503 && data->pfile->main_file != file)
1504 {
1505 if (data->paths == NULL__null)
1506 {
1507 data->paths = XCNEWVEC (const char *, data->count)((const char * *) xcalloc ((data->count), sizeof (const char
*)))
;
1508 data->count = 0;
1509 }
1510
1511 data->paths[data->count++] = file->path;
1512 }
1513 }
1514
1515 /* Keep traversing the hash table. */
1516 return 1;
1517}
1518
1519/* Comparison function for qsort. */
1520static int
1521report_missing_guard_cmp (const void *p1, const void *p2)
1522{
1523 return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1524}
1525
1526/* Report on all files that might benefit from a multiple include guard.
1527 Triggered by -H. */
1528void
1529_cpp_report_missing_guards (cpp_reader *pfile)
1530{
1531 struct report_missing_guard_data data;
1532
1533 data.pfile = pfile;
1534 data.paths = NULL__null;
1535 data.count = htab_elements (pfile->file_hash);
1536 htab_traverse (pfile->file_hash, report_missing_guard, &data);
1537
1538 if (data.paths != NULL__null)
1539 {
1540 size_t i;
1541
1542 /* Sort the paths to avoid outputting them in hash table
1543 order. */
1544 qsort (data.paths, data.count, sizeof (const char *),
1545 report_missing_guard_cmp);
1546 fputs (_("Multiple include guards may be useful for:\n"),fputs_unlocked (dgettext ("cpplib", "Multiple include guards may be useful for:\n"
), stderr)
1547 stderr)fputs_unlocked (dgettext ("cpplib", "Multiple include guards may be useful for:\n"
), stderr)
;
1548 for (i = 0; i < data.count; i++)
1549 {
1550 fputs (data.paths[i], stderr)fputs_unlocked (data.paths[i], stderr);
1551 putc ('\n', stderr)putc_unlocked ('\n', stderr);
1552 }
1553 free (data.paths);
1554 }
1555}
1556
1557/* Locate HEADER, and determine whether it is newer than the current
1558 file. If it cannot be located or dated, return -1, if it is
1559 newer, return 1, otherwise 0. */
1560int
1561_cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1562 int angle_brackets)
1563{
1564 _cpp_file *file;
1565 struct cpp_dir *dir;
1566
1567 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1568 if (!dir)
1569 return -1;
1570
1571 file = _cpp_find_file (pfile, fname, dir, angle_brackets, _cpp_FFK_NORMAL, 0);
1572 if (file->err_no)
1573 return -1;
1574
1575 if (file->fd != -1)
1576 {
1577 close (file->fd);
1578 file->fd = -1;
1579 }
1580
1581 return file->st.st_mtimest_mtim.tv_sec > pfile->buffer->file->st.st_mtimest_mtim.tv_sec;
1582}
1583
1584/* Pushes the given file onto the buffer stack. Returns nonzero if
1585 successful. */
1586bool
1587cpp_push_include (cpp_reader *pfile, const char *fname)
1588{
1589 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE,
1590 pfile->line_table->highest_line);
1591}
1592
1593/* Pushes the given file, implicitly included at the start of a
1594 compilation, onto the buffer stack but without any errors if the
1595 file is not found. Returns nonzero if successful. */
1596bool
1597cpp_push_default_include (cpp_reader *pfile, const char *fname)
1598{
1599 return _cpp_stack_include (pfile, fname, true, IT_DEFAULT,
1
Calling '_cpp_stack_include'
1600 pfile->line_table->highest_line);
1601}
1602
1603/* Do appropriate cleanup when a file INC's buffer is popped off the
1604 input stack. */
1605void
1606_cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file,
1607 const unsigned char *to_free)
1608{
1609 /* Record the inclusion-preventing macro, which could be NULL
1610 meaning no controlling macro. */
1611 if (pfile->mi_valid && file->cmacro == NULL__null)
1612 file->cmacro = pfile->mi_cmacro;
1613
1614 /* Invalidate control macros in the #including file. */
1615 pfile->mi_valid = false;
1616
1617 if (to_free)
1618 {
1619 if (to_free == file->buffer_start)
1620 {
1621 file->buffer_start = NULL__null;
1622 file->buffer = NULL__null;
1623 file->buffer_valid = false;
1624 }
1625 free ((void *) to_free);
1626 }
1627}
1628
1629/* Return the file name associated with FILE. */
1630const char *
1631_cpp_get_file_name (_cpp_file *file)
1632{
1633 return file->name;
1634}
1635
1636/* Inteface to file statistics record in _cpp_file structure. */
1637struct stat *
1638_cpp_get_file_stat (_cpp_file *file)
1639{
1640 return &file->st;
1641}
1642
1643/* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1644 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1645 directory of the including file.
1646
1647 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,
1650 int quote_ignores_source_dir)
1651{
1652 pfile->quote_include = quote;
1653 pfile->bracket_include = quote;
1654 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1655
1656 for (; quote; quote = quote->next)
1657 {
1658 quote->name_map = NULL__null;
1659 quote->len = strlen (quote->name);
1660 if (quote == bracket)
1661 pfile->bracket_include = bracket;
1662 }
1663}
1664
1665/* Append the file name to the directory to create the path, but don't
1666 turn / into // or // into ///; // may be a namespace escape. */
1667static char *
1668append_file_to_dir (const char *fname, cpp_dir *dir)
1669{
1670 size_t dlen, flen;
1671 char *path;
1672
1673 dlen = dir->len;
1674 flen = strlen (fname);
1675 path = XNEWVEC (char, dlen + 1 + flen + 1)((char *) xmalloc (sizeof (char) * (dlen + 1 + flen + 1)));
1676 memcpy (path, dir->name, dlen);
1677 if (dlen && !IS_DIR_SEPARATOR (path[dlen - 1])(((path[dlen - 1]) == '/') || (((path[dlen - 1]) == '\\') &&
(0)))
)
1678 path[dlen++] = '/';
1679 memcpy (&path[dlen], fname, flen + 1);
1680
1681 return path;
1682}
1683
1684/* Read a space delimited string of unlimited length from a stdio
1685 file F. */
1686static char *
1687read_filename_string (int ch, FILE *f)
1688{
1689 char *alloc, *set;
1690 int len;
1691
1692 len = 20;
1693 set = alloc = XNEWVEC (char, len + 1)((char *) xmalloc (sizeof (char) * (len + 1)));
1694 if (! is_space (ch)(_sch_istable[(ch) & 0xff] & (unsigned short)(_sch_iscppsp
))
)
1695 {
1696 *set++ = ch;
1697 while ((ch = getc (f)getc_unlocked (f)) != EOF(-1) && ! is_space (ch)(_sch_istable[(ch) & 0xff] & (unsigned short)(_sch_iscppsp
))
)
1698 {
1699 if (set - alloc == len)
1700 {
1701 len *= 2;
1702 alloc = XRESIZEVEC (char, alloc, len + 1)((char *) xrealloc ((void *) (alloc), sizeof (char) * (len + 1
)))
;
1703 set = alloc + len / 2;
1704 }
1705 *set++ = ch;
1706 }
1707 }
1708 *set = '\0';
1709 ungetc (ch, f);
1710 return alloc;
1711}
1712
1713/* Read the file name map file for DIR. */
1714static void
1715read_name_map (cpp_dir *dir)
1716{
1717 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1718 char *name;
1719 FILE *f;
1720 size_t len, count = 0, room = 9;
1721
1722 len = dir->len;
1723 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1)__builtin_alloca(len + sizeof (FILE_NAME_MAP_FILE) + 1);
1724 memcpy (name, dir->name, len);
1725 if (len && !IS_DIR_SEPARATOR (name[len - 1])(((name[len - 1]) == '/') || (((name[len - 1]) == '\\') &&
(0)))
)
1726 name[len++] = '/';
1727 strcpy (name + len, FILE_NAME_MAP_FILE);
1728 f = fopen (name, "r")fopen_unlocked(name,"r");
1729
1730 dir->name_map = XNEWVEC (const char *, room)((const char * *) xmalloc (sizeof (const char *) * (room)));
1731
1732 /* Silently return NULL if we cannot open. */
1733 if (f)
1734 {
1735 int ch;
1736
1737 while ((ch = getc (f)getc_unlocked (f)) != EOF(-1))
1738 {
1739 char *to;
1740
1741 if (is_space (ch)(_sch_istable[(ch) & 0xff] & (unsigned short)(_sch_iscppsp
))
)
1742 continue;
1743
1744 if (count + 2 > room)
1745 {
1746 room += 8;
1747 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room)((const char * *) xrealloc ((void *) (dir->name_map), sizeof
(const char *) * (room)))
;
1748 }
1749
1750 dir->name_map[count] = read_filename_string (ch, f);
1751 while ((ch = getc (f)getc_unlocked (f)) != EOF(-1) && is_hspace (ch)(_sch_istable[(ch) & 0xff] & (unsigned short)(_sch_isblank
))
)
1752 ;
1753
1754 to = read_filename_string (ch, f);
1755 if (IS_ABSOLUTE_PATH (to)(((((to)[0]) == '/') || ((((to)[0]) == '\\') && (0)))
|| ((to)[0] && ((to)[1] == ':') && (0)))
)
1756 dir->name_map[count + 1] = to;
1757 else
1758 {
1759 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1760 free (to);
1761 }
1762
1763 count += 2;
1764 while ((ch = getc (f)getc_unlocked (f)) != '\n')
1765 if (ch == EOF(-1))
1766 break;
1767 }
1768
1769 fclose (f);
1770 }
1771
1772 /* Terminate the list of maps. */
1773 dir->name_map[count] = NULL__null;
1774}
1775
1776/* Remap a FILE's name based on the file_name_map, if any, for
1777 FILE->dir. If the file name has any directory separators,
1778 recursively check those directories too. */
1779static char *
1780remap_filename (cpp_reader *pfile, _cpp_file *file)
1781{
1782 const char *fname, *p;
1783 char *new_dir, *p3;
1784 cpp_dir *dir;
1785 size_t index, len;
1786
1787 dir = file->dir;
1788 fname = file->name;
1789
1790 for (;;)
1791 {
1792 if (!dir->name_map)
1793 read_name_map (dir);
1794
1795 for (index = 0; dir->name_map[index]; index += 2)
1796 if (!filename_cmp (dir->name_map[index], fname))
1797 return xstrdup (dir->name_map[index + 1]);
1798 if (IS_ABSOLUTE_PATH (fname)(((((fname)[0]) == '/') || ((((fname)[0]) == '\\') &&
(0))) || ((fname)[0] && ((fname)[1] == ':') &&
(0)))
)
1799 return NULL__null;
1800 p = strchr (fname, '/');
1801#ifdef HAVE_DOS_BASED_FILE_SYSTEM
1802 {
1803 const char *p2 = strchr (fname, '\\');
1804 if (!p || (p > p2))
1805 p = p2;
1806 }
1807#endif
1808 if (!p || p == fname)
1809 return NULL__null;
1810
1811 len = dir->len + (p - fname + 1);
1812 new_dir = XNEWVEC (char, len + 2)((char *) xmalloc (sizeof (char) * (len + 2)));
1813 p3 = new_dir + dir->len;
1814 memcpy (new_dir, dir->name, dir->len);
1815 if (dir->len && !IS_DIR_SEPARATOR (dir->name[dir->len - 1])(((dir->name[dir->len - 1]) == '/') || (((dir->name[
dir->len - 1]) == '\\') && (0)))
)
1816 {
1817 *p3++ = '/';
1818 len++;
1819 }
1820 memcpy (p3, fname, p - fname + 1);
1821 new_dir[len] = '\0';
1822
1823 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1824 fname = p + 1;
1825 }
1826}
1827
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{
1832 const char *saved_path = file->path;
1833 bool valid = false;
1834
1835 file->path = pchname;
1836 if (open_file (file))
1837 {
1838 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1839
1840 if (!valid)
1841 {
1842 close (file->fd);
1843 file->fd = -1;
1844 }
1845
1846 if (CPP_OPTION (pfile, print_include_names)((pfile)->opts.print_include_names))
1847 {
1848 unsigned int i;
1849 for (i = 1; i < pfile->line_table->depth; i++)
1850 putc ('.', stderr)putc_unlocked ('.', stderr);
1851 fprintf (stderrstderr, "%c %s\n",
1852 valid ? '!' : 'x', pchname);
1853 }
1854 }
1855
1856 file->path = saved_path;
1857 return valid;
1858}
1859
1860/* Get the path associated with the _cpp_file F. The path includes
1861 the base name from the include directive and the directory it was
1862 found in via the search path. */
1863
1864const char *
1865cpp_get_path (struct _cpp_file *f)
1866{
1867 return f->path;
1868}
1869
1870/* Get the directory associated with the _cpp_file F. */
1871
1872cpp_dir *
1873cpp_get_dir (struct _cpp_file *f)
1874{
1875 return f->dir;
1876}
1877
1878/* Get the cpp_buffer currently associated with the cpp_reader
1879 PFILE. */
1880
1881cpp_buffer *
1882cpp_get_buffer (cpp_reader *pfile)
1883{
1884 return pfile->buffer;
1885}
1886
1887/* Get the _cpp_file associated with the cpp_buffer B. */
1888
1889_cpp_file *
1890cpp_get_file (cpp_buffer *b)
1891{
1892 return b->file;
1893}
1894
1895/* Get the previous cpp_buffer given a cpp_buffer B. The previous
1896 buffer is the buffer that included the given buffer. */
1897
1898cpp_buffer *
1899cpp_get_prev (cpp_buffer *b)
1900{
1901 return b->prev;
1902}
1903
1904/* This data structure holds the list of header files that were seen
1905 while the PCH was being built. The 'entries' field is kept sorted
1906 in memcmp() order; yes, this means that on little-endian systems,
1907 it's sorted initially by the least-significant byte of 'size', but
1908 that's OK. The code does rely on having entries with the same size
1909 next to each other. */
1910
1911struct pchf_entry {
1912 /* The size of this file. This is used to save running a MD5 checksum
1913 if the sizes don't match. */
1914 off_t size;
1915 /* The MD5 checksum of this file. */
1916 unsigned char sum[16];
1917 /* Is this file to be included only once? */
1918 bool once_only;
1919};
1920
1921struct pchf_data {
1922 /* Number of pchf_entry structures. */
1923 size_t count;
1924
1925 /* Are there any values with once_only set?
1926 This is used as an optimisation, it means we don't have to search
1927 the structure if we're processing a regular #include. */
1928 bool have_once_only;
1929
1930 struct pchf_entry entries[1];
1931};
1932
1933static struct pchf_data *pchf;
1934
1935/* A qsort ordering function for pchf_entry structures. */
1936
1937static int
1938pchf_save_compare (const void *e1, const void *e2)
1939{
1940 return memcmp (e1, e2, sizeof (struct pchf_entry));
1941}
1942
1943/* Create and write to F a pchf_data structure. */
1944
1945bool
1946_cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1947{
1948 size_t count = 0;
1949 struct pchf_data *result;
1950 size_t result_size;
1951 _cpp_file *f;
1952 bool ret;
1953
1954 for (f = pfile->all_files; f; f = f->next_file)
1955 ++count;
1956
1957 result_size = (sizeof (struct pchf_data)
1958 + sizeof (struct pchf_entry) * (count - 1));
1959 result = XCNEWVAR (struct pchf_data, result_size)((struct pchf_data *) xcalloc (1, (result_size)));
1960
1961 result->count = 0;
1962 result->have_once_only = false;
1963
1964 for (f = pfile->all_files; f; f = f->next_file)
1965 {
1966 size_t count;
1967
1968 /* This should probably never happen, since if a read error occurred
1969 the PCH file shouldn't be written... */
1970 if (f->dont_read || f->err_no)
1971 continue;
1972
1973 if (f->stack_count == 0)
1974 continue;
1975
1976 count = result->count++;
1977
1978 result->entries[count].once_only = f->once_only;
1979 /* |= is avoided in the next line because of an HP C compiler bug */
1980 result->have_once_only = result->have_once_only | f->once_only;
1981 if (f->buffer_valid)
1982 md5_buffer ((const char *)f->buffer,
1983 f->st.st_size, result->entries[count].sum);
1984 else
1985 {
1986 FILE *ff;
1987 int oldfd = f->fd;
1988
1989 if (!open_file (f))
1990 {
1991 open_file_failed (pfile, f, 0, 0);
1992 free (result);
1993 return false;
1994 }
1995 ff = fdopen (f->fd, "rb")fdopen_unlocked(f->fd,"rb");
1996 md5_stream (ff, result->entries[count].sum);
1997 fclose (ff);
1998 f->fd = oldfd;
1999 }
2000 result->entries[count].size = f->st.st_size;
2001 }
2002
2003 result_size = (sizeof (struct pchf_data)
2004 + sizeof (struct pchf_entry) * (result->count - 1));
2005
2006 qsort (result->entries, result->count, sizeof (struct pchf_entry),
2007 pchf_save_compare);
2008
2009 ret = fwrite (result, result_size, 1, fp)fwrite_unlocked (result, result_size, 1, fp) == 1;
2010 free (result);
2011 return ret;
2012}
2013
2014/* Read the pchf_data structure from F. */
2015
2016bool
2017_cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED__attribute__ ((__unused__)), FILE *f)
2018{
2019 struct pchf_data d;
2020
2021 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)
2022 != 1)
2023 return false;
2024
2025 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)((struct pchf_data *) xmalloc ((sizeof (struct pchf_data) + sizeof
(struct pchf_entry) * (d.count - 1))))
2026 + sizeof (struct pchf_entry) * (d.count - 1))((struct pchf_data *) xmalloc ((sizeof (struct pchf_data) + sizeof
(struct pchf_entry) * (d.count - 1))))
;
2027 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
2028 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)fread_unlocked (pchf->entries, sizeof (struct pchf_entry),
d.count, f)
2029 != d.count)
2030 return false;
2031 return true;
2032}
2033
2034/* The parameters for pchf_compare. */
2035
2036struct pchf_compare_data
2037{
2038 /* The size of the file we're looking for. */
2039 off_t size;
2040
2041 /* The MD5 checksum of the file, if it's been computed. */
2042 unsigned char sum[16];
2043
2044 /* Is SUM valid? */
2045 bool sum_computed;
2046
2047 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
2048 bool check_included;
2049
2050 /* The file that we're searching for. */
2051 _cpp_file *f;
2052};
2053
2054/* bsearch comparison function; look for D_P in E_P. */
2055
2056static int
2057pchf_compare (const void *d_p, const void *e_p)
2058{
2059 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
2060 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
2061 int result;
2062
2063 result = memcmp (&d->size, &e->size, sizeof (off_t));
2064 if (result != 0)
2065 return result;
2066
2067 if (! d->sum_computed)
2068 {
2069 _cpp_file *const f = d->f;
2070
2071 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
2072 d->sum_computed = true;
2073 }
2074
2075 result = memcmp (d->sum, e->sum, 16);
2076 if (result != 0)
2077 return result;
2078
2079 if (d->check_included || e->once_only)
2080 return 0;
2081 else
2082 return 1;
2083}
2084
2085/* Check that F is not in a list read from a PCH file (if any).
2086 Assumes that f->buffer_valid is true. Return TRUE if the file
2087 should not be read. */
2088
2089static bool
2090check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
2091 _cpp_file *f,
2092 bool check_included)
2093{
2094 struct pchf_compare_data d;
2095
2096 if (pchf == NULL__null
41
Assuming 'pchf' is equal to NULL
2097 || (! check_included && ! pchf->have_once_only))
2098 return false;
42
Returning without writing to 'pfile->seen_once_only', which participates in a condition later
43
Returning without writing to 'pfile->all_files', which participates in a condition later
44
Returning zero, which participates in a condition later
2099
2100 d.size = f->st.st_size;
2101 d.sum_computed = false;
2102 d.f = f;
2103 d.check_included = check_included;
2104 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
2105 pchf_compare) != NULL__null;
2106}
2107
2108/* Return true if the file FNAME is found in the appropriate include file path
2109 as indicated by ANGLE_BRACKETS. */
2110
2111bool
2112_cpp_has_header (cpp_reader *pfile, const char *fname, int angle_brackets,
2113 enum include_type type)
2114{
2115 cpp_dir *start_dir = search_path_head (pfile, fname, angle_brackets, type);
2116 _cpp_file *file = _cpp_find_file (pfile, fname, start_dir, angle_brackets,
2117 _cpp_FFK_HAS_INCLUDE, 0);
2118 return file->err_no != ENOENT2;
2119}
2120