OSDN Git Service

51175a9a67b0ff594e3be911d27e03020390d09d
[pf3gnuchains/gcc-fork.git] / libcpp / pch.c
1 /* Part of CPP library.  (Precompiled header reading/writing.)
2    Copyright (C) 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
3
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
7 later version.
8
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.
13
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.  */
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
25 static int write_macdef (cpp_reader *, cpp_hashnode *, void *);
26 static int save_idents (cpp_reader *, cpp_hashnode *, void *);
27 static hashval_t hashmem (const void *, size_t);
28 static hashval_t cpp_string_hash (const void *);
29 static int cpp_string_eq (const void *, const void *);
30 static int count_defs (cpp_reader *, cpp_hashnode *, void *);
31 static int comp_hashnodes (const void *, const void *);
32 static int collect_ht_nodes (cpp_reader *, cpp_hashnode *, void *);
33 static int write_defs (cpp_reader *, cpp_hashnode *, void *);
34 static int save_macros (cpp_reader *, cpp_hashnode *, void *);
35
36 /* This structure represents a macro definition on disk.  */
37 struct macrodef_struct 
38 {
39   unsigned int definition_length;
40   unsigned short name_length;
41   unsigned short flags;
42 };
43
44 /* This is how we write out a macro definition.  
45    Suitable for being called by cpp_forall_identifiers.  */
46
47 static int
48 write_macdef (cpp_reader *pfile, cpp_hashnode *hn, void *file_p)
49 {
50   FILE *f = (FILE *) file_p;
51   switch (hn->type)
52     {
53     case NT_VOID:
54       if (! (hn->flags & NODE_POISONED))
55         return 1;
56       
57     case NT_MACRO:
58       if ((hn->flags & NODE_BUILTIN))
59         return 1;
60
61       {
62         struct macrodef_struct s;
63         const unsigned char *defn;
64
65         s.name_length = NODE_LEN (hn);
66         s.flags = hn->flags & NODE_POISONED;
67
68         if (hn->type == NT_MACRO)
69           {
70             defn = cpp_macro_definition (pfile, hn);
71             s.definition_length = ustrlen (defn);
72           }
73         else
74           {
75             defn = NODE_NAME (hn);
76             s.definition_length = s.name_length;
77           }
78         
79         if (fwrite (&s, sizeof (s), 1, f) != 1
80             || fwrite (defn, 1, s.definition_length, f) != s.definition_length)
81           {
82             cpp_errno (pfile, CPP_DL_ERROR,
83                        "while writing precompiled header");
84             return 0;
85           }
86       }
87       return 1;
88       
89     case NT_ASSERTION:
90       /* Not currently implemented.  */
91       return 1;
92
93     default:
94       abort ();
95     }
96 }
97
98 /* This structure records the names of the defined macros.
99    It's also used as a callback structure for size_initial_idents
100    and save_idents.  */
101
102 struct cpp_savedstate
103 {
104   /* A hash table of the defined identifiers.  */
105   htab_t definedhash;
106   /* The size of the definitions of those identifiers (the size of
107      'definedstrs').  */
108   size_t hashsize;
109   /* Number of definitions */
110   size_t n_defs;
111   /* Array of definitions.  In cpp_write_pch_deps it is used for sorting.  */
112   cpp_hashnode **defs;
113   /* Space for the next definition.  Definitions are null-terminated
114      strings.  */
115   unsigned char *definedstrs;
116 };
117
118 /* Save this identifier into the state: put it in the hash table,
119    put the definition in 'definedstrs'.  */
120
121 static int
122 save_idents (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
123 {
124   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
125   
126   if (hn->type != NT_VOID)
127     {
128       struct cpp_string news;
129       void **slot;
130
131       news.len = NODE_LEN (hn);
132       news.text= NODE_NAME (hn);
133       slot = htab_find_slot (ss->definedhash, &news, INSERT);
134       if (*slot == NULL)
135         {
136           struct cpp_string *sp;
137           unsigned char *text;
138           
139           sp = xmalloc (sizeof (struct cpp_string));
140           *slot = sp;
141
142           sp->len = NODE_LEN (hn);
143           sp->text = text = xmalloc (NODE_LEN (hn));
144           memcpy (text, NODE_NAME (hn), NODE_LEN (hn));
145         }
146     }
147
148   return 1;
149 }
150
151 /* Hash some memory in a generic way.  */
152
153 static hashval_t
154 hashmem (const void *p_p, size_t sz)
155 {
156   const unsigned char *p = (const unsigned char *)p_p;
157   size_t i;
158   hashval_t h;
159   
160   h = 0;
161   for (i = 0; i < sz; i++)
162     h = h * 67 - (*p++ - 113);
163   return h;
164 }
165
166 /* Hash a cpp string for the hashtable machinery.  */
167
168 static hashval_t
169 cpp_string_hash (const void *a_p)
170 {
171   const struct cpp_string *a = (const struct cpp_string *) a_p;
172   return hashmem (a->text, a->len);
173 }
174
175 /* Compare two cpp strings for the hashtable machinery.  */
176
177 static int
178 cpp_string_eq (const void *a_p, const void *b_p)
179 {
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);
184 }
185
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.  */
190
191 int
192 cpp_save_state (cpp_reader *r, FILE *f)
193 {
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);
199   
200   /* Write out the list of defined identifiers.  */
201   cpp_forall_identifiers (r, write_macdef, f);
202
203   return 0;
204 }
205
206 /* Calculate the 'hashsize' field of the saved state.  */
207
208 static int
209 count_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
210 {
211   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
212   
213   switch (hn->type)
214     {
215     case NT_MACRO:
216       if (hn->flags & NODE_BUILTIN)
217         return 1;
218       
219       /* else fall through.  */
220
221     case NT_VOID:
222       {
223         struct cpp_string news;
224         void **slot;
225         
226         news.len = NODE_LEN (hn);
227         news.text = NODE_NAME (hn);
228         slot = htab_find (ss->definedhash, &news);
229         if (slot == NULL)
230           {
231             ss->hashsize += NODE_LEN (hn) + 1;
232             ss->n_defs += 1;
233           }
234       }
235       return 1;
236
237     case NT_ASSERTION:
238       /* Not currently implemented.  */
239       return 1;
240
241     default:
242       abort ();
243     }
244 }
245
246 /* Collect the identifiers into the state's string table.  */
247 static int
248 write_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
249 {
250   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
251   
252   switch (hn->type)
253     {
254     case NT_MACRO:
255       if (hn->flags & NODE_BUILTIN)
256         return 1;
257       
258       /* else fall through.  */
259
260     case NT_VOID:
261       {
262         struct cpp_string news;
263         void **slot;
264         
265         news.len = NODE_LEN (hn);
266         news.text = NODE_NAME (hn);
267         slot = htab_find (ss->definedhash, &news);
268         if (slot == NULL)
269           {
270             ss->defs[ss->n_defs] = hn;
271             ss->n_defs += 1;
272           }
273       }
274       return 1;
275
276     case NT_ASSERTION:
277       /* Not currently implemented.  */
278       return 1;
279
280     default:
281       abort ();
282     }
283 }
284
285 /* Comparison function for qsort.  The arguments point to pointers of
286    type ht_hashnode *.  */
287 static int
288 comp_hashnodes (const void *px, const void *py)
289 {
290   cpp_hashnode *x = *(cpp_hashnode **) px;
291   cpp_hashnode *y = *(cpp_hashnode **) py;
292   return ustrcmp (NODE_NAME (x), NODE_NAME (y));
293 }
294
295 /* Write out the remainder of the dependency information.  This should be
296    called after the PCH is ready to be saved.  */
297
298 int
299 cpp_write_pch_deps (cpp_reader *r, FILE *f)
300 {
301   struct macrodef_struct z;
302   struct cpp_savedstate *const ss = r->savedstate;
303   unsigned char *definedstrs;
304   size_t i;
305   
306   /* Collect the list of identifiers which have been seen and
307      weren't defined to anything previously.  */
308   ss->hashsize = 0;
309   ss->n_defs = 0;
310   cpp_forall_identifiers (r, count_defs, ss);
311
312   ss->defs = xmalloc (ss->n_defs * sizeof (cpp_hashnode *));
313   ss->n_defs = 0;
314   cpp_forall_identifiers (r, write_defs, ss);
315
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)
320     {
321       size_t len = NODE_LEN (ss->defs[i]);
322       memcpy (definedstrs, NODE_NAME (ss->defs[i]), len + 1);
323       definedstrs += len + 1;
324     }
325
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)
330     {
331       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
332       return -1;
333     }
334   free (ss->definedstrs);
335
336   /* Free the saved state.  */
337   free (ss);
338   r->savedstate = NULL;
339   return 0;
340 }
341
342 /* Write out the definitions of the preprocessor, in a form suitable for
343    cpp_read_state.  */
344
345 int
346 cpp_write_pch_state (cpp_reader *r, FILE *f)
347 {
348   struct macrodef_struct z;
349
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)
354     {
355       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
356       return -1;
357     }
358
359   if (!r->deps)
360     r->deps = deps_init ();
361
362   if (deps_save (r->deps, f) != 0)
363     {
364       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
365       return -1;
366     }
367
368   if (! _cpp_save_file_entries (r, f))
369     {
370       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
371       return -1;
372     }
373
374   return 0;
375 }
376
377
378 /* Data structure to transform hash table nodes into a sorted list */
379
380 struct ht_node_list
381 {
382   /* Array of nodes */
383   cpp_hashnode **defs;
384   /* Number of nodes in the array */
385   size_t n_defs;
386   /* Size of the allocated array */
387   size_t asize;
388 };
389
390 /* Callback for collecting identifiers from hash table */
391
392 static int
393 collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn,
394                   void *nl_p)
395 {
396   struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
397
398   if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
399     {
400       if (nl->n_defs == nl->asize)
401         {
402           nl->asize *= 2;
403           nl->defs = xrealloc (nl->defs, nl->asize * sizeof (cpp_hashnode *));
404         }
405
406       nl->defs[nl->n_defs] = hn;
407       ++nl->n_defs;
408     }
409   return 1;
410 }
411
412
413 /* Return nonzero if FD is a precompiled header which is consistent
414    with the preprocessor's current definitions.  It will be consistent
415    when:
416
417    - anything that was defined just before the PCH was generated 
418      is defined the same way now; and
419    - anything that was not defined then, but is defined now, was not
420      used by the PCH.
421
422    NAME is used to print warnings if `warn_invalid_pch' is set in the
423    reader's flags.
424 */
425
426 int
427 cpp_valid_state (cpp_reader *r, const char *name, int fd)
428 {
429   struct macrodef_struct m;
430   size_t namebufsz = 256;
431   unsigned char *namebuf = xmalloc (namebufsz);
432   unsigned char *undeftab = NULL;
433   struct ht_node_list nl = { 0, 0, 0 };
434   unsigned char *first, *last;
435   unsigned int i;
436   
437   /* Read in the list of identifiers that must be defined
438      Check that they are defined in the same way.  */
439   for (;;)
440     {
441       cpp_hashnode *h;
442       const unsigned char *newdefn;
443       
444       if (read (fd, &m, sizeof (m)) != sizeof (m))
445         goto error;
446       
447       if (m.name_length == 0)
448         break;
449
450       if (m.definition_length > namebufsz)
451         {
452           free (namebuf);
453           namebufsz = m.definition_length + 256;
454           namebuf = xmalloc (namebufsz);
455         }
456       
457       if ((size_t)read (fd, namebuf, m.definition_length) 
458           != m.definition_length)
459         goto error;
460       
461       h = cpp_lookup (r, namebuf, m.name_length);
462       if (m.flags & NODE_POISONED
463           || h->type != NT_MACRO
464           || h->flags & NODE_POISONED)
465         {
466           if (CPP_OPTION (r, warn_invalid_pch))
467             cpp_error (r, CPP_DL_WARNING_SYSHDR,
468                        "%s: not used because `%.*s' not defined",
469                        name, m.name_length, namebuf);
470           goto fail;
471         }
472
473       newdefn = cpp_macro_definition (r, h);
474       
475       if (m.definition_length != ustrlen (newdefn)
476           || memcmp (namebuf, newdefn, m.definition_length) != 0)
477         {
478           if (CPP_OPTION (r, warn_invalid_pch))
479             cpp_error (r, CPP_DL_WARNING_SYSHDR,
480                "%s: not used because `%.*s' defined as `%s' not `%.*s'",
481                        name, m.name_length, namebuf, newdefn + m.name_length,
482                        m.definition_length - m.name_length,
483                        namebuf +  m.name_length);
484           goto fail;
485         }
486     }
487   free (namebuf);
488   namebuf = NULL;
489
490   /* Read in the list of identifiers that must not be defined.
491      Check that they really aren't.  */
492   undeftab = xmalloc (m.definition_length);
493   if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
494     goto error;
495
496   /* Collect identifiers from the current hash table.  */
497   nl.n_defs = 0;
498   nl.asize = 10;
499   nl.defs = xmalloc (nl.asize * sizeof (cpp_hashnode *));
500   cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
501   qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
502  
503   /* Loop through nl.defs and undeftab, both of which are sorted lists.
504      There should be no matches.  */
505   first = undeftab;
506   last = undeftab + m.definition_length;
507   i = 0;
508  
509   while (first < last && i < nl.n_defs)
510     {
511       int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
512  
513       if (cmp < 0)
514         first += ustrlen (first) + 1;
515       else if (cmp > 0)
516         ++i;
517       else
518         {
519           if (CPP_OPTION (r, warn_invalid_pch))
520             cpp_error (r, CPP_DL_WARNING_SYSHDR, 
521                        "%s: not used because `%s' is defined",
522                        name, first);
523           goto fail;
524         }
525     }
526    
527   free(nl.defs);
528   free (undeftab);
529
530   /* We win!  */
531   return 0;
532
533  error:
534   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
535   return -1;
536
537  fail:
538   if (namebuf != NULL)
539     free (namebuf);
540   if (undeftab != NULL)
541     free (undeftab);
542   if (nl.defs != NULL)
543     free (nl.defs);
544   return 1;
545 }
546
547 /* Save all the existing macros and assertions.  
548    This code assumes that there might be hundreds, but not thousands of
549    existing definitions.  */
550
551 struct save_macro_item {
552   struct save_macro_item *next;
553   struct cpp_hashnode macs[64];
554 };
555
556 struct save_macro_data 
557 {
558   struct save_macro_item *macros;
559   size_t count;
560   char **saved_pragmas;
561 };
562
563 /* Save the definition of a single macro, so that it will persist across
564    a PCH restore.  */
565
566 static int 
567 save_macros (cpp_reader *r ATTRIBUTE_UNUSED, cpp_hashnode *h, void *data_p)
568 {
569   struct save_macro_data *data = (struct save_macro_data *)data_p;
570   if (h->type != NT_VOID
571       && (h->flags & NODE_BUILTIN) == 0)
572     {
573       cpp_hashnode *save;
574       if (data->count == ARRAY_SIZE (data->macros->macs))
575         {
576           struct save_macro_item *d = data->macros;
577           data->macros = xmalloc (sizeof (struct save_macro_item));
578           data->macros->next = d;
579           data->count = 0;
580         }
581       save = data->macros->macs + data->count;
582       data->count++;
583       memcpy (save, h, sizeof (struct cpp_hashnode));
584       HT_STR (&save->ident) = xmemdup (HT_STR (HT_NODE (save)),
585                                        HT_LEN (HT_NODE (save)),
586                                        HT_LEN (HT_NODE (save)) + 1);
587     }
588   return 1;
589 }
590
591 /* Prepare to restore the state, by saving the currently-defined
592    macros in 'data'.  */
593
594 void
595 cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
596 {
597   struct save_macro_data *d = xmalloc (sizeof (struct save_macro_data));
598   
599   d->macros = NULL;
600   d->count = ARRAY_SIZE (d->macros->macs);
601   cpp_forall_identifiers (r, save_macros, d);
602   d->saved_pragmas = _cpp_save_pragma_names (r);
603   *data = d;
604 }
605
606 /* Given a precompiled header that was previously determined to be valid,
607    apply all its definitions (and undefinitions) to the current state. 
608    DEPNAME is passed to deps_restore.  */
609
610 int
611 cpp_read_state (cpp_reader *r, const char *name, FILE *f,
612                 struct save_macro_data *data)
613 {
614   struct macrodef_struct m;
615   size_t defnlen = 256;
616   unsigned char *defn = xmalloc (defnlen);
617   struct lexer_state old_state;
618   struct save_macro_item *d;
619   size_t i, mac_count;
620
621   /* Restore spec_nodes, which will be full of references to the old 
622      hashtable entries and so will now be invalid.  */
623   {
624     struct spec_nodes *s = &r->spec_nodes;
625     s->n_defined        = cpp_lookup (r, DSC("defined"));
626     s->n_true           = cpp_lookup (r, DSC("true"));
627     s->n_false          = cpp_lookup (r, DSC("false"));
628     s->n__VA_ARGS__     = cpp_lookup (r, DSC("__VA_ARGS__"));
629   }
630
631   /* Run through the carefully-saved macros, insert them.  */
632   d = data->macros;
633   mac_count = data->count;
634   while (d)
635     {
636       struct save_macro_item *nextd;
637       for (i = 0; i < mac_count; i++)
638         {
639           cpp_hashnode *h;
640           
641           h = cpp_lookup (r, HT_STR (HT_NODE (&d->macs[i])), 
642                           HT_LEN (HT_NODE (&d->macs[i])));
643           h->type = d->macs[i].type;
644           h->flags = d->macs[i].flags;
645           h->value = d->macs[i].value;
646           free ((void *)HT_STR (HT_NODE (&d->macs[i])));
647         }
648       nextd = d->next;
649       free (d);
650       d = nextd;
651       mac_count = ARRAY_SIZE (d->macs);
652     }
653
654   _cpp_restore_pragma_names (r, data->saved_pragmas);
655
656   free (data);
657
658   old_state = r->state;
659
660   r->state.in_directive = 1;
661   r->state.prevent_expansion = 1;
662   r->state.angled_headers = 0;
663
664   /* Read in the identifiers that must be defined.  */
665   for (;;)
666     {
667       cpp_hashnode *h;
668       
669       if (fread (&m, sizeof (m), 1, f) != 1)
670         goto error;
671       
672       if (m.name_length == 0)
673         break;
674
675       if (defnlen < m.definition_length + 1)
676         {
677           defnlen = m.definition_length + 256;
678           defn = xrealloc (defn, defnlen);
679         }
680
681       if (fread (defn, 1, m.definition_length, f) != m.definition_length)
682         goto error;
683       defn[m.definition_length] = '\n';
684       
685       h = cpp_lookup (r, defn, m.name_length);
686
687       if (h->type == NT_MACRO)
688         _cpp_free_definition (h);
689       if (m.flags & NODE_POISONED)
690         h->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
691       else if (m.name_length != m.definition_length)
692         {
693           if (cpp_push_buffer (r, defn + m.name_length, 
694                                m.definition_length - m.name_length, true)
695               != NULL)
696             {
697               _cpp_clean_line (r);
698               if (!_cpp_create_definition (r, h))
699                 abort ();
700               _cpp_pop_buffer (r);
701             }
702           else
703             abort ();
704         }
705     }
706
707   r->state = old_state;
708   free (defn);
709   defn = NULL;
710
711   if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
712       != 0)
713     goto error;
714
715   if (! _cpp_read_file_entries (r, f))
716     goto error;
717
718   return 0;
719   
720  error:
721   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
722   return -1;
723 }