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