gcc/cpppch.c

   1 /* Part of CPP library.  (Precompiled header reading/writing.)
   2    Copyright (C) 2000, 2001, 2002 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 2, 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; if not, write to the Free Software
  16 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 #include "config.h"
  19 #include "system.h"
  20 #include "coretypes.h"
  21 #include "cpplib.h"
  22 #include "cpphash.h"
  23 #include "intl.h"
  24 #include "hashtab.h"
  25 #include "mkdeps.h"
  26
  27 static int write_macdef PARAMS ((cpp_reader *, cpp_hashnode *, void *));
  28 static int save_idents PARAMS ((cpp_reader *, cpp_hashnode *, void *));
  29 static hashval_t hashmem PARAMS ((const void *, size_t));
  30 static hashval_t cpp_string_hash PARAMS ((const void *));
  31 static int cpp_string_eq PARAMS ((const void *, const void *));
  32 static int count_defs PARAMS ((cpp_reader *, cpp_hashnode *, void *));
  33 static int comp_hashnodes PARAMS ((const void *, const void *));
  34 static int collect_ht_nodes PARAMS ((cpp_reader *, cpp_hashnode *, void *));
  35 static int write_defs PARAMS ((cpp_reader *, cpp_hashnode *, void *));
  36 static int save_macros PARAMS ((cpp_reader *, cpp_hashnode *, void *));
  37 static int reset_ht PARAMS ((cpp_reader *, cpp_hashnode *, void *));
  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 (pfile, hn, file_p)
  52      cpp_reader *pfile;
  53      cpp_hashnode *hn;
  54      void *file_p;
  55 {
  56   FILE *f = (FILE *) file_p;
  57   switch (hn->type)
  58     {
  59     case NT_VOID:
  60       if (! (hn->flags & NODE_POISONED))
  61         return 1;
  62
  63     case NT_MACRO:
  64       if ((hn->flags & NODE_BUILTIN))
  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, DL_ERROR, "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 (pfile, hn, ss_p)
 128      cpp_reader *pfile ATTRIBUTE_UNUSED;
 129      cpp_hashnode *hn;
 130      void *ss_p;
 131 {
 132   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
 133
 134   if (hn->type != NT_VOID)
 135     {
 136       struct cpp_string news;
 137       void **slot;
 138
 139       news.len = NODE_LEN (hn);
 140       news.text= NODE_NAME (hn);
 141       slot = htab_find_slot (ss->definedhash, &news, INSERT);
 142       if (*slot == NULL)
 143         {
 144           struct cpp_string *sp;
 145           unsigned char *text;
 146
 147           sp = xmalloc (sizeof (struct cpp_string));
 148           *slot = sp;
 149
 150           sp->len = NODE_LEN (hn);
 151           sp->text = text = xmalloc (NODE_LEN (hn));
 152           memcpy (text, NODE_NAME (hn), NODE_LEN (hn));
 153         }
 154     }
 155
 156   return 1;
 157 }
 158
 159 /* Hash some memory in a generic way.  */
 160
 161 static hashval_t
 162 hashmem (p_p, sz)
 163      const void *p_p;
 164      size_t sz;
 165 {
 166   const unsigned char *p = (const unsigned char *)p_p;
 167   size_t i;
 168   hashval_t h;
 169
 170   h = 0;
 171   for (i = 0; i < sz; i++)
 172     h = h * 67 - (*p++ - 113);
 173   return h;
 174 }
 175
 176 /* Hash a cpp string for the hashtable machinery.  */
 177
 178 static hashval_t
 179 cpp_string_hash (a_p)
 180      const void *a_p;
 181 {
 182   const struct cpp_string *a = (const struct cpp_string *) a_p;
 183   return hashmem (a->text, a->len);
 184 }
 185
 186 /* Compare two cpp strings for the hashtable machinery.  */
 187
 188 static int
 189 cpp_string_eq (a_p, b_p)
 190      const void *a_p;
 191      const void *b_p;
 192 {
 193   const struct cpp_string *a = (const struct cpp_string *) a_p;
 194   const struct cpp_string *b = (const struct cpp_string *) b_p;
 195   return (a->len == b->len
 196           && memcmp (a->text, b->text, a->len) == 0);
 197 }
 198
 199 /* Save the current definitions of the cpp_reader for dependency
 200    checking purposes.  When writing a precompiled header, this should
 201    be called at the same point in the compilation as cpp_valid_state
 202    would be called when reading the precompiled header back in.  */
 203
 204 int
 205 cpp_save_state (r, f)
 206      cpp_reader *r;
 207      FILE *f;
 208 {
 209   /* Save the list of non-void identifiers for the dependency checking.  */
 210   r->savedstate = xmalloc (sizeof (struct cpp_savedstate));
 211   r->savedstate->definedhash = htab_create (100, cpp_string_hash,
 212                                             cpp_string_eq, NULL);
 213   cpp_forall_identifiers (r, save_idents, r->savedstate);
 214
 215   /* Write out the list of defined identifiers.  */
 216   cpp_forall_identifiers (r, write_macdef, f);
 217
 218   return 0;
 219 }
 220
 221 /* Calculate the 'hashsize' field of the saved state.  */
 222
 223 static int
 224 count_defs (pfile, hn, ss_p)
 225      cpp_reader *pfile ATTRIBUTE_UNUSED;
 226      cpp_hashnode *hn;
 227      void *ss_p;
 228 {
 229   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
 230
 231   switch (hn->type)
 232     {
 233     case NT_MACRO:
 234       if (hn->flags & NODE_BUILTIN)
 235         return 1;
 236
 237       /* else fall through.  */
 238
 239     case NT_VOID:
 240       {
 241         struct cpp_string news;
 242         void **slot;
 243
 244         news.len = NODE_LEN (hn);
 245         news.text = NODE_NAME (hn);
 246         slot = htab_find (ss->definedhash, &news);
 247         if (slot == NULL)
 248           {
 249             ss->hashsize += NODE_LEN (hn) + 1;
 250             ss->n_defs += 1;
 251           }
 252       }
 253       return 1;
 254
 255     case NT_ASSERTION:
 256       /* Not currently implemented.  */
 257       return 1;
 258
 259     default:
 260       abort ();
 261     }
 262 }
 263
 264 /* Collect the identifiers into the state's string table. */
 265 static int
 266 write_defs (pfile, hn, ss_p)
 267      cpp_reader *pfile ATTRIBUTE_UNUSED;
 268      cpp_hashnode *hn;
 269      void *ss_p;
 270 {
 271   struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
 272
 273   switch (hn->type)
 274     {
 275     case NT_MACRO:
 276       if (hn->flags & NODE_BUILTIN)
 277         return 1;
 278
 279       /* else fall through.  */
 280
 281     case NT_VOID:
 282       {
 283         struct cpp_string news;
 284         void **slot;
 285
 286         news.len = NODE_LEN (hn);
 287         news.text = NODE_NAME (hn);
 288         slot = htab_find (ss->definedhash, &news);
 289         if (slot == NULL)
 290           {
 291             ss->defs[ss->n_defs] = hn;
 292             ss->n_defs += 1;
 293           }
 294       }
 295       return 1;
 296
 297     case NT_ASSERTION:
 298       /* Not currently implemented.  */
 299       return 1;
 300
 301     default:
 302       abort ();
 303     }
 304 }
 305
 306 /* Comparison function for qsort.  The arguments point to pointers of
 307    type ht_hashnode *.  */
 308 static int
 309 comp_hashnodes (px, py)
 310      const void *px;
 311      const void *py;
 312 {
 313   cpp_hashnode *x = *(cpp_hashnode **) px;
 314   cpp_hashnode *y = *(cpp_hashnode **) py;
 315   return ustrcmp (NODE_NAME (x), NODE_NAME (y));
 316 }
 317
 318 /* Write out the remainder of the dependency information.  This should be
 319    called after the PCH is ready to be saved.  */
 320
 321 int
 322 cpp_write_pch_deps (r, f)
 323      cpp_reader *r;
 324      FILE *f;
 325 {
 326   struct macrodef_struct z;
 327   struct cpp_savedstate *const ss = r->savedstate;
 328   unsigned char *definedstrs;
 329   size_t i;
 330
 331   /* Collect the list of identifiers which have been seen and
 332      weren't defined to anything previously.  */
 333   ss->hashsize = 0;
 334   ss->n_defs = 0;
 335   cpp_forall_identifiers (r, count_defs, ss);
 336
 337   ss->defs = xmalloc (ss->n_defs * sizeof (cpp_hashnode *));
 338   ss->n_defs = 0;
 339   cpp_forall_identifiers (r, write_defs, ss);
 340
 341   /* Sort the list, copy it into a buffer, and write it out. */
 342   qsort (ss->defs, ss->n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
 343   definedstrs = ss->definedstrs = xmalloc (ss->hashsize);
 344   for (i = 0; i < ss->n_defs; ++i)
 345     {
 346       size_t len = NODE_LEN (ss->defs[i]);
 347       memcpy (definedstrs, NODE_NAME (ss->defs[i]), len + 1);
 348       definedstrs += len + 1;
 349     }
 350
 351   memset (&z, 0, sizeof (z));
 352   z.definition_length = ss->hashsize;
 353   if (fwrite (&z, sizeof (z), 1, f) != 1
 354       || fwrite (ss->definedstrs, ss->hashsize, 1, f) != 1)
 355     {
 356       cpp_errno (r, DL_ERROR, "while writing precompiled header");
 357       return -1;
 358     }
 359   free (ss->definedstrs);
 360
 361   /* Free the saved state.  */
 362   free (ss);
 363   r->savedstate = NULL;
 364   return 0;
 365 }
 366
 367 /* Write out the definitions of the preprocessor, in a form suitable for
 368    cpp_read_state.  */
 369
 370 int
 371 cpp_write_pch_state (r, f)
 372      cpp_reader *r;
 373      FILE *f;
 374 {
 375   struct macrodef_struct z;
 376
 377   /* Write out the list of defined identifiers.  */
 378   cpp_forall_identifiers (r, write_macdef, f);
 379   memset (&z, 0, sizeof (z));
 380   if (fwrite (&z, sizeof (z), 1, f) != 1)
 381     {
 382       cpp_errno (r, DL_ERROR, "while writing precompiled header");
 383       return -1;
 384     }
 385
 386   if (!r->deps)
 387     r->deps = deps_init ();
 388
 389   if (deps_save (r->deps, f) != 0)
 390     {
 391       cpp_errno (r, DL_ERROR, "while writing precompiled header");
 392       return -1;
 393     }
 394
 395   return 0;
 396 }
 397
 398
 399 /* Data structure to transform hash table nodes into a sorted list */
 400
 401 struct ht_node_list
 402 {
 403   /* Array of nodes */
 404   cpp_hashnode **defs;
 405   /* Number of nodes in the array */
 406   size_t n_defs;
 407   /* Size of the allocated array */
 408   size_t asize;
 409 };
 410
 411 /* Callback for collecting identifiers from hash table */
 412
 413 static int
 414 collect_ht_nodes (pfile, hn, nl_p)
 415      cpp_reader *pfile ATTRIBUTE_UNUSED;
 416      cpp_hashnode *hn;
 417      void *nl_p;
 418 {
 419   struct ht_node_list *const nl = (struct ht_node_list *)nl_p;
 420
 421   if (hn->type != NT_VOID || hn->flags & NODE_POISONED)
 422     {
 423       if (nl->n_defs == nl->asize)
 424         {
 425           nl->asize *= 2;
 426           nl->defs = xrealloc (nl->defs, nl->asize * sizeof (cpp_hashnode *));
 427         }
 428
 429       nl->defs[nl->n_defs] = hn;
 430       ++nl->n_defs;
 431     }
 432   return 1;
 433 }
 434
 435
 436 /* Return nonzero if FD is a precompiled header which is consistent
 437    with the preprocessor's current definitions.  It will be consistent
 438    when:
 439
 440    - anything that was defined just before the PCH was generated
 441      is defined the same way now; and
 442    - anything that was not defined then, but is defined now, was not
 443      used by the PCH.
 444
 445    NAME is used to print warnings if `warn_invalid_pch' is set in the
 446    reader's flags.
 447 */
 448
 449 int
 450 cpp_valid_state (r, name, fd)
 451      cpp_reader *r;
 452      const char *name;
 453      int fd;
 454 {
 455   struct macrodef_struct m;
 456   size_t namebufsz = 256;
 457   unsigned char *namebuf = xmalloc (namebufsz);
 458   unsigned char *undeftab = NULL;
 459   struct ht_node_list nl;
 460   unsigned char *first, *last;
 461   unsigned int i;
 462
 463   /* Read in the list of identifiers that must be defined
 464      Check that they are defined in the same way.  */
 465   for (;;)
 466     {
 467       cpp_hashnode *h;
 468       const unsigned char *newdefn;
 469
 470       if (read (fd, &m, sizeof (m)) != sizeof (m))
 471         goto error;
 472
 473       if (m.name_length == 0)
 474         break;
 475
 476       if (m.definition_length > namebufsz)
 477         {
 478           free (namebuf);
 479           namebufsz = m.definition_length + 256;
 480           namebuf = xmalloc (namebufsz);
 481         }
 482
 483       if ((size_t)read (fd, namebuf, m.definition_length)
 484           != m.definition_length)
 485         goto error;
 486
 487       h = cpp_lookup (r, namebuf, m.name_length);
 488       if (m.flags & NODE_POISONED
 489           || h->type != NT_MACRO
 490           || h->flags & NODE_POISONED)
 491         {
 492           if (CPP_OPTION (r, warn_invalid_pch))
 493             cpp_error (r, DL_WARNING_SYSHDR,
 494                        "%s: not used because `%.*s' not defined",
 495                        name, m.name_length, namebuf);
 496           goto fail;
 497         }
 498
 499       newdefn = cpp_macro_definition (r, h);
 500
 501       if (m.definition_length != ustrlen (newdefn)
 502           || memcmp (namebuf, newdefn, m.definition_length) != 0)
 503         {
 504           if (CPP_OPTION (r, warn_invalid_pch))
 505             cpp_error (r, DL_WARNING_SYSHDR,
 506                "%s: not used because `%.*s' defined as `%s' not `%.*s'",
 507                        name, m.name_length, namebuf, newdefn + m.name_length,
 508                        m.definition_length - m.name_length,
 509                        namebuf +  m.name_length);
 510           goto fail;
 511         }
 512     }
 513   free (namebuf);
 514   namebuf = NULL;
 515
 516   /* Read in the list of identifiers that must not be defined.
 517      Check that they really aren't.  */
 518   undeftab = xmalloc (m.definition_length);
 519   if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
 520     goto error;
 521
 522   /* Collect identifiers from the current hash table.  */
 523   nl.n_defs = 0;
 524   nl.asize = 10;
 525   nl.defs = xmalloc (nl.asize * sizeof (cpp_hashnode *));
 526   cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
 527   qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
 528
 529   /* Loop through nl.defs and undeftab, both of which are sorted lists.
 530      There should be no matches. */
 531   first = undeftab;
 532   last = undeftab + m.definition_length;
 533   i = 0;
 534
 535   while (first < last && i < nl.n_defs)
 536     {
 537       int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
 538
 539       if (cmp < 0)
 540         first += ustrlen (first) + 1;
 541       else if (cmp > 0)
 542         ++i;
 543       else
 544         goto fail;
 545     }
 546
 547   free(nl.defs);
 548   free (undeftab);
 549
 550   /* We win!  */
 551   return 0;
 552
 553  error:
 554   cpp_errno (r, DL_ERROR, "while reading precompiled header");
 555   return -1;
 556
 557  fail:
 558   if (namebuf != NULL)
 559     free (namebuf);
 560   if (undeftab != NULL)
 561     free (undeftab);
 562   if (nl.defs != NULL)
 563     free (nl.defs);
 564   return 1;
 565 }
 566
 567 /* Save all the existing macros and assertions.
 568    This code assumes that there might be hundreds, but not thousands of
 569    existing definitions.  */
 570
 571 struct save_macro_item {
 572   struct save_macro_item *next;
 573   struct cpp_hashnode macs[64];
 574 };
 575
 576 struct save_macro_data
 577 {
 578   struct save_macro_item *macros;
 579   size_t count;
 580   char **saved_pragmas;
 581 };
 582
 583 /* Save the definition of a single macro, so that it will persist across
 584    a PCH restore.  */
 585
 586 static int
 587 save_macros (r, h, data_p)
 588      cpp_reader *r ATTRIBUTE_UNUSED;
 589      cpp_hashnode *h;
 590      void *data_p;
 591 {
 592   struct save_macro_data *data = (struct save_macro_data *)data_p;
 593   if (h->type != NT_VOID
 594       && (h->flags & NODE_BUILTIN) == 0)
 595     {
 596       cpp_hashnode *save;
 597       if (data->count == ARRAY_SIZE (data->macros->macs))
 598         {
 599           struct save_macro_item *d = data->macros;
 600           data->macros = xmalloc (sizeof (struct save_macro_item));
 601           data->macros->next = d;
 602           data->count = 0;
 603         }
 604       save = data->macros->macs + data->count;
 605       data->count++;
 606       memcpy (save, h, sizeof (struct cpp_hashnode));
 607       HT_STR (&save->ident) = xmemdup (HT_STR (HT_NODE (save)),
 608                                        HT_LEN (HT_NODE (save)),
 609                                        HT_LEN (HT_NODE (save)) + 1);
 610     }
 611   return 1;
 612 }
 613
 614 /* Prepare to restore the state, by saving the currently-defined
 615    macros in 'data'.  */
 616
 617 void
 618 cpp_prepare_state (r, data)
 619      cpp_reader *r;
 620      struct save_macro_data **data;
 621 {
 622   struct save_macro_data *d = xmalloc (sizeof (struct save_macro_data));
 623
 624   d->macros = NULL;
 625   d->count = ARRAY_SIZE (d->macros->macs);
 626   cpp_forall_identifiers (r, save_macros, d);
 627   d->saved_pragmas = _cpp_save_pragma_names (r);
 628   *data = d;
 629 }
 630
 631 /* Erase all the existing macros and assertions.  */
 632
 633 static int
 634 reset_ht (r, h, unused)
 635      cpp_reader *r ATTRIBUTE_UNUSED;
 636      cpp_hashnode *h;
 637      void *unused ATTRIBUTE_UNUSED;
 638 {
 639   if (h->type != NT_VOID
 640       && (h->flags & NODE_BUILTIN) == 0)
 641     {
 642       h->type = NT_VOID;
 643       memset (&h->value, 0, sizeof (h->value));
 644     }
 645   return 1;
 646 }
 647
 648 /* Given a precompiled header that was previously determined to be valid,
 649    apply all its definitions (and undefinitions) to the current state.
 650    DEPNAME is passed to deps_restore.  */
 651
 652 int
 653 cpp_read_state (r, name, f, data)
 654      cpp_reader *r;
 655      const char *name;
 656      FILE *f;
 657      struct save_macro_data *data;
 658 {
 659   struct macrodef_struct m;
 660   size_t defnlen = 256;
 661   unsigned char *defn = xmalloc (defnlen);
 662   struct lexer_state old_state;
 663   struct save_macro_item *d;
 664   size_t i, mac_count;
 665   int saved_line = r->line;
 666
 667   /* Erase all the existing hashtable entries for macros.  At this
 668      point, they're all from the PCH file, and their pointers won't be
 669      valid.  */
 670   cpp_forall_identifiers (r, reset_ht, NULL);
 671
 672   /* Restore spec_nodes, which will be full of references to the old
 673      hashtable entries and so will now be invalid.  */
 674   {
 675     struct spec_nodes *s = &r->spec_nodes;
 676     s->n_defined        = cpp_lookup (r, DSC("defined"));
 677     s->n_true           = cpp_lookup (r, DSC("true"));
 678     s->n_false          = cpp_lookup (r, DSC("false"));
 679     s->n__VA_ARGS__     = cpp_lookup (r, DSC("__VA_ARGS__"));
 680   }
 681
 682   /* Run through the carefully-saved macros, insert them.  */
 683   d = data->macros;
 684   mac_count = data->count;
 685   while (d)
 686     {
 687       struct save_macro_item *nextd;
 688       for (i = 0; i < mac_count; i++)
 689         {
 690           cpp_hashnode *h;
 691
 692           h = cpp_lookup (r, HT_STR (HT_NODE (&d->macs[i])),
 693                           HT_LEN (HT_NODE (&d->macs[i])));
 694           h->type = d->macs[i].type;
 695           h->flags = d->macs[i].flags;
 696           h->value = d->macs[i].value;
 697           free ((void *)HT_STR (HT_NODE (&d->macs[i])));
 698         }
 699       nextd = d->next;
 700       free (d);
 701       d = nextd;
 702       mac_count = ARRAY_SIZE (d->macs);
 703     }
 704
 705   _cpp_restore_pragma_names (r, data->saved_pragmas);
 706
 707   free (data);
 708
 709   old_state = r->state;
 710
 711   r->state.in_directive = 1;
 712   r->state.prevent_expansion = 1;
 713   r->state.angled_headers = 0;
 714
 715   /* Read in the identifiers that must be defined.  */
 716   for (;;)
 717     {
 718       cpp_hashnode *h;
 719
 720       if (fread (&m, sizeof (m), 1, f) != 1)
 721         goto error;
 722
 723       if (m.name_length == 0)
 724         break;
 725
 726       if (defnlen < m.definition_length + 1)
 727         {
 728           defnlen = m.definition_length + 256;
 729           defn = xrealloc (defn, defnlen);
 730         }
 731
 732       if (fread (defn, 1, m.definition_length, f) != m.definition_length)
 733         goto error;
 734       defn[m.definition_length] = '\0';
 735
 736       h = cpp_lookup (r, defn, m.name_length);
 737
 738       if (h->type == NT_MACRO)
 739         _cpp_free_definition (h);
 740       if (m.flags & NODE_POISONED)
 741         h->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
 742       else if (m.name_length != m.definition_length)
 743         {
 744           if (cpp_push_buffer (r, defn + m.name_length,
 745                                m.definition_length - m.name_length,
 746                                true, 1) != NULL)
 747             {
 748               if (!_cpp_create_definition (r, h))
 749                 abort ();
 750               _cpp_pop_buffer (r);
 751             }
 752           else
 753             abort ();
 754         }
 755     }
 756
 757   r->state = old_state;
 758   r->line = saved_line;
 759   free (defn);
 760   defn = NULL;
 761
 762   if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
 763       != 0)
 764     goto error;
 765
 766   return 0;
 767
 768  error:
 769   cpp_errno (r, DL_ERROR, "while reading precompiled header");
 770   return -1;
 771 }