OSDN Git Service

include:
[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   if (!r->deps)
349     r->deps = deps_init ();
350
351   if (deps_save (r->deps, f) != 0)
352     {
353       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
354       return -1;
355     }
356
357   if (! _cpp_save_file_entries (r, f))
358     {
359       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
360       return -1;
361     }
362
363   return 0;
364 }
365
366
367 /* Data structure to transform hash table nodes into a sorted list */
368
369 struct ht_node_list
370 {
371   /* Array of nodes */
372   cpp_hashnode **defs;
373   /* Number of nodes in the array */
374   size_t n_defs;
375   /* Size of the allocated array */
376   size_t asize;
377 };
378
379 /* Callback for collecting identifiers from hash table */
380
381 static int
382 collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn,
383                   void *nl_p)
384 {
385   struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
386
387   if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
388     {
389       if (nl->n_defs == nl->asize)
390         {
391           nl->asize *= 2;
392           nl->defs = xrealloc (nl->defs, nl->asize * sizeof (cpp_hashnode *));
393         }
394
395       nl->defs[nl->n_defs] = hn;
396       ++nl->n_defs;
397     }
398   return 1;
399 }
400
401
402 /* Return nonzero if FD is a precompiled header which is consistent
403    with the preprocessor's current definitions.  It will be consistent
404    when:
405
406    - anything that was defined just before the PCH was generated 
407      is defined the same way now; and
408    - anything that was not defined then, but is defined now, was not
409      used by the PCH.
410
411    NAME is used to print warnings if `warn_invalid_pch' is set in the
412    reader's flags.
413 */
414
415 int
416 cpp_valid_state (cpp_reader *r, const char *name, int fd)
417 {
418   struct macrodef_struct m;
419   size_t namebufsz = 256;
420   unsigned char *namebuf = xmalloc (namebufsz);
421   unsigned char *undeftab = NULL;
422   struct ht_node_list nl = { 0, 0, 0 };
423   unsigned char *first, *last;
424   unsigned int i;
425   
426   /* Read in the list of identifiers that must be defined
427      Check that they are defined in the same way.  */
428   for (;;)
429     {
430       cpp_hashnode *h;
431       const unsigned char *newdefn;
432       
433       if (read (fd, &m, sizeof (m)) != sizeof (m))
434         goto error;
435       
436       if (m.name_length == 0)
437         break;
438
439       /* If this file is already preprocessed, there won't be any
440          macros defined, and that's OK.  */
441       if (CPP_OPTION (r, preprocessed))
442         {
443           if (lseek (fd, m.definition_length, SEEK_CUR) == -1)
444             goto error;
445           continue;
446         }
447
448       if (m.definition_length > namebufsz)
449         {
450           free (namebuf);
451           namebufsz = m.definition_length + 256;
452           namebuf = xmalloc (namebufsz);
453         }
454
455       if ((size_t)read (fd, namebuf, m.definition_length) 
456           != m.definition_length)
457         goto error;
458       
459       h = cpp_lookup (r, namebuf, m.name_length);
460       if (m.flags & NODE_POISONED
461           || h->type != NT_MACRO
462           || h->flags & NODE_POISONED)
463         {
464           if (CPP_OPTION (r, warn_invalid_pch))
465             cpp_error (r, CPP_DL_WARNING_SYSHDR,
466                        "%s: not used because `%.*s' not defined",
467                        name, m.name_length, namebuf);
468           goto fail;
469         }
470
471       newdefn = cpp_macro_definition (r, h);
472       
473       if (m.definition_length != ustrlen (newdefn)
474           || memcmp (namebuf, newdefn, m.definition_length) != 0)
475         {
476           if (CPP_OPTION (r, warn_invalid_pch))
477             cpp_error (r, CPP_DL_WARNING_SYSHDR,
478                "%s: not used because `%.*s' defined as `%s' not `%.*s'",
479                        name, m.name_length, namebuf, newdefn + m.name_length,
480                        m.definition_length - m.name_length,
481                        namebuf +  m.name_length);
482           goto fail;
483         }
484     }
485   free (namebuf);
486   namebuf = NULL;
487
488   /* Read in the list of identifiers that must not be defined.
489      Check that they really aren't.  */
490   undeftab = xmalloc (m.definition_length);
491   if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
492     goto error;
493
494   /* Collect identifiers from the current hash table.  */
495   nl.n_defs = 0;
496   nl.asize = 10;
497   nl.defs = xmalloc (nl.asize * sizeof (cpp_hashnode *));
498   cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
499   qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
500  
501   /* Loop through nl.defs and undeftab, both of which are sorted lists.
502      There should be no matches.  */
503   first = undeftab;
504   last = undeftab + m.definition_length;
505   i = 0;
506  
507   while (first < last && i < nl.n_defs)
508     {
509       int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
510  
511       if (cmp < 0)
512         first += ustrlen (first) + 1;
513       else if (cmp > 0)
514         ++i;
515       else
516         {
517           if (CPP_OPTION (r, warn_invalid_pch))
518             cpp_error (r, CPP_DL_WARNING_SYSHDR, 
519                        "%s: not used because `%s' is defined",
520                        name, first);
521           goto fail;
522         }
523     }
524    
525   free(nl.defs);
526   free (undeftab);
527
528   /* We win!  */
529   return 0;
530
531  error:
532   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
533   return -1;
534
535  fail:
536   if (namebuf != NULL)
537     free (namebuf);
538   if (undeftab != NULL)
539     free (undeftab);
540   if (nl.defs != NULL)
541     free (nl.defs);
542   return 1;
543 }
544
545 /* Save all the existing macros.  */
546
547 struct save_macro_data 
548 {
549   uchar **defns;
550   size_t count;
551   size_t array_size;
552   char **saved_pragmas;
553 };
554
555 /* Save the definition of a single macro, so that it will persist
556    across a PCH restore.  Because macro data is in GCed memory, which
557    will be blown away by PCH, it must be temporarily copied to
558    malloced memory.  (The macros will refer to identifier nodes which
559    are also GCed and so on, so the copying is done by turning them
560    into self-contained strings.)  The assumption is that most macro
561    definitions will come from the PCH file, not from the compilation
562    before the PCH file is loaded, so it doesn't matter that this is
563    a little expensive.
564
565    It would reduce the cost even further if macros defined in the PCH
566    file were not saved in this way, but this is not done (yet), except
567    for builtins, and for #assert by default.  */
568
569 static int 
570 save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p)
571 {
572   struct save_macro_data *data = (struct save_macro_data *)data_p;
573   if (h->type != NT_VOID
574       && (h->flags & NODE_BUILTIN) == 0)
575     {
576       if (data->count == data->array_size)
577         {
578           data->array_size *= 2;
579           data->defns = xrealloc (data->defns, (data->array_size 
580                                                 * sizeof (uchar *)));
581         }
582       
583       switch (h->type)
584         {
585         case NT_ASSERTION:
586           /* Not currently implemented.  */
587           return 1;
588
589         case NT_MACRO:
590           {
591             const uchar * defn = cpp_macro_definition (r, h);
592             size_t defnlen = ustrlen (defn);
593
594             data->defns[data->count] = xmemdup (defn, defnlen, defnlen + 2);
595             data->defns[data->count][defnlen] = '\n';
596           }
597           break;
598           
599         default:
600           abort ();
601         }
602       data->count++;
603     }
604   return 1;
605 }
606
607 /* Prepare to restore the state, by saving the currently-defined
608    macros in 'data'.  */
609
610 void
611 cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
612 {
613   struct save_macro_data *d = xmalloc (sizeof (struct save_macro_data));
614   
615   d->array_size = 512;
616   d->defns = xmalloc (d->array_size * sizeof (d->defns[0]));
617   d->count = 0;
618   cpp_forall_identifiers (r, save_macros, d);
619   d->saved_pragmas = _cpp_save_pragma_names (r);
620   *data = d;
621 }
622
623 /* Given a precompiled header that was previously determined to be valid,
624    apply all its definitions (and undefinitions) to the current state. 
625    DEPNAME is passed to deps_restore.  */
626
627 int
628 cpp_read_state (cpp_reader *r, const char *name, FILE *f,
629                 struct save_macro_data *data)
630 {
631   size_t i;
632   struct lexer_state old_state;
633
634   /* Restore spec_nodes, which will be full of references to the old 
635      hashtable entries and so will now be invalid.  */
636   {
637     struct spec_nodes *s = &r->spec_nodes;
638     s->n_defined        = cpp_lookup (r, DSC("defined"));
639     s->n_true           = cpp_lookup (r, DSC("true"));
640     s->n_false          = cpp_lookup (r, DSC("false"));
641     s->n__VA_ARGS__     = cpp_lookup (r, DSC("__VA_ARGS__"));
642   }
643
644   old_state = r->state;
645   r->state.in_directive = 1;
646   r->state.prevent_expansion = 1;
647   r->state.angled_headers = 0;
648
649   /* Run through the carefully-saved macros, insert them.  */
650   for (i = 0; i < data->count; i++)
651     {
652       cpp_hashnode *h;
653       size_t namelen;
654       uchar *defn;
655
656       namelen = ustrcspn (data->defns[i], "( \n");
657       h = cpp_lookup (r, data->defns[i], namelen);
658       defn = data->defns[i] + namelen;
659
660       /* The PCH file is valid, so we know that if there is a definition
661          from the PCH file it must be the same as the one we had
662          originally, and so do not need to restore it.  */
663       if (h->type == NT_VOID)
664         {
665           if (cpp_push_buffer (r, defn, ustrchr (defn, '\n') - defn, true)
666               != NULL)
667             {
668               _cpp_clean_line (r);
669               if (!_cpp_create_definition (r, h))
670                 abort ();
671               _cpp_pop_buffer (r);
672             }
673           else
674             abort ();
675         }
676
677       free (data->defns[i]);
678     }
679   r->state = old_state;
680
681   _cpp_restore_pragma_names (r, data->saved_pragmas);
682
683   free (data);
684
685   if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
686       != 0)
687     goto error;
688
689   if (! _cpp_read_file_entries (r, f))
690     goto error;
691
692   return 0;
693   
694  error:
695   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
696   return -1;
697 }