OSDN Git Service

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