1/* Part of CPP library. (Precompiled header reading/writing.)
2 Copyright (C) 2000-2025 Free Software Foundation, Inc.
3
4This program is free software; you can redistribute it and/or modify it
5under the terms of the GNU General Public License as published by the
6Free Software Foundation; either version 3, or (at your option) any
7later version.
8
9This program is distributed in the hope that it will be useful,
10but WITHOUT ANY WARRANTY; without even the implied warranty of
11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12GNU General Public License for more details.
13
14You should have received a copy of the GNU General Public License
15along with this program; see the file COPYING3. If not see
16<http://www.gnu.org/licenses/>. */
17
18#include "config.h"
19#include "system.h"
20#include "cpplib.h"
21#include "internal.h"
22#include "hashtab.h"
23#include "mkdeps.h"
24
25static int write_macdef (cpp_reader *, cpp_hashnode *, void *);
26static int save_idents (cpp_reader *, cpp_hashnode *, void *);
27static hashval_t hashmem (const void *, size_t);
28static hashval_t cpp_string_hash (const void *);
29static int cpp_string_eq (const void *, const void *);
30static int count_defs (cpp_reader *, cpp_hashnode *, void *);
31static int comp_hashnodes (const void *, const void *);
32static int collect_ht_nodes (cpp_reader *, cpp_hashnode *, void *);
33static int write_defs (cpp_reader *, cpp_hashnode *, void *);
34static int save_macros (cpp_reader *, cpp_hashnode *, void *);
35static int _cpp_save_pushed_macros (cpp_reader *, FILE *);
36static int _cpp_restore_pushed_macros (cpp_reader *, FILE *);
37
38/* This structure represents a macro definition on disk. */
39struct macrodef_struct
40{
41 unsigned int definition_length;
42 unsigned short name_length;
43 unsigned short flags;
44};
45
46/* This is how we write out a macro definition.
47 Suitable for being called by cpp_forall_identifiers. */
48
49static int
50write_macdef (cpp_reader *pfile, cpp_hashnode *hn, void *file_p)
51{
52 FILE *f = (FILE *) file_p;
53 bool is_void = false;
54 switch (hn->type)
55 {
56 case NT_VOID:
57 if (! (hn->flags & NODE_POISONED))
58 return 1;
59 is_void = true;
60 goto poisoned;
61
62 case NT_BUILTIN_MACRO:
63 return 1;
64
65 case NT_USER_MACRO:
66 if (hn->value.macro->kind != cmk_assert)
67 {
68 poisoned:
69 struct macrodef_struct s;
70 const unsigned char *defn;
71
72 s.name_length = NODE_LEN (hn);
73 s.flags = hn->flags & NODE_POISONED;
74
75 if (is_void)
76 {
77 defn = NODE_NAME (hn);
78 s.definition_length = s.name_length;
79 }
80 else
81 {
82 defn = cpp_macro_definition (pfile, hn);
83 s.definition_length = ustrlen (s1: defn);
84 }
85
86 if (fwrite (&s, sizeof (s), 1, f) != 1
87 || fwrite (defn, 1, s.definition_length, f) != s.definition_length)
88 {
89 cpp_errno (pfile, CPP_DL_ERROR,
90 msgid: "while writing precompiled header");
91 return 0;
92 }
93 }
94 return 1;
95
96 default:
97 abort ();
98 }
99}
100
101/* This structure records the names of the defined macros.
102 It's also used as a callback structure for size_initial_idents
103 and save_idents. */
104
105struct cpp_savedstate
106{
107 /* A hash table of the defined identifiers. */
108 htab_t definedhash;
109 /* The size of the definitions of those identifiers (the size of
110 'definedstrs'). */
111 size_t hashsize;
112 /* Number of definitions */
113 size_t n_defs;
114 /* Array of definitions. In cpp_write_pch_deps it is used for sorting. */
115 cpp_hashnode **defs;
116 /* Space for the next definition. Definitions are null-terminated
117 strings. */
118 unsigned char *definedstrs;
119};
120
121/* Save this identifier into the state: put it in the hash table,
122 put the definition in 'definedstrs'. */
123
124static int
125save_idents (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
126{
127 struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
128
129 if (hn->type != NT_VOID)
130 {
131 struct cpp_string news;
132 void **slot;
133
134 news.len = NODE_LEN (hn);
135 news.text= NODE_NAME (hn);
136 slot = htab_find_slot (ss->definedhash, &news, INSERT);
137 if (*slot == NULL)
138 {
139 struct cpp_string *sp;
140 unsigned char *text;
141
142 sp = XNEW (struct cpp_string);
143 *slot = sp;
144
145 sp->len = NODE_LEN (hn);
146 sp->text = text = XNEWVEC (unsigned char, NODE_LEN (hn));
147 memcpy (dest: text, NODE_NAME (hn), NODE_LEN (hn));
148 }
149 }
150
151 return 1;
152}
153
154/* Hash some memory in a generic way. */
155
156static hashval_t
157hashmem (const void *p_p, size_t sz)
158{
159 const unsigned char *p = (const unsigned char *)p_p;
160 size_t i;
161 hashval_t h;
162
163 h = 0;
164 for (i = 0; i < sz; i++)
165 h = h * 67 - (*p++ - 113);
166 return h;
167}
168
169/* Hash a cpp string for the hashtable machinery. */
170
171static hashval_t
172cpp_string_hash (const void *a_p)
173{
174 const struct cpp_string *a = (const struct cpp_string *) a_p;
175 return hashmem (p_p: a->text, sz: a->len);
176}
177
178/* Compare two cpp strings for the hashtable machinery. */
179
180static int
181cpp_string_eq (const void *a_p, const void *b_p)
182{
183 const struct cpp_string *a = (const struct cpp_string *) a_p;
184 const struct cpp_string *b = (const struct cpp_string *) b_p;
185 return (a->len == b->len
186 && memcmp (s1: a->text, s2: b->text, n: a->len) == 0);
187}
188
189/* Free memory associated with cpp_string. */
190
191static void
192cpp_string_free (void *a_p)
193{
194 struct cpp_string *a = (struct cpp_string *) a_p;
195 free (ptr: (void *) a->text);
196 free (ptr: a);
197}
198
199/* Save the current definitions of the cpp_reader for dependency
200 checking purposes. When writing a precompiled header, this should
201 be called at the same point in the compilation as cpp_valid_state
202 would be called when reading the precompiled header back in. */
203
204int
205cpp_save_state (cpp_reader *r, FILE *f)
206{
207 /* Save the list of non-void identifiers for the dependency checking. */
208 r->savedstate = XNEW (struct cpp_savedstate);
209 r->savedstate->definedhash = htab_create (100, cpp_string_hash,
210 cpp_string_eq, cpp_string_free);
211 cpp_forall_identifiers (r, save_idents, r->savedstate);
212
213 /* Write out the list of defined identifiers. */
214 cpp_forall_identifiers (r, write_macdef, f);
215
216 return 0;
217}
218
219/* Calculate the 'hashsize' field of the saved state. */
220
221static int
222count_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
223{
224 struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
225
226 switch (hn->type)
227 {
228 case NT_BUILTIN_MACRO:
229 return 1;
230
231 case NT_USER_MACRO:
232 if (hn->value.macro->kind == cmk_assert)
233 return 1;
234
235 /* fall through. */
236
237 case NT_VOID:
238 {
239 struct cpp_string news;
240 void **slot;
241
242 news.len = NODE_LEN (hn);
243 news.text = NODE_NAME (hn);
244 slot = (void **) htab_find (ss->definedhash, &news);
245 if (slot == NULL)
246 {
247 ss->hashsize += NODE_LEN (hn) + 1;
248 ss->n_defs += 1;
249 }
250 }
251 return 1;
252
253 default:
254 abort ();
255 }
256}
257
258/* Collect the identifiers into the state's string table. */
259static int
260write_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
261{
262 struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
263
264 switch (hn->type)
265 {
266 case NT_BUILTIN_MACRO:
267 return 1;
268
269 case NT_USER_MACRO:
270 if (hn->value.macro->kind == cmk_assert)
271 return 1;
272
273 /* fall through. */
274
275 case NT_VOID:
276 {
277 struct cpp_string news;
278 void **slot;
279
280 news.len = NODE_LEN (hn);
281 news.text = NODE_NAME (hn);
282 slot = (void **) htab_find (ss->definedhash, &news);
283 if (slot == NULL)
284 {
285 ss->defs[ss->n_defs] = hn;
286 ss->n_defs += 1;
287 }
288 }
289 return 1;
290
291 default:
292 abort ();
293 }
294}
295
296/* Comparison function for qsort. The arguments point to pointers of
297 type ht_hashnode *. */
298static int
299comp_hashnodes (const void *px, const void *py)
300{
301 cpp_hashnode *x = *(cpp_hashnode **) px;
302 cpp_hashnode *y = *(cpp_hashnode **) py;
303 return ustrcmp (NODE_NAME (x), NODE_NAME (y));
304}
305
306/* Write out the remainder of the dependency information. This should be
307 called after the PCH is ready to be saved. */
308
309int
310cpp_write_pch_deps (cpp_reader *r, FILE *f)
311{
312 struct macrodef_struct z;
313 struct cpp_savedstate *const ss = r->savedstate;
314 unsigned char *definedstrs;
315 size_t i;
316
317 /* Collect the list of identifiers which have been seen and
318 weren't defined to anything previously. */
319 ss->hashsize = 0;
320 ss->n_defs = 0;
321 cpp_forall_identifiers (r, count_defs, ss);
322
323 ss->defs = XNEWVEC (cpp_hashnode *, ss->n_defs);
324 ss->n_defs = 0;
325 cpp_forall_identifiers (r, write_defs, ss);
326
327 /* Sort the list, copy it into a buffer, and write it out. */
328 qsort (base: ss->defs, nmemb: ss->n_defs, size: sizeof (cpp_hashnode *), compar: &comp_hashnodes);
329 definedstrs = ss->definedstrs = XNEWVEC (unsigned char, ss->hashsize);
330 for (i = 0; i < ss->n_defs; ++i)
331 {
332 size_t len = NODE_LEN (ss->defs[i]);
333 memcpy (dest: definedstrs, NODE_NAME (ss->defs[i]), n: len + 1);
334 definedstrs += len + 1;
335 }
336
337 memset (s: &z, c: 0, n: sizeof (z));
338 z.definition_length = ss->hashsize;
339 if (fwrite (&z, sizeof (z), 1, f) != 1
340 || fwrite (ss->definedstrs, ss->hashsize, 1, f) != 1)
341 {
342 cpp_errno (r, CPP_DL_ERROR, msgid: "while writing precompiled header");
343 return -1;
344 }
345 free (ptr: ss->definedstrs);
346 free (ptr: ss->defs);
347 htab_delete (ss->definedhash);
348
349 /* Free the saved state. */
350 free (ptr: ss);
351 r->savedstate = NULL;
352
353 /* Save the next value of __COUNTER__. */
354 if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1)
355 {
356 cpp_errno (r, CPP_DL_ERROR, msgid: "while writing precompiled header");
357 return -1;
358 }
359
360 return 0;
361}
362
363/* Write out the definitions of the preprocessor, in a form suitable for
364 cpp_read_state. */
365
366int
367cpp_write_pch_state (cpp_reader *r, FILE *f)
368{
369 if (!r->deps)
370 r->deps = deps_init ();
371
372 if (deps_save (r->deps, f) != 0)
373 {
374 cpp_errno (r, CPP_DL_ERROR, msgid: "while writing precompiled header");
375 return -1;
376 }
377
378 if (! _cpp_save_file_entries (pfile: r, f))
379 {
380 cpp_errno (r, CPP_DL_ERROR, msgid: "while writing precompiled header");
381 return -1;
382 }
383
384 /* Save the next __COUNTER__ value. When we include a precompiled header,
385 we need to start at the offset we would have if the header had been
386 included normally. */
387 if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1)
388 {
389 cpp_errno (r, CPP_DL_ERROR, msgid: "while writing precompiled header");
390 return -1;
391 }
392
393 /* Write saved macros. */
394 if (! _cpp_save_pushed_macros (r, f))
395 {
396 cpp_errno (r, CPP_DL_ERROR, msgid: "while writing precompiled header");
397 return -1;
398 }
399
400 return 0;
401}
402
403static int
404_cpp_restore_pushed_macros (cpp_reader *r, FILE *f)
405{
406 size_t count_saved = 0;
407 size_t i;
408 struct def_pragma_macro *p;
409 size_t nlen;
410 uchar *defn;
411 size_t defnlen;
412
413 if (fread (&count_saved, sizeof (count_saved), 1, f) != 1)
414 return 0;
415 if (! count_saved)
416 return 1;
417 for (i = 0; i < count_saved; i++)
418 {
419 if (fread (&nlen, sizeof (nlen), 1, f) != 1)
420 return 0;
421 p = XNEW (struct def_pragma_macro);
422 memset (s: p, c: 0, n: sizeof (struct def_pragma_macro));
423 p->name = XNEWVAR (char, nlen + 1);
424 p->name[nlen] = 0;
425 if (fread (p->name, nlen, 1, f) != 1)
426 return 0;
427 if (fread (&defnlen, sizeof (defnlen), 1, f) != 1)
428 return 0;
429 if (defnlen == 0)
430 p->is_undef = 1;
431 else
432 {
433 defn = XNEWVEC (uchar, defnlen + 1);
434 defn[defnlen] = 0;
435
436 if (fread (defn, defnlen, 1, f) != 1)
437 return 0;
438
439 p->definition = defn;
440 if (fread (&(p->line), sizeof (location_t), 1, f) != 1)
441 return 0;
442 defnlen = 0;
443 if (fread (&defnlen, sizeof (defnlen), 1, f) != 1)
444 return 0;
445 p->syshdr = ((defnlen & 1) != 0 ? 1 : 0);
446 p->used = ((defnlen & 2) != 0 ? 1 : 0);
447 }
448
449 p->next = r->pushed_macros;
450 r->pushed_macros = p;
451 }
452 return 1;
453}
454
455static int
456_cpp_save_pushed_macros (cpp_reader *r, FILE *f)
457{
458 size_t count_saved = 0;
459 size_t i;
460 struct def_pragma_macro *p,**pp;
461 size_t defnlen;
462
463 /* Get count. */
464 p = r->pushed_macros;
465 while (p != NULL)
466 {
467 count_saved++;
468 p = p->next;
469 }
470 if (fwrite (&count_saved, sizeof (count_saved), 1, f) != 1)
471 return 0;
472 if (!count_saved)
473 return 1;
474
475 pp = (struct def_pragma_macro **) alloca (sizeof (struct def_pragma_macro *)
476 * count_saved);
477 /* Store them in reverse order. */
478 p = r->pushed_macros;
479 i = count_saved;
480 while (p != NULL)
481 {
482 --i;
483 pp[i] = p;
484 p = p->next;
485 }
486 for (i = 0; i < count_saved; i++)
487 {
488 defnlen = strlen (s: pp[i]->name);
489 if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1
490 || fwrite (pp[i]->name, defnlen, 1, f) != 1)
491 return 0;
492 if (pp[i]->is_undef)
493 {
494 defnlen = 0;
495 if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1)
496 return 0;
497 }
498 else
499 {
500 defnlen = ustrlen (s1: pp[i]->definition);
501 if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1
502 || fwrite (pp[i]->definition, defnlen, 1, f) != 1)
503 return 0;
504 if (fwrite (&(pp[i]->line), sizeof (location_t), 1, f) != 1)
505 return 0;
506 defnlen = 0;
507 defnlen |= (pp[i]->syshdr != 0 ? 1 : 0);
508 defnlen |= (pp[i]->used != 0 ? 2 : 0);
509 if (fwrite (&defnlen, sizeof (defnlen), 1, f) != 1)
510 return 0;
511 }
512 }
513 return 1;
514}
515
516
517/* Data structure to transform hash table nodes into a sorted list */
518
519struct ht_node_list
520{
521 /* Array of nodes */
522 cpp_hashnode **defs;
523 /* Number of nodes in the array */
524 size_t n_defs;
525 /* Size of the allocated array */
526 size_t asize;
527};
528
529/* Callback for collecting identifiers from hash table */
530
531static int
532collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn,
533 void *nl_p)
534{
535 struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
536
537 if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
538 {
539 if (nl->n_defs == nl->asize)
540 {
541 nl->asize *= 2;
542 nl->defs = XRESIZEVEC (cpp_hashnode *, nl->defs, nl->asize);
543 }
544
545 nl->defs[nl->n_defs] = hn;
546 ++nl->n_defs;
547 }
548 return 1;
549}
550
551
552/* Return nonzero if FD is a precompiled header which is consistent
553 with the preprocessor's current definitions. It will be consistent
554 when:
555
556 - anything that was defined just before the PCH was generated
557 is defined the same way now; and
558 - anything that was not defined then, but is defined now, was not
559 used by the PCH.
560
561 NAME is used to print warnings if `warn_invalid_pch' is set in the
562 reader's flags.
563*/
564
565int
566cpp_valid_state (cpp_reader *r, const char *name, int fd)
567{
568 struct macrodef_struct m;
569 size_t namebufsz = 256;
570 unsigned char *namebuf = XNEWVEC (unsigned char, namebufsz);
571 unsigned char *undeftab = NULL;
572 struct ht_node_list nl = { .defs: 0, .n_defs: 0, .asize: 0 };
573 unsigned char *first, *last;
574 unsigned int i;
575 unsigned int counter;
576
577 /* Read in the list of identifiers that must be defined
578 Check that they are defined in the same way. */
579 for (;;)
580 {
581 cpp_hashnode *h;
582 const unsigned char *newdefn;
583
584 if (read (fd: fd, buf: &m, nbytes: sizeof (m)) != sizeof (m))
585 goto error;
586
587 if (m.name_length == 0)
588 break;
589
590 /* If this file is already preprocessed, there won't be any
591 macros defined, and that's OK. */
592 if (CPP_OPTION (r, preprocessed))
593 {
594 if (lseek (fd: fd, offset: m.definition_length, SEEK_CUR) == -1)
595 goto error;
596 continue;
597 }
598
599 if (m.definition_length > namebufsz)
600 {
601 free (ptr: namebuf);
602 namebufsz = m.definition_length + 256;
603 namebuf = XNEWVEC (unsigned char, namebufsz);
604 }
605
606 if ((size_t)read (fd: fd, buf: namebuf, nbytes: m.definition_length)
607 != m.definition_length)
608 goto error;
609
610 h = cpp_lookup (r, namebuf, m.name_length);
611 if (m.flags & NODE_POISONED
612 || h->flags & NODE_POISONED)
613 {
614 if (CPP_OPTION (r, warn_invalid_pch))
615 cpp_warning_syshdr (r, reason: CPP_W_INVALID_PCH,
616 msgid: "%s: not used because %<%.*s%> is poisoned",
617 name, m.name_length, namebuf);
618 goto fail;
619 }
620
621 if (h->type == NT_VOID)
622 {
623 /* It's ok if __GCC_HAVE_DWARF2_CFI_ASM becomes undefined,
624 as in, when the PCH file is created with -g and we're
625 attempting to use it without -g. Restoring the PCH file
626 is supposed to bring in this definition *and* enable the
627 generation of call frame information, so that precompiled
628 definitions that take this macro into account, to decide
629 what asm to emit, won't issue .cfi directives when the
630 compiler doesn't. */
631 if (!(h->flags & NODE_USED)
632 && m.name_length == sizeof ("__GCC_HAVE_DWARF2_CFI_ASM") - 1
633 && !memcmp (s1: namebuf, s2: "__GCC_HAVE_DWARF2_CFI_ASM", n: m.name_length))
634 continue;
635
636 if (CPP_OPTION (r, warn_invalid_pch))
637 cpp_warning_syshdr (r, reason: CPP_W_INVALID_PCH,
638 msgid: "%s: not used because %<%.*s%> not defined",
639 name, m.name_length, namebuf);
640 goto fail;
641 }
642
643 newdefn = cpp_macro_definition (r, h);
644
645 if (m.definition_length != ustrlen (s1: newdefn)
646 || memcmp (s1: namebuf, s2: newdefn, n: m.definition_length) != 0)
647 {
648 if (CPP_OPTION (r, warn_invalid_pch))
649 cpp_warning_syshdr (r, reason: CPP_W_INVALID_PCH,
650 msgid: "%s: not used because %<%.*s%> defined as "
651 "%qs not %<%.*s%>",
652 name, m.name_length, namebuf,
653 newdefn + m.name_length,
654 m.definition_length - m.name_length,
655 namebuf + m.name_length);
656 goto fail;
657 }
658 }
659 free (ptr: namebuf);
660 namebuf = NULL;
661
662 /* Read in the list of identifiers that must not be defined.
663 Check that they really aren't. */
664 undeftab = XNEWVEC (unsigned char, m.definition_length);
665 if ((size_t) read (fd: fd, buf: undeftab, nbytes: m.definition_length) != m.definition_length)
666 goto error;
667
668 /* Collect identifiers from the current hash table. */
669 nl.n_defs = 0;
670 nl.asize = 10;
671 nl.defs = XNEWVEC (cpp_hashnode *, nl.asize);
672 cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
673 qsort (base: nl.defs, nmemb: nl.n_defs, size: sizeof (cpp_hashnode *), compar: &comp_hashnodes);
674
675 /* Loop through nl.defs and undeftab, both of which are sorted lists.
676 There should be no matches. */
677 first = undeftab;
678 last = undeftab + m.definition_length;
679 i = 0;
680
681 while (first < last && i < nl.n_defs)
682 {
683 int cmp = ustrcmp (s1: first, NODE_NAME (nl.defs[i]));
684
685 if (cmp < 0)
686 first += ustrlen (s1: first) + 1;
687 else if (cmp > 0)
688 ++i;
689 else
690 {
691 if (CPP_OPTION (r, warn_invalid_pch))
692 cpp_warning_syshdr (r, reason: CPP_W_INVALID_PCH,
693 msgid: "%s: not used because %qs is defined",
694 name, first);
695 goto fail;
696 }
697 }
698
699 free(ptr: nl.defs);
700 nl.defs = NULL;
701 free (ptr: undeftab);
702 undeftab = NULL;
703
704 /* Read in the next value of __COUNTER__.
705 Check that (a) __COUNTER__ was not used in the pch or (b) __COUNTER__
706 has not been used in this translation unit. */
707 if (read (fd: fd, buf: &counter, nbytes: sizeof (counter)) != sizeof (counter))
708 goto error;
709 if (counter && r->counter)
710 {
711 if (CPP_OPTION (r, warn_invalid_pch))
712 cpp_warning_syshdr (r, reason: CPP_W_INVALID_PCH,
713 msgid: "%s: not used because %<__COUNTER__%> is invalid",
714 name);
715 goto fail;
716 }
717
718 /* We win! */
719 return 0;
720
721 error:
722 cpp_errno (r, CPP_DL_ERROR, msgid: "while reading precompiled header");
723
724 fail:
725 free (ptr: namebuf);
726 free (ptr: undeftab);
727 free (ptr: nl.defs);
728 return 1;
729}
730
731/* Save all the existing macros. */
732
733struct save_macro_data
734{
735 uchar **defns;
736 size_t count;
737 size_t array_size;
738 char **saved_pragmas;
739};
740
741/* Save the definition of a single macro, so that it will persist
742 across a PCH restore. Because macro data is in GCed memory, which
743 will be blown away by PCH, it must be temporarily copied to
744 malloced memory. (The macros will refer to identifier nodes which
745 are also GCed and so on, so the copying is done by turning them
746 into self-contained strings.) The assumption is that most macro
747 definitions will come from the PCH file, not from the compilation
748 before the PCH file is loaded, so it doesn't matter that this is
749 a little expensive.
750
751 It would reduce the cost even further if macros defined in the PCH
752 file were not saved in this way, but this is not done (yet), except
753 for builtins, and for #assert by default. */
754
755static int
756save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p)
757{
758 struct save_macro_data *data = (struct save_macro_data *)data_p;
759
760 if (cpp_user_macro_p (node: h))
761 {
762 if (data->count == data->array_size)
763 {
764 data->array_size *= 2;
765 data->defns = XRESIZEVEC (uchar *, data->defns, (data->array_size));
766 }
767
768 const uchar * defn = cpp_macro_definition (r, h);
769 size_t defnlen = ustrlen (s1: defn);
770
771 data->defns[data->count] = (uchar *) xmemdup (defn, defnlen, defnlen + 2);
772 data->defns[data->count][defnlen] = '\n';
773 data->count++;
774 }
775
776 return 1;
777}
778
779/* Prepare to restore the state, by saving the currently-defined
780 macros in 'data'. */
781
782void
783cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
784{
785 struct save_macro_data *d = XNEW (struct save_macro_data);
786
787 d->array_size = 512;
788 d->defns = XNEWVEC (uchar *, d->array_size);
789 d->count = 0;
790 cpp_forall_identifiers (r, save_macros, d);
791 d->saved_pragmas = _cpp_save_pragma_names (r);
792 *data = d;
793}
794
795/* Given a precompiled header that was previously determined to be valid,
796 apply all its definitions (and undefinitions) to the current state.
797 DEPNAME is passed to deps_restore. */
798
799int
800cpp_read_state (cpp_reader *r, const char *name, FILE *f,
801 struct save_macro_data *data)
802{
803 size_t i;
804 struct lexer_state old_state;
805 unsigned int counter;
806
807 /* Restore spec_nodes, which will be full of references to the old
808 hashtable entries and so will now be invalid. */
809 {
810 struct spec_nodes *s = &r->spec_nodes;
811 s->n_defined = cpp_lookup (r, DSC("defined"));
812 s->n_true = cpp_lookup (r, DSC("true"));
813 s->n_false = cpp_lookup (r, DSC("false"));
814 s->n__VA_ARGS__ = cpp_lookup (r, DSC("__VA_ARGS__"));
815 s->n__VA_OPT__ = cpp_lookup (r, DSC("__VA_OPT__"));
816 }
817
818 old_state = r->state;
819 r->state.in_directive = 1;
820 r->state.prevent_expansion = 1;
821 r->state.angled_headers = 0;
822
823 /* Run through the carefully-saved macros, insert them. */
824 for (i = 0; i < data->count; i++)
825 {
826 cpp_hashnode *h;
827 size_t namelen;
828 uchar *defn;
829
830 namelen = ustrcspn (s1: data->defns[i], s2: "( \n");
831 h = cpp_lookup (r, data->defns[i], namelen);
832 defn = data->defns[i] + namelen;
833
834 /* The PCH file is valid, so we know that if there is a definition
835 from the PCH file it must be the same as the one we had
836 originally, and so do not need to restore it. */
837 if (h->type == NT_VOID)
838 {
839 if (cpp_push_buffer (r, defn, ustrchr (s1: defn, c: '\n') - defn, true)
840 != NULL)
841 {
842 _cpp_clean_line (r);
843
844 /* ??? Using r->line_table->highest_line is not ideal here, but we
845 do need to use some location that is relative to the new line
846 map just loaded, not the old one that was in effect when these
847 macros were lexed. The proper fix is to remember the file name
848 and line number where each macro was defined, and then add
849 these locations into the new line map. See PR105608. */
850 if (!_cpp_create_definition (r, h, r->line_table->highest_line))
851 abort ();
852 _cpp_pop_buffer (r);
853 }
854 else
855 abort ();
856 }
857
858 free (ptr: data->defns[i]);
859 }
860 r->state = old_state;
861
862 _cpp_restore_pragma_names (r, data->saved_pragmas);
863
864 free (ptr: data);
865
866 if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
867 != 0)
868 goto error;
869
870 if (! _cpp_read_file_entries (r, f))
871 goto error;
872
873 if (fread (&counter, sizeof (counter), 1, f) != 1)
874 goto error;
875
876 if (!r->counter)
877 r->counter = counter;
878
879 /* Read pushed macros. */
880 if (! _cpp_restore_pushed_macros (r, f))
881 goto error;
882 return 0;
883
884 error:
885 cpp_errno (r, CPP_DL_ERROR, msgid: "while reading precompiled header");
886 return -1;
887}
888

source code of libcpp/pch.cc