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