* gcc.target/i386/pr23376: Compile with -mmmx.
[official-gcc.git] / libcpp / pch.c
blobcc23b4ee908771957adf24c2d9101eab7acf32ff
1 /* Part of CPP library. (Precompiled header reading/writing.)
2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005
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 2, 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; if not, write to the Free Software
17 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
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;
340 return 0;
343 /* Write out the definitions of the preprocessor, in a form suitable for
344 cpp_read_state. */
347 cpp_write_pch_state (cpp_reader *r, FILE *f)
349 if (!r->deps)
350 r->deps = deps_init ();
352 if (deps_save (r->deps, f) != 0)
354 cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
355 return -1;
358 if (! _cpp_save_file_entries (r, f))
360 cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
361 return -1;
364 return 0;
368 /* Data structure to transform hash table nodes into a sorted list */
370 struct ht_node_list
372 /* Array of nodes */
373 cpp_hashnode **defs;
374 /* Number of nodes in the array */
375 size_t n_defs;
376 /* Size of the allocated array */
377 size_t asize;
380 /* Callback for collecting identifiers from hash table */
382 static int
383 collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn,
384 void *nl_p)
386 struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
388 if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
390 if (nl->n_defs == nl->asize)
392 nl->asize *= 2;
393 nl->defs = XRESIZEVEC (cpp_hashnode *, nl->defs, nl->asize);
396 nl->defs[nl->n_defs] = hn;
397 ++nl->n_defs;
399 return 1;
403 /* Return nonzero if FD is a precompiled header which is consistent
404 with the preprocessor's current definitions. It will be consistent
405 when:
407 - anything that was defined just before the PCH was generated
408 is defined the same way now; and
409 - anything that was not defined then, but is defined now, was not
410 used by the PCH.
412 NAME is used to print warnings if `warn_invalid_pch' is set in the
413 reader's flags.
417 cpp_valid_state (cpp_reader *r, const char *name, int fd)
419 struct macrodef_struct m;
420 size_t namebufsz = 256;
421 unsigned char *namebuf = XNEWVEC (unsigned char, namebufsz);
422 unsigned char *undeftab = NULL;
423 struct ht_node_list nl = { 0, 0, 0 };
424 unsigned char *first, *last;
425 unsigned int i;
427 /* Read in the list of identifiers that must be defined
428 Check that they are defined in the same way. */
429 for (;;)
431 cpp_hashnode *h;
432 const unsigned char *newdefn;
434 if (read (fd, &m, sizeof (m)) != sizeof (m))
435 goto error;
437 if (m.name_length == 0)
438 break;
440 /* If this file is already preprocessed, there won't be any
441 macros defined, and that's OK. */
442 if (CPP_OPTION (r, preprocessed))
444 if (lseek (fd, m.definition_length, SEEK_CUR) == -1)
445 goto error;
446 continue;
449 if (m.definition_length > namebufsz)
451 free (namebuf);
452 namebufsz = m.definition_length + 256;
453 namebuf = XNEWVEC (unsigned char, namebufsz);
456 if ((size_t)read (fd, namebuf, m.definition_length)
457 != m.definition_length)
458 goto error;
460 h = cpp_lookup (r, namebuf, m.name_length);
461 if (m.flags & NODE_POISONED
462 || h->type != NT_MACRO
463 || h->flags & NODE_POISONED)
465 if (CPP_OPTION (r, warn_invalid_pch))
466 cpp_error (r, CPP_DL_WARNING_SYSHDR,
467 "%s: not used because `%.*s' not defined",
468 name, m.name_length, namebuf);
469 goto fail;
472 newdefn = cpp_macro_definition (r, h);
474 if (m.definition_length != ustrlen (newdefn)
475 || memcmp (namebuf, newdefn, m.definition_length) != 0)
477 if (CPP_OPTION (r, warn_invalid_pch))
478 cpp_error (r, CPP_DL_WARNING_SYSHDR,
479 "%s: not used because `%.*s' defined as `%s' not `%.*s'",
480 name, m.name_length, namebuf, newdefn + m.name_length,
481 m.definition_length - m.name_length,
482 namebuf + m.name_length);
483 goto fail;
486 free (namebuf);
487 namebuf = NULL;
489 /* Read in the list of identifiers that must not be defined.
490 Check that they really aren't. */
491 undeftab = XNEWVEC (unsigned char, m.definition_length);
492 if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
493 goto error;
495 /* Collect identifiers from the current hash table. */
496 nl.n_defs = 0;
497 nl.asize = 10;
498 nl.defs = XNEWVEC (cpp_hashnode *, nl.asize);
499 cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
500 qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
502 /* Loop through nl.defs and undeftab, both of which are sorted lists.
503 There should be no matches. */
504 first = undeftab;
505 last = undeftab + m.definition_length;
506 i = 0;
508 while (first < last && i < nl.n_defs)
510 int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
512 if (cmp < 0)
513 first += ustrlen (first) + 1;
514 else if (cmp > 0)
515 ++i;
516 else
518 if (CPP_OPTION (r, warn_invalid_pch))
519 cpp_error (r, CPP_DL_WARNING_SYSHDR,
520 "%s: not used because `%s' is defined",
521 name, first);
522 goto fail;
526 free(nl.defs);
527 free (undeftab);
529 /* We win! */
530 return 0;
532 error:
533 cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
534 return -1;
536 fail:
537 if (namebuf != NULL)
538 free (namebuf);
539 if (undeftab != NULL)
540 free (undeftab);
541 if (nl.defs != NULL)
542 free (nl.defs);
543 return 1;
546 /* Save all the existing macros. */
548 struct save_macro_data
550 uchar **defns;
551 size_t count;
552 size_t array_size;
553 char **saved_pragmas;
556 /* Save the definition of a single macro, so that it will persist
557 across a PCH restore. Because macro data is in GCed memory, which
558 will be blown away by PCH, it must be temporarily copied to
559 malloced memory. (The macros will refer to identifier nodes which
560 are also GCed and so on, so the copying is done by turning them
561 into self-contained strings.) The assumption is that most macro
562 definitions will come from the PCH file, not from the compilation
563 before the PCH file is loaded, so it doesn't matter that this is
564 a little expensive.
566 It would reduce the cost even further if macros defined in the PCH
567 file were not saved in this way, but this is not done (yet), except
568 for builtins, and for #assert by default. */
570 static int
571 save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p)
573 struct save_macro_data *data = (struct save_macro_data *)data_p;
574 if (h->type != NT_VOID
575 && (h->flags & NODE_BUILTIN) == 0)
577 if (data->count == data->array_size)
579 data->array_size *= 2;
580 data->defns = XRESIZEVEC (uchar *, data->defns, (data->array_size));
583 switch (h->type)
585 case NT_ASSERTION:
586 /* Not currently implemented. */
587 return 1;
589 case NT_MACRO:
591 const uchar * defn = cpp_macro_definition (r, h);
592 size_t defnlen = ustrlen (defn);
594 data->defns[data->count] = (uchar *) xmemdup (defn, defnlen,
595 defnlen + 2);
596 data->defns[data->count][defnlen] = '\n';
598 break;
600 default:
601 abort ();
603 data->count++;
605 return 1;
608 /* Prepare to restore the state, by saving the currently-defined
609 macros in 'data'. */
611 void
612 cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
614 struct save_macro_data *d = XNEW (struct save_macro_data);
616 d->array_size = 512;
617 d->defns = XNEWVEC (uchar *, d->array_size);
618 d->count = 0;
619 cpp_forall_identifiers (r, save_macros, d);
620 d->saved_pragmas = _cpp_save_pragma_names (r);
621 *data = d;
624 /* Given a precompiled header that was previously determined to be valid,
625 apply all its definitions (and undefinitions) to the current state.
626 DEPNAME is passed to deps_restore. */
629 cpp_read_state (cpp_reader *r, const char *name, FILE *f,
630 struct save_macro_data *data)
632 size_t i;
633 struct lexer_state old_state;
635 /* Restore spec_nodes, which will be full of references to the old
636 hashtable entries and so will now be invalid. */
638 struct spec_nodes *s = &r->spec_nodes;
639 s->n_defined = cpp_lookup (r, DSC("defined"));
640 s->n_true = cpp_lookup (r, DSC("true"));
641 s->n_false = cpp_lookup (r, DSC("false"));
642 s->n__VA_ARGS__ = cpp_lookup (r, DSC("__VA_ARGS__"));
645 old_state = r->state;
646 r->state.in_directive = 1;
647 r->state.prevent_expansion = 1;
648 r->state.angled_headers = 0;
650 /* Run through the carefully-saved macros, insert them. */
651 for (i = 0; i < data->count; i++)
653 cpp_hashnode *h;
654 size_t namelen;
655 uchar *defn;
657 namelen = ustrcspn (data->defns[i], "( \n");
658 h = cpp_lookup (r, data->defns[i], namelen);
659 defn = data->defns[i] + namelen;
661 /* The PCH file is valid, so we know that if there is a definition
662 from the PCH file it must be the same as the one we had
663 originally, and so do not need to restore it. */
664 if (h->type == NT_VOID)
666 if (cpp_push_buffer (r, defn, ustrchr (defn, '\n') - defn, true)
667 != NULL)
669 _cpp_clean_line (r);
670 if (!_cpp_create_definition (r, h))
671 abort ();
672 _cpp_pop_buffer (r);
674 else
675 abort ();
678 free (data->defns[i]);
680 r->state = old_state;
682 _cpp_restore_pragma_names (r, data->saved_pragmas);
684 free (data);
686 if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
687 != 0)
688 goto error;
690 if (! _cpp_read_file_entries (r, f))
691 goto error;
693 return 0;
695 error:
696 cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
697 return -1;