libcpp/pch.c

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