OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libcpp/] [pch.c] - Blame information for rev 730

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.