]>
Commit | Line | Data |
---|---|---|
573aba85 | 1 | /* Part of CPP library. (Precompiled header reading/writing.) |
fbd26352 | 2 | Copyright (C) 2000-2019 Free Software Foundation, Inc. |
573aba85 | 3 | |
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 | |
6bc9506f | 6 | Free Software Foundation; either version 3, or (at your option) any |
573aba85 | 7 | later version. |
8 | ||
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. | |
13 | ||
14 | You should have received a copy of the GNU General Public License | |
6bc9506f | 15 | along with this program; see the file COPYING3. If not see |
16 | <http://www.gnu.org/licenses/>. */ | |
573aba85 | 17 | |
18 | #include "config.h" | |
19 | #include "system.h" | |
573aba85 | 20 | #include "cpplib.h" |
d856c8a6 | 21 | #include "internal.h" |
573aba85 | 22 | #include "hashtab.h" |
23 | #include "mkdeps.h" | |
24 | ||
f7fdd7a1 | 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 *); | |
038c21f1 | 35 | static int _cpp_save_pushed_macros (cpp_reader *, FILE *); |
36 | static int _cpp_restore_pushed_macros (cpp_reader *, FILE *); | |
573aba85 | 37 | |
38 | /* This structure represents a macro definition on disk. */ | |
e0dff4da | 39 | struct macrodef_struct |
573aba85 | 40 | { |
41 | unsigned int definition_length; | |
42 | unsigned short name_length; | |
43 | unsigned short flags; | |
44 | }; | |
45 | ||
e0dff4da | 46 | /* This is how we write out a macro definition. |
573aba85 | 47 | Suitable for being called by cpp_forall_identifiers. */ |
48 | ||
49 | static int | |
f7fdd7a1 | 50 | write_macdef (cpp_reader *pfile, cpp_hashnode *hn, void *file_p) |
573aba85 | 51 | { |
52 | FILE *f = (FILE *) file_p; | |
33bb12b1 | 53 | bool is_void = false; |
573aba85 | 54 | switch (hn->type) |
55 | { | |
56 | case NT_VOID: | |
57 | if (! (hn->flags & NODE_POISONED)) | |
58 | return 1; | |
33bb12b1 | 59 | is_void = true; |
60 | goto poisoned; | |
e0dff4da | 61 | |
33bb12b1 | 62 | case NT_BUILTIN_MACRO: |
573aba85 | 63 | return 1; |
e0dff4da | 64 | |
33bb12b1 | 65 | case NT_USER_MACRO: |
66 | if (hn->value.macro->kind != cmk_assert) | |
67 | { | |
68 | poisoned: | |
69 | struct macrodef_struct s; | |
70 | const unsigned char *defn; | |
71 | ||
72 | s.name_length = NODE_LEN (hn); | |
73 | s.flags = hn->flags & NODE_POISONED; | |
74 | ||
75 | if (is_void) | |
76 | { | |
77 | defn = NODE_NAME (hn); | |
78 | s.definition_length = s.name_length; | |
79 | } | |
80 | else | |
81 | { | |
82 | defn = cpp_macro_definition (pfile, hn); | |
83 | s.definition_length = ustrlen (defn); | |
84 | } | |
85 | ||
86 | if (fwrite (&s, sizeof (s), 1, f) != 1 | |
87 | || fwrite (defn, 1, s.definition_length, f) != s.definition_length) | |
88 | { | |
89 | cpp_errno (pfile, CPP_DL_ERROR, | |
90 | "while writing precompiled header"); | |
91 | return 0; | |
92 | } | |
93 | } | |
573aba85 | 94 | return 1; |
95 | ||
96 | default: | |
97 | abort (); | |
98 | } | |
99 | } | |
100 | ||
101 | /* This structure records the names of the defined macros. | |
102 | It's also used as a callback structure for size_initial_idents | |
103 | and save_idents. */ | |
104 | ||
105 | struct cpp_savedstate | |
106 | { | |
107 | /* A hash table of the defined identifiers. */ | |
108 | htab_t definedhash; | |
109 | /* The size of the definitions of those identifiers (the size of | |
110 | 'definedstrs'). */ | |
111 | size_t hashsize; | |
d35c4ac4 | 112 | /* Number of definitions */ |
113 | size_t n_defs; | |
6473f3f4 | 114 | /* Array of definitions. In cpp_write_pch_deps it is used for sorting. */ |
d35c4ac4 | 115 | cpp_hashnode **defs; |
573aba85 | 116 | /* Space for the next definition. Definitions are null-terminated |
117 | strings. */ | |
118 | unsigned char *definedstrs; | |
119 | }; | |
120 | ||
121 | /* Save this identifier into the state: put it in the hash table, | |
122 | put the definition in 'definedstrs'. */ | |
123 | ||
124 | static int | |
f7fdd7a1 | 125 | save_idents (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p) |
573aba85 | 126 | { |
127 | struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p; | |
e0dff4da | 128 | |
573aba85 | 129 | if (hn->type != NT_VOID) |
130 | { | |
131 | struct cpp_string news; | |
132 | void **slot; | |
133 | ||
134 | news.len = NODE_LEN (hn); | |
135 | news.text= NODE_NAME (hn); | |
136 | slot = htab_find_slot (ss->definedhash, &news, INSERT); | |
137 | if (*slot == NULL) | |
138 | { | |
139 | struct cpp_string *sp; | |
140 | unsigned char *text; | |
e0dff4da | 141 | |
720aca92 | 142 | sp = XNEW (struct cpp_string); |
573aba85 | 143 | *slot = sp; |
144 | ||
145 | sp->len = NODE_LEN (hn); | |
720aca92 | 146 | sp->text = text = XNEWVEC (unsigned char, NODE_LEN (hn)); |
573aba85 | 147 | memcpy (text, NODE_NAME (hn), NODE_LEN (hn)); |
148 | } | |
149 | } | |
150 | ||
151 | return 1; | |
152 | } | |
153 | ||
154 | /* Hash some memory in a generic way. */ | |
155 | ||
156 | static hashval_t | |
f7fdd7a1 | 157 | hashmem (const void *p_p, size_t sz) |
573aba85 | 158 | { |
159 | const unsigned char *p = (const unsigned char *)p_p; | |
160 | size_t i; | |
161 | hashval_t h; | |
e0dff4da | 162 | |
573aba85 | 163 | h = 0; |
164 | for (i = 0; i < sz; i++) | |
165 | h = h * 67 - (*p++ - 113); | |
166 | return h; | |
167 | } | |
168 | ||
169 | /* Hash a cpp string for the hashtable machinery. */ | |
170 | ||
171 | static hashval_t | |
f7fdd7a1 | 172 | cpp_string_hash (const void *a_p) |
573aba85 | 173 | { |
174 | const struct cpp_string *a = (const struct cpp_string *) a_p; | |
175 | return hashmem (a->text, a->len); | |
176 | } | |
177 | ||
178 | /* Compare two cpp strings for the hashtable machinery. */ | |
179 | ||
180 | static int | |
f7fdd7a1 | 181 | cpp_string_eq (const void *a_p, const void *b_p) |
573aba85 | 182 | { |
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); | |
187 | } | |
188 | ||
39bcf299 | 189 | /* Free memory associated with cpp_string. */ |
190 | ||
191 | static void | |
192 | cpp_string_free (void *a_p) | |
193 | { | |
194 | struct cpp_string *a = (struct cpp_string *) a_p; | |
195 | free ((void *) a->text); | |
196 | free (a); | |
197 | } | |
198 | ||
573aba85 | 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. */ | |
203 | ||
204 | int | |
f7fdd7a1 | 205 | cpp_save_state (cpp_reader *r, FILE *f) |
573aba85 | 206 | { |
207 | /* Save the list of non-void identifiers for the dependency checking. */ | |
720aca92 | 208 | r->savedstate = XNEW (struct cpp_savedstate); |
e0dff4da | 209 | r->savedstate->definedhash = htab_create (100, cpp_string_hash, |
39bcf299 | 210 | cpp_string_eq, cpp_string_free); |
573aba85 | 211 | cpp_forall_identifiers (r, save_idents, r->savedstate); |
e0dff4da | 212 | |
573aba85 | 213 | /* Write out the list of defined identifiers. */ |
214 | cpp_forall_identifiers (r, write_macdef, f); | |
215 | ||
216 | return 0; | |
217 | } | |
218 | ||
219 | /* Calculate the 'hashsize' field of the saved state. */ | |
220 | ||
221 | static int | |
f7fdd7a1 | 222 | count_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p) |
573aba85 | 223 | { |
224 | struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p; | |
e0dff4da | 225 | |
573aba85 | 226 | switch (hn->type) |
227 | { | |
33bb12b1 | 228 | case NT_BUILTIN_MACRO: |
229 | return 1; | |
230 | ||
231 | case NT_USER_MACRO: | |
232 | if (hn->value.macro->kind == cmk_assert) | |
573aba85 | 233 | return 1; |
e0dff4da | 234 | |
e3533433 | 235 | /* fall through. */ |
573aba85 | 236 | |
237 | case NT_VOID: | |
238 | { | |
239 | struct cpp_string news; | |
240 | void **slot; | |
e0dff4da | 241 | |
573aba85 | 242 | news.len = NODE_LEN (hn); |
243 | news.text = NODE_NAME (hn); | |
720aca92 | 244 | slot = (void **) htab_find (ss->definedhash, &news); |
573aba85 | 245 | if (slot == NULL) |
d35c4ac4 | 246 | { |
247 | ss->hashsize += NODE_LEN (hn) + 1; | |
248 | ss->n_defs += 1; | |
249 | } | |
573aba85 | 250 | } |
251 | return 1; | |
252 | ||
573aba85 | 253 | default: |
254 | abort (); | |
255 | } | |
256 | } | |
257 | ||
6473f3f4 | 258 | /* Collect the identifiers into the state's string table. */ |
573aba85 | 259 | static int |
f7fdd7a1 | 260 | write_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p) |
573aba85 | 261 | { |
262 | struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p; | |
e0dff4da | 263 | |
573aba85 | 264 | switch (hn->type) |
265 | { | |
33bb12b1 | 266 | case NT_BUILTIN_MACRO: |
267 | return 1; | |
268 | ||
269 | case NT_USER_MACRO: | |
270 | if (hn->value.macro->kind == cmk_assert) | |
573aba85 | 271 | return 1; |
e0dff4da | 272 | |
e3533433 | 273 | /* fall through. */ |
573aba85 | 274 | |
275 | case NT_VOID: | |
276 | { | |
277 | struct cpp_string news; | |
278 | void **slot; | |
e0dff4da | 279 | |
573aba85 | 280 | news.len = NODE_LEN (hn); |
281 | news.text = NODE_NAME (hn); | |
720aca92 | 282 | slot = (void **) htab_find (ss->definedhash, &news); |
573aba85 | 283 | if (slot == NULL) |
284 | { | |
d35c4ac4 | 285 | ss->defs[ss->n_defs] = hn; |
286 | ss->n_defs += 1; | |
573aba85 | 287 | } |
288 | } | |
289 | return 1; | |
290 | ||
573aba85 | 291 | default: |
292 | abort (); | |
293 | } | |
294 | } | |
295 | ||
d35c4ac4 | 296 | /* Comparison function for qsort. The arguments point to pointers of |
297 | type ht_hashnode *. */ | |
298 | static int | |
f7fdd7a1 | 299 | comp_hashnodes (const void *px, const void *py) |
d35c4ac4 | 300 | { |
301 | cpp_hashnode *x = *(cpp_hashnode **) px; | |
302 | cpp_hashnode *y = *(cpp_hashnode **) py; | |
303 | return ustrcmp (NODE_NAME (x), NODE_NAME (y)); | |
304 | } | |
305 | ||
573aba85 | 306 | /* Write out the remainder of the dependency information. This should be |
307 | called after the PCH is ready to be saved. */ | |
308 | ||
309 | int | |
f7fdd7a1 | 310 | cpp_write_pch_deps (cpp_reader *r, FILE *f) |
573aba85 | 311 | { |
312 | struct macrodef_struct z; | |
313 | struct cpp_savedstate *const ss = r->savedstate; | |
314 | unsigned char *definedstrs; | |
d35c4ac4 | 315 | size_t i; |
e0dff4da | 316 | |
d35c4ac4 | 317 | /* Collect the list of identifiers which have been seen and |
573aba85 | 318 | weren't defined to anything previously. */ |
d35c4ac4 | 319 | ss->hashsize = 0; |
320 | ss->n_defs = 0; | |
573aba85 | 321 | cpp_forall_identifiers (r, count_defs, ss); |
d35c4ac4 | 322 | |
720aca92 | 323 | ss->defs = XNEWVEC (cpp_hashnode *, ss->n_defs); |
d35c4ac4 | 324 | ss->n_defs = 0; |
573aba85 | 325 | cpp_forall_identifiers (r, write_defs, ss); |
d35c4ac4 | 326 | |
6473f3f4 | 327 | /* Sort the list, copy it into a buffer, and write it out. */ |
d35c4ac4 | 328 | qsort (ss->defs, ss->n_defs, sizeof (cpp_hashnode *), &comp_hashnodes); |
720aca92 | 329 | definedstrs = ss->definedstrs = XNEWVEC (unsigned char, ss->hashsize); |
d35c4ac4 | 330 | for (i = 0; i < ss->n_defs; ++i) |
331 | { | |
332 | size_t len = NODE_LEN (ss->defs[i]); | |
333 | memcpy (definedstrs, NODE_NAME (ss->defs[i]), len + 1); | |
334 | definedstrs += len + 1; | |
335 | } | |
336 | ||
573aba85 | 337 | memset (&z, 0, sizeof (z)); |
338 | z.definition_length = ss->hashsize; | |
339 | if (fwrite (&z, sizeof (z), 1, f) != 1 | |
d35c4ac4 | 340 | || fwrite (ss->definedstrs, ss->hashsize, 1, f) != 1) |
573aba85 | 341 | { |
d80d2074 | 342 | cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header"); |
573aba85 | 343 | return -1; |
344 | } | |
d35c4ac4 | 345 | free (ss->definedstrs); |
39bcf299 | 346 | free (ss->defs); |
347 | htab_delete (ss->definedhash); | |
573aba85 | 348 | |
349 | /* Free the saved state. */ | |
350 | free (ss); | |
351 | r->savedstate = NULL; | |
ce079f70 | 352 | |
353 | /* Save the next value of __COUNTER__. */ | |
354 | if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1) | |
355 | { | |
356 | cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header"); | |
357 | return -1; | |
358 | } | |
359 | ||
573aba85 | 360 | return 0; |
361 | } | |
362 | ||
363 | /* Write out the definitions of the preprocessor, in a form suitable for | |
364 | cpp_read_state. */ | |
365 | ||
366 | int | |
f7fdd7a1 | 367 | cpp_write_pch_state (cpp_reader *r, FILE *f) |
573aba85 | 368 | { |
573aba85 | 369 | if (!r->deps) |
370 | r->deps = deps_init (); | |
371 | ||
372 | if (deps_save (r->deps, f) != 0) | |
373 | { | |
d80d2074 | 374 | cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header"); |
573aba85 | 375 | return -1; |
376 | } | |
377 | ||
9f787687 | 378 | if (! _cpp_save_file_entries (r, f)) |
379 | { | |
380 | cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header"); | |
381 | return -1; | |
382 | } | |
383 | ||
ce079f70 | 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) | |
388 | { | |
389 | cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header"); | |
390 | return -1; | |
391 | } | |
392 | ||
038c21f1 | 393 | /* Write saved macros. */ |
394 | if (! _cpp_save_pushed_macros (r, f)) | |
395 | { | |
396 | cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header"); | |
397 | return -1; | |
398 | } | |
399 | ||
573aba85 | 400 | return 0; |
401 | } | |
402 | ||
038c21f1 | 403 | static int |
404 | _cpp_restore_pushed_macros (cpp_reader *r, FILE *f) | |
405 | { | |
406 | size_t count_saved = 0; | |
407 | size_t i; | |
408 | struct def_pragma_macro *p; | |
409 | size_t nlen; | |
038c21f1 | 410 | uchar *defn; |
411 | size_t defnlen; | |
412 | ||
413 | if (fread (&count_saved, sizeof (count_saved), 1, f) != 1) | |
414 | return 0; | |
415 | if (! count_saved) | |
416 | return 1; | |
417 | for (i = 0; i < count_saved; i++) | |
418 | { | |
419 | if (fread (&nlen, sizeof (nlen), 1, f) != 1) | |
420 | return 0; | |
421 | p = XNEW (struct def_pragma_macro); | |
0d601ff4 | 422 | memset (p, 0, sizeof (struct def_pragma_macro)); |
038c21f1 | 423 | p->name = XNEWVAR (char, nlen + 1); |
424 | p->name[nlen] = 0; | |
425 | if (fread (p->name, nlen, 1, f) != 1) | |
426 | return 0; | |
038c21f1 | 427 | if (fread (&defnlen, sizeof (defnlen), 1, f) != 1) |
428 | return 0; | |
0d601ff4 | 429 | if (defnlen == 0) |
430 | p->is_undef = 1; | |
431 | else | |
432 | { | |
433 | defn = XNEWVEC (uchar, defnlen + 1); | |
434 | defn[defnlen] = 0; | |
435 | ||
436 | if (fread (defn, defnlen, 1, f) != 1) | |
437 | return 0; | |
038c21f1 | 438 | |
0d601ff4 | 439 | p->definition = defn; |
be1e7283 | 440 | if (fread (&(p->line), sizeof (location_t), 1, f) != 1) |
0d601ff4 | 441 | return 0; |
442 | defnlen = 0; | |
443 | if (fread (&defnlen, sizeof (defnlen), 1, f) != 1) | |
444 | return 0; | |
445 | p->syshdr = ((defnlen & 1) != 0 ? 1 : 0); | |
446 | p->used = ((defnlen & 2) != 0 ? 1 : 0); | |
447 | } | |
038c21f1 | 448 | |
038c21f1 | 449 | p->next = r->pushed_macros; |
450 | r->pushed_macros = p; | |
038c21f1 | 451 | } |
452 | return 1; | |
453 | } | |
454 | ||
455 | static int | |
456 | _cpp_save_pushed_macros (cpp_reader *r, FILE *f) | |
457 | { | |
458 | size_t count_saved = 0; | |
459 | size_t i; | |
460 | struct def_pragma_macro *p,**pp; | |
038c21f1 | 461 | size_t defnlen; |
038c21f1 | 462 | |
463 | /* Get count. */ | |
464 | p = r->pushed_macros; | |
465 | while (p != NULL) | |
466 | { | |
467 | count_saved++; | |
468 | p = p->next; | |
469 | } | |
470 | if (fwrite (&count_saved, sizeof (count_saved), 1, f) != 1) | |
471 | return 0; | |
472 | if (!count_saved) | |
473 | return 1; | |
474 | ||
475 | pp = (struct def_pragma_macro **) alloca (sizeof (struct def_pragma_macro *) | |
476 | * count_saved); | |
477 | /* Store them in reverse order. */ | |
478 | p = r->pushed_macros; | |
479 | i = count_saved; | |
480 | while (p != NULL) | |
481 | { | |
482 | --i; | |
483 | pp[i] = p; | |
484 | p = p->next; | |
485 | } | |
486 | for (i = 0; i < count_saved; i++) | |
487 | { | |
038c21f1 | 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) | |
491 | return 0; | |
0d601ff4 | 492 | if (pp[i]->is_undef) |
493 | { | |
494 | defnlen = 0; | |
495 | if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1) | |
496 | return 0; | |
497 | } | |
498 | else | |
499 | { | |
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) | |
503 | return 0; | |
be1e7283 | 504 | if (fwrite (&(pp[i]->line), sizeof (location_t), 1, f) != 1) |
0d601ff4 | 505 | return 0; |
506 | defnlen = 0; | |
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) | |
510 | return 0; | |
511 | } | |
038c21f1 | 512 | } |
513 | return 1; | |
514 | } | |
515 | ||
d35c4ac4 | 516 | |
517 | /* Data structure to transform hash table nodes into a sorted list */ | |
518 | ||
519 | struct ht_node_list | |
520 | { | |
521 | /* Array of nodes */ | |
522 | cpp_hashnode **defs; | |
523 | /* Number of nodes in the array */ | |
524 | size_t n_defs; | |
525 | /* Size of the allocated array */ | |
526 | size_t asize; | |
527 | }; | |
528 | ||
529 | /* Callback for collecting identifiers from hash table */ | |
530 | ||
531 | static int | |
f7fdd7a1 | 532 | collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, |
533 | void *nl_p) | |
d35c4ac4 | 534 | { |
535 | struct ht_node_list *const nl = (struct ht_node_list *)nl_p; | |
536 | ||
537 | if (hn->type != NT_VOID || hn->flags & NODE_POISONED) | |
538 | { | |
539 | if (nl->n_defs == nl->asize) | |
540 | { | |
541 | nl->asize *= 2; | |
720aca92 | 542 | nl->defs = XRESIZEVEC (cpp_hashnode *, nl->defs, nl->asize); |
d35c4ac4 | 543 | } |
544 | ||
545 | nl->defs[nl->n_defs] = hn; | |
546 | ++nl->n_defs; | |
547 | } | |
548 | return 1; | |
549 | } | |
550 | ||
551 | ||
573aba85 | 552 | /* Return nonzero if FD is a precompiled header which is consistent |
553 | with the preprocessor's current definitions. It will be consistent | |
554 | when: | |
555 | ||
e0dff4da | 556 | - anything that was defined just before the PCH was generated |
573aba85 | 557 | is defined the same way now; and |
558 | - anything that was not defined then, but is defined now, was not | |
559 | used by the PCH. | |
560 | ||
561 | NAME is used to print warnings if `warn_invalid_pch' is set in the | |
562 | reader's flags. | |
563 | */ | |
564 | ||
565 | int | |
f7fdd7a1 | 566 | cpp_valid_state (cpp_reader *r, const char *name, int fd) |
573aba85 | 567 | { |
568 | struct macrodef_struct m; | |
569 | size_t namebufsz = 256; | |
720aca92 | 570 | unsigned char *namebuf = XNEWVEC (unsigned char, namebufsz); |
573aba85 | 571 | unsigned char *undeftab = NULL; |
506b1f4e | 572 | struct ht_node_list nl = { 0, 0, 0 }; |
d35c4ac4 | 573 | unsigned char *first, *last; |
573aba85 | 574 | unsigned int i; |
ce079f70 | 575 | unsigned int counter; |
e0dff4da | 576 | |
573aba85 | 577 | /* Read in the list of identifiers that must be defined |
578 | Check that they are defined in the same way. */ | |
579 | for (;;) | |
580 | { | |
581 | cpp_hashnode *h; | |
582 | const unsigned char *newdefn; | |
e0dff4da | 583 | |
573aba85 | 584 | if (read (fd, &m, sizeof (m)) != sizeof (m)) |
585 | goto error; | |
e0dff4da | 586 | |
573aba85 | 587 | if (m.name_length == 0) |
588 | break; | |
589 | ||
d718b525 | 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)) | |
593 | { | |
594 | if (lseek (fd, m.definition_length, SEEK_CUR) == -1) | |
595 | goto error; | |
596 | continue; | |
597 | } | |
598 | ||
573aba85 | 599 | if (m.definition_length > namebufsz) |
600 | { | |
601 | free (namebuf); | |
602 | namebufsz = m.definition_length + 256; | |
720aca92 | 603 | namebuf = XNEWVEC (unsigned char, namebufsz); |
573aba85 | 604 | } |
d718b525 | 605 | |
e0dff4da | 606 | if ((size_t)read (fd, namebuf, m.definition_length) |
573aba85 | 607 | != m.definition_length) |
608 | goto error; | |
e0dff4da | 609 | |
573aba85 | 610 | h = cpp_lookup (r, namebuf, m.name_length); |
611 | if (m.flags & NODE_POISONED | |
573aba85 | 612 | || h->flags & NODE_POISONED) |
613 | { | |
c1203b1c | 614 | if (CPP_OPTION (r, warn_invalid_pch)) |
3a79f5da | 615 | cpp_warning_syshdr (r, CPP_W_INVALID_PCH, |
616 | "%s: not used because `%.*s' is poisoned", | |
617 | name, m.name_length, namebuf); | |
c1203b1c | 618 | goto fail; |
619 | } | |
620 | ||
33bb12b1 | 621 | if (h->type == NT_VOID) |
c1203b1c | 622 | { |
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 | |
2fbe7a32 | 628 | definitions that take this macro into account, to decide |
c1203b1c | 629 | what asm to emit, won't issue .cfi directives when the |
630 | compiler doesn't. */ | |
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)) | |
634 | continue; | |
635 | ||
573aba85 | 636 | if (CPP_OPTION (r, warn_invalid_pch)) |
3a79f5da | 637 | cpp_warning_syshdr (r, CPP_W_INVALID_PCH, |
638 | "%s: not used because `%.*s' not defined", | |
639 | name, m.name_length, namebuf); | |
573aba85 | 640 | goto fail; |
641 | } | |
642 | ||
643 | newdefn = cpp_macro_definition (r, h); | |
e0dff4da | 644 | |
573aba85 | 645 | if (m.definition_length != ustrlen (newdefn) |
646 | || memcmp (namebuf, newdefn, m.definition_length) != 0) | |
647 | { | |
648 | if (CPP_OPTION (r, warn_invalid_pch)) | |
3a79f5da | 649 | cpp_warning_syshdr (r, CPP_W_INVALID_PCH, |
573aba85 | 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); | |
654 | goto fail; | |
655 | } | |
656 | } | |
657 | free (namebuf); | |
658 | namebuf = NULL; | |
659 | ||
660 | /* Read in the list of identifiers that must not be defined. | |
661 | Check that they really aren't. */ | |
720aca92 | 662 | undeftab = XNEWVEC (unsigned char, m.definition_length); |
573aba85 | 663 | if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length) |
664 | goto error; | |
d35c4ac4 | 665 | |
666 | /* Collect identifiers from the current hash table. */ | |
667 | nl.n_defs = 0; | |
668 | nl.asize = 10; | |
720aca92 | 669 | nl.defs = XNEWVEC (cpp_hashnode *, nl.asize); |
d35c4ac4 | 670 | cpp_forall_identifiers (r, &collect_ht_nodes, &nl); |
671 | qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes); | |
e0dff4da | 672 | |
d35c4ac4 | 673 | /* Loop through nl.defs and undeftab, both of which are sorted lists. |
6473f3f4 | 674 | There should be no matches. */ |
d35c4ac4 | 675 | first = undeftab; |
676 | last = undeftab + m.definition_length; | |
677 | i = 0; | |
e0dff4da | 678 | |
d35c4ac4 | 679 | while (first < last && i < nl.n_defs) |
573aba85 | 680 | { |
d35c4ac4 | 681 | int cmp = ustrcmp (first, NODE_NAME (nl.defs[i])); |
e0dff4da | 682 | |
d35c4ac4 | 683 | if (cmp < 0) |
684 | first += ustrlen (first) + 1; | |
685 | else if (cmp > 0) | |
686 | ++i; | |
687 | else | |
1b17fe86 | 688 | { |
689 | if (CPP_OPTION (r, warn_invalid_pch)) | |
3a79f5da | 690 | cpp_warning_syshdr (r, CPP_W_INVALID_PCH, |
691 | "%s: not used because `%s' is defined", | |
692 | name, first); | |
1b17fe86 | 693 | goto fail; |
694 | } | |
573aba85 | 695 | } |
e0dff4da | 696 | |
d35c4ac4 | 697 | free(nl.defs); |
ce079f70 | 698 | nl.defs = NULL; |
573aba85 | 699 | free (undeftab); |
ce079f70 | 700 | undeftab = NULL; |
701 | ||
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)) | |
706 | goto error; | |
707 | if (counter && r->counter) | |
708 | { | |
709 | if (CPP_OPTION (r, warn_invalid_pch)) | |
3a79f5da | 710 | cpp_warning_syshdr (r, CPP_W_INVALID_PCH, |
711 | "%s: not used because `__COUNTER__' is invalid", | |
712 | name); | |
5c6f6a61 | 713 | goto fail; |
ce079f70 | 714 | } |
573aba85 | 715 | |
716 | /* We win! */ | |
717 | return 0; | |
718 | ||
719 | error: | |
d80d2074 | 720 | cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header"); |
573aba85 | 721 | |
722 | fail: | |
dd045aee | 723 | free (namebuf); |
724 | free (undeftab); | |
725 | free (nl.defs); | |
573aba85 | 726 | return 1; |
727 | } | |
728 | ||
c39ed964 | 729 | /* Save all the existing macros. */ |
573aba85 | 730 | |
e0dff4da | 731 | struct save_macro_data |
573aba85 | 732 | { |
c39ed964 | 733 | uchar **defns; |
573aba85 | 734 | size_t count; |
c39ed964 | 735 | size_t array_size; |
573aba85 | 736 | char **saved_pragmas; |
737 | }; | |
738 | ||
c39ed964 | 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 | |
747 | a little expensive. | |
748 | ||
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. */ | |
573aba85 | 752 | |
e0dff4da | 753 | static int |
c39ed964 | 754 | save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p) |
573aba85 | 755 | { |
756 | struct save_macro_data *data = (struct save_macro_data *)data_p; | |
25692381 | 757 | |
33bb12b1 | 758 | if (cpp_user_macro_p (h)) |
573aba85 | 759 | { |
c39ed964 | 760 | if (data->count == data->array_size) |
761 | { | |
762 | data->array_size *= 2; | |
e0dff4da | 763 | data->defns = XRESIZEVEC (uchar *, data->defns, (data->array_size)); |
c39ed964 | 764 | } |
e0dff4da | 765 | |
33bb12b1 | 766 | const uchar * defn = cpp_macro_definition (r, h); |
767 | size_t defnlen = ustrlen (defn); | |
c39ed964 | 768 | |
33bb12b1 | 769 | data->defns[data->count] = (uchar *) xmemdup (defn, defnlen, defnlen + 2); |
770 | data->defns[data->count][defnlen] = '\n'; | |
573aba85 | 771 | data->count++; |
573aba85 | 772 | } |
33bb12b1 | 773 | |
573aba85 | 774 | return 1; |
775 | } | |
776 | ||
777 | /* Prepare to restore the state, by saving the currently-defined | |
778 | macros in 'data'. */ | |
779 | ||
780 | void | |
f7fdd7a1 | 781 | cpp_prepare_state (cpp_reader *r, struct save_macro_data **data) |
573aba85 | 782 | { |
720aca92 | 783 | struct save_macro_data *d = XNEW (struct save_macro_data); |
e0dff4da | 784 | |
c39ed964 | 785 | d->array_size = 512; |
720aca92 | 786 | d->defns = XNEWVEC (uchar *, d->array_size); |
c39ed964 | 787 | d->count = 0; |
573aba85 | 788 | cpp_forall_identifiers (r, save_macros, d); |
789 | d->saved_pragmas = _cpp_save_pragma_names (r); | |
790 | *data = d; | |
791 | } | |
792 | ||
573aba85 | 793 | /* Given a precompiled header that was previously determined to be valid, |
e0dff4da | 794 | apply all its definitions (and undefinitions) to the current state. |
573aba85 | 795 | DEPNAME is passed to deps_restore. */ |
796 | ||
797 | int | |
f7fdd7a1 | 798 | cpp_read_state (cpp_reader *r, const char *name, FILE *f, |
799 | struct save_macro_data *data) | |
573aba85 | 800 | { |
09f10c94 | 801 | size_t i; |
c39ed964 | 802 | struct lexer_state old_state; |
ce079f70 | 803 | unsigned int counter; |
573aba85 | 804 | |
e0dff4da | 805 | /* Restore spec_nodes, which will be full of references to the old |
573aba85 | 806 | hashtable entries and so will now be invalid. */ |
807 | { | |
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__")); | |
86136db8 | 813 | s->n__VA_OPT__ = cpp_lookup (r, DSC("__VA_OPT__")); |
f6751ff2 | 814 | s->n__has_include__ = cpp_lookup (r, DSC("__has_include__")); |
815 | s->n__has_include_next__ = cpp_lookup (r, DSC("__has_include_next__")); | |
573aba85 | 816 | } |
817 | ||
573aba85 | 818 | old_state = r->state; |
573aba85 | 819 | r->state.in_directive = 1; |
820 | r->state.prevent_expansion = 1; | |
821 | r->state.angled_headers = 0; | |
822 | ||
c39ed964 | 823 | /* Run through the carefully-saved macros, insert them. */ |
824 | for (i = 0; i < data->count; i++) | |
573aba85 | 825 | { |
826 | cpp_hashnode *h; | |
c39ed964 | 827 | size_t namelen; |
828 | uchar *defn; | |
573aba85 | 829 | |
bb30d1f4 | 830 | namelen = ustrcspn (data->defns[i], "( \n"); |
c39ed964 | 831 | h = cpp_lookup (r, data->defns[i], namelen); |
832 | defn = data->defns[i] + namelen; | |
573aba85 | 833 | |
c39ed964 | 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) | |
573aba85 | 838 | { |
c39ed964 | 839 | if (cpp_push_buffer (r, defn, ustrchr (defn, '\n') - defn, true) |
9eb74666 | 840 | != NULL) |
573aba85 | 841 | { |
a54e0bf8 | 842 | _cpp_clean_line (r); |
573aba85 | 843 | if (!_cpp_create_definition (r, h)) |
844 | abort (); | |
845 | _cpp_pop_buffer (r); | |
846 | } | |
847 | else | |
848 | abort (); | |
849 | } | |
573aba85 | 850 | |
c39ed964 | 851 | free (data->defns[i]); |
852 | } | |
573aba85 | 853 | r->state = old_state; |
c39ed964 | 854 | |
855 | _cpp_restore_pragma_names (r, data->saved_pragmas); | |
856 | ||
857 | free (data); | |
573aba85 | 858 | |
859 | if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL) | |
860 | != 0) | |
861 | goto error; | |
862 | ||
9f787687 | 863 | if (! _cpp_read_file_entries (r, f)) |
864 | goto error; | |
865 | ||
ce079f70 | 866 | if (fread (&counter, sizeof (counter), 1, f) != 1) |
867 | goto error; | |
868 | ||
869 | if (!r->counter) | |
870 | r->counter = counter; | |
871 | ||
038c21f1 | 872 | /* Read pushed macros. */ |
873 | if (! _cpp_restore_pushed_macros (r, f)) | |
874 | goto error; | |
573aba85 | 875 | return 0; |
e0dff4da | 876 | |
573aba85 | 877 | error: |
d80d2074 | 878 | cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header"); |
573aba85 | 879 | return -1; |
880 | } |