OSDN Git Service

PR driver/40144
[pf3gnuchains/gcc-fork.git] / libcpp / pch.c
1 /* Part of CPP library.  (Precompiled header reading/writing.)
2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009
3    Free Software Foundation, Inc.
4
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 3, or (at your option) any
8 later version.
9
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.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; see the file COPYING3.  If not see
17 <http://www.gnu.org/licenses/>.  */
18
19 #include "config.h"
20 #include "system.h"
21 #include "cpplib.h"
22 #include "internal.h"
23 #include "hashtab.h"
24 #include "mkdeps.h"
25
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 *);
36
37 /* This structure represents a macro definition on disk.  */
38 struct macrodef_struct
39 {
40   unsigned int definition_length;
41   unsigned short name_length;
42   unsigned short flags;
43 };
44
45 /* This is how we write out a macro definition.
46    Suitable for being called by cpp_forall_identifiers.  */
47
48 static int
49 write_macdef (cpp_reader *pfile, cpp_hashnode *hn, void *file_p)
50 {
51   FILE *f = (FILE *) file_p;
52   switch (hn->type)
53     {
54     case NT_VOID:
55       if (! (hn->flags & NODE_POISONED))
56         return 1;
57
58     case NT_MACRO:
59       if ((hn->flags & NODE_BUILTIN))
60         return 1;
61
62       {
63         struct macrodef_struct s;
64         const unsigned char *defn;
65
66         s.name_length = NODE_LEN (hn);
67         s.flags = hn->flags & NODE_POISONED;
68
69         if (hn->type == NT_MACRO)
70           {
71             defn = cpp_macro_definition (pfile, hn);
72             s.definition_length = ustrlen (defn);
73           }
74         else
75           {
76             defn = NODE_NAME (hn);
77             s.definition_length = s.name_length;
78           }
79
80         if (fwrite (&s, sizeof (s), 1, f) != 1
81             || fwrite (defn, 1, s.definition_length, f) != s.definition_length)
82           {
83             cpp_errno (pfile, CPP_DL_ERROR,
84                        "while writing precompiled header");
85             return 0;
86           }
87       }
88       return 1;
89
90     case NT_ASSERTION:
91       /* Not currently implemented.  */
92       return 1;
93
94     default:
95       abort ();
96     }
97 }
98
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.  */
102
103 struct cpp_savedstate
104 {
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;
117 };
118
119 /* Save this identifier into the state: put it in the hash table,
120    put the definition in 'definedstrs'.  */
121
122 static int
123 save_idents (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
124 {
125   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
126
127   if (hn->type != NT_VOID)
128     {
129       struct cpp_string news;
130       void **slot;
131
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)
136         {
137           struct cpp_string *sp;
138           unsigned char *text;
139
140           sp = XNEW (struct cpp_string);
141           *slot = sp;
142
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));
146         }
147     }
148
149   return 1;
150 }
151
152 /* Hash some memory in a generic way.  */
153
154 static hashval_t
155 hashmem (const void *p_p, size_t sz)
156 {
157   const unsigned char *p = (const unsigned char *)p_p;
158   size_t i;
159   hashval_t h;
160
161   h = 0;
162   for (i = 0; i < sz; i++)
163     h = h * 67 - (*p++ - 113);
164   return h;
165 }
166
167 /* Hash a cpp string for the hashtable machinery.  */
168
169 static hashval_t
170 cpp_string_hash (const void *a_p)
171 {
172   const struct cpp_string *a = (const struct cpp_string *) a_p;
173   return hashmem (a->text, a->len);
174 }
175
176 /* Compare two cpp strings for the hashtable machinery.  */
177
178 static int
179 cpp_string_eq (const void *a_p, const void *b_p)
180 {
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);
185 }
186
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.  */
191
192 int
193 cpp_save_state (cpp_reader *r, FILE *f)
194 {
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);
200
201   /* Write out the list of defined identifiers.  */
202   cpp_forall_identifiers (r, write_macdef, f);
203
204   return 0;
205 }
206
207 /* Calculate the 'hashsize' field of the saved state.  */
208
209 static int
210 count_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
211 {
212   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
213
214   switch (hn->type)
215     {
216     case NT_MACRO:
217       if (hn->flags & NODE_BUILTIN)
218         return 1;
219
220       /* else fall through.  */
221
222     case NT_VOID:
223       {
224         struct cpp_string news;
225         void **slot;
226
227         news.len = NODE_LEN (hn);
228         news.text = NODE_NAME (hn);
229         slot = (void **) htab_find (ss->definedhash, &news);
230         if (slot == NULL)
231           {
232             ss->hashsize += NODE_LEN (hn) + 1;
233             ss->n_defs += 1;
234           }
235       }
236       return 1;
237
238     case NT_ASSERTION:
239       /* Not currently implemented.  */
240       return 1;
241
242     default:
243       abort ();
244     }
245 }
246
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)
250 {
251   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
252
253   switch (hn->type)
254     {
255     case NT_MACRO:
256       if (hn->flags & NODE_BUILTIN)
257         return 1;
258
259       /* else fall through.  */
260
261     case NT_VOID:
262       {
263         struct cpp_string news;
264         void **slot;
265
266         news.len = NODE_LEN (hn);
267         news.text = NODE_NAME (hn);
268         slot = (void **) htab_find (ss->definedhash, &news);
269         if (slot == NULL)
270           {
271             ss->defs[ss->n_defs] = hn;
272             ss->n_defs += 1;
273           }
274       }
275       return 1;
276
277     case NT_ASSERTION:
278       /* Not currently implemented.  */
279       return 1;
280
281     default:
282       abort ();
283     }
284 }
285
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)
290 {
291   cpp_hashnode *x = *(cpp_hashnode **) px;
292   cpp_hashnode *y = *(cpp_hashnode **) py;
293   return ustrcmp (NODE_NAME (x), NODE_NAME (y));
294 }
295
296 /* Write out the remainder of the dependency information.  This should be
297    called after the PCH is ready to be saved.  */
298
299 int
300 cpp_write_pch_deps (cpp_reader *r, FILE *f)
301 {
302   struct macrodef_struct z;
303   struct cpp_savedstate *const ss = r->savedstate;
304   unsigned char *definedstrs;
305   size_t i;
306
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);
312
313   ss->defs = XNEWVEC (cpp_hashnode *, ss->n_defs);
314   ss->n_defs = 0;
315   cpp_forall_identifiers (r, write_defs, ss);
316
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)
321     {
322       size_t len = NODE_LEN (ss->defs[i]);
323       memcpy (definedstrs, NODE_NAME (ss->defs[i]), len + 1);
324       definedstrs += len + 1;
325     }
326
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)
331     {
332       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
333       return -1;
334     }
335   free (ss->definedstrs);
336
337   /* Free the saved state.  */
338   free (ss);
339   r->savedstate = NULL;
340
341   /* Save the next value of __COUNTER__. */
342   if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1)
343     {
344       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
345       return -1;
346     }
347
348   return 0;
349 }
350
351 /* Write out the definitions of the preprocessor, in a form suitable for
352    cpp_read_state.  */
353
354 int
355 cpp_write_pch_state (cpp_reader *r, FILE *f)
356 {
357   if (!r->deps)
358     r->deps = deps_init ();
359
360   if (deps_save (r->deps, f) != 0)
361     {
362       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
363       return -1;
364     }
365
366   if (! _cpp_save_file_entries (r, f))
367     {
368       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
369       return -1;
370     }
371
372   /* Save the next __COUNTER__ value.  When we include a precompiled header,
373      we need to start at the offset we would have if the header had been
374      included normally. */
375   if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1)
376     {
377       cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
378       return -1;
379     }
380
381   return 0;
382 }
383
384
385 /* Data structure to transform hash table nodes into a sorted list */
386
387 struct ht_node_list
388 {
389   /* Array of nodes */
390   cpp_hashnode **defs;
391   /* Number of nodes in the array */
392   size_t n_defs;
393   /* Size of the allocated array */
394   size_t asize;
395 };
396
397 /* Callback for collecting identifiers from hash table */
398
399 static int
400 collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn,
401                   void *nl_p)
402 {
403   struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
404
405   if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
406     {
407       if (nl->n_defs == nl->asize)
408         {
409           nl->asize *= 2;
410           nl->defs = XRESIZEVEC (cpp_hashnode *, nl->defs, nl->asize);
411         }
412
413       nl->defs[nl->n_defs] = hn;
414       ++nl->n_defs;
415     }
416   return 1;
417 }
418
419
420 /* Return nonzero if FD is a precompiled header which is consistent
421    with the preprocessor's current definitions.  It will be consistent
422    when:
423
424    - anything that was defined just before the PCH was generated
425      is defined the same way now; and
426    - anything that was not defined then, but is defined now, was not
427      used by the PCH.
428
429    NAME is used to print warnings if `warn_invalid_pch' is set in the
430    reader's flags.
431 */
432
433 int
434 cpp_valid_state (cpp_reader *r, const char *name, int fd)
435 {
436   struct macrodef_struct m;
437   size_t namebufsz = 256;
438   unsigned char *namebuf = XNEWVEC (unsigned char, namebufsz);
439   unsigned char *undeftab = NULL;
440   struct ht_node_list nl = { 0, 0, 0 };
441   unsigned char *first, *last;
442   unsigned int i;
443   unsigned int counter;
444
445   /* Read in the list of identifiers that must be defined
446      Check that they are defined in the same way.  */
447   for (;;)
448     {
449       cpp_hashnode *h;
450       const unsigned char *newdefn;
451
452       if (read (fd, &m, sizeof (m)) != sizeof (m))
453         goto error;
454
455       if (m.name_length == 0)
456         break;
457
458       /* If this file is already preprocessed, there won't be any
459          macros defined, and that's OK.  */
460       if (CPP_OPTION (r, preprocessed))
461         {
462           if (lseek (fd, m.definition_length, SEEK_CUR) == -1)
463             goto error;
464           continue;
465         }
466
467       if (m.definition_length > namebufsz)
468         {
469           free (namebuf);
470           namebufsz = m.definition_length + 256;
471           namebuf = XNEWVEC (unsigned char, namebufsz);
472         }
473
474       if ((size_t)read (fd, namebuf, m.definition_length)
475           != m.definition_length)
476         goto error;
477
478       h = cpp_lookup (r, namebuf, m.name_length);
479       if (m.flags & NODE_POISONED
480           || h->flags & NODE_POISONED)
481         {
482           if (CPP_OPTION (r, warn_invalid_pch))
483             cpp_error (r, CPP_DL_WARNING_SYSHDR,
484                        "%s: not used because `%.*s' is poisoned",
485                        name, m.name_length, namebuf);
486           goto fail;
487         }
488
489       if (h->type != NT_MACRO)
490         {
491           /* It's ok if __GCC_HAVE_DWARF2_CFI_ASM becomes undefined,
492              as in, when the PCH file is created with -g and we're
493              attempting to use it without -g.  Restoring the PCH file
494              is supposed to bring in this definition *and* enable the
495              generation of call frame information, so that precompiled
496              definitions that take this macro into accout, to decide
497              what asm to emit, won't issue .cfi directives when the
498              compiler doesn't.  */
499           if (!(h->flags & NODE_USED)
500               && m.name_length == sizeof ("__GCC_HAVE_DWARF2_CFI_ASM") - 1
501               && !memcmp (namebuf, "__GCC_HAVE_DWARF2_CFI_ASM", m.name_length))
502             continue;
503
504           if (CPP_OPTION (r, warn_invalid_pch))
505             cpp_error (r, CPP_DL_WARNING_SYSHDR,
506                        "%s: not used because `%.*s' not defined",
507                        name, m.name_length, namebuf);
508           goto fail;
509         }
510
511       newdefn = cpp_macro_definition (r, h);
512
513       if (m.definition_length != ustrlen (newdefn)
514           || memcmp (namebuf, newdefn, m.definition_length) != 0)
515         {
516           if (CPP_OPTION (r, warn_invalid_pch))
517             cpp_error (r, CPP_DL_WARNING_SYSHDR,
518                "%s: not used because `%.*s' defined as `%s' not `%.*s'",
519                        name, m.name_length, namebuf, newdefn + m.name_length,
520                        m.definition_length - m.name_length,
521                        namebuf +  m.name_length);
522           goto fail;
523         }
524     }
525   free (namebuf);
526   namebuf = NULL;
527
528   /* Read in the list of identifiers that must not be defined.
529      Check that they really aren't.  */
530   undeftab = XNEWVEC (unsigned char, m.definition_length);
531   if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
532     goto error;
533
534   /* Collect identifiers from the current hash table.  */
535   nl.n_defs = 0;
536   nl.asize = 10;
537   nl.defs = XNEWVEC (cpp_hashnode *, nl.asize);
538   cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
539   qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
540
541   /* Loop through nl.defs and undeftab, both of which are sorted lists.
542      There should be no matches.  */
543   first = undeftab;
544   last = undeftab + m.definition_length;
545   i = 0;
546
547   while (first < last && i < nl.n_defs)
548     {
549       int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
550
551       if (cmp < 0)
552         first += ustrlen (first) + 1;
553       else if (cmp > 0)
554         ++i;
555       else
556         {
557           if (CPP_OPTION (r, warn_invalid_pch))
558             cpp_error (r, CPP_DL_WARNING_SYSHDR,
559                        "%s: not used because `%s' is defined",
560                        name, first);
561           goto fail;
562         }
563     }
564
565   free(nl.defs);
566   nl.defs = NULL;
567   free (undeftab);
568   undeftab = NULL;
569
570   /* Read in the next value of __COUNTER__.
571      Check that (a) __COUNTER__ was not used in the pch or (b) __COUNTER__
572      has not been used in this translation unit. */
573   if (read (fd, &counter, sizeof (counter)) != sizeof (counter))
574     goto error;
575   if (counter && r->counter)
576     {
577       if (CPP_OPTION (r, warn_invalid_pch))
578         cpp_error (r, CPP_DL_WARNING_SYSHDR,
579                    "%s: not used because `__COUNTER__' is invalid",
580                    name);
581         goto fail;
582     }
583
584   /* We win!  */
585   return 0;
586
587  error:
588   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
589   return -1;
590
591  fail:
592   if (namebuf != NULL)
593     free (namebuf);
594   if (undeftab != NULL)
595     free (undeftab);
596   if (nl.defs != NULL)
597     free (nl.defs);
598   return 1;
599 }
600
601 /* Save all the existing macros.  */
602
603 struct save_macro_data
604 {
605   uchar **defns;
606   size_t count;
607   size_t array_size;
608   char **saved_pragmas;
609 };
610
611 /* Save the definition of a single macro, so that it will persist
612    across a PCH restore.  Because macro data is in GCed memory, which
613    will be blown away by PCH, it must be temporarily copied to
614    malloced memory.  (The macros will refer to identifier nodes which
615    are also GCed and so on, so the copying is done by turning them
616    into self-contained strings.)  The assumption is that most macro
617    definitions will come from the PCH file, not from the compilation
618    before the PCH file is loaded, so it doesn't matter that this is
619    a little expensive.
620
621    It would reduce the cost even further if macros defined in the PCH
622    file were not saved in this way, but this is not done (yet), except
623    for builtins, and for #assert by default.  */
624
625 static int
626 save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p)
627 {
628   struct save_macro_data *data = (struct save_macro_data *)data_p;
629   if (h->type != NT_VOID
630       && (h->flags & NODE_BUILTIN) == 0)
631     {
632       if (data->count == data->array_size)
633         {
634           data->array_size *= 2;
635           data->defns = XRESIZEVEC (uchar *, data->defns, (data->array_size));
636         }
637
638       switch (h->type)
639         {
640         case NT_ASSERTION:
641           /* Not currently implemented.  */
642           return 1;
643
644         case NT_MACRO:
645           {
646             const uchar * defn = cpp_macro_definition (r, h);
647             size_t defnlen = ustrlen (defn);
648
649             data->defns[data->count] = (uchar *) xmemdup (defn, defnlen,
650                                                           defnlen + 2);
651             data->defns[data->count][defnlen] = '\n';
652           }
653           break;
654
655         default:
656           abort ();
657         }
658       data->count++;
659     }
660   return 1;
661 }
662
663 /* Prepare to restore the state, by saving the currently-defined
664    macros in 'data'.  */
665
666 void
667 cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
668 {
669   struct save_macro_data *d = XNEW (struct save_macro_data);
670
671   d->array_size = 512;
672   d->defns = XNEWVEC (uchar *, d->array_size);
673   d->count = 0;
674   cpp_forall_identifiers (r, save_macros, d);
675   d->saved_pragmas = _cpp_save_pragma_names (r);
676   *data = d;
677 }
678
679 /* Given a precompiled header that was previously determined to be valid,
680    apply all its definitions (and undefinitions) to the current state.
681    DEPNAME is passed to deps_restore.  */
682
683 int
684 cpp_read_state (cpp_reader *r, const char *name, FILE *f,
685                 struct save_macro_data *data)
686 {
687   size_t i;
688   struct lexer_state old_state;
689   unsigned int counter;
690
691   /* Restore spec_nodes, which will be full of references to the old
692      hashtable entries and so will now be invalid.  */
693   {
694     struct spec_nodes *s = &r->spec_nodes;
695     s->n_defined        = cpp_lookup (r, DSC("defined"));
696     s->n_true           = cpp_lookup (r, DSC("true"));
697     s->n_false          = cpp_lookup (r, DSC("false"));
698     s->n__VA_ARGS__     = cpp_lookup (r, DSC("__VA_ARGS__"));
699   }
700
701   old_state = r->state;
702   r->state.in_directive = 1;
703   r->state.prevent_expansion = 1;
704   r->state.angled_headers = 0;
705
706   /* Run through the carefully-saved macros, insert them.  */
707   for (i = 0; i < data->count; i++)
708     {
709       cpp_hashnode *h;
710       size_t namelen;
711       uchar *defn;
712
713       namelen = ustrcspn (data->defns[i], "( \n");
714       h = cpp_lookup (r, data->defns[i], namelen);
715       defn = data->defns[i] + namelen;
716
717       /* The PCH file is valid, so we know that if there is a definition
718          from the PCH file it must be the same as the one we had
719          originally, and so do not need to restore it.  */
720       if (h->type == NT_VOID)
721         {
722           if (cpp_push_buffer (r, defn, ustrchr (defn, '\n') - defn, true)
723               != NULL)
724             {
725               _cpp_clean_line (r);
726               if (!_cpp_create_definition (r, h))
727                 abort ();
728               _cpp_pop_buffer (r);
729             }
730           else
731             abort ();
732         }
733
734       free (data->defns[i]);
735     }
736   r->state = old_state;
737
738   _cpp_restore_pragma_names (r, data->saved_pragmas);
739
740   free (data);
741
742   if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
743       != 0)
744     goto error;
745
746   if (! _cpp_read_file_entries (r, f))
747     goto error;
748
749   if (fread (&counter, sizeof (counter), 1, f) != 1)
750     goto error;
751
752   if (!r->counter)
753     r->counter = counter;
754
755   return 0;
756
757  error:
758   cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
759   return -1;
760 }