1 /* Part of CPP library. (Precompiled header reading/writing.)
2 Copyright (C) 2000-2020 Free Software Foundation, Inc.
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 3, or (at your option) any
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.
14 You should have received a copy of the GNU General Public License
15 along with this program; see the file COPYING3. If not see
16 <http://www.gnu.org/licenses/>. */
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 static int _cpp_save_pushed_macros (cpp_reader
*, FILE *);
36 static int _cpp_restore_pushed_macros (cpp_reader
*, FILE *);
38 /* This structure represents a macro definition on disk. */
39 struct macrodef_struct
41 unsigned int definition_length
;
42 unsigned short name_length
;
46 /* This is how we write out a macro definition.
47 Suitable for being called by cpp_forall_identifiers. */
50 write_macdef (cpp_reader
*pfile
, cpp_hashnode
*hn
, void *file_p
)
52 FILE *f
= (FILE *) file_p
;
57 if (! (hn
->flags
& NODE_POISONED
))
62 case NT_BUILTIN_MACRO
:
66 if (hn
->value
.macro
->kind
!= cmk_assert
)
69 struct macrodef_struct s
;
70 const unsigned char *defn
;
72 s
.name_length
= NODE_LEN (hn
);
73 s
.flags
= hn
->flags
& NODE_POISONED
;
77 defn
= NODE_NAME (hn
);
78 s
.definition_length
= s
.name_length
;
82 defn
= cpp_macro_definition (pfile
, hn
);
83 s
.definition_length
= ustrlen (defn
);
86 if (fwrite (&s
, sizeof (s
), 1, f
) != 1
87 || fwrite (defn
, 1, s
.definition_length
, f
) != s
.definition_length
)
89 cpp_errno (pfile
, CPP_DL_ERROR
,
90 "while writing precompiled header");
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 /* Free memory associated with cpp_string. */
192 cpp_string_free (void *a_p
)
194 struct cpp_string
*a
= (struct cpp_string
*) a_p
;
195 free ((void *) a
->text
);
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. */
205 cpp_save_state (cpp_reader
*r
, FILE *f
)
207 /* Save the list of non-void identifiers for the dependency checking. */
208 r
->savedstate
= XNEW (struct cpp_savedstate
);
209 r
->savedstate
->definedhash
= htab_create (100, cpp_string_hash
,
210 cpp_string_eq
, cpp_string_free
);
211 cpp_forall_identifiers (r
, save_idents
, r
->savedstate
);
213 /* Write out the list of defined identifiers. */
214 cpp_forall_identifiers (r
, write_macdef
, f
);
219 /* Calculate the 'hashsize' field of the saved state. */
222 count_defs (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
, void *ss_p
)
224 struct cpp_savedstate
*const ss
= (struct cpp_savedstate
*)ss_p
;
228 case NT_BUILTIN_MACRO
:
232 if (hn
->value
.macro
->kind
== cmk_assert
)
239 struct cpp_string news
;
242 news
.len
= NODE_LEN (hn
);
243 news
.text
= NODE_NAME (hn
);
244 slot
= (void **) htab_find (ss
->definedhash
, &news
);
247 ss
->hashsize
+= NODE_LEN (hn
) + 1;
258 /* Collect the identifiers into the state's string table. */
260 write_defs (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
, void *ss_p
)
262 struct cpp_savedstate
*const ss
= (struct cpp_savedstate
*)ss_p
;
266 case NT_BUILTIN_MACRO
:
270 if (hn
->value
.macro
->kind
== cmk_assert
)
277 struct cpp_string news
;
280 news
.len
= NODE_LEN (hn
);
281 news
.text
= NODE_NAME (hn
);
282 slot
= (void **) htab_find (ss
->definedhash
, &news
);
285 ss
->defs
[ss
->n_defs
] = hn
;
296 /* Comparison function for qsort. The arguments point to pointers of
297 type ht_hashnode *. */
299 comp_hashnodes (const void *px
, const void *py
)
301 cpp_hashnode
*x
= *(cpp_hashnode
**) px
;
302 cpp_hashnode
*y
= *(cpp_hashnode
**) py
;
303 return ustrcmp (NODE_NAME (x
), NODE_NAME (y
));
306 /* Write out the remainder of the dependency information. This should be
307 called after the PCH is ready to be saved. */
310 cpp_write_pch_deps (cpp_reader
*r
, FILE *f
)
312 struct macrodef_struct z
;
313 struct cpp_savedstate
*const ss
= r
->savedstate
;
314 unsigned char *definedstrs
;
317 /* Collect the list of identifiers which have been seen and
318 weren't defined to anything previously. */
321 cpp_forall_identifiers (r
, count_defs
, ss
);
323 ss
->defs
= XNEWVEC (cpp_hashnode
*, ss
->n_defs
);
325 cpp_forall_identifiers (r
, write_defs
, ss
);
327 /* Sort the list, copy it into a buffer, and write it out. */
328 qsort (ss
->defs
, ss
->n_defs
, sizeof (cpp_hashnode
*), &comp_hashnodes
);
329 definedstrs
= ss
->definedstrs
= XNEWVEC (unsigned char, ss
->hashsize
);
330 for (i
= 0; i
< ss
->n_defs
; ++i
)
332 size_t len
= NODE_LEN (ss
->defs
[i
]);
333 memcpy (definedstrs
, NODE_NAME (ss
->defs
[i
]), len
+ 1);
334 definedstrs
+= len
+ 1;
337 memset (&z
, 0, sizeof (z
));
338 z
.definition_length
= ss
->hashsize
;
339 if (fwrite (&z
, sizeof (z
), 1, f
) != 1
340 || fwrite (ss
->definedstrs
, ss
->hashsize
, 1, f
) != 1)
342 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
345 free (ss
->definedstrs
);
347 htab_delete (ss
->definedhash
);
349 /* Free the saved state. */
351 r
->savedstate
= NULL
;
353 /* Save the next value of __COUNTER__. */
354 if (fwrite (&r
->counter
, sizeof (r
->counter
), 1, f
) != 1)
356 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
363 /* Write out the definitions of the preprocessor, in a form suitable for
367 cpp_write_pch_state (cpp_reader
*r
, FILE *f
)
370 r
->deps
= deps_init ();
372 if (deps_save (r
->deps
, f
) != 0)
374 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
378 if (! _cpp_save_file_entries (r
, f
))
380 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
384 /* Save the next __COUNTER__ value. When we include a precompiled header,
385 we need to start at the offset we would have if the header had been
386 included normally. */
387 if (fwrite (&r
->counter
, sizeof (r
->counter
), 1, f
) != 1)
389 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
393 /* Write saved macros. */
394 if (! _cpp_save_pushed_macros (r
, f
))
396 cpp_errno (r
, CPP_DL_ERROR
, "while writing precompiled header");
404 _cpp_restore_pushed_macros (cpp_reader
*r
, FILE *f
)
406 size_t count_saved
= 0;
408 struct def_pragma_macro
*p
;
413 if (fread (&count_saved
, sizeof (count_saved
), 1, f
) != 1)
417 for (i
= 0; i
< count_saved
; i
++)
419 if (fread (&nlen
, sizeof (nlen
), 1, f
) != 1)
421 p
= XNEW (struct def_pragma_macro
);
422 memset (p
, 0, sizeof (struct def_pragma_macro
));
423 p
->name
= XNEWVAR (char, nlen
+ 1);
425 if (fread (p
->name
, nlen
, 1, f
) != 1)
427 if (fread (&defnlen
, sizeof (defnlen
), 1, f
) != 1)
433 defn
= XNEWVEC (uchar
, defnlen
+ 1);
436 if (fread (defn
, defnlen
, 1, f
) != 1)
439 p
->definition
= defn
;
440 if (fread (&(p
->line
), sizeof (location_t
), 1, f
) != 1)
443 if (fread (&defnlen
, sizeof (defnlen
), 1, f
) != 1)
445 p
->syshdr
= ((defnlen
& 1) != 0 ? 1 : 0);
446 p
->used
= ((defnlen
& 2) != 0 ? 1 : 0);
449 p
->next
= r
->pushed_macros
;
450 r
->pushed_macros
= p
;
456 _cpp_save_pushed_macros (cpp_reader
*r
, FILE *f
)
458 size_t count_saved
= 0;
460 struct def_pragma_macro
*p
,**pp
;
464 p
= r
->pushed_macros
;
470 if (fwrite (&count_saved
, sizeof (count_saved
), 1, f
) != 1)
475 pp
= (struct def_pragma_macro
**) alloca (sizeof (struct def_pragma_macro
*)
477 /* Store them in reverse order. */
478 p
= r
->pushed_macros
;
486 for (i
= 0; i
< count_saved
; i
++)
488 defnlen
= strlen (pp
[i
]->name
);
489 if (fwrite (&defnlen
, sizeof (size_t), 1, f
) != 1
490 || fwrite (pp
[i
]->name
, defnlen
, 1, f
) != 1)
495 if (fwrite (&defnlen
, sizeof (size_t), 1, f
) != 1)
500 defnlen
= ustrlen (pp
[i
]->definition
);
501 if (fwrite (&defnlen
, sizeof (size_t), 1, f
) != 1
502 || fwrite (pp
[i
]->definition
, defnlen
, 1, f
) != 1)
504 if (fwrite (&(pp
[i
]->line
), sizeof (location_t
), 1, f
) != 1)
507 defnlen
|= (pp
[i
]->syshdr
!= 0 ? 1 : 0);
508 defnlen
|= (pp
[i
]->used
!= 0 ? 2 : 0);
509 if (fwrite (&defnlen
, sizeof (defnlen
), 1, f
) != 1)
517 /* Data structure to transform hash table nodes into a sorted list */
523 /* Number of nodes in the array */
525 /* Size of the allocated array */
529 /* Callback for collecting identifiers from hash table */
532 collect_ht_nodes (cpp_reader
*pfile ATTRIBUTE_UNUSED
, cpp_hashnode
*hn
,
535 struct ht_node_list
*const nl
= (struct ht_node_list
*)nl_p
;
537 if (hn
->type
!= NT_VOID
|| hn
->flags
& NODE_POISONED
)
539 if (nl
->n_defs
== nl
->asize
)
542 nl
->defs
= XRESIZEVEC (cpp_hashnode
*, nl
->defs
, nl
->asize
);
545 nl
->defs
[nl
->n_defs
] = hn
;
552 /* Return nonzero if FD is a precompiled header which is consistent
553 with the preprocessor's current definitions. It will be consistent
556 - anything that was defined just before the PCH was generated
557 is defined the same way now; and
558 - anything that was not defined then, but is defined now, was not
561 NAME is used to print warnings if `warn_invalid_pch' is set in the
566 cpp_valid_state (cpp_reader
*r
, const char *name
, int fd
)
568 struct macrodef_struct m
;
569 size_t namebufsz
= 256;
570 unsigned char *namebuf
= XNEWVEC (unsigned char, namebufsz
);
571 unsigned char *undeftab
= NULL
;
572 struct ht_node_list nl
= { 0, 0, 0 };
573 unsigned char *first
, *last
;
575 unsigned int counter
;
577 /* Read in the list of identifiers that must be defined
578 Check that they are defined in the same way. */
582 const unsigned char *newdefn
;
584 if (read (fd
, &m
, sizeof (m
)) != sizeof (m
))
587 if (m
.name_length
== 0)
590 /* If this file is already preprocessed, there won't be any
591 macros defined, and that's OK. */
592 if (CPP_OPTION (r
, preprocessed
))
594 if (lseek (fd
, m
.definition_length
, SEEK_CUR
) == -1)
599 if (m
.definition_length
> namebufsz
)
602 namebufsz
= m
.definition_length
+ 256;
603 namebuf
= XNEWVEC (unsigned char, namebufsz
);
606 if ((size_t)read (fd
, namebuf
, m
.definition_length
)
607 != m
.definition_length
)
610 h
= cpp_lookup (r
, namebuf
, m
.name_length
);
611 if (m
.flags
& NODE_POISONED
612 || h
->flags
& NODE_POISONED
)
614 if (CPP_OPTION (r
, warn_invalid_pch
))
615 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
616 "%s: not used because `%.*s' is poisoned",
617 name
, m
.name_length
, namebuf
);
621 if (h
->type
== NT_VOID
)
623 /* It's ok if __GCC_HAVE_DWARF2_CFI_ASM becomes undefined,
624 as in, when the PCH file is created with -g and we're
625 attempting to use it without -g. Restoring the PCH file
626 is supposed to bring in this definition *and* enable the
627 generation of call frame information, so that precompiled
628 definitions that take this macro into account, to decide
629 what asm to emit, won't issue .cfi directives when the
631 if (!(h
->flags
& NODE_USED
)
632 && m
.name_length
== sizeof ("__GCC_HAVE_DWARF2_CFI_ASM") - 1
633 && !memcmp (namebuf
, "__GCC_HAVE_DWARF2_CFI_ASM", m
.name_length
))
636 if (CPP_OPTION (r
, warn_invalid_pch
))
637 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
638 "%s: not used because `%.*s' not defined",
639 name
, m
.name_length
, namebuf
);
643 newdefn
= cpp_macro_definition (r
, h
);
645 if (m
.definition_length
!= ustrlen (newdefn
)
646 || memcmp (namebuf
, newdefn
, m
.definition_length
) != 0)
648 if (CPP_OPTION (r
, warn_invalid_pch
))
649 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
650 "%s: not used because `%.*s' defined as `%s' not `%.*s'",
651 name
, m
.name_length
, namebuf
, newdefn
+ m
.name_length
,
652 m
.definition_length
- m
.name_length
,
653 namebuf
+ m
.name_length
);
660 /* Read in the list of identifiers that must not be defined.
661 Check that they really aren't. */
662 undeftab
= XNEWVEC (unsigned char, m
.definition_length
);
663 if ((size_t) read (fd
, undeftab
, m
.definition_length
) != m
.definition_length
)
666 /* Collect identifiers from the current hash table. */
669 nl
.defs
= XNEWVEC (cpp_hashnode
*, nl
.asize
);
670 cpp_forall_identifiers (r
, &collect_ht_nodes
, &nl
);
671 qsort (nl
.defs
, nl
.n_defs
, sizeof (cpp_hashnode
*), &comp_hashnodes
);
673 /* Loop through nl.defs and undeftab, both of which are sorted lists.
674 There should be no matches. */
676 last
= undeftab
+ m
.definition_length
;
679 while (first
< last
&& i
< nl
.n_defs
)
681 int cmp
= ustrcmp (first
, NODE_NAME (nl
.defs
[i
]));
684 first
+= ustrlen (first
) + 1;
689 if (CPP_OPTION (r
, warn_invalid_pch
))
690 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
691 "%s: not used because `%s' is defined",
702 /* Read in the next value of __COUNTER__.
703 Check that (a) __COUNTER__ was not used in the pch or (b) __COUNTER__
704 has not been used in this translation unit. */
705 if (read (fd
, &counter
, sizeof (counter
)) != sizeof (counter
))
707 if (counter
&& r
->counter
)
709 if (CPP_OPTION (r
, warn_invalid_pch
))
710 cpp_warning_syshdr (r
, CPP_W_INVALID_PCH
,
711 "%s: not used because `__COUNTER__' is invalid",
720 cpp_errno (r
, CPP_DL_ERROR
, "while reading precompiled header");
729 /* Save all the existing macros. */
731 struct save_macro_data
736 char **saved_pragmas
;
739 /* Save the definition of a single macro, so that it will persist
740 across a PCH restore. Because macro data is in GCed memory, which
741 will be blown away by PCH, it must be temporarily copied to
742 malloced memory. (The macros will refer to identifier nodes which
743 are also GCed and so on, so the copying is done by turning them
744 into self-contained strings.) The assumption is that most macro
745 definitions will come from the PCH file, not from the compilation
746 before the PCH file is loaded, so it doesn't matter that this is
749 It would reduce the cost even further if macros defined in the PCH
750 file were not saved in this way, but this is not done (yet), except
751 for builtins, and for #assert by default. */
754 save_macros (cpp_reader
*r
, cpp_hashnode
*h
, void *data_p
)
756 struct save_macro_data
*data
= (struct save_macro_data
*)data_p
;
758 if (cpp_user_macro_p (h
))
760 if (data
->count
== data
->array_size
)
762 data
->array_size
*= 2;
763 data
->defns
= XRESIZEVEC (uchar
*, data
->defns
, (data
->array_size
));
766 const uchar
* defn
= cpp_macro_definition (r
, h
);
767 size_t defnlen
= ustrlen (defn
);
769 data
->defns
[data
->count
] = (uchar
*) xmemdup (defn
, defnlen
, defnlen
+ 2);
770 data
->defns
[data
->count
][defnlen
] = '\n';
777 /* Prepare to restore the state, by saving the currently-defined
781 cpp_prepare_state (cpp_reader
*r
, struct save_macro_data
**data
)
783 struct save_macro_data
*d
= XNEW (struct save_macro_data
);
786 d
->defns
= XNEWVEC (uchar
*, d
->array_size
);
788 cpp_forall_identifiers (r
, save_macros
, d
);
789 d
->saved_pragmas
= _cpp_save_pragma_names (r
);
793 /* Given a precompiled header that was previously determined to be valid,
794 apply all its definitions (and undefinitions) to the current state.
795 DEPNAME is passed to deps_restore. */
798 cpp_read_state (cpp_reader
*r
, const char *name
, FILE *f
,
799 struct save_macro_data
*data
)
802 struct lexer_state old_state
;
803 unsigned int counter
;
805 /* Restore spec_nodes, which will be full of references to the old
806 hashtable entries and so will now be invalid. */
808 struct spec_nodes
*s
= &r
->spec_nodes
;
809 s
->n_defined
= cpp_lookup (r
, DSC("defined"));
810 s
->n_true
= cpp_lookup (r
, DSC("true"));
811 s
->n_false
= cpp_lookup (r
, DSC("false"));
812 s
->n__VA_ARGS__
= cpp_lookup (r
, DSC("__VA_ARGS__"));
813 s
->n__VA_OPT__
= cpp_lookup (r
, DSC("__VA_OPT__"));
814 s
->n__has_include
= cpp_lookup (r
, DSC("__has_include"));
815 s
->n__has_include_next
= cpp_lookup (r
, DSC("__has_include_next"));
818 old_state
= r
->state
;
819 r
->state
.in_directive
= 1;
820 r
->state
.prevent_expansion
= 1;
821 r
->state
.angled_headers
= 0;
823 /* Run through the carefully-saved macros, insert them. */
824 for (i
= 0; i
< data
->count
; i
++)
830 namelen
= ustrcspn (data
->defns
[i
], "( \n");
831 h
= cpp_lookup (r
, data
->defns
[i
], namelen
);
832 defn
= data
->defns
[i
] + namelen
;
834 /* The PCH file is valid, so we know that if there is a definition
835 from the PCH file it must be the same as the one we had
836 originally, and so do not need to restore it. */
837 if (h
->type
== NT_VOID
)
839 if (cpp_push_buffer (r
, defn
, ustrchr (defn
, '\n') - defn
, true)
843 if (!_cpp_create_definition (r
, h
))
851 free (data
->defns
[i
]);
853 r
->state
= old_state
;
855 _cpp_restore_pragma_names (r
, data
->saved_pragmas
);
859 if (deps_restore (r
->deps
, f
, CPP_OPTION (r
, restore_pch_deps
) ? name
: NULL
)
863 if (! _cpp_read_file_entries (r
, f
))
866 if (fread (&counter
, sizeof (counter
), 1, f
) != 1)
870 r
->counter
= counter
;
872 /* Read pushed macros. */
873 if (! _cpp_restore_pushed_macros (r
, f
))
878 cpp_errno (r
, CPP_DL_ERROR
, "while reading precompiled header");