libcpp/pch.c

   1 /* Part of CPP library.  (Precompiled header reading/writing.)
   2    Copyright (C) 2000-2014 Free Software Foundation, Inc.
   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
   6 Free Software Foundation; either version 3, or (at your option) any
   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
  15 along 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
  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 *);
  35 static int _cpp_save_pushed_macros (cpp_reader *, FILE *);
  36 static int _cpp_restore_pushed_macros (cpp_reader *, FILE *);
  37
  38 /* This structure represents a macro definition on disk.  */
  39 struct 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
  49 static int
  50 write_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
 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;
 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
 125 static int
 126 save_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
 157 static hashval_t
 158 hashmem (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
 172 static hashval_t
 173 cpp_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
 181 static int
 182 cpp_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
 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
 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
 206 cpp_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
 222 static int
 223 count_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.  */
 261 static int
 262 write_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 *.  */
 301 static int
 302 comp_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
 312 int
 313 cpp_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
 369 int
 370 cpp_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
 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;
 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
 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;
 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
 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
 535 collect_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
 568 int
 569 cpp_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
 734 struct 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
 756 static int
 757 save_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
 803 void
 804 cpp_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
 820 int
 821 cpp_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 }