* gcc-plugin.h (enum plugin_event): Add PLUGIN_ALL_IPA_PASSES_START,
[official-gcc.git] / libcpp / pch.c
blobf656418a19285bc45ced4fc669ef303515bcb852
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.
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.
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.
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/>. */
19 #include "config.h"
20 #include "system.h"
21 #include "cpplib.h"
22 #include "internal.h"
23 #include "hashtab.h"
24 #include "mkdeps.h"
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 *);
37 /* This structure represents a macro definition on disk. */
38 struct macrodef_struct
40 unsigned int definition_length;
41 unsigned short name_length;
42 unsigned short flags;
45 /* This is how we write out a macro definition.
46 Suitable for being called by cpp_forall_identifiers. */
48 static int
49 write_macdef (cpp_reader *pfile, cpp_hashnode *hn, void *file_p)
51 FILE *f = (FILE *) file_p;
52 switch (hn->type)
54 case NT_VOID:
55 if (! (hn->flags & NODE_POISONED))
56 return 1;
58 case NT_MACRO:
59 if ((hn->flags & NODE_BUILTIN))
60 return 1;
63 struct macrodef_struct s;
64 const unsigned char *defn;
66 s.name_length = NODE_LEN (hn);
67 s.flags = hn->flags & NODE_POISONED;
69 if (hn->type == NT_MACRO)
71 defn = cpp_macro_definition (pfile, hn);
72 s.definition_length = ustrlen (defn);
74 else
76 defn = NODE_NAME (hn);
77 s.definition_length = s.name_length;
80 if (fwrite (&s, sizeof (s), 1, f) != 1
81 || fwrite (defn, 1, s.definition_length, f) != s.definition_length)
83 cpp_errno (pfile, CPP_DL_ERROR,
84 "while writing precompiled header");
85 return 0;
88 return 1;
90 case NT_ASSERTION:
91 /* Not currently implemented. */
92 return 1;
94 default:
95 abort ();
99 /* This structure records the names of the defined macros.
100 It's also used as a callback structure for size_initial_idents
101 and save_idents. */
103 struct cpp_savedstate
105 /* A hash table of the defined identifiers. */
106 htab_t definedhash;
107 /* The size of the definitions of those identifiers (the size of
108 'definedstrs'). */
109 size_t hashsize;
110 /* Number of definitions */
111 size_t n_defs;
112 /* Array of definitions. In cpp_write_pch_deps it is used for sorting. */
113 cpp_hashnode **defs;
114 /* Space for the next definition. Definitions are null-terminated
115 strings. */
116 unsigned char *definedstrs;
119 /* Save this identifier into the state: put it in the hash table,
120 put the definition in 'definedstrs'. */
122 static int
123 save_idents (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
125 struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
127 if (hn->type != NT_VOID)
129 struct cpp_string news;
130 void **slot;
132 news.len = NODE_LEN (hn);
133 news.text= NODE_NAME (hn);
134 slot = htab_find_slot (ss->definedhash, &news, INSERT);
135 if (*slot == NULL)
137 struct cpp_string *sp;
138 unsigned char *text;
140 sp = XNEW (struct cpp_string);
141 *slot = sp;
143 sp->len = NODE_LEN (hn);
144 sp->text = text = XNEWVEC (unsigned char, NODE_LEN (hn));
145 memcpy (text, NODE_NAME (hn), NODE_LEN (hn));
149 return 1;
152 /* Hash some memory in a generic way. */
154 static hashval_t
155 hashmem (const void *p_p, size_t sz)
157 const unsigned char *p = (const unsigned char *)p_p;
158 size_t i;
159 hashval_t h;
161 h = 0;
162 for (i = 0; i < sz; i++)
163 h = h * 67 - (*p++ - 113);
164 return h;
167 /* Hash a cpp string for the hashtable machinery. */
169 static hashval_t
170 cpp_string_hash (const void *a_p)
172 const struct cpp_string *a = (const struct cpp_string *) a_p;
173 return hashmem (a->text, a->len);
176 /* Compare two cpp strings for the hashtable machinery. */
178 static int
179 cpp_string_eq (const void *a_p, const void *b_p)
181 const struct cpp_string *a = (const struct cpp_string *) a_p;
182 const struct cpp_string *b = (const struct cpp_string *) b_p;
183 return (a->len == b->len
184 && memcmp (a->text, b->text, a->len) == 0);
187 /* Save the current definitions of the cpp_reader for dependency
188 checking purposes. When writing a precompiled header, this should
189 be called at the same point in the compilation as cpp_valid_state
190 would be called when reading the precompiled header back in. */
193 cpp_save_state (cpp_reader *r, FILE *f)
195 /* Save the list of non-void identifiers for the dependency checking. */
196 r->savedstate = XNEW (struct cpp_savedstate);
197 r->savedstate->definedhash = htab_create (100, cpp_string_hash,
198 cpp_string_eq, NULL);
199 cpp_forall_identifiers (r, save_idents, r->savedstate);
201 /* Write out the list of defined identifiers. */
202 cpp_forall_identifiers (r, write_macdef, f);
204 return 0;
207 /* Calculate the 'hashsize' field of the saved state. */
209 static int
210 count_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
212 struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
214 switch (hn->type)
216 case NT_MACRO:
217 if (hn->flags & NODE_BUILTIN)
218 return 1;
220 /* else fall through. */
222 case NT_VOID:
224 struct cpp_string news;
225 void **slot;
227 news.len = NODE_LEN (hn);
228 news.text = NODE_NAME (hn);
229 slot = (void **) htab_find (ss->definedhash, &news);
230 if (slot == NULL)
232 ss->hashsize += NODE_LEN (hn) + 1;
233 ss->n_defs += 1;
236 return 1;
238 case NT_ASSERTION:
239 /* Not currently implemented. */
240 return 1;
242 default:
243 abort ();
247 /* Collect the identifiers into the state's string table. */
248 static int
249 write_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
251 struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
253 switch (hn->type)
255 case NT_MACRO:
256 if (hn->flags & NODE_BUILTIN)
257 return 1;
259 /* else fall through. */
261 case NT_VOID:
263 struct cpp_string news;
264 void **slot;
266 news.len = NODE_LEN (hn);
267 news.text = NODE_NAME (hn);
268 slot = (void **) htab_find (ss->definedhash, &news);
269 if (slot == NULL)
271 ss->defs[ss->n_defs] = hn;
272 ss->n_defs += 1;
275 return 1;
277 case NT_ASSERTION:
278 /* Not currently implemented. */
279 return 1;
281 default:
282 abort ();
286 /* Comparison function for qsort. The arguments point to pointers of
287 type ht_hashnode *. */
288 static int
289 comp_hashnodes (const void *px, const void *py)
291 cpp_hashnode *x = *(cpp_hashnode **) px;
292 cpp_hashnode *y = *(cpp_hashnode **) py;
293 return ustrcmp (NODE_NAME (x), NODE_NAME (y));
296 /* Write out the remainder of the dependency information. This should be
297 called after the PCH is ready to be saved. */
300 cpp_write_pch_deps (cpp_reader *r, FILE *f)
302 struct macrodef_struct z;
303 struct cpp_savedstate *const ss = r->savedstate;
304 unsigned char *definedstrs;
305 size_t i;
307 /* Collect the list of identifiers which have been seen and
308 weren't defined to anything previously. */
309 ss->hashsize = 0;
310 ss->n_defs = 0;
311 cpp_forall_identifiers (r, count_defs, ss);
313 ss->defs = XNEWVEC (cpp_hashnode *, ss->n_defs);
314 ss->n_defs = 0;
315 cpp_forall_identifiers (r, write_defs, ss);
317 /* Sort the list, copy it into a buffer, and write it out. */
318 qsort (ss->defs, ss->n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
319 definedstrs = ss->definedstrs = XNEWVEC (unsigned char, ss->hashsize);
320 for (i = 0; i < ss->n_defs; ++i)
322 size_t len = NODE_LEN (ss->defs[i]);
323 memcpy (definedstrs, NODE_NAME (ss->defs[i]), len + 1);
324 definedstrs += len + 1;
327 memset (&z, 0, sizeof (z));
328 z.definition_length = ss->hashsize;
329 if (fwrite (&z, sizeof (z), 1, f) != 1
330 || fwrite (ss->definedstrs, ss->hashsize, 1, f) != 1)
332 cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
333 return -1;
335 free (ss->definedstrs);
337 /* Free the saved state. */
338 free (ss);
339 r->savedstate = NULL;
341 /* Save the next value of __COUNTER__. */
342 if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1)
344 cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
345 return -1;
348 return 0;
351 /* Write out the definitions of the preprocessor, in a form suitable for
352 cpp_read_state. */
355 cpp_write_pch_state (cpp_reader *r, FILE *f)
357 if (!r->deps)
358 r->deps = deps_init ();
360 if (deps_save (r->deps, f) != 0)
362 cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
363 return -1;
366 if (! _cpp_save_file_entries (r, f))
368 cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
369 return -1;
372 /* Save the next __COUNTER__ value. When we include a precompiled header,
373 we need to start at the offset we would have if the header had been
374 included normally. */
375 if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1)
377 cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
378 return -1;
381 return 0;
385 /* Data structure to transform hash table nodes into a sorted list */
387 struct ht_node_list
389 /* Array of nodes */
390 cpp_hashnode **defs;
391 /* Number of nodes in the array */
392 size_t n_defs;
393 /* Size of the allocated array */
394 size_t asize;
397 /* Callback for collecting identifiers from hash table */
399 static int
400 collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn,
401 void *nl_p)
403 struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
405 if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
407 if (nl->n_defs == nl->asize)
409 nl->asize *= 2;
410 nl->defs = XRESIZEVEC (cpp_hashnode *, nl->defs, nl->asize);
413 nl->defs[nl->n_defs] = hn;
414 ++nl->n_defs;
416 return 1;
420 /* Return nonzero if FD is a precompiled header which is consistent
421 with the preprocessor's current definitions. It will be consistent
422 when:
424 - anything that was defined just before the PCH was generated
425 is defined the same way now; and
426 - anything that was not defined then, but is defined now, was not
427 used by the PCH.
429 NAME is used to print warnings if `warn_invalid_pch' is set in the
430 reader's flags.
434 cpp_valid_state (cpp_reader *r, const char *name, int fd)
436 struct macrodef_struct m;
437 size_t namebufsz = 256;
438 unsigned char *namebuf = XNEWVEC (unsigned char, namebufsz);
439 unsigned char *undeftab = NULL;
440 struct ht_node_list nl = { 0, 0, 0 };
441 unsigned char *first, *last;
442 unsigned int i;
443 unsigned int counter;
445 /* Read in the list of identifiers that must be defined
446 Check that they are defined in the same way. */
447 for (;;)
449 cpp_hashnode *h;
450 const unsigned char *newdefn;
452 if (read (fd, &m, sizeof (m)) != sizeof (m))
453 goto error;
455 if (m.name_length == 0)
456 break;
458 /* If this file is already preprocessed, there won't be any
459 macros defined, and that's OK. */
460 if (CPP_OPTION (r, preprocessed))
462 if (lseek (fd, m.definition_length, SEEK_CUR) == -1)
463 goto error;
464 continue;
467 if (m.definition_length > namebufsz)
469 free (namebuf);
470 namebufsz = m.definition_length + 256;
471 namebuf = XNEWVEC (unsigned char, namebufsz);
474 if ((size_t)read (fd, namebuf, m.definition_length)
475 != m.definition_length)
476 goto error;
478 h = cpp_lookup (r, namebuf, m.name_length);
479 if (m.flags & NODE_POISONED
480 || h->flags & NODE_POISONED)
482 if (CPP_OPTION (r, warn_invalid_pch))
483 cpp_error (r, CPP_DL_WARNING_SYSHDR,
484 "%s: not used because `%.*s' is poisoned",
485 name, m.name_length, namebuf);
486 goto fail;
489 if (h->type != NT_MACRO)
491 /* It's ok if __GCC_HAVE_DWARF2_CFI_ASM becomes undefined,
492 as in, when the PCH file is created with -g and we're
493 attempting to use it without -g. Restoring the PCH file
494 is supposed to bring in this definition *and* enable the
495 generation of call frame information, so that precompiled
496 definitions that take this macro into accout, to decide
497 what asm to emit, won't issue .cfi directives when the
498 compiler doesn't. */
499 if (!(h->flags & NODE_USED)
500 && m.name_length == sizeof ("__GCC_HAVE_DWARF2_CFI_ASM") - 1
501 && !memcmp (namebuf, "__GCC_HAVE_DWARF2_CFI_ASM", m.name_length))
502 continue;
504 if (CPP_OPTION (r, warn_invalid_pch))
505 cpp_error (r, CPP_DL_WARNING_SYSHDR,
506 "%s: not used because `%.*s' not defined",
507 name, m.name_length, namebuf);
508 goto fail;
511 newdefn = cpp_macro_definition (r, h);
513 if (m.definition_length != ustrlen (newdefn)
514 || memcmp (namebuf, newdefn, m.definition_length) != 0)
516 if (CPP_OPTION (r, warn_invalid_pch))
517 cpp_error (r, CPP_DL_WARNING_SYSHDR,
518 "%s: not used because `%.*s' defined as `%s' not `%.*s'",
519 name, m.name_length, namebuf, newdefn + m.name_length,
520 m.definition_length - m.name_length,
521 namebuf + m.name_length);
522 goto fail;
525 free (namebuf);
526 namebuf = NULL;
528 /* Read in the list of identifiers that must not be defined.
529 Check that they really aren't. */
530 undeftab = XNEWVEC (unsigned char, m.definition_length);
531 if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
532 goto error;
534 /* Collect identifiers from the current hash table. */
535 nl.n_defs = 0;
536 nl.asize = 10;
537 nl.defs = XNEWVEC (cpp_hashnode *, nl.asize);
538 cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
539 qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
541 /* Loop through nl.defs and undeftab, both of which are sorted lists.
542 There should be no matches. */
543 first = undeftab;
544 last = undeftab + m.definition_length;
545 i = 0;
547 while (first < last && i < nl.n_defs)
549 int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
551 if (cmp < 0)
552 first += ustrlen (first) + 1;
553 else if (cmp > 0)
554 ++i;
555 else
557 if (CPP_OPTION (r, warn_invalid_pch))
558 cpp_error (r, CPP_DL_WARNING_SYSHDR,
559 "%s: not used because `%s' is defined",
560 name, first);
561 goto fail;
565 free(nl.defs);
566 nl.defs = NULL;
567 free (undeftab);
568 undeftab = NULL;
570 /* Read in the next value of __COUNTER__.
571 Check that (a) __COUNTER__ was not used in the pch or (b) __COUNTER__
572 has not been used in this translation unit. */
573 if (read (fd, &counter, sizeof (counter)) != sizeof (counter))
574 goto error;
575 if (counter && r->counter)
577 if (CPP_OPTION (r, warn_invalid_pch))
578 cpp_error (r, CPP_DL_WARNING_SYSHDR,
579 "%s: not used because `__COUNTER__' is invalid",
580 name);
581 goto fail;
584 /* We win! */
585 return 0;
587 error:
588 cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
589 return -1;
591 fail:
592 if (namebuf != NULL)
593 free (namebuf);
594 if (undeftab != NULL)
595 free (undeftab);
596 if (nl.defs != NULL)
597 free (nl.defs);
598 return 1;
601 /* Save all the existing macros. */
603 struct save_macro_data
605 uchar **defns;
606 size_t count;
607 size_t array_size;
608 char **saved_pragmas;
611 /* Save the definition of a single macro, so that it will persist
612 across a PCH restore. Because macro data is in GCed memory, which
613 will be blown away by PCH, it must be temporarily copied to
614 malloced memory. (The macros will refer to identifier nodes which
615 are also GCed and so on, so the copying is done by turning them
616 into self-contained strings.) The assumption is that most macro
617 definitions will come from the PCH file, not from the compilation
618 before the PCH file is loaded, so it doesn't matter that this is
619 a little expensive.
621 It would reduce the cost even further if macros defined in the PCH
622 file were not saved in this way, but this is not done (yet), except
623 for builtins, and for #assert by default. */
625 static int
626 save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p)
628 struct save_macro_data *data = (struct save_macro_data *)data_p;
629 if (h->type != NT_VOID
630 && (h->flags & NODE_BUILTIN) == 0)
632 if (data->count == data->array_size)
634 data->array_size *= 2;
635 data->defns = XRESIZEVEC (uchar *, data->defns, (data->array_size));
638 switch (h->type)
640 case NT_ASSERTION:
641 /* Not currently implemented. */
642 return 1;
644 case NT_MACRO:
646 const uchar * defn = cpp_macro_definition (r, h);
647 size_t defnlen = ustrlen (defn);
649 data->defns[data->count] = (uchar *) xmemdup (defn, defnlen,
650 defnlen + 2);
651 data->defns[data->count][defnlen] = '\n';
653 break;
655 default:
656 abort ();
658 data->count++;
660 return 1;
663 /* Prepare to restore the state, by saving the currently-defined
664 macros in 'data'. */
666 void
667 cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
669 struct save_macro_data *d = XNEW (struct save_macro_data);
671 d->array_size = 512;
672 d->defns = XNEWVEC (uchar *, d->array_size);
673 d->count = 0;
674 cpp_forall_identifiers (r, save_macros, d);
675 d->saved_pragmas = _cpp_save_pragma_names (r);
676 *data = d;
679 /* Given a precompiled header that was previously determined to be valid,
680 apply all its definitions (and undefinitions) to the current state.
681 DEPNAME is passed to deps_restore. */
684 cpp_read_state (cpp_reader *r, const char *name, FILE *f,
685 struct save_macro_data *data)
687 size_t i;
688 struct lexer_state old_state;
689 unsigned int counter;
691 /* Restore spec_nodes, which will be full of references to the old
692 hashtable entries and so will now be invalid. */
694 struct spec_nodes *s = &r->spec_nodes;
695 s->n_defined = cpp_lookup (r, DSC("defined"));
696 s->n_true = cpp_lookup (r, DSC("true"));
697 s->n_false = cpp_lookup (r, DSC("false"));
698 s->n__VA_ARGS__ = cpp_lookup (r, DSC("__VA_ARGS__"));
701 old_state = r->state;
702 r->state.in_directive = 1;
703 r->state.prevent_expansion = 1;
704 r->state.angled_headers = 0;
706 /* Run through the carefully-saved macros, insert them. */
707 for (i = 0; i < data->count; i++)
709 cpp_hashnode *h;
710 size_t namelen;
711 uchar *defn;
713 namelen = ustrcspn (data->defns[i], "( \n");
714 h = cpp_lookup (r, data->defns[i], namelen);
715 defn = data->defns[i] + namelen;
717 /* The PCH file is valid, so we know that if there is a definition
718 from the PCH file it must be the same as the one we had
719 originally, and so do not need to restore it. */
720 if (h->type == NT_VOID)
722 if (cpp_push_buffer (r, defn, ustrchr (defn, '\n') - defn, true)
723 != NULL)
725 _cpp_clean_line (r);
726 if (!_cpp_create_definition (r, h))
727 abort ();
728 _cpp_pop_buffer (r);
730 else
731 abort ();
734 free (data->defns[i]);
736 r->state = old_state;
738 _cpp_restore_pragma_names (r, data->saved_pragmas);
740 free (data);
742 if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
743 != 0)
744 goto error;
746 if (! _cpp_read_file_entries (r, f))
747 goto error;
749 if (fread (&counter, sizeof (counter), 1, f) != 1)
750 goto error;
752 if (!r->counter)
753 r->counter = counter;
755 return 0;
757 error:
758 cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
759 return -1;