OSDN Git Service

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