]>
Commit | Line | Data |
---|---|---|
17211ab5 | 1 | /* Part of CPP library. (Precompiled header reading/writing.) |
31c3e631 KH |
2 | Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 |
3 | Free Software Foundation, Inc. | |
17211ab5 GK |
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 2, 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; if not, write to the Free Software | |
200031d1 | 17 | Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ |
17211ab5 GK |
18 | |
19 | #include "config.h" | |
20 | #include "system.h" | |
17211ab5 | 21 | #include "cpplib.h" |
4f4e53dd | 22 | #include "internal.h" |
17211ab5 GK |
23 | #include "hashtab.h" |
24 | #include "mkdeps.h" | |
25 | ||
6cf87ca4 ZW |
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 *); | |
17211ab5 GK |
36 | |
37 | /* This structure represents a macro definition on disk. */ | |
b699150b | 38 | struct macrodef_struct |
17211ab5 GK |
39 | { |
40 | unsigned int definition_length; | |
41 | unsigned short name_length; | |
42 | unsigned short flags; | |
43 | }; | |
44 | ||
b699150b | 45 | /* This is how we write out a macro definition. |
17211ab5 GK |
46 | Suitable for being called by cpp_forall_identifiers. */ |
47 | ||
48 | static int | |
6cf87ca4 | 49 | write_macdef (cpp_reader *pfile, cpp_hashnode *hn, void *file_p) |
17211ab5 GK |
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; | |
b699150b | 57 | |
17211ab5 GK |
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 | } | |
b699150b | 79 | |
17211ab5 GK |
80 | if (fwrite (&s, sizeof (s), 1, f) != 1 |
81 | || fwrite (defn, 1, s.definition_length, f) != s.definition_length) | |
82 | { | |
0527bc4e JDA |
83 | cpp_errno (pfile, CPP_DL_ERROR, |
84 | "while writing precompiled header"); | |
17211ab5 GK |
85 | return 0; |
86 | } | |
87 | } | |
88 | return 1; | |
b699150b | 89 | |
17211ab5 GK |
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; | |
c419b113 MA |
110 | /* Number of definitions */ |
111 | size_t n_defs; | |
71c0e7fc | 112 | /* Array of definitions. In cpp_write_pch_deps it is used for sorting. */ |
c419b113 | 113 | cpp_hashnode **defs; |
17211ab5 GK |
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 | |
6cf87ca4 | 123 | save_idents (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p) |
17211ab5 GK |
124 | { |
125 | struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p; | |
b699150b | 126 | |
17211ab5 GK |
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; | |
b699150b | 139 | |
c3f829c1 | 140 | sp = XNEW (struct cpp_string); |
17211ab5 GK |
141 | *slot = sp; |
142 | ||
143 | sp->len = NODE_LEN (hn); | |
c3f829c1 | 144 | sp->text = text = XNEWVEC (unsigned char, NODE_LEN (hn)); |
17211ab5 GK |
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 | |
6cf87ca4 | 155 | hashmem (const void *p_p, size_t sz) |
17211ab5 GK |
156 | { |
157 | const unsigned char *p = (const unsigned char *)p_p; | |
158 | size_t i; | |
159 | hashval_t h; | |
b699150b | 160 | |
17211ab5 GK |
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 | |
6cf87ca4 | 170 | cpp_string_hash (const void *a_p) |
17211ab5 GK |
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 | |
6cf87ca4 | 179 | cpp_string_eq (const void *a_p, const void *b_p) |
17211ab5 GK |
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 | |
6cf87ca4 | 193 | cpp_save_state (cpp_reader *r, FILE *f) |
17211ab5 GK |
194 | { |
195 | /* Save the list of non-void identifiers for the dependency checking. */ | |
c3f829c1 | 196 | r->savedstate = XNEW (struct cpp_savedstate); |
b699150b | 197 | r->savedstate->definedhash = htab_create (100, cpp_string_hash, |
17211ab5 GK |
198 | cpp_string_eq, NULL); |
199 | cpp_forall_identifiers (r, save_idents, r->savedstate); | |
b699150b | 200 | |
17211ab5 GK |
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 | |
6cf87ca4 | 210 | count_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p) |
17211ab5 GK |
211 | { |
212 | struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p; | |
b699150b | 213 | |
17211ab5 GK |
214 | switch (hn->type) |
215 | { | |
216 | case NT_MACRO: | |
217 | if (hn->flags & NODE_BUILTIN) | |
218 | return 1; | |
b699150b | 219 | |
17211ab5 GK |
220 | /* else fall through. */ |
221 | ||
222 | case NT_VOID: | |
223 | { | |
224 | struct cpp_string news; | |
225 | void **slot; | |
b699150b | 226 | |
17211ab5 GK |
227 | news.len = NODE_LEN (hn); |
228 | news.text = NODE_NAME (hn); | |
c3f829c1 | 229 | slot = (void **) htab_find (ss->definedhash, &news); |
17211ab5 | 230 | if (slot == NULL) |
c419b113 MA |
231 | { |
232 | ss->hashsize += NODE_LEN (hn) + 1; | |
233 | ss->n_defs += 1; | |
234 | } | |
17211ab5 GK |
235 | } |
236 | return 1; | |
237 | ||
238 | case NT_ASSERTION: | |
239 | /* Not currently implemented. */ | |
240 | return 1; | |
241 | ||
242 | default: | |
243 | abort (); | |
244 | } | |
245 | } | |
246 | ||
71c0e7fc | 247 | /* Collect the identifiers into the state's string table. */ |
17211ab5 | 248 | static int |
6cf87ca4 | 249 | write_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p) |
17211ab5 GK |
250 | { |
251 | struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p; | |
b699150b | 252 | |
17211ab5 GK |
253 | switch (hn->type) |
254 | { | |
255 | case NT_MACRO: | |
256 | if (hn->flags & NODE_BUILTIN) | |
257 | return 1; | |
b699150b | 258 | |
17211ab5 GK |
259 | /* else fall through. */ |
260 | ||
261 | case NT_VOID: | |
262 | { | |
263 | struct cpp_string news; | |
264 | void **slot; | |
b699150b | 265 | |
17211ab5 GK |
266 | news.len = NODE_LEN (hn); |
267 | news.text = NODE_NAME (hn); | |
c3f829c1 | 268 | slot = (void **) htab_find (ss->definedhash, &news); |
17211ab5 GK |
269 | if (slot == NULL) |
270 | { | |
c419b113 MA |
271 | ss->defs[ss->n_defs] = hn; |
272 | ss->n_defs += 1; | |
17211ab5 GK |
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 | ||
c419b113 MA |
286 | /* Comparison function for qsort. The arguments point to pointers of |
287 | type ht_hashnode *. */ | |
288 | static int | |
6cf87ca4 | 289 | comp_hashnodes (const void *px, const void *py) |
c419b113 MA |
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 | ||
17211ab5 GK |
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 | |
6cf87ca4 | 300 | cpp_write_pch_deps (cpp_reader *r, FILE *f) |
17211ab5 GK |
301 | { |
302 | struct macrodef_struct z; | |
303 | struct cpp_savedstate *const ss = r->savedstate; | |
304 | unsigned char *definedstrs; | |
c419b113 | 305 | size_t i; |
b699150b | 306 | |
c419b113 | 307 | /* Collect the list of identifiers which have been seen and |
17211ab5 | 308 | weren't defined to anything previously. */ |
c419b113 MA |
309 | ss->hashsize = 0; |
310 | ss->n_defs = 0; | |
17211ab5 | 311 | cpp_forall_identifiers (r, count_defs, ss); |
c419b113 | 312 | |
c3f829c1 | 313 | ss->defs = XNEWVEC (cpp_hashnode *, ss->n_defs); |
c419b113 | 314 | ss->n_defs = 0; |
17211ab5 | 315 | cpp_forall_identifiers (r, write_defs, ss); |
c419b113 | 316 | |
71c0e7fc | 317 | /* Sort the list, copy it into a buffer, and write it out. */ |
c419b113 | 318 | qsort (ss->defs, ss->n_defs, sizeof (cpp_hashnode *), &comp_hashnodes); |
c3f829c1 | 319 | definedstrs = ss->definedstrs = XNEWVEC (unsigned char, ss->hashsize); |
c419b113 MA |
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 | ||
17211ab5 GK |
327 | memset (&z, 0, sizeof (z)); |
328 | z.definition_length = ss->hashsize; | |
329 | if (fwrite (&z, sizeof (z), 1, f) != 1 | |
c419b113 | 330 | || fwrite (ss->definedstrs, ss->hashsize, 1, f) != 1) |
17211ab5 | 331 | { |
0527bc4e | 332 | cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header"); |
17211ab5 GK |
333 | return -1; |
334 | } | |
c419b113 | 335 | free (ss->definedstrs); |
17211ab5 GK |
336 | |
337 | /* Free the saved state. */ | |
338 | free (ss); | |
339 | r->savedstate = NULL; | |
a702045a OW |
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 | ||
17211ab5 GK |
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 | |
6cf87ca4 | 355 | cpp_write_pch_state (cpp_reader *r, FILE *f) |
17211ab5 | 356 | { |
17211ab5 GK |
357 | if (!r->deps) |
358 | r->deps = deps_init (); | |
359 | ||
360 | if (deps_save (r->deps, f) != 0) | |
361 | { | |
0527bc4e | 362 | cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header"); |
17211ab5 GK |
363 | return -1; |
364 | } | |
365 | ||
73e61092 GK |
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 | ||
a702045a OW |
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 | ||
17211ab5 GK |
381 | return 0; |
382 | } | |
383 | ||
c419b113 MA |
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 | |
6cf87ca4 ZW |
400 | collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, |
401 | void *nl_p) | |
c419b113 MA |
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; | |
c3f829c1 | 410 | nl->defs = XRESIZEVEC (cpp_hashnode *, nl->defs, nl->asize); |
c419b113 MA |
411 | } |
412 | ||
413 | nl->defs[nl->n_defs] = hn; | |
414 | ++nl->n_defs; | |
415 | } | |
416 | return 1; | |
417 | } | |
418 | ||
419 | ||
17211ab5 GK |
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 | ||
b699150b | 424 | - anything that was defined just before the PCH was generated |
17211ab5 GK |
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 | |
6cf87ca4 | 434 | cpp_valid_state (cpp_reader *r, const char *name, int fd) |
17211ab5 GK |
435 | { |
436 | struct macrodef_struct m; | |
437 | size_t namebufsz = 256; | |
c3f829c1 | 438 | unsigned char *namebuf = XNEWVEC (unsigned char, namebufsz); |
17211ab5 | 439 | unsigned char *undeftab = NULL; |
36801818 | 440 | struct ht_node_list nl = { 0, 0, 0 }; |
c419b113 | 441 | unsigned char *first, *last; |
17211ab5 | 442 | unsigned int i; |
a702045a | 443 | unsigned int counter; |
b699150b | 444 | |
17211ab5 GK |
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; | |
b699150b | 451 | |
17211ab5 GK |
452 | if (read (fd, &m, sizeof (m)) != sizeof (m)) |
453 | goto error; | |
b699150b | 454 | |
17211ab5 GK |
455 | if (m.name_length == 0) |
456 | break; | |
457 | ||
c0d578e6 GK |
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 | ||
17211ab5 GK |
467 | if (m.definition_length > namebufsz) |
468 | { | |
469 | free (namebuf); | |
470 | namebufsz = m.definition_length + 256; | |
c3f829c1 | 471 | namebuf = XNEWVEC (unsigned char, namebufsz); |
17211ab5 | 472 | } |
c0d578e6 | 473 | |
b699150b | 474 | if ((size_t)read (fd, namebuf, m.definition_length) |
17211ab5 GK |
475 | != m.definition_length) |
476 | goto error; | |
b699150b | 477 | |
17211ab5 GK |
478 | h = cpp_lookup (r, namebuf, m.name_length); |
479 | if (m.flags & NODE_POISONED | |
480 | || h->type != NT_MACRO | |
481 | || h->flags & NODE_POISONED) | |
482 | { | |
483 | if (CPP_OPTION (r, warn_invalid_pch)) | |
0527bc4e | 484 | cpp_error (r, CPP_DL_WARNING_SYSHDR, |
17211ab5 GK |
485 | "%s: not used because `%.*s' not defined", |
486 | name, m.name_length, namebuf); | |
487 | goto fail; | |
488 | } | |
489 | ||
490 | newdefn = cpp_macro_definition (r, h); | |
b699150b | 491 | |
17211ab5 GK |
492 | if (m.definition_length != ustrlen (newdefn) |
493 | || memcmp (namebuf, newdefn, m.definition_length) != 0) | |
494 | { | |
495 | if (CPP_OPTION (r, warn_invalid_pch)) | |
0527bc4e | 496 | cpp_error (r, CPP_DL_WARNING_SYSHDR, |
17211ab5 GK |
497 | "%s: not used because `%.*s' defined as `%s' not `%.*s'", |
498 | name, m.name_length, namebuf, newdefn + m.name_length, | |
499 | m.definition_length - m.name_length, | |
500 | namebuf + m.name_length); | |
501 | goto fail; | |
502 | } | |
503 | } | |
504 | free (namebuf); | |
505 | namebuf = NULL; | |
506 | ||
507 | /* Read in the list of identifiers that must not be defined. | |
508 | Check that they really aren't. */ | |
c3f829c1 | 509 | undeftab = XNEWVEC (unsigned char, m.definition_length); |
17211ab5 GK |
510 | if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length) |
511 | goto error; | |
c419b113 MA |
512 | |
513 | /* Collect identifiers from the current hash table. */ | |
514 | nl.n_defs = 0; | |
515 | nl.asize = 10; | |
c3f829c1 | 516 | nl.defs = XNEWVEC (cpp_hashnode *, nl.asize); |
c419b113 MA |
517 | cpp_forall_identifiers (r, &collect_ht_nodes, &nl); |
518 | qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes); | |
b699150b | 519 | |
c419b113 | 520 | /* Loop through nl.defs and undeftab, both of which are sorted lists. |
71c0e7fc | 521 | There should be no matches. */ |
c419b113 MA |
522 | first = undeftab; |
523 | last = undeftab + m.definition_length; | |
524 | i = 0; | |
b699150b | 525 | |
c419b113 | 526 | while (first < last && i < nl.n_defs) |
17211ab5 | 527 | { |
c419b113 | 528 | int cmp = ustrcmp (first, NODE_NAME (nl.defs[i])); |
b699150b | 529 | |
c419b113 MA |
530 | if (cmp < 0) |
531 | first += ustrlen (first) + 1; | |
532 | else if (cmp > 0) | |
533 | ++i; | |
534 | else | |
ccc01444 GK |
535 | { |
536 | if (CPP_OPTION (r, warn_invalid_pch)) | |
b699150b | 537 | cpp_error (r, CPP_DL_WARNING_SYSHDR, |
ccc01444 GK |
538 | "%s: not used because `%s' is defined", |
539 | name, first); | |
540 | goto fail; | |
541 | } | |
17211ab5 | 542 | } |
b699150b | 543 | |
c419b113 | 544 | free(nl.defs); |
a702045a | 545 | nl.defs = NULL; |
17211ab5 | 546 | free (undeftab); |
a702045a OW |
547 | undeftab = NULL; |
548 | ||
549 | /* Read in the next value of __COUNTER__. | |
550 | Check that (a) __COUNTER__ was not used in the pch or (b) __COUNTER__ | |
551 | has not been used in this translation unit. */ | |
552 | if (read (fd, &counter, sizeof (counter)) != sizeof (counter)) | |
553 | goto error; | |
554 | if (counter && r->counter) | |
555 | { | |
556 | if (CPP_OPTION (r, warn_invalid_pch)) | |
b699150b | 557 | cpp_error (r, CPP_DL_WARNING_SYSHDR, |
a702045a OW |
558 | "%s: not used because `__COUNTER__' is invalid", |
559 | name); | |
560 | goto fail; | |
561 | } | |
17211ab5 GK |
562 | |
563 | /* We win! */ | |
564 | return 0; | |
565 | ||
566 | error: | |
0527bc4e | 567 | cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header"); |
17211ab5 GK |
568 | return -1; |
569 | ||
570 | fail: | |
571 | if (namebuf != NULL) | |
572 | free (namebuf); | |
573 | if (undeftab != NULL) | |
574 | free (undeftab); | |
c419b113 MA |
575 | if (nl.defs != NULL) |
576 | free (nl.defs); | |
17211ab5 GK |
577 | return 1; |
578 | } | |
579 | ||
d8044160 | 580 | /* Save all the existing macros. */ |
17211ab5 | 581 | |
b699150b | 582 | struct save_macro_data |
17211ab5 | 583 | { |
d8044160 | 584 | uchar **defns; |
17211ab5 | 585 | size_t count; |
d8044160 | 586 | size_t array_size; |
17211ab5 GK |
587 | char **saved_pragmas; |
588 | }; | |
589 | ||
d8044160 GK |
590 | /* Save the definition of a single macro, so that it will persist |
591 | across a PCH restore. Because macro data is in GCed memory, which | |
592 | will be blown away by PCH, it must be temporarily copied to | |
593 | malloced memory. (The macros will refer to identifier nodes which | |
594 | are also GCed and so on, so the copying is done by turning them | |
595 | into self-contained strings.) The assumption is that most macro | |
596 | definitions will come from the PCH file, not from the compilation | |
597 | before the PCH file is loaded, so it doesn't matter that this is | |
598 | a little expensive. | |
599 | ||
600 | It would reduce the cost even further if macros defined in the PCH | |
601 | file were not saved in this way, but this is not done (yet), except | |
602 | for builtins, and for #assert by default. */ | |
17211ab5 | 603 | |
b699150b | 604 | static int |
d8044160 | 605 | save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p) |
17211ab5 GK |
606 | { |
607 | struct save_macro_data *data = (struct save_macro_data *)data_p; | |
608 | if (h->type != NT_VOID | |
609 | && (h->flags & NODE_BUILTIN) == 0) | |
610 | { | |
d8044160 GK |
611 | if (data->count == data->array_size) |
612 | { | |
613 | data->array_size *= 2; | |
b699150b | 614 | data->defns = XRESIZEVEC (uchar *, data->defns, (data->array_size)); |
d8044160 | 615 | } |
b699150b | 616 | |
d8044160 | 617 | switch (h->type) |
17211ab5 | 618 | { |
d8044160 GK |
619 | case NT_ASSERTION: |
620 | /* Not currently implemented. */ | |
621 | return 1; | |
622 | ||
623 | case NT_MACRO: | |
624 | { | |
625 | const uchar * defn = cpp_macro_definition (r, h); | |
626 | size_t defnlen = ustrlen (defn); | |
627 | ||
c3f829c1 GDR |
628 | data->defns[data->count] = (uchar *) xmemdup (defn, defnlen, |
629 | defnlen + 2); | |
d8044160 GK |
630 | data->defns[data->count][defnlen] = '\n'; |
631 | } | |
632 | break; | |
b699150b | 633 | |
d8044160 GK |
634 | default: |
635 | abort (); | |
17211ab5 | 636 | } |
17211ab5 | 637 | data->count++; |
17211ab5 GK |
638 | } |
639 | return 1; | |
640 | } | |
641 | ||
642 | /* Prepare to restore the state, by saving the currently-defined | |
643 | macros in 'data'. */ | |
644 | ||
645 | void | |
6cf87ca4 | 646 | cpp_prepare_state (cpp_reader *r, struct save_macro_data **data) |
17211ab5 | 647 | { |
c3f829c1 | 648 | struct save_macro_data *d = XNEW (struct save_macro_data); |
b699150b | 649 | |
d8044160 | 650 | d->array_size = 512; |
c3f829c1 | 651 | d->defns = XNEWVEC (uchar *, d->array_size); |
d8044160 | 652 | d->count = 0; |
17211ab5 GK |
653 | cpp_forall_identifiers (r, save_macros, d); |
654 | d->saved_pragmas = _cpp_save_pragma_names (r); | |
655 | *data = d; | |
656 | } | |
657 | ||
17211ab5 | 658 | /* Given a precompiled header that was previously determined to be valid, |
b699150b | 659 | apply all its definitions (and undefinitions) to the current state. |
17211ab5 GK |
660 | DEPNAME is passed to deps_restore. */ |
661 | ||
662 | int | |
6cf87ca4 ZW |
663 | cpp_read_state (cpp_reader *r, const char *name, FILE *f, |
664 | struct save_macro_data *data) | |
17211ab5 | 665 | { |
646544e3 | 666 | size_t i; |
d8044160 | 667 | struct lexer_state old_state; |
a702045a | 668 | unsigned int counter; |
17211ab5 | 669 | |
b699150b | 670 | /* Restore spec_nodes, which will be full of references to the old |
17211ab5 GK |
671 | hashtable entries and so will now be invalid. */ |
672 | { | |
673 | struct spec_nodes *s = &r->spec_nodes; | |
674 | s->n_defined = cpp_lookup (r, DSC("defined")); | |
675 | s->n_true = cpp_lookup (r, DSC("true")); | |
676 | s->n_false = cpp_lookup (r, DSC("false")); | |
677 | s->n__VA_ARGS__ = cpp_lookup (r, DSC("__VA_ARGS__")); | |
678 | } | |
679 | ||
17211ab5 | 680 | old_state = r->state; |
17211ab5 GK |
681 | r->state.in_directive = 1; |
682 | r->state.prevent_expansion = 1; | |
683 | r->state.angled_headers = 0; | |
684 | ||
d8044160 GK |
685 | /* Run through the carefully-saved macros, insert them. */ |
686 | for (i = 0; i < data->count; i++) | |
17211ab5 GK |
687 | { |
688 | cpp_hashnode *h; | |
d8044160 GK |
689 | size_t namelen; |
690 | uchar *defn; | |
17211ab5 | 691 | |
be0f1e54 | 692 | namelen = ustrcspn (data->defns[i], "( \n"); |
d8044160 GK |
693 | h = cpp_lookup (r, data->defns[i], namelen); |
694 | defn = data->defns[i] + namelen; | |
17211ab5 | 695 | |
d8044160 GK |
696 | /* The PCH file is valid, so we know that if there is a definition |
697 | from the PCH file it must be the same as the one we had | |
698 | originally, and so do not need to restore it. */ | |
699 | if (h->type == NT_VOID) | |
17211ab5 | 700 | { |
d8044160 | 701 | if (cpp_push_buffer (r, defn, ustrchr (defn, '\n') - defn, true) |
40de9f76 | 702 | != NULL) |
17211ab5 | 703 | { |
26aea073 | 704 | _cpp_clean_line (r); |
17211ab5 GK |
705 | if (!_cpp_create_definition (r, h)) |
706 | abort (); | |
707 | _cpp_pop_buffer (r); | |
708 | } | |
709 | else | |
710 | abort (); | |
711 | } | |
17211ab5 | 712 | |
d8044160 GK |
713 | free (data->defns[i]); |
714 | } | |
17211ab5 | 715 | r->state = old_state; |
d8044160 GK |
716 | |
717 | _cpp_restore_pragma_names (r, data->saved_pragmas); | |
718 | ||
719 | free (data); | |
17211ab5 GK |
720 | |
721 | if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL) | |
722 | != 0) | |
723 | goto error; | |
724 | ||
73e61092 GK |
725 | if (! _cpp_read_file_entries (r, f)) |
726 | goto error; | |
727 | ||
a702045a OW |
728 | if (fread (&counter, sizeof (counter), 1, f) != 1) |
729 | goto error; | |
730 | ||
731 | if (!r->counter) | |
732 | r->counter = counter; | |
733 | ||
17211ab5 | 734 | return 0; |
b699150b | 735 | |
17211ab5 | 736 | error: |
0527bc4e | 737 | cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header"); |
17211ab5 GK |
738 | return -1; |
739 | } |