1/* Part of CPP library. (Precompiled header reading/writing.) 2 Copyright (C) 2000-2015 Free Software Foundation, Inc. 3 4This program is free software; you can redistribute it and/or modify it 5under the terms of the GNU General Public License as published by the 6Free Software Foundation; either version 3, or (at your option) any 7later version. 8 9This program is distributed in the hope that it will be useful, 10but WITHOUT ANY WARRANTY; without even the implied warranty of 11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12GNU General Public License for more details. 13 14You should have received a copy of the GNU General Public License 15along with this program; see the file COPYING3. If not see 16<http://www.gnu.org/licenses/>. */ 17 18#include "config.h" 19#include "system.h" 20#include "cpplib.h" 21#include "internal.h" 22#include "hashtab.h" 23#include "mkdeps.h" 24 25static int write_macdef (cpp_reader *, cpp_hashnode *, void *); 26static int save_idents (cpp_reader *, cpp_hashnode *, void *); 27static hashval_t hashmem (const void *, size_t); 28static hashval_t cpp_string_hash (const void *); 29static int cpp_string_eq (const void *, const void *); 30static int count_defs (cpp_reader *, cpp_hashnode *, void *); 31static int comp_hashnodes (const void *, const void *); 32static int collect_ht_nodes (cpp_reader *, cpp_hashnode *, void *); 33static int write_defs (cpp_reader *, cpp_hashnode *, void *); 34static int save_macros (cpp_reader *, cpp_hashnode *, void *); 35static int _cpp_save_pushed_macros (cpp_reader *, FILE *); 36static int _cpp_restore_pushed_macros (cpp_reader *, FILE *); 37 38/* This structure represents a macro definition on disk. */ 39struct macrodef_struct 40{ 41 unsigned int definition_length; 42 unsigned short name_length; 43 unsigned short flags; 44}; 45 46/* This is how we write out a macro definition. 47 Suitable for being called by cpp_forall_identifiers. */ 48 49static int 50write_macdef (cpp_reader *pfile, cpp_hashnode *hn, void *file_p) 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; 58 59 case NT_MACRO: 60 if ((hn->flags & NODE_BUILTIN) 61 && (!pfile->cb.user_builtin_macro 62 || !pfile->cb.user_builtin_macro (pfile, hn))) 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 } 82 83 if (fwrite (&s, sizeof (s), 1, f) != 1 84 || fwrite (defn, 1, s.definition_length, f) != s.definition_length) 85 { 86 cpp_errno (pfile, CPP_DL_ERROR, 87 "while writing precompiled header"); 88 return 0; 89 } 90 } 91 return 1; 92 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 106struct 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; 113 /* Number of definitions */ 114 size_t n_defs; 115 /* Array of definitions. In cpp_write_pch_deps it is used for sorting. */ 116 cpp_hashnode **defs; 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 125static int 126save_idents (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p) 127{ 128 struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p; 129 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; 142 143 sp = XNEW (struct cpp_string); 144 *slot = sp; 145 146 sp->len = NODE_LEN (hn); 147 sp->text = text = XNEWVEC (unsigned char, NODE_LEN (hn)); 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 157static hashval_t 158hashmem (const void *p_p, size_t sz) 159{ 160 const unsigned char *p = (const unsigned char *)p_p; 161 size_t i; 162 hashval_t h; 163 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 172static hashval_t 173cpp_string_hash (const void *a_p) 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 181static int 182cpp_string_eq (const void *a_p, const void *b_p) 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 190/* Free memory associated with cpp_string. */ 191 192static void 193cpp_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 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 205int 206cpp_save_state (cpp_reader *r, FILE *f) 207{ 208 /* Save the list of non-void identifiers for the dependency checking. */ 209 r->savedstate = XNEW (struct cpp_savedstate); 210 r->savedstate->definedhash = htab_create (100, cpp_string_hash, 211 cpp_string_eq, cpp_string_free); 212 cpp_forall_identifiers (r, save_idents, r->savedstate); 213 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 222static int 223count_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p) 224{ 225 struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p; 226 227 switch (hn->type) 228 { 229 case NT_MACRO: 230 if (hn->flags & NODE_BUILTIN) 231 return 1; 232 233 /* else fall through. */ 234 235 case NT_VOID: 236 { 237 struct cpp_string news; 238 void **slot; 239 240 news.len = NODE_LEN (hn); 241 news.text = NODE_NAME (hn); 242 slot = (void **) htab_find (ss->definedhash, &news); 243 if (slot == NULL) 244 { 245 ss->hashsize += NODE_LEN (hn) + 1; 246 ss->n_defs += 1; 247 } 248 } 249 return 1; 250 251 case NT_ASSERTION: 252 /* Not currently implemented. */ 253 return 1; 254 255 default: 256 abort (); 257 } 258} 259 260/* Collect the identifiers into the state's string table. */ 261static int 262write_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p) 263{ 264 struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p; 265 266 switch (hn->type) 267 { 268 case NT_MACRO: 269 if (hn->flags & NODE_BUILTIN) 270 return 1; 271 272 /* else fall through. */ 273 274 case NT_VOID: 275 { 276 struct cpp_string news; 277 void **slot; 278 279 news.len = NODE_LEN (hn); 280 news.text = NODE_NAME (hn); 281 slot = (void **) htab_find (ss->definedhash, &news); 282 if (slot == NULL) 283 { 284 ss->defs[ss->n_defs] = hn; 285 ss->n_defs += 1; 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 299/* Comparison function for qsort. The arguments point to pointers of 300 type ht_hashnode *. */ 301static int 302comp_hashnodes (const void *px, const void *py) 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 309/* Write out the remainder of the dependency information. This should be 310 called after the PCH is ready to be saved. */ 311 312int 313cpp_write_pch_deps (cpp_reader *r, FILE *f) 314{ 315 struct macrodef_struct z; 316 struct cpp_savedstate *const ss = r->savedstate; 317 unsigned char *definedstrs; 318 size_t i; 319 320 /* Collect the list of identifiers which have been seen and 321 weren't defined to anything previously. */ 322 ss->hashsize = 0; 323 ss->n_defs = 0; 324 cpp_forall_identifiers (r, count_defs, ss); 325 326 ss->defs = XNEWVEC (cpp_hashnode *, ss->n_defs); 327 ss->n_defs = 0; 328 cpp_forall_identifiers (r, write_defs, ss); 329 330 /* Sort the list, copy it into a buffer, and write it out. */ 331 qsort (ss->defs, ss->n_defs, sizeof (cpp_hashnode *), &comp_hashnodes); 332 definedstrs = ss->definedstrs = XNEWVEC (unsigned char, ss->hashsize); 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 340 memset (&z, 0, sizeof (z)); 341 z.definition_length = ss->hashsize; 342 if (fwrite (&z, sizeof (z), 1, f) != 1 343 || fwrite (ss->definedstrs, ss->hashsize, 1, f) != 1) 344 { 345 cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header"); 346 return -1; 347 } 348 free (ss->definedstrs); 349 free (ss->defs); 350 htab_delete (ss->definedhash); 351 352 /* Free the saved state. */ 353 free (ss); 354 r->savedstate = NULL; 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 363 return 0; 364} 365 366/* Write out the definitions of the preprocessor, in a form suitable for 367 cpp_read_state. */ 368 369int 370cpp_write_pch_state (cpp_reader *r, FILE *f) 371{ 372 if (!r->deps) 373 r->deps = deps_init (); 374 375 if (deps_save (r->deps, f) != 0) 376 { 377 cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header"); 378 return -1; 379 } 380 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 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 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 403 return 0; 404} 405 406static 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; 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); 425 memset (p, 0, sizeof (struct def_pragma_macro)); 426 p->name = XNEWVAR (char, nlen + 1); 427 p->name[nlen] = 0; 428 if (fread (p->name, nlen, 1, f) != 1) 429 return 0; 430 if (fread (&defnlen, sizeof (defnlen), 1, f) != 1) 431 return 0; 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; 441 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 } 451 452 p->next = r->pushed_macros; 453 r->pushed_macros = p; 454 } 455 return 1; 456} 457 458static 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; 464 size_t defnlen; 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 { 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; 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 } 515 } 516 return 1; 517} 518 519 520/* Data structure to transform hash table nodes into a sorted list */ 521 522struct 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 534static int 535collect_ht_nodes (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, 536 void *nl_p) 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; 545 nl->defs = XRESIZEVEC (cpp_hashnode *, nl->defs, nl->asize); 546 } 547 548 nl->defs[nl->n_defs] = hn; 549 ++nl->n_defs; 550 } 551 return 1; 552} 553 554 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 559 - anything that was defined just before the PCH was generated 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 568int 569cpp_valid_state (cpp_reader *r, const char *name, int fd) 570{ 571 struct macrodef_struct m; 572 size_t namebufsz = 256; 573 unsigned char *namebuf = XNEWVEC (unsigned char, namebufsz); 574 unsigned char *undeftab = NULL; 575 struct ht_node_list nl = { 0, 0, 0 }; 576 unsigned char *first, *last; 577 unsigned int i; 578 unsigned int counter; 579 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; 586 587 if (read (fd, &m, sizeof (m)) != sizeof (m)) 588 goto error; 589 590 if (m.name_length == 0) 591 break; 592 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 602 if (m.definition_length > namebufsz) 603 { 604 free (namebuf); 605 namebufsz = m.definition_length + 256; 606 namebuf = XNEWVEC (unsigned char, namebufsz); 607 } 608 609 if ((size_t)read (fd, namebuf, m.definition_length) 610 != m.definition_length) 611 goto error; 612 613 h = cpp_lookup (r, namebuf, m.name_length); 614 if (m.flags & NODE_POISONED 615 || h->flags & NODE_POISONED) 616 { 617 if (CPP_OPTION (r, warn_invalid_pch)) 618 cpp_warning_syshdr (r, CPP_W_INVALID_PCH, 619 "%s: not used because `%.*s' is poisoned", 620 name, m.name_length, namebuf); 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 639 if (CPP_OPTION (r, warn_invalid_pch)) 640 cpp_warning_syshdr (r, CPP_W_INVALID_PCH, 641 "%s: not used because `%.*s' not defined", 642 name, m.name_length, namebuf); 643 goto fail; 644 } 645 646 newdefn = cpp_macro_definition (r, h); 647 648 if (m.definition_length != ustrlen (newdefn) 649 || memcmp (namebuf, newdefn, m.definition_length) != 0) 650 { 651 if (CPP_OPTION (r, warn_invalid_pch)) 652 cpp_warning_syshdr (r, CPP_W_INVALID_PCH, 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. */ 665 undeftab = XNEWVEC (unsigned char, m.definition_length); 666 if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length) 667 goto error; 668 669 /* Collect identifiers from the current hash table. */ 670 nl.n_defs = 0; 671 nl.asize = 10; 672 nl.defs = XNEWVEC (cpp_hashnode *, nl.asize); 673 cpp_forall_identifiers (r, &collect_ht_nodes, &nl); 674 qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes); 675 676 /* Loop through nl.defs and undeftab, both of which are sorted lists. 677 There should be no matches. */ 678 first = undeftab; 679 last = undeftab + m.definition_length; 680 i = 0; 681 682 while (first < last && i < nl.n_defs) 683 { 684 int cmp = ustrcmp (first, NODE_NAME (nl.defs[i])); 685 686 if (cmp < 0) 687 first += ustrlen (first) + 1; 688 else if (cmp > 0) 689 ++i; 690 else 691 { 692 if (CPP_OPTION (r, warn_invalid_pch)) 693 cpp_warning_syshdr (r, CPP_W_INVALID_PCH, 694 "%s: not used because `%s' is defined", 695 name, first); 696 goto fail; 697 } 698 } 699 700 free(nl.defs); 701 nl.defs = NULL; 702 free (undeftab); 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)) 713 cpp_warning_syshdr (r, CPP_W_INVALID_PCH, 714 "%s: not used because `__COUNTER__' is invalid", 715 name); 716 goto fail; 717 } 718 719 /* We win! */ 720 return 0; 721 722 error: 723 cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header"); 724 725 fail: 726 free (namebuf); 727 free (undeftab); 728 free (nl.defs); 729 return 1; 730} 731 732/* Save all the existing macros. */ 733 734struct save_macro_data 735{ 736 uchar **defns; 737 size_t count; 738 size_t array_size; 739 char **saved_pragmas; 740}; 741 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. */ 755 756static int 757save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p) 758{ 759 struct save_macro_data *data = (struct save_macro_data *)data_p; 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 766 if (h->type != NT_VOID 767 && (h->flags & NODE_BUILTIN) == 0) 768 { 769 if (data->count == data->array_size) 770 { 771 data->array_size *= 2; 772 data->defns = XRESIZEVEC (uchar *, data->defns, (data->array_size)); 773 } 774 775 switch (h->type) 776 { 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 786 data->defns[data->count] = (uchar *) xmemdup (defn, defnlen, 787 defnlen + 2); 788 data->defns[data->count][defnlen] = '\n'; 789 } 790 break; 791 792 default: 793 abort (); 794 } 795 data->count++; 796 } 797 return 1; 798} 799 800/* Prepare to restore the state, by saving the currently-defined 801 macros in 'data'. */ 802 803void 804cpp_prepare_state (cpp_reader *r, struct save_macro_data **data) 805{ 806 struct save_macro_data *d = XNEW (struct save_macro_data); 807 808 d->array_size = 512; 809 d->defns = XNEWVEC (uchar *, d->array_size); 810 d->count = 0; 811 cpp_forall_identifiers (r, save_macros, d); 812 d->saved_pragmas = _cpp_save_pragma_names (r); 813 *data = d; 814} 815 816/* Given a precompiled header that was previously determined to be valid, 817 apply all its definitions (and undefinitions) to the current state. 818 DEPNAME is passed to deps_restore. */ 819 820int 821cpp_read_state (cpp_reader *r, const char *name, FILE *f, 822 struct save_macro_data *data) 823{ 824 size_t i; 825 struct lexer_state old_state; 826 unsigned int counter; 827 828 /* Restore spec_nodes, which will be full of references to the old 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 s->n__has_include__ = cpp_lookup (r, DSC("__has_include__")); 837 s->n__has_include_next__ = cpp_lookup (r, DSC("__has_include_next__")); 838 } 839 840 old_state = r->state; 841 r->state.in_directive = 1; 842 r->state.prevent_expansion = 1; 843 r->state.angled_headers = 0; 844 845 /* Run through the carefully-saved macros, insert them. */ 846 for (i = 0; i < data->count; i++) 847 { 848 cpp_hashnode *h; 849 size_t namelen; 850 uchar *defn; 851 852 namelen = ustrcspn (data->defns[i], "( \n"); 853 h = cpp_lookup (r, data->defns[i], namelen); 854 defn = data->defns[i] + namelen; 855 856 /* The PCH file is valid, so we know that if there is a definition 857 from the PCH file it must be the same as the one we had 858 originally, and so do not need to restore it. */ 859 if (h->type == NT_VOID) 860 { 861 if (cpp_push_buffer (r, defn, ustrchr (defn, '\n') - defn, true) 862 != NULL) 863 { 864 _cpp_clean_line (r); 865 if (!_cpp_create_definition (r, h)) 866 abort (); 867 _cpp_pop_buffer (r); 868 } 869 else 870 abort (); 871 } 872 873 free (data->defns[i]); 874 } 875 r->state = old_state; 876 877 _cpp_restore_pragma_names (r, data->saved_pragmas); 878 879 free (data); 880 881 if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL) 882 != 0) 883 goto error; 884 885 if (! _cpp_read_file_entries (r, f)) 886 goto error; 887 888 if (fread (&counter, sizeof (counter), 1, f) != 1) 889 goto error; 890 891 if (!r->counter) 892 r->counter = counter; 893 894 /* Read pushed macros. */ 895 if (! _cpp_restore_pushed_macros (r, f)) 896 goto error; 897 return 0; 898 899 error: 900 cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header"); 901 return -1; 902} 903