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