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.
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
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; see the file COPYING3. If not see
17 <http://www.gnu.org/licenses/>. */
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 static int _cpp_save_pushed_macros (cpp_reader
*, FILE *);
37 static int _cpp_restore_pushed_macros (cpp_reader
*, FILE *);
39 /* This structure represents a macro definition on disk. */
40 struct macrodef_struct
42 unsigned int definition_length
;
43 unsigned short name_length
;
47 /* This is how we write out a macro definition.
48 Suitable for being called by cpp_forall_identifiers. */
51 write_macdef (cpp_reader
*pfile
, cpp_hashnode
*hn
, void *file_p
)
53 FILE *f
= (FILE *) file_p
;
57 if (! (hn
->flags
& NODE_POISONED
))
61 if ((hn
->flags
& NODE_BUILTIN
)
62 && (!pfile
->cb
.user_builtin_macro
63 || !pfile
->cb
.user_builtin_macro (pfile
, hn
)))
67 struct macrodef_struct s
;
68 const unsigned char *defn
;
70 s
.name_length
= NODE_LEN (hn
);
71 s
.flags
= hn
->flags
& NODE_POISONED
;
73 if (hn
->type
== NT_MACRO
)
75 defn
= cpp_macro_definition (pfile
, hn
);
76 s
.definition_length
= ustrlen (defn
);
80 defn
= NODE_NAME (hn
);
81 s
.definition_length
= s
.name_length
;
84 if (fwrite (&s
, sizeof (s
), 1, f
) != 1
85 || fwrite (defn
, 1, s
.definition_length
, f
) != s
.definition_length
)
87 cpp_errno (pfile
, CPP_DL_ERROR
,
88 "while writing precompiled header");
95 /* Not currently implemented. */
103 /* This structure records the names of the defined macros.
104 It's also used as a callback structure for size_initial_idents
107 struct cpp_savedstate
109 /* A hash table of the defined identifiers. */
111 /* The size of the definitions of those identifiers (the size of
114 /* Number of definitions */
116 /* Array of definitions. In cpp_write_pch_deps it is used for sorting. */
118 /* Space for the next definition. Definitions are null-terminated
120 unsigned char *definedstrs
;
123 /* Save this identifier into the state: put it in the hash table,
124 put the definition in 'definedstrs'. */
127 save_idents (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
, void *ss_p
)
129 struct cpp_savedstate
*const ss
= (struct cpp_savedstate
*)ss_p
;
131 if (hn
->type
!= NT_VOID
)
133 struct cpp_string news
;
136 news
.len
= NODE_LEN (hn
);
137 news
.text
= NODE_NAME (hn
);
138 slot
= htab_find_slot (ss
->definedhash
, &news
, INSERT
);
141 struct cpp_string
*sp
;
144 sp
= XNEW (struct cpp_string
);
147 sp
->len
= NODE_LEN (hn
);
148 sp
->text
= text
= XNEWVEC (unsigned char, NODE_LEN (hn
));
149 memcpy (text
, NODE_NAME (hn
), NODE_LEN (hn
));
156 /* Hash some memory in a generic way. */
159 hashmem (const void *p_p
, size_t sz
)
161 const unsigned char *p
= (const unsigned char *)p_p
;
166 for (i
= 0; i
< sz
; i
++)
167 h
= h
* 67 - (*p
++ - 113);
171 /* Hash a cpp string for the hashtable machinery. */
174 cpp_string_hash (const void *a_p
)
176 const struct cpp_string
*a
= (const struct cpp_string
*) a_p
;
177 return hashmem (a
->text
, a
->len
);
180 /* Compare two cpp strings for the hashtable machinery. */
183 cpp_string_eq (const void *a_p
, const void *b_p
)
185 const struct cpp_string
*a
= (const struct cpp_string
*) a_p
;
186 const struct cpp_string
*b
= (const struct cpp_string
*) b_p
;
187 return (a
->len
== b
->len
188 && memcmp (a
->text
, b
->text
, a
->len
) == 0);
191 /* Save the current definitions of the cpp_reader for dependency
192 checking purposes. When writing a precompiled header, this should
193 be called at the same point in the compilation as cpp_valid_state
194 would be called when reading the precompiled header back in. */
197 cpp_save_state (cpp_reader
*r
, FILE *f
)
199 /* Save the list of non-void identifiers for the dependency checking. */
200 r
->savedstate
= XNEW (struct cpp_savedstate
);
201 r
->savedstate
->definedhash
= htab_create (100, cpp_string_hash
,
202 cpp_string_eq
, NULL
);
203 cpp_forall_identifiers (r
, save_idents
, r
->savedstate
);
205 /* Write out the list of defined identifiers. */
206 cpp_forall_identifiers (r
, write_macdef
, f
);
211 /* Calculate the 'hashsize' field of the saved state. */
214 count_defs (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
, void *ss_p
)
216 struct cpp_savedstate
*const ss
= (struct cpp_savedstate
*)ss_p
;
221 if (hn
->flags
& NODE_BUILTIN
)
224 /* else fall through. */
228 struct cpp_string news
;
231 news
.len
= NODE_LEN (hn
);
232 news
.text
= NODE_NAME (hn
);
233 slot
= (void **) htab_find (ss
->definedhash
, &news
);
236 ss
->hashsize
+= NODE_LEN (hn
) + 1;
243 /* Not currently implemented. */
251 /* Collect the identifiers into the state's string table. */
253 write_defs (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
, void *ss_p
)
255 struct cpp_savedstate
*const ss
= (struct cpp_savedstate
*)ss_p
;
260 if (hn
->flags
& NODE_BUILTIN
)
263 /* else fall through. */
267 struct cpp_string news
;
270 news
.len
= NODE_LEN (hn
);
271 news
.text
= NODE_NAME (hn
);
272 slot
= (void **) htab_find (ss
->definedhash
, &news
);
275 ss
->defs
[ss
->n_defs
] = hn
;
282 /* Not currently implemented. */
290 /* Comparison function for qsort. The arguments point to pointers of
291 type ht_hashnode *. */
293 comp_hashnodes (const void *px
, const void *py
)
295 cpp_hashnode
*x
= *(cpp_hashnode
**) px
;
296 cpp_hashnode
*y
= *(cpp_hashnode
**) py
;
297 return ustrcmp (NODE_NAME (x
), NODE_NAME (y
));
300 /* Write out the remainder of the dependency information. This should be
301 called after the PCH is ready to be saved. */
304 cpp_write_pch_deps (cpp_reader
*r
, FILE *f
)
306 struct macrodef_struct z
;
307 struct cpp_savedstate
*const ss
= r
->savedstate
;
308 unsigned char *definedstrs
;
311 /* Collect the list of identifiers which have been seen and
312 weren't defined to anything previously. */
315 cpp_forall_identifiers (r
, count_defs
, ss
);
317 ss
->defs
= XNEWVEC (cpp_hashnode
*, ss
->n_defs
);
319 cpp_forall_identifiers (r
, write_defs
, ss
);
321 /* Sort the list, copy it into a buffer, and write it out. */
322 qsort (ss
->defs
, ss
->n_defs
, sizeof (cpp_hashnode
*), &comp_hashnodes
);
323 definedstrs
= ss
->definedstrs
= XNEWVEC (unsigned char, ss
->hashsize
);
324 for (i
= 0; i
< ss
->n_defs
; ++i
)
326 size_t len
= NODE_LEN (ss
->defs
[i
]);
327 memcpy (definedstrs
, NODE_NAME (ss
->defs
[i
]), len
+ 1);
328 definedstrs
+= len
+ 1;
331 memset (&z
, 0, sizeof (z
));
332 z
.definition_length
= ss
->hashsize
;
333 if (fwrite (&z
, sizeof (z
), 1, f
) != 1
334 || fwrite (ss
->definedstrs
, ss
->hashsize
, 1, f
) != 1)
336 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
339 free (ss
->definedstrs
);
341 /* Free the saved state. */
343 r
->savedstate
= NULL
;
345 /* Save the next value of __COUNTER__. */
346 if (fwrite (&r
->counter
, sizeof (r
->counter
), 1, f
) != 1)
348 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
355 /* Write out the definitions of the preprocessor, in a form suitable for
359 cpp_write_pch_state (cpp_reader
*r
, FILE *f
)
362 r
->deps
= deps_init ();
364 if (deps_save (r
->deps
, f
) != 0)
366 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
370 if (! _cpp_save_file_entries (r
, f
))
372 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
376 /* Save the next __COUNTER__ value. When we include a precompiled header,
377 we need to start at the offset we would have if the header had been
378 included normally. */
379 if (fwrite (&r
->counter
, sizeof (r
->counter
), 1, f
) != 1)
381 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
385 /* Write saved macros. */
386 if (! _cpp_save_pushed_macros (r
, f
))
388 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
396 _cpp_restore_pushed_macros (cpp_reader
*r
, FILE *f
)
398 size_t count_saved
= 0;
400 struct def_pragma_macro
*p
;
402 cpp_hashnode
*h
= NULL
;
407 if (fread (&count_saved
, sizeof (count_saved
), 1, f
) != 1)
411 for (i
= 0; i
< count_saved
; i
++)
413 if (fread (&nlen
, sizeof (nlen
), 1, f
) != 1)
415 p
= XNEW (struct def_pragma_macro
);
416 p
->name
= XNEWVAR (char, nlen
+ 1);
418 if (fread (p
->name
, nlen
, 1, f
) != 1)
420 /* Save old state. */
421 m
= cpp_push_definition (r
, p
->name
);
422 if (fread (&defnlen
, sizeof (defnlen
), 1, f
) != 1)
424 defn
= XNEWVAR (uchar
, defnlen
+ 2);
425 defn
[defnlen
] = '\n';
426 defn
[defnlen
+ 1] = 0;
428 if (fread (defn
, defnlen
, 1, f
) != 1)
430 cpp_pop_definition (r
, p
->name
, NULL
);
435 namelen
= ustrcspn (defn
, "( \n");
436 h
= cpp_lookup (r
, defn
, namelen
);
440 h
->flags
&= ~(NODE_POISONED
|NODE_BUILTIN
|NODE_DISABLED
|NODE_USED
);
441 if (cpp_push_buffer (r
, dn
, ustrchr (dn
, '\n') - dn
, true)
445 if (!_cpp_create_definition (r
, h
))
452 p
->value
= cpp_push_definition (r
, p
->name
);
455 p
->next
= r
->pushed_macros
;
456 r
->pushed_macros
= p
;
457 /* Restore current state. */
458 cpp_pop_definition (r
, p
->name
, m
);
464 _cpp_save_pushed_macros (cpp_reader
*r
, FILE *f
)
466 size_t count_saved
= 0;
468 struct def_pragma_macro
*p
,**pp
;
475 p
= r
->pushed_macros
;
481 if (fwrite (&count_saved
, sizeof (count_saved
), 1, f
) != 1)
486 pp
= (struct def_pragma_macro
**) alloca (sizeof (struct def_pragma_macro
*)
488 /* Store them in reverse order. */
489 p
= r
->pushed_macros
;
497 for (i
= 0; i
< count_saved
; i
++)
499 /* Save old state. */
500 m
= cpp_push_definition (r
, pp
[i
]->name
);
501 /* Set temporary macro name to saved state. */
502 cpp_pop_definition (r
, pp
[i
]->name
, pp
[i
]->value
);
503 node
= _cpp_lex_identifier (r
, pp
[i
]->name
);
504 defnlen
= strlen (pp
[i
]->name
);
505 if (fwrite (&defnlen
, sizeof (size_t), 1, f
) != 1
506 || fwrite (pp
[i
]->name
, defnlen
, 1, f
) != 1)
508 defn
= cpp_macro_definition (r
, node
);
509 defnlen
= ustrlen (defn
);
510 if (fwrite (&defnlen
, sizeof (size_t), 1, f
) != 1
511 || fwrite (defn
, defnlen
, 1, f
) != 1)
513 /* Restore current state. */
514 cpp_pop_definition (r
, pp
[i
]->name
, m
);
520 /* Data structure to transform hash table nodes into a sorted list */
526 /* Number of nodes in the array */
528 /* Size of the allocated array */
532 /* Callback for collecting identifiers from hash table */
535 collect_ht_nodes (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
,
538 struct ht_node_list
*const nl
= (struct ht_node_list
*)nl_p
;
540 if (hn
->type
!= NT_VOID
|| hn
->flags
& NODE_POISONED
)
542 if (nl
->n_defs
== nl
->asize
)
545 nl
->defs
= XRESIZEVEC (cpp_hashnode
*, nl
->defs
, nl
->asize
);
548 nl
->defs
[nl
->n_defs
] = hn
;
555 /* Return nonzero if FD is a precompiled header which is consistent
556 with the preprocessor's current definitions. It will be consistent
559 - anything that was defined just before the PCH was generated
560 is defined the same way now; and
561 - anything that was not defined then, but is defined now, was not
564 NAME is used to print warnings if `warn_invalid_pch' is set in the
569 cpp_valid_state (cpp_reader
*r
, const char *name
, int fd
)
571 struct macrodef_struct m
;
572 size_t namebufsz
= 256;
573 unsigned char *namebuf
= XNEWVEC (unsigned char, namebufsz
);
574 unsigned char *undeftab
= NULL
;
575 struct ht_node_list nl
= { 0, 0, 0 };
576 unsigned char *first
, *last
;
578 unsigned int counter
;
580 /* Read in the list of identifiers that must be defined
581 Check that they are defined in the same way. */
585 const unsigned char *newdefn
;
587 if (read (fd
, &m
, sizeof (m
)) != sizeof (m
))
590 if (m
.name_length
== 0)
593 /* If this file is already preprocessed, there won't be any
594 macros defined, and that's OK. */
595 if (CPP_OPTION (r
, preprocessed
))
597 if (lseek (fd
, m
.definition_length
, SEEK_CUR
) == -1)
602 if (m
.definition_length
> namebufsz
)
605 namebufsz
= m
.definition_length
+ 256;
606 namebuf
= XNEWVEC (unsigned char, namebufsz
);
609 if ((size_t)read (fd
, namebuf
, m
.definition_length
)
610 != m
.definition_length
)
613 h
= cpp_lookup (r
, namebuf
, m
.name_length
);
614 if (m
.flags
& NODE_POISONED
615 || h
->flags
& NODE_POISONED
)
617 if (CPP_OPTION (r
, warn_invalid_pch
))
618 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
619 "%s: not used because `%.*s' is poisoned",
620 name
, m
.name_length
, namebuf
);
624 if (h
->type
!= NT_MACRO
)
626 /* It's ok if __GCC_HAVE_DWARF2_CFI_ASM becomes undefined,
627 as in, when the PCH file is created with -g and we're
628 attempting to use it without -g. Restoring the PCH file
629 is supposed to bring in this definition *and* enable the
630 generation of call frame information, so that precompiled
631 definitions that take this macro into accout, to decide
632 what asm to emit, won't issue .cfi directives when the
634 if (!(h
->flags
& NODE_USED
)
635 && m
.name_length
== sizeof ("__GCC_HAVE_DWARF2_CFI_ASM") - 1
636 && !memcmp (namebuf
, "__GCC_HAVE_DWARF2_CFI_ASM", m
.name_length
))
639 if (CPP_OPTION (r
, warn_invalid_pch
))
640 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
641 "%s: not used because `%.*s' not defined",
642 name
, m
.name_length
, namebuf
);
646 newdefn
= cpp_macro_definition (r
, h
);
648 if (m
.definition_length
!= ustrlen (newdefn
)
649 || memcmp (namebuf
, newdefn
, m
.definition_length
) != 0)
651 if (CPP_OPTION (r
, warn_invalid_pch
))
652 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
653 "%s: not used because `%.*s' defined as `%s' not `%.*s'",
654 name
, m
.name_length
, namebuf
, newdefn
+ m
.name_length
,
655 m
.definition_length
- m
.name_length
,
656 namebuf
+ m
.name_length
);
663 /* Read in the list of identifiers that must not be defined.
664 Check that they really aren't. */
665 undeftab
= XNEWVEC (unsigned char, m
.definition_length
);
666 if ((size_t) read (fd
, undeftab
, m
.definition_length
) != m
.definition_length
)
669 /* Collect identifiers from the current hash table. */
672 nl
.defs
= XNEWVEC (cpp_hashnode
*, nl
.asize
);
673 cpp_forall_identifiers (r
, &collect_ht_nodes
, &nl
);
674 qsort (nl
.defs
, nl
.n_defs
, sizeof (cpp_hashnode
*), &comp_hashnodes
);
676 /* Loop through nl.defs and undeftab, both of which are sorted lists.
677 There should be no matches. */
679 last
= undeftab
+ m
.definition_length
;
682 while (first
< last
&& i
< nl
.n_defs
)
684 int cmp
= ustrcmp (first
, NODE_NAME (nl
.defs
[i
]));
687 first
+= ustrlen (first
) + 1;
692 if (CPP_OPTION (r
, warn_invalid_pch
))
693 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
694 "%s: not used because `%s' is defined",
705 /* Read in the next value of __COUNTER__.
706 Check that (a) __COUNTER__ was not used in the pch or (b) __COUNTER__
707 has not been used in this translation unit. */
708 if (read (fd
, &counter
, sizeof (counter
)) != sizeof (counter
))
710 if (counter
&& r
->counter
)
712 if (CPP_OPTION (r
, warn_invalid_pch
))
713 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
714 "%s: not used because `__COUNTER__' is invalid",
723 cpp_errno (r
, CPP_DL_ERROR
, "while reading precompiled header");
729 if (undeftab
!= NULL
)
736 /* Save all the existing macros. */
738 struct save_macro_data
743 char **saved_pragmas
;
746 /* Save the definition of a single macro, so that it will persist
747 across a PCH restore. Because macro data is in GCed memory, which
748 will be blown away by PCH, it must be temporarily copied to
749 malloced memory. (The macros will refer to identifier nodes which
750 are also GCed and so on, so the copying is done by turning them
751 into self-contained strings.) The assumption is that most macro
752 definitions will come from the PCH file, not from the compilation
753 before the PCH file is loaded, so it doesn't matter that this is
756 It would reduce the cost even further if macros defined in the PCH
757 file were not saved in this way, but this is not done (yet), except
758 for builtins, and for #assert by default. */
761 save_macros (cpp_reader
*r
, cpp_hashnode
*h
, void *data_p
)
763 struct save_macro_data
*data
= (struct save_macro_data
*)data_p
;
765 if ((h
->flags
& NODE_BUILTIN
)
766 && h
->type
== NT_MACRO
767 && r
->cb
.user_builtin_macro
)
768 r
->cb
.user_builtin_macro (r
, h
);
770 if (h
->type
!= NT_VOID
771 && (h
->flags
& NODE_BUILTIN
) == 0)
773 if (data
->count
== data
->array_size
)
775 data
->array_size
*= 2;
776 data
->defns
= XRESIZEVEC (uchar
*, data
->defns
, (data
->array_size
));
782 /* Not currently implemented. */
787 const uchar
* defn
= cpp_macro_definition (r
, h
);
788 size_t defnlen
= ustrlen (defn
);
790 data
->defns
[data
->count
] = (uchar
*) xmemdup (defn
, defnlen
,
792 data
->defns
[data
->count
][defnlen
] = '\n';
804 /* Prepare to restore the state, by saving the currently-defined
808 cpp_prepare_state (cpp_reader
*r
, struct save_macro_data
**data
)
810 struct save_macro_data
*d
= XNEW (struct save_macro_data
);
813 d
->defns
= XNEWVEC (uchar
*, d
->array_size
);
815 cpp_forall_identifiers (r
, save_macros
, d
);
816 d
->saved_pragmas
= _cpp_save_pragma_names (r
);
820 /* Given a precompiled header that was previously determined to be valid,
821 apply all its definitions (and undefinitions) to the current state.
822 DEPNAME is passed to deps_restore. */
825 cpp_read_state (cpp_reader
*r
, const char *name
, FILE *f
,
826 struct save_macro_data
*data
)
829 struct lexer_state old_state
;
830 unsigned int counter
;
832 /* Restore spec_nodes, which will be full of references to the old
833 hashtable entries and so will now be invalid. */
835 struct spec_nodes
*s
= &r
->spec_nodes
;
836 s
->n_defined
= cpp_lookup (r
, DSC("defined"));
837 s
->n_true
= cpp_lookup (r
, DSC("true"));
838 s
->n_false
= cpp_lookup (r
, DSC("false"));
839 s
->n__VA_ARGS__
= cpp_lookup (r
, DSC("__VA_ARGS__"));
842 old_state
= r
->state
;
843 r
->state
.in_directive
= 1;
844 r
->state
.prevent_expansion
= 1;
845 r
->state
.angled_headers
= 0;
847 /* Run through the carefully-saved macros, insert them. */
848 for (i
= 0; i
< data
->count
; i
++)
854 namelen
= ustrcspn (data
->defns
[i
], "( \n");
855 h
= cpp_lookup (r
, data
->defns
[i
], namelen
);
856 defn
= data
->defns
[i
] + namelen
;
858 /* The PCH file is valid, so we know that if there is a definition
859 from the PCH file it must be the same as the one we had
860 originally, and so do not need to restore it. */
861 if (h
->type
== NT_VOID
)
863 if (cpp_push_buffer (r
, defn
, ustrchr (defn
, '\n') - defn
, true)
867 if (!_cpp_create_definition (r
, h
))
875 free (data
->defns
[i
]);
877 r
->state
= old_state
;
879 _cpp_restore_pragma_names (r
, data
->saved_pragmas
);
883 if (deps_restore (r
->deps
, f
, CPP_OPTION (r
, restore_pch_deps
) ? name
: NULL
)
887 if (! _cpp_read_file_entries (r
, f
))
890 if (fread (&counter
, sizeof (counter
), 1, f
) != 1)
894 r
->counter
= counter
;
896 /* Read pushed macros. */
897 if (! _cpp_restore_pushed_macros (r
, f
))
902 cpp_errno (r
, CPP_DL_ERROR
, "while reading precompiled header");