1 /* Part of CPP library. (Precompiled header reading/writing.)
2 Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify it
5 under the terms of the GNU General Public License as published by the
6 Free Software Foundation; either version 2, or (at your option) any
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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;
45 /* This is how we write out a macro definition.
46 Suitable for being called by cpp_forall_identifiers. */
49 write_macdef (cpp_reader *pfile, cpp_hashnode *hn, void *file_p)
51 FILE *f = (FILE *) file_p;
55 if (! (hn->flags & NODE_POISONED))
59 if ((hn->flags & NODE_BUILTIN))
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);
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, DL_ERROR, "while writing precompiled header");
90 /* Not currently implemented. */
98 /* This structure records the names of the defined macros.
99 It's also used as a callback structure for size_initial_idents
102 struct cpp_savedstate
104 /* A hash table of the defined identifiers. */
106 /* The size of the definitions of those identifiers (the size of
109 /* Number of definitions */
111 /* Array of definitions. In cpp_write_pch_deps it is used for sorting. */
113 /* Space for the next definition. Definitions are null-terminated
115 unsigned char *definedstrs;
118 /* Save this identifier into the state: put it in the hash table,
119 put the definition in 'definedstrs'. */
122 save_idents (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
124 struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
126 if (hn->type != NT_VOID)
128 struct cpp_string news;
131 news.len = NODE_LEN (hn);
132 news.text= NODE_NAME (hn);
133 slot = htab_find_slot (ss->definedhash, &news, INSERT);
136 struct cpp_string *sp;
139 sp = xmalloc (sizeof (struct cpp_string));
142 sp->len = NODE_LEN (hn);
143 sp->text = text = xmalloc (NODE_LEN (hn));
144 memcpy (text, NODE_NAME (hn), NODE_LEN (hn));
151 /* Hash some memory in a generic way. */
154 hashmem (const void *p_p, size_t sz)
156 const unsigned char *p = (const unsigned char *)p_p;
161 for (i = 0; i < sz; i++)
162 h = h * 67 - (*p++ - 113);
166 /* Hash a cpp string for the hashtable machinery. */
169 cpp_string_hash (const void *a_p)
171 const struct cpp_string *a = (const struct cpp_string *) a_p;
172 return hashmem (a->text, a->len);
175 /* Compare two cpp strings for the hashtable machinery. */
178 cpp_string_eq (const void *a_p, const void *b_p)
180 const struct cpp_string *a = (const struct cpp_string *) a_p;
181 const struct cpp_string *b = (const struct cpp_string *) b_p;
182 return (a->len == b->len
183 && memcmp (a->text, b->text, a->len) == 0);
186 /* Save the current definitions of the cpp_reader for dependency
187 checking purposes. When writing a precompiled header, this should
188 be called at the same point in the compilation as cpp_valid_state
189 would be called when reading the precompiled header back in. */
192 cpp_save_state (cpp_reader *r, FILE *f)
194 /* Save the list of non-void identifiers for the dependency checking. */
195 r->savedstate = xmalloc (sizeof (struct cpp_savedstate));
196 r->savedstate->definedhash = htab_create (100, cpp_string_hash,
197 cpp_string_eq, NULL);
198 cpp_forall_identifiers (r, save_idents, r->savedstate);
200 /* Write out the list of defined identifiers. */
201 cpp_forall_identifiers (r, write_macdef, f);
206 /* Calculate the 'hashsize' field of the saved state. */
209 count_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
211 struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
216 if (hn->flags & NODE_BUILTIN)
219 /* else fall through. */
223 struct cpp_string news;
226 news.len = NODE_LEN (hn);
227 news.text = NODE_NAME (hn);
228 slot = htab_find (ss->definedhash, &news);
231 ss->hashsize += NODE_LEN (hn) + 1;
238 /* Not currently implemented. */
246 /* Collect the identifiers into the state's string table. */
248 write_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
250 struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
255 if (hn->flags & NODE_BUILTIN)
258 /* else fall through. */
262 struct cpp_string news;
265 news.len = NODE_LEN (hn);
266 news.text = NODE_NAME (hn);
267 slot = htab_find (ss->definedhash, &news);
270 ss->defs[ss->n_defs] = hn;
277 /* Not currently implemented. */
285 /* Comparison function for qsort. The arguments point to pointers of
286 type ht_hashnode *. */
288 comp_hashnodes (const void *px, const void *py)
290 cpp_hashnode *x = *(cpp_hashnode **) px;
291 cpp_hashnode *y = *(cpp_hashnode **) py;
292 return ustrcmp (NODE_NAME (x), NODE_NAME (y));
295 /* Write out the remainder of the dependency information. This should be
296 called after the PCH is ready to be saved. */
299 cpp_write_pch_deps (cpp_reader *r, FILE *f)
301 struct macrodef_struct z;
302 struct cpp_savedstate *const ss = r->savedstate;
303 unsigned char *definedstrs;
306 /* Collect the list of identifiers which have been seen and
307 weren't defined to anything previously. */
310 cpp_forall_identifiers (r, count_defs, ss);
312 ss->defs = xmalloc (ss->n_defs * sizeof (cpp_hashnode *));
314 cpp_forall_identifiers (r, write_defs, ss);
316 /* Sort the list, copy it into a buffer, and write it out. */
317 qsort (ss->defs, ss->n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
318 definedstrs = ss->definedstrs = xmalloc (ss->hashsize);
319 for (i = 0; i < ss->n_defs; ++i)
321 size_t len = NODE_LEN (ss->defs[i]);
322 memcpy (definedstrs, NODE_NAME (ss->defs[i]), len + 1);
323 definedstrs += len + 1;
326 memset (&z, 0, sizeof (z));
327 z.definition_length = ss->hashsize;
328 if (fwrite (&z, sizeof (z), 1, f) != 1
329 || fwrite (ss->definedstrs, ss->hashsize, 1, f) != 1)
331 cpp_errno (r, DL_ERROR, "while writing precompiled header");
334 free (ss->definedstrs);
336 /* Free the saved state. */
338 r->savedstate = NULL;
342 /* Write out the definitions of the preprocessor, in a form suitable for
346 cpp_write_pch_state (cpp_reader *r, FILE *f)
348 struct macrodef_struct z;
350 /* Write out the list of defined identifiers. */
351 cpp_forall_identifiers (r, write_macdef, f);
352 memset (&z, 0, sizeof (z));
353 if (fwrite (&z, sizeof (z), 1, f) != 1)
355 cpp_errno (r, DL_ERROR, "while writing precompiled header");
360 r->deps = deps_init ();
362 if (deps_save (r->deps, f) != 0)
364 cpp_errno (r, DL_ERROR, "while writing precompiled header");
372 /* Data structure to transform hash table nodes into a sorted list */
378 /* Number of nodes in the array */
380 /* Size of the allocated array */
384 /* Callback for collecting identifiers from hash table */
387 collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn,
390 struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
392 if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
394 if (nl->n_defs == nl->asize)
397 nl->defs = xrealloc (nl->defs, nl->asize * sizeof (cpp_hashnode *));
400 nl->defs[nl->n_defs] = hn;
407 /* Return nonzero if FD is a precompiled header which is consistent
408 with the preprocessor's current definitions. It will be consistent
411 - anything that was defined just before the PCH was generated
412 is defined the same way now; and
413 - anything that was not defined then, but is defined now, was not
416 NAME is used to print warnings if `warn_invalid_pch' is set in the
421 cpp_valid_state (cpp_reader *r, const char *name, int fd)
423 struct macrodef_struct m;
424 size_t namebufsz = 256;
425 unsigned char *namebuf = xmalloc (namebufsz);
426 unsigned char *undeftab = NULL;
427 struct ht_node_list nl = { 0, 0, 0 };
428 unsigned char *first, *last;
431 /* Read in the list of identifiers that must be defined
432 Check that they are defined in the same way. */
436 const unsigned char *newdefn;
438 if (read (fd, &m, sizeof (m)) != sizeof (m))
441 if (m.name_length == 0)
444 if (m.definition_length > namebufsz)
447 namebufsz = m.definition_length + 256;
448 namebuf = xmalloc (namebufsz);
451 if ((size_t)read (fd, namebuf, m.definition_length)
452 != m.definition_length)
455 h = cpp_lookup (r, namebuf, m.name_length);
456 if (m.flags & NODE_POISONED
457 || h->type != NT_MACRO
458 || h->flags & NODE_POISONED)
460 if (CPP_OPTION (r, warn_invalid_pch))
461 cpp_error (r, DL_WARNING_SYSHDR,
462 "%s: not used because `%.*s' not defined",
463 name, m.name_length, namebuf);
467 newdefn = cpp_macro_definition (r, h);
469 if (m.definition_length != ustrlen (newdefn)
470 || memcmp (namebuf, newdefn, m.definition_length) != 0)
472 if (CPP_OPTION (r, warn_invalid_pch))
473 cpp_error (r, DL_WARNING_SYSHDR,
474 "%s: not used because `%.*s' defined as `%s' not `%.*s'",
475 name, m.name_length, namebuf, newdefn + m.name_length,
476 m.definition_length - m.name_length,
477 namebuf + m.name_length);
484 /* Read in the list of identifiers that must not be defined.
485 Check that they really aren't. */
486 undeftab = xmalloc (m.definition_length);
487 if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
490 /* Collect identifiers from the current hash table. */
493 nl.defs = xmalloc (nl.asize * sizeof (cpp_hashnode *));
494 cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
495 qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
497 /* Loop through nl.defs and undeftab, both of which are sorted lists.
498 There should be no matches. */
500 last = undeftab + m.definition_length;
503 while (first < last && i < nl.n_defs)
505 int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
508 first += ustrlen (first) + 1;
513 if (CPP_OPTION (r, warn_invalid_pch))
514 cpp_error (r, DL_WARNING_SYSHDR,
515 "%s: not used because `%s' is defined",
528 cpp_errno (r, DL_ERROR, "while reading precompiled header");
534 if (undeftab != NULL)
541 /* Save all the existing macros and assertions.
542 This code assumes that there might be hundreds, but not thousands of
543 existing definitions. */
545 struct save_macro_item {
546 struct save_macro_item *next;
547 struct cpp_hashnode macs[64];
550 struct save_macro_data
552 struct save_macro_item *macros;
554 char **saved_pragmas;
557 /* Save the definition of a single macro, so that it will persist across
561 save_macros (cpp_reader *r ATTRIBUTE_UNUSED, cpp_hashnode *h, void *data_p)
563 struct save_macro_data *data = (struct save_macro_data *)data_p;
564 if (h->type != NT_VOID
565 && (h->flags & NODE_BUILTIN) == 0)
568 if (data->count == ARRAY_SIZE (data->macros->macs))
570 struct save_macro_item *d = data->macros;
571 data->macros = xmalloc (sizeof (struct save_macro_item));
572 data->macros->next = d;
575 save = data->macros->macs + data->count;
577 memcpy (save, h, sizeof (struct cpp_hashnode));
578 HT_STR (&save->ident) = xmemdup (HT_STR (HT_NODE (save)),
579 HT_LEN (HT_NODE (save)),
580 HT_LEN (HT_NODE (save)) + 1);
585 /* Prepare to restore the state, by saving the currently-defined
589 cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
591 struct save_macro_data *d = xmalloc (sizeof (struct save_macro_data));
594 d->count = ARRAY_SIZE (d->macros->macs);
595 cpp_forall_identifiers (r, save_macros, d);
596 d->saved_pragmas = _cpp_save_pragma_names (r);
600 /* Given a precompiled header that was previously determined to be valid,
601 apply all its definitions (and undefinitions) to the current state.
602 DEPNAME is passed to deps_restore. */
605 cpp_read_state (cpp_reader *r, const char *name, FILE *f,
606 struct save_macro_data *data)
608 struct macrodef_struct m;
609 size_t defnlen = 256;
610 unsigned char *defn = xmalloc (defnlen);
611 struct lexer_state old_state;
612 struct save_macro_item *d;
614 int saved_line = r->line;
616 /* Restore spec_nodes, which will be full of references to the old
617 hashtable entries and so will now be invalid. */
619 struct spec_nodes *s = &r->spec_nodes;
620 s->n_defined = cpp_lookup (r, DSC("defined"));
621 s->n_true = cpp_lookup (r, DSC("true"));
622 s->n_false = cpp_lookup (r, DSC("false"));
623 s->n__VA_ARGS__ = cpp_lookup (r, DSC("__VA_ARGS__"));
626 /* Run through the carefully-saved macros, insert them. */
628 mac_count = data->count;
631 struct save_macro_item *nextd;
632 for (i = 0; i < mac_count; i++)
636 h = cpp_lookup (r, HT_STR (HT_NODE (&d->macs[i])),
637 HT_LEN (HT_NODE (&d->macs[i])));
638 h->type = d->macs[i].type;
639 h->flags = d->macs[i].flags;
640 h->value = d->macs[i].value;
641 free ((void *)HT_STR (HT_NODE (&d->macs[i])));
646 mac_count = ARRAY_SIZE (d->macs);
649 _cpp_restore_pragma_names (r, data->saved_pragmas);
653 old_state = r->state;
655 r->state.in_directive = 1;
656 r->state.prevent_expansion = 1;
657 r->state.angled_headers = 0;
659 /* Read in the identifiers that must be defined. */
664 if (fread (&m, sizeof (m), 1, f) != 1)
667 if (m.name_length == 0)
670 if (defnlen < m.definition_length + 1)
672 defnlen = m.definition_length + 256;
673 defn = xrealloc (defn, defnlen);
676 if (fread (defn, 1, m.definition_length, f) != m.definition_length)
678 defn[m.definition_length] = '\n';
680 h = cpp_lookup (r, defn, m.name_length);
682 if (h->type == NT_MACRO)
683 _cpp_free_definition (h);
684 if (m.flags & NODE_POISONED)
685 h->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
686 else if (m.name_length != m.definition_length)
688 if (cpp_push_buffer (r, defn + m.name_length,
689 m.definition_length - m.name_length, true)
693 if (!_cpp_create_definition (r, h))
702 r->state = old_state;
703 r->line = saved_line;
707 if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
714 cpp_errno (r, DL_ERROR, "while reading precompiled header");