]>
gcc.gnu.org Git - gcc.git/blob - 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.
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
))
65 struct macrodef_struct s
;
66 const unsigned char *defn
;
68 s
.name_length
= NODE_LEN (hn
);
69 s
.flags
= hn
->flags
& NODE_POISONED
;
71 if (hn
->type
== NT_MACRO
)
73 defn
= cpp_macro_definition (pfile
, hn
);
74 s
.definition_length
= ustrlen (defn
);
78 defn
= NODE_NAME (hn
);
79 s
.definition_length
= s
.name_length
;
82 if (fwrite (&s
, sizeof (s
), 1, f
) != 1
83 || fwrite (defn
, 1, s
.definition_length
, f
) != s
.definition_length
)
85 cpp_errno (pfile
, CPP_DL_ERROR
,
86 "while writing precompiled header");
93 /* Not currently implemented. */
101 /* This structure records the names of the defined macros.
102 It's also used as a callback structure for size_initial_idents
105 struct cpp_savedstate
107 /* A hash table of the defined identifiers. */
109 /* The size of the definitions of those identifiers (the size of
112 /* Number of definitions */
114 /* Array of definitions. In cpp_write_pch_deps it is used for sorting. */
116 /* Space for the next definition. Definitions are null-terminated
118 unsigned char *definedstrs
;
121 /* Save this identifier into the state: put it in the hash table,
122 put the definition in 'definedstrs'. */
125 save_idents (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
, void *ss_p
)
127 struct cpp_savedstate
*const ss
= (struct cpp_savedstate
*)ss_p
;
129 if (hn
->type
!= NT_VOID
)
131 struct cpp_string news
;
134 news
.len
= NODE_LEN (hn
);
135 news
.text
= NODE_NAME (hn
);
136 slot
= htab_find_slot (ss
->definedhash
, &news
, INSERT
);
139 struct cpp_string
*sp
;
142 sp
= XNEW (struct cpp_string
);
145 sp
->len
= NODE_LEN (hn
);
146 sp
->text
= text
= XNEWVEC (unsigned char, NODE_LEN (hn
));
147 memcpy (text
, NODE_NAME (hn
), NODE_LEN (hn
));
154 /* Hash some memory in a generic way. */
157 hashmem (const void *p_p
, size_t sz
)
159 const unsigned char *p
= (const unsigned char *)p_p
;
164 for (i
= 0; i
< sz
; i
++)
165 h
= h
* 67 - (*p
++ - 113);
169 /* Hash a cpp string for the hashtable machinery. */
172 cpp_string_hash (const void *a_p
)
174 const struct cpp_string
*a
= (const struct cpp_string
*) a_p
;
175 return hashmem (a
->text
, a
->len
);
178 /* Compare two cpp strings for the hashtable machinery. */
181 cpp_string_eq (const void *a_p
, const void *b_p
)
183 const struct cpp_string
*a
= (const struct cpp_string
*) a_p
;
184 const struct cpp_string
*b
= (const struct cpp_string
*) b_p
;
185 return (a
->len
== b
->len
186 && memcmp (a
->text
, b
->text
, a
->len
) == 0);
189 /* Save the current definitions of the cpp_reader for dependency
190 checking purposes. When writing a precompiled header, this should
191 be called at the same point in the compilation as cpp_valid_state
192 would be called when reading the precompiled header back in. */
195 cpp_save_state (cpp_reader
*r
, FILE *f
)
197 /* Save the list of non-void identifiers for the dependency checking. */
198 r
->savedstate
= XNEW (struct cpp_savedstate
);
199 r
->savedstate
->definedhash
= htab_create (100, cpp_string_hash
,
200 cpp_string_eq
, NULL
);
201 cpp_forall_identifiers (r
, save_idents
, r
->savedstate
);
203 /* Write out the list of defined identifiers. */
204 cpp_forall_identifiers (r
, write_macdef
, f
);
209 /* Calculate the 'hashsize' field of the saved state. */
212 count_defs (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
, void *ss_p
)
214 struct cpp_savedstate
*const ss
= (struct cpp_savedstate
*)ss_p
;
219 if (hn
->flags
& NODE_BUILTIN
)
222 /* else fall through. */
226 struct cpp_string news
;
229 news
.len
= NODE_LEN (hn
);
230 news
.text
= NODE_NAME (hn
);
231 slot
= (void **) htab_find (ss
->definedhash
, &news
);
234 ss
->hashsize
+= NODE_LEN (hn
) + 1;
241 /* Not currently implemented. */
249 /* Collect the identifiers into the state's string table. */
251 write_defs (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
, void *ss_p
)
253 struct cpp_savedstate
*const ss
= (struct cpp_savedstate
*)ss_p
;
258 if (hn
->flags
& NODE_BUILTIN
)
261 /* else fall through. */
265 struct cpp_string news
;
268 news
.len
= NODE_LEN (hn
);
269 news
.text
= NODE_NAME (hn
);
270 slot
= (void **) htab_find (ss
->definedhash
, &news
);
273 ss
->defs
[ss
->n_defs
] = hn
;
280 /* Not currently implemented. */
288 /* Comparison function for qsort. The arguments point to pointers of
289 type ht_hashnode *. */
291 comp_hashnodes (const void *px
, const void *py
)
293 cpp_hashnode
*x
= *(cpp_hashnode
**) px
;
294 cpp_hashnode
*y
= *(cpp_hashnode
**) py
;
295 return ustrcmp (NODE_NAME (x
), NODE_NAME (y
));
298 /* Write out the remainder of the dependency information. This should be
299 called after the PCH is ready to be saved. */
302 cpp_write_pch_deps (cpp_reader
*r
, FILE *f
)
304 struct macrodef_struct z
;
305 struct cpp_savedstate
*const ss
= r
->savedstate
;
306 unsigned char *definedstrs
;
309 /* Collect the list of identifiers which have been seen and
310 weren't defined to anything previously. */
313 cpp_forall_identifiers (r
, count_defs
, ss
);
315 ss
->defs
= XNEWVEC (cpp_hashnode
*, ss
->n_defs
);
317 cpp_forall_identifiers (r
, write_defs
, ss
);
319 /* Sort the list, copy it into a buffer, and write it out. */
320 qsort (ss
->defs
, ss
->n_defs
, sizeof (cpp_hashnode
*), &comp_hashnodes
);
321 definedstrs
= ss
->definedstrs
= XNEWVEC (unsigned char, ss
->hashsize
);
322 for (i
= 0; i
< ss
->n_defs
; ++i
)
324 size_t len
= NODE_LEN (ss
->defs
[i
]);
325 memcpy (definedstrs
, NODE_NAME (ss
->defs
[i
]), len
+ 1);
326 definedstrs
+= len
+ 1;
329 memset (&z
, 0, sizeof (z
));
330 z
.definition_length
= ss
->hashsize
;
331 if (fwrite (&z
, sizeof (z
), 1, f
) != 1
332 || fwrite (ss
->definedstrs
, ss
->hashsize
, 1, f
) != 1)
334 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
337 free (ss
->definedstrs
);
339 /* Free the saved state. */
341 r
->savedstate
= NULL
;
343 /* Save the next value of __COUNTER__. */
344 if (fwrite (&r
->counter
, sizeof (r
->counter
), 1, f
) != 1)
346 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
353 /* Write out the definitions of the preprocessor, in a form suitable for
357 cpp_write_pch_state (cpp_reader
*r
, FILE *f
)
360 r
->deps
= deps_init ();
362 if (deps_save (r
->deps
, f
) != 0)
364 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
368 if (! _cpp_save_file_entries (r
, f
))
370 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
374 /* Save the next __COUNTER__ value. When we include a precompiled header,
375 we need to start at the offset we would have if the header had been
376 included normally. */
377 if (fwrite (&r
->counter
, sizeof (r
->counter
), 1, f
) != 1)
379 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
383 /* Write saved macros. */
384 if (! _cpp_save_pushed_macros (r
, f
))
386 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
394 _cpp_restore_pushed_macros (cpp_reader
*r
, FILE *f
)
396 size_t count_saved
= 0;
398 struct def_pragma_macro
*p
;
400 cpp_hashnode
*h
= NULL
;
405 if (fread (&count_saved
, sizeof (count_saved
), 1, f
) != 1)
409 for (i
= 0; i
< count_saved
; i
++)
411 if (fread (&nlen
, sizeof (nlen
), 1, f
) != 1)
413 p
= XNEW (struct def_pragma_macro
);
414 p
->name
= XNEWVAR (char, nlen
+ 1);
416 if (fread (p
->name
, nlen
, 1, f
) != 1)
418 /* Save old state. */
419 m
= cpp_push_definition (r
, p
->name
);
420 if (fread (&defnlen
, sizeof (defnlen
), 1, f
) != 1)
422 defn
= XNEWVAR (uchar
, defnlen
+ 2);
423 defn
[defnlen
] = '\n';
424 defn
[defnlen
+ 1] = 0;
426 if (fread (defn
, defnlen
, 1, f
) != 1)
428 cpp_pop_definition (r
, p
->name
, NULL
);
433 namelen
= ustrcspn (defn
, "( \n");
434 h
= cpp_lookup (r
, defn
, namelen
);
438 h
->flags
&= ~(NODE_POISONED
|NODE_BUILTIN
|NODE_DISABLED
|NODE_USED
);
439 if (cpp_push_buffer (r
, dn
, ustrchr (dn
, '\n') - dn
, true)
443 if (!_cpp_create_definition (r
, h
))
450 p
->value
= cpp_push_definition (r
, p
->name
);
453 p
->next
= r
->pushed_macros
;
454 r
->pushed_macros
= p
;
455 /* Restore current state. */
456 cpp_pop_definition (r
, p
->name
, m
);
462 _cpp_save_pushed_macros (cpp_reader
*r
, FILE *f
)
464 size_t count_saved
= 0;
466 struct def_pragma_macro
*p
,**pp
;
473 p
= r
->pushed_macros
;
479 if (fwrite (&count_saved
, sizeof (count_saved
), 1, f
) != 1)
484 pp
= (struct def_pragma_macro
**) alloca (sizeof (struct def_pragma_macro
*)
486 /* Store them in reverse order. */
487 p
= r
->pushed_macros
;
495 for (i
= 0; i
< count_saved
; i
++)
497 /* Save old state. */
498 m
= cpp_push_definition (r
, pp
[i
]->name
);
499 /* Set temporary macro name to saved state. */
500 cpp_pop_definition (r
, pp
[i
]->name
, pp
[i
]->value
);
501 node
= _cpp_lex_identifier (r
, pp
[i
]->name
);
502 defnlen
= strlen (pp
[i
]->name
);
503 if (fwrite (&defnlen
, sizeof (size_t), 1, f
) != 1
504 || fwrite (pp
[i
]->name
, defnlen
, 1, f
) != 1)
506 defn
= cpp_macro_definition (r
, node
);
507 defnlen
= ustrlen (defn
);
508 if (fwrite (&defnlen
, sizeof (size_t), 1, f
) != 1
509 || fwrite (defn
, defnlen
, 1, f
) != 1)
511 /* Restore current state. */
512 cpp_pop_definition (r
, pp
[i
]->name
, m
);
518 /* Data structure to transform hash table nodes into a sorted list */
524 /* Number of nodes in the array */
526 /* Size of the allocated array */
530 /* Callback for collecting identifiers from hash table */
533 collect_ht_nodes (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
,
536 struct ht_node_list
*const nl
= (struct ht_node_list
*)nl_p
;
538 if (hn
->type
!= NT_VOID
|| hn
->flags
& NODE_POISONED
)
540 if (nl
->n_defs
== nl
->asize
)
543 nl
->defs
= XRESIZEVEC (cpp_hashnode
*, nl
->defs
, nl
->asize
);
546 nl
->defs
[nl
->n_defs
] = hn
;
553 /* Return nonzero if FD is a precompiled header which is consistent
554 with the preprocessor's current definitions. It will be consistent
557 - anything that was defined just before the PCH was generated
558 is defined the same way now; and
559 - anything that was not defined then, but is defined now, was not
562 NAME is used to print warnings if `warn_invalid_pch' is set in the
567 cpp_valid_state (cpp_reader
*r
, const char *name
, int fd
)
569 struct macrodef_struct m
;
570 size_t namebufsz
= 256;
571 unsigned char *namebuf
= XNEWVEC (unsigned char, namebufsz
);
572 unsigned char *undeftab
= NULL
;
573 struct ht_node_list nl
= { 0, 0, 0 };
574 unsigned char *first
, *last
;
576 unsigned int counter
;
578 /* Read in the list of identifiers that must be defined
579 Check that they are defined in the same way. */
583 const unsigned char *newdefn
;
585 if (read (fd
, &m
, sizeof (m
)) != sizeof (m
))
588 if (m
.name_length
== 0)
591 /* If this file is already preprocessed, there won't be any
592 macros defined, and that's OK. */
593 if (CPP_OPTION (r
, preprocessed
))
595 if (lseek (fd
, m
.definition_length
, SEEK_CUR
) == -1)
600 if (m
.definition_length
> namebufsz
)
603 namebufsz
= m
.definition_length
+ 256;
604 namebuf
= XNEWVEC (unsigned char, namebufsz
);
607 if ((size_t)read (fd
, namebuf
, m
.definition_length
)
608 != m
.definition_length
)
611 h
= cpp_lookup (r
, namebuf
, m
.name_length
);
612 if (m
.flags
& NODE_POISONED
613 || h
->flags
& NODE_POISONED
)
615 if (CPP_OPTION (r
, warn_invalid_pch
))
616 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
617 "%s: not used because `%.*s' is poisoned",
618 name
, m
.name_length
, namebuf
);
622 if (h
->type
!= NT_MACRO
)
624 /* It's ok if __GCC_HAVE_DWARF2_CFI_ASM becomes undefined,
625 as in, when the PCH file is created with -g and we're
626 attempting to use it without -g. Restoring the PCH file
627 is supposed to bring in this definition *and* enable the
628 generation of call frame information, so that precompiled
629 definitions that take this macro into accout, to decide
630 what asm to emit, won't issue .cfi directives when the
632 if (!(h
->flags
& NODE_USED
)
633 && m
.name_length
== sizeof ("__GCC_HAVE_DWARF2_CFI_ASM") - 1
634 && !memcmp (namebuf
, "__GCC_HAVE_DWARF2_CFI_ASM", m
.name_length
))
637 if (CPP_OPTION (r
, warn_invalid_pch
))
638 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
639 "%s: not used because `%.*s' not defined",
640 name
, m
.name_length
, namebuf
);
644 newdefn
= cpp_macro_definition (r
, h
);
646 if (m
.definition_length
!= ustrlen (newdefn
)
647 || memcmp (namebuf
, newdefn
, m
.definition_length
) != 0)
649 if (CPP_OPTION (r
, warn_invalid_pch
))
650 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
651 "%s: not used because `%.*s' defined as `%s' not `%.*s'",
652 name
, m
.name_length
, namebuf
, newdefn
+ m
.name_length
,
653 m
.definition_length
- m
.name_length
,
654 namebuf
+ m
.name_length
);
661 /* Read in the list of identifiers that must not be defined.
662 Check that they really aren't. */
663 undeftab
= XNEWVEC (unsigned char, m
.definition_length
);
664 if ((size_t) read (fd
, undeftab
, m
.definition_length
) != m
.definition_length
)
667 /* Collect identifiers from the current hash table. */
670 nl
.defs
= XNEWVEC (cpp_hashnode
*, nl
.asize
);
671 cpp_forall_identifiers (r
, &collect_ht_nodes
, &nl
);
672 qsort (nl
.defs
, nl
.n_defs
, sizeof (cpp_hashnode
*), &comp_hashnodes
);
674 /* Loop through nl.defs and undeftab, both of which are sorted lists.
675 There should be no matches. */
677 last
= undeftab
+ m
.definition_length
;
680 while (first
< last
&& i
< nl
.n_defs
)
682 int cmp
= ustrcmp (first
, NODE_NAME (nl
.defs
[i
]));
685 first
+= ustrlen (first
) + 1;
690 if (CPP_OPTION (r
, warn_invalid_pch
))
691 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
692 "%s: not used because `%s' is defined",
703 /* Read in the next value of __COUNTER__.
704 Check that (a) __COUNTER__ was not used in the pch or (b) __COUNTER__
705 has not been used in this translation unit. */
706 if (read (fd
, &counter
, sizeof (counter
)) != sizeof (counter
))
708 if (counter
&& r
->counter
)
710 if (CPP_OPTION (r
, warn_invalid_pch
))
711 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
712 "%s: not used because `__COUNTER__' is invalid",
721 cpp_errno (r
, CPP_DL_ERROR
, "while reading precompiled header");
727 if (undeftab
!= NULL
)
734 /* Save all the existing macros. */
736 struct save_macro_data
741 char **saved_pragmas
;
744 /* Save the definition of a single macro, so that it will persist
745 across a PCH restore. Because macro data is in GCed memory, which
746 will be blown away by PCH, it must be temporarily copied to
747 malloced memory. (The macros will refer to identifier nodes which
748 are also GCed and so on, so the copying is done by turning them
749 into self-contained strings.) The assumption is that most macro
750 definitions will come from the PCH file, not from the compilation
751 before the PCH file is loaded, so it doesn't matter that this is
754 It would reduce the cost even further if macros defined in the PCH
755 file were not saved in this way, but this is not done (yet), except
756 for builtins, and for #assert by default. */
759 save_macros (cpp_reader
*r
, cpp_hashnode
*h
, void *data_p
)
761 struct save_macro_data
*data
= (struct save_macro_data
*)data_p
;
762 if (h
->type
!= NT_VOID
763 && (h
->flags
& NODE_BUILTIN
) == 0)
765 if (data
->count
== data
->array_size
)
767 data
->array_size
*= 2;
768 data
->defns
= XRESIZEVEC (uchar
*, data
->defns
, (data
->array_size
));
774 /* Not currently implemented. */
779 const uchar
* defn
= cpp_macro_definition (r
, h
);
780 size_t defnlen
= ustrlen (defn
);
782 data
->defns
[data
->count
] = (uchar
*) xmemdup (defn
, defnlen
,
784 data
->defns
[data
->count
][defnlen
] = '\n';
796 /* Prepare to restore the state, by saving the currently-defined
800 cpp_prepare_state (cpp_reader
*r
, struct save_macro_data
**data
)
802 struct save_macro_data
*d
= XNEW (struct save_macro_data
);
805 d
->defns
= XNEWVEC (uchar
*, d
->array_size
);
807 cpp_forall_identifiers (r
, save_macros
, d
);
808 d
->saved_pragmas
= _cpp_save_pragma_names (r
);
812 /* Given a precompiled header that was previously determined to be valid,
813 apply all its definitions (and undefinitions) to the current state.
814 DEPNAME is passed to deps_restore. */
817 cpp_read_state (cpp_reader
*r
, const char *name
, FILE *f
,
818 struct save_macro_data
*data
)
821 struct lexer_state old_state
;
822 unsigned int counter
;
824 /* Restore spec_nodes, which will be full of references to the old
825 hashtable entries and so will now be invalid. */
827 struct spec_nodes
*s
= &r
->spec_nodes
;
828 s
->n_defined
= cpp_lookup (r
, DSC("defined"));
829 s
->n_true
= cpp_lookup (r
, DSC("true"));
830 s
->n_false
= cpp_lookup (r
, DSC("false"));
831 s
->n__VA_ARGS__
= cpp_lookup (r
, DSC("__VA_ARGS__"));
834 old_state
= r
->state
;
835 r
->state
.in_directive
= 1;
836 r
->state
.prevent_expansion
= 1;
837 r
->state
.angled_headers
= 0;
839 /* Run through the carefully-saved macros, insert them. */
840 for (i
= 0; i
< data
->count
; i
++)
846 namelen
= ustrcspn (data
->defns
[i
], "( \n");
847 h
= cpp_lookup (r
, data
->defns
[i
], namelen
);
848 defn
= data
->defns
[i
] + namelen
;
850 /* The PCH file is valid, so we know that if there is a definition
851 from the PCH file it must be the same as the one we had
852 originally, and so do not need to restore it. */
853 if (h
->type
== NT_VOID
)
855 if (cpp_push_buffer (r
, defn
, ustrchr (defn
, '\n') - defn
, true)
859 if (!_cpp_create_definition (r
, h
))
867 free (data
->defns
[i
]);
869 r
->state
= old_state
;
871 _cpp_restore_pragma_names (r
, data
->saved_pragmas
);
875 if (deps_restore (r
->deps
, f
, CPP_OPTION (r
, restore_pch_deps
) ? name
: NULL
)
879 if (! _cpp_read_file_entries (r
, f
))
882 if (fread (&counter
, sizeof (counter
), 1, f
) != 1)
886 r
->counter
= counter
;
888 /* Read pushed macros. */
889 if (! _cpp_restore_pushed_macros (r
, f
))
894 cpp_errno (r
, CPP_DL_ERROR
, "while reading precompiled header");
This page took 0.075081 seconds and 5 git commands to generate.