contrib/gcc-8.0/libcpp/pch.c

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