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