/* Part of CPP library. (Precompiled header reading/writing.)
- Copyright (C) 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2008
+ Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
#include "config.h"
#include "system.h"
static int save_macros (cpp_reader *, cpp_hashnode *, void *);
/* This structure represents a macro definition on disk. */
-struct macrodef_struct
+struct macrodef_struct
{
unsigned int definition_length;
unsigned short name_length;
unsigned short flags;
};
-/* This is how we write out a macro definition.
+/* This is how we write out a macro definition.
Suitable for being called by cpp_forall_identifiers. */
static int
case NT_VOID:
if (! (hn->flags & NODE_POISONED))
return 1;
-
+
case NT_MACRO:
if ((hn->flags & NODE_BUILTIN))
return 1;
defn = NODE_NAME (hn);
s.definition_length = s.name_length;
}
-
+
if (fwrite (&s, sizeof (s), 1, f) != 1
|| fwrite (defn, 1, s.definition_length, f) != s.definition_length)
{
}
}
return 1;
-
+
case NT_ASSERTION:
/* Not currently implemented. */
return 1;
save_idents (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
{
struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
-
+
if (hn->type != NT_VOID)
{
struct cpp_string news;
{
struct cpp_string *sp;
unsigned char *text;
-
- sp = xmalloc (sizeof (struct cpp_string));
+
+ sp = XNEW (struct cpp_string);
*slot = sp;
sp->len = NODE_LEN (hn);
- sp->text = text = xmalloc (NODE_LEN (hn));
+ sp->text = text = XNEWVEC (unsigned char, NODE_LEN (hn));
memcpy (text, NODE_NAME (hn), NODE_LEN (hn));
}
}
const unsigned char *p = (const unsigned char *)p_p;
size_t i;
hashval_t h;
-
+
h = 0;
for (i = 0; i < sz; i++)
h = h * 67 - (*p++ - 113);
cpp_save_state (cpp_reader *r, FILE *f)
{
/* Save the list of non-void identifiers for the dependency checking. */
- r->savedstate = xmalloc (sizeof (struct cpp_savedstate));
- r->savedstate->definedhash = htab_create (100, cpp_string_hash,
+ r->savedstate = XNEW (struct cpp_savedstate);
+ r->savedstate->definedhash = htab_create (100, cpp_string_hash,
cpp_string_eq, NULL);
cpp_forall_identifiers (r, save_idents, r->savedstate);
-
+
/* Write out the list of defined identifiers. */
cpp_forall_identifiers (r, write_macdef, f);
count_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
{
struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
-
+
switch (hn->type)
{
case NT_MACRO:
if (hn->flags & NODE_BUILTIN)
return 1;
-
+
/* else fall through. */
case NT_VOID:
{
struct cpp_string news;
void **slot;
-
+
news.len = NODE_LEN (hn);
news.text = NODE_NAME (hn);
- slot = htab_find (ss->definedhash, &news);
+ slot = (void **) htab_find (ss->definedhash, &news);
if (slot == NULL)
{
ss->hashsize += NODE_LEN (hn) + 1;
write_defs (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *hn, void *ss_p)
{
struct cpp_savedstate *const ss = (struct cpp_savedstate *)ss_p;
-
+
switch (hn->type)
{
case NT_MACRO:
if (hn->flags & NODE_BUILTIN)
return 1;
-
+
/* else fall through. */
case NT_VOID:
{
struct cpp_string news;
void **slot;
-
+
news.len = NODE_LEN (hn);
news.text = NODE_NAME (hn);
- slot = htab_find (ss->definedhash, &news);
+ slot = (void **) htab_find (ss->definedhash, &news);
if (slot == NULL)
{
ss->defs[ss->n_defs] = hn;
struct cpp_savedstate *const ss = r->savedstate;
unsigned char *definedstrs;
size_t i;
-
+
/* Collect the list of identifiers which have been seen and
weren't defined to anything previously. */
ss->hashsize = 0;
ss->n_defs = 0;
cpp_forall_identifiers (r, count_defs, ss);
- ss->defs = xmalloc (ss->n_defs * sizeof (cpp_hashnode *));
+ ss->defs = XNEWVEC (cpp_hashnode *, ss->n_defs);
ss->n_defs = 0;
cpp_forall_identifiers (r, write_defs, ss);
/* Sort the list, copy it into a buffer, and write it out. */
qsort (ss->defs, ss->n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
- definedstrs = ss->definedstrs = xmalloc (ss->hashsize);
+ definedstrs = ss->definedstrs = XNEWVEC (unsigned char, ss->hashsize);
for (i = 0; i < ss->n_defs; ++i)
{
size_t len = NODE_LEN (ss->defs[i]);
/* Free the saved state. */
free (ss);
r->savedstate = NULL;
+
+ /* Save the next value of __COUNTER__. */
+ if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1)
+ {
+ cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
+ return -1;
+ }
+
return 0;
}
int
cpp_write_pch_state (cpp_reader *r, FILE *f)
{
- struct macrodef_struct z;
+ if (!r->deps)
+ r->deps = deps_init ();
- /* Write out the list of defined identifiers. */
- cpp_forall_identifiers (r, write_macdef, f);
- memset (&z, 0, sizeof (z));
- if (fwrite (&z, sizeof (z), 1, f) != 1)
+ if (deps_save (r->deps, f) != 0)
{
cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
return -1;
}
- if (!r->deps)
- r->deps = deps_init ();
-
- if (deps_save (r->deps, f) != 0)
+ if (! _cpp_save_file_entries (r, f))
{
cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
return -1;
}
- if (! _cpp_save_file_entries (r, f))
+ /* Save the next __COUNTER__ value. When we include a precompiled header,
+ we need to start at the offset we would have if the header had been
+ included normally. */
+ if (fwrite (&r->counter, sizeof (r->counter), 1, f) != 1)
{
cpp_errno (r, CPP_DL_ERROR, "while writing precompiled header");
return -1;
if (nl->n_defs == nl->asize)
{
nl->asize *= 2;
- nl->defs = xrealloc (nl->defs, nl->asize * sizeof (cpp_hashnode *));
+ nl->defs = XRESIZEVEC (cpp_hashnode *, nl->defs, nl->asize);
}
nl->defs[nl->n_defs] = hn;
with the preprocessor's current definitions. It will be consistent
when:
- - anything that was defined just before the PCH was generated
+ - anything that was defined just before the PCH was generated
is defined the same way now; and
- anything that was not defined then, but is defined now, was not
used by the PCH.
{
struct macrodef_struct m;
size_t namebufsz = 256;
- unsigned char *namebuf = xmalloc (namebufsz);
+ unsigned char *namebuf = XNEWVEC (unsigned char, namebufsz);
unsigned char *undeftab = NULL;
struct ht_node_list nl = { 0, 0, 0 };
unsigned char *first, *last;
unsigned int i;
-
+ unsigned int counter;
+
/* Read in the list of identifiers that must be defined
Check that they are defined in the same way. */
for (;;)
{
cpp_hashnode *h;
const unsigned char *newdefn;
-
+
if (read (fd, &m, sizeof (m)) != sizeof (m))
goto error;
-
+
if (m.name_length == 0)
break;
+ /* If this file is already preprocessed, there won't be any
+ macros defined, and that's OK. */
+ if (CPP_OPTION (r, preprocessed))
+ {
+ if (lseek (fd, m.definition_length, SEEK_CUR) == -1)
+ goto error;
+ continue;
+ }
+
if (m.definition_length > namebufsz)
{
free (namebuf);
namebufsz = m.definition_length + 256;
- namebuf = xmalloc (namebufsz);
+ namebuf = XNEWVEC (unsigned char, namebufsz);
}
-
- if ((size_t)read (fd, namebuf, m.definition_length)
+
+ if ((size_t)read (fd, namebuf, m.definition_length)
!= m.definition_length)
goto error;
-
+
h = cpp_lookup (r, namebuf, m.name_length);
if (m.flags & NODE_POISONED
- || h->type != NT_MACRO
|| h->flags & NODE_POISONED)
{
if (CPP_OPTION (r, warn_invalid_pch))
cpp_error (r, CPP_DL_WARNING_SYSHDR,
+ "%s: not used because `%.*s' is poisoned",
+ name, m.name_length, namebuf);
+ goto fail;
+ }
+
+ if (h->type != NT_MACRO)
+ {
+ /* It's ok if __GCC_HAVE_DWARF2_CFI_ASM becomes undefined,
+ as in, when the PCH file is created with -g and we're
+ attempting to use it without -g. Restoring the PCH file
+ is supposed to bring in this definition *and* enable the
+ generation of call frame information, so that precompiled
+ definitions that take this macro into accout, to decide
+ what asm to emit, won't issue .cfi directives when the
+ compiler doesn't. */
+ if (!(h->flags & NODE_USED)
+ && m.name_length == sizeof ("__GCC_HAVE_DWARF2_CFI_ASM") - 1
+ && !memcmp (namebuf, "__GCC_HAVE_DWARF2_CFI_ASM", m.name_length))
+ continue;
+
+ if (CPP_OPTION (r, warn_invalid_pch))
+ cpp_error (r, CPP_DL_WARNING_SYSHDR,
"%s: not used because `%.*s' not defined",
name, m.name_length, namebuf);
goto fail;
}
newdefn = cpp_macro_definition (r, h);
-
+
if (m.definition_length != ustrlen (newdefn)
|| memcmp (namebuf, newdefn, m.definition_length) != 0)
{
/* Read in the list of identifiers that must not be defined.
Check that they really aren't. */
- undeftab = xmalloc (m.definition_length);
+ undeftab = XNEWVEC (unsigned char, m.definition_length);
if ((size_t) read (fd, undeftab, m.definition_length) != m.definition_length)
goto error;
/* Collect identifiers from the current hash table. */
nl.n_defs = 0;
nl.asize = 10;
- nl.defs = xmalloc (nl.asize * sizeof (cpp_hashnode *));
+ nl.defs = XNEWVEC (cpp_hashnode *, nl.asize);
cpp_forall_identifiers (r, &collect_ht_nodes, &nl);
qsort (nl.defs, nl.n_defs, sizeof (cpp_hashnode *), &comp_hashnodes);
-
+
/* Loop through nl.defs and undeftab, both of which are sorted lists.
There should be no matches. */
first = undeftab;
last = undeftab + m.definition_length;
i = 0;
-
+
while (first < last && i < nl.n_defs)
{
int cmp = ustrcmp (first, NODE_NAME (nl.defs[i]));
-
+
if (cmp < 0)
first += ustrlen (first) + 1;
else if (cmp > 0)
else
{
if (CPP_OPTION (r, warn_invalid_pch))
- cpp_error (r, CPP_DL_WARNING_SYSHDR,
+ cpp_error (r, CPP_DL_WARNING_SYSHDR,
"%s: not used because `%s' is defined",
name, first);
goto fail;
}
}
-
+
free(nl.defs);
+ nl.defs = NULL;
free (undeftab);
+ undeftab = NULL;
+
+ /* Read in the next value of __COUNTER__.
+ Check that (a) __COUNTER__ was not used in the pch or (b) __COUNTER__
+ has not been used in this translation unit. */
+ if (read (fd, &counter, sizeof (counter)) != sizeof (counter))
+ goto error;
+ if (counter && r->counter)
+ {
+ if (CPP_OPTION (r, warn_invalid_pch))
+ cpp_error (r, CPP_DL_WARNING_SYSHDR,
+ "%s: not used because `__COUNTER__' is invalid",
+ name);
+ goto fail;
+ }
/* We win! */
return 0;
return 1;
}
-/* Save all the existing macros and assertions.
- This code assumes that there might be hundreds, but not thousands of
- existing definitions. */
+/* Save all the existing macros. */
-struct save_macro_item {
- struct save_macro_item *next;
- struct cpp_hashnode macs[64];
-};
-
-struct save_macro_data
+struct save_macro_data
{
- struct save_macro_item *macros;
+ uchar **defns;
size_t count;
+ size_t array_size;
char **saved_pragmas;
};
-/* Save the definition of a single macro, so that it will persist across
- a PCH restore. */
+/* Save the definition of a single macro, so that it will persist
+ across a PCH restore. Because macro data is in GCed memory, which
+ will be blown away by PCH, it must be temporarily copied to
+ malloced memory. (The macros will refer to identifier nodes which
+ are also GCed and so on, so the copying is done by turning them
+ into self-contained strings.) The assumption is that most macro
+ definitions will come from the PCH file, not from the compilation
+ before the PCH file is loaded, so it doesn't matter that this is
+ a little expensive.
+
+ It would reduce the cost even further if macros defined in the PCH
+ file were not saved in this way, but this is not done (yet), except
+ for builtins, and for #assert by default. */
-static int
-save_macros (cpp_reader *r ATTRIBUTE_UNUSED, cpp_hashnode *h, void *data_p)
+static int
+save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p)
{
struct save_macro_data *data = (struct save_macro_data *)data_p;
if (h->type != NT_VOID
&& (h->flags & NODE_BUILTIN) == 0)
{
- cpp_hashnode *save;
- if (data->count == ARRAY_SIZE (data->macros->macs))
+ if (data->count == data->array_size)
+ {
+ data->array_size *= 2;
+ data->defns = XRESIZEVEC (uchar *, data->defns, (data->array_size));
+ }
+
+ switch (h->type)
{
- struct save_macro_item *d = data->macros;
- data->macros = xmalloc (sizeof (struct save_macro_item));
- data->macros->next = d;
- data->count = 0;
+ case NT_ASSERTION:
+ /* Not currently implemented. */
+ return 1;
+
+ case NT_MACRO:
+ {
+ const uchar * defn = cpp_macro_definition (r, h);
+ size_t defnlen = ustrlen (defn);
+
+ data->defns[data->count] = (uchar *) xmemdup (defn, defnlen,
+ defnlen + 2);
+ data->defns[data->count][defnlen] = '\n';
+ }
+ break;
+
+ default:
+ abort ();
}
- save = data->macros->macs + data->count;
data->count++;
- memcpy (save, h, sizeof (struct cpp_hashnode));
- HT_STR (&save->ident) = xmemdup (HT_STR (HT_NODE (save)),
- HT_LEN (HT_NODE (save)),
- HT_LEN (HT_NODE (save)) + 1);
}
return 1;
}
void
cpp_prepare_state (cpp_reader *r, struct save_macro_data **data)
{
- struct save_macro_data *d = xmalloc (sizeof (struct save_macro_data));
-
- d->macros = NULL;
- d->count = ARRAY_SIZE (d->macros->macs);
+ struct save_macro_data *d = XNEW (struct save_macro_data);
+
+ d->array_size = 512;
+ d->defns = XNEWVEC (uchar *, d->array_size);
+ d->count = 0;
cpp_forall_identifiers (r, save_macros, d);
d->saved_pragmas = _cpp_save_pragma_names (r);
*data = d;
}
/* Given a precompiled header that was previously determined to be valid,
- apply all its definitions (and undefinitions) to the current state.
+ apply all its definitions (and undefinitions) to the current state.
DEPNAME is passed to deps_restore. */
int
cpp_read_state (cpp_reader *r, const char *name, FILE *f,
struct save_macro_data *data)
{
- struct macrodef_struct m;
- size_t defnlen = 256;
- unsigned char *defn = xmalloc (defnlen);
+ size_t i;
struct lexer_state old_state;
- struct save_macro_item *d;
- size_t i, mac_count;
+ unsigned int counter;
- /* Restore spec_nodes, which will be full of references to the old
+ /* Restore spec_nodes, which will be full of references to the old
hashtable entries and so will now be invalid. */
{
struct spec_nodes *s = &r->spec_nodes;
s->n__VA_ARGS__ = cpp_lookup (r, DSC("__VA_ARGS__"));
}
- /* Run through the carefully-saved macros, insert them. */
- d = data->macros;
- mac_count = data->count;
- while (d)
- {
- struct save_macro_item *nextd;
- for (i = 0; i < mac_count; i++)
- {
- cpp_hashnode *h;
-
- h = cpp_lookup (r, HT_STR (HT_NODE (&d->macs[i])),
- HT_LEN (HT_NODE (&d->macs[i])));
- h->type = d->macs[i].type;
- h->flags = d->macs[i].flags;
- h->value = d->macs[i].value;
- free ((void *)HT_STR (HT_NODE (&d->macs[i])));
- }
- nextd = d->next;
- free (d);
- d = nextd;
- mac_count = ARRAY_SIZE (d->macs);
- }
-
- _cpp_restore_pragma_names (r, data->saved_pragmas);
-
- free (data);
-
old_state = r->state;
-
r->state.in_directive = 1;
r->state.prevent_expansion = 1;
r->state.angled_headers = 0;
- /* Read in the identifiers that must be defined. */
- for (;;)
+ /* Run through the carefully-saved macros, insert them. */
+ for (i = 0; i < data->count; i++)
{
cpp_hashnode *h;
-
- if (fread (&m, sizeof (m), 1, f) != 1)
- goto error;
-
- if (m.name_length == 0)
- break;
+ size_t namelen;
+ uchar *defn;
- if (defnlen < m.definition_length + 1)
- {
- defnlen = m.definition_length + 256;
- defn = xrealloc (defn, defnlen);
- }
+ namelen = ustrcspn (data->defns[i], "( \n");
+ h = cpp_lookup (r, data->defns[i], namelen);
+ defn = data->defns[i] + namelen;
- if (fread (defn, 1, m.definition_length, f) != m.definition_length)
- goto error;
- defn[m.definition_length] = '\n';
-
- h = cpp_lookup (r, defn, m.name_length);
-
- if (h->type == NT_MACRO)
- _cpp_free_definition (h);
- if (m.flags & NODE_POISONED)
- h->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
- else if (m.name_length != m.definition_length)
+ /* The PCH file is valid, so we know that if there is a definition
+ from the PCH file it must be the same as the one we had
+ originally, and so do not need to restore it. */
+ if (h->type == NT_VOID)
{
- if (cpp_push_buffer (r, defn + m.name_length,
- m.definition_length - m.name_length, true)
+ if (cpp_push_buffer (r, defn, ustrchr (defn, '\n') - defn, true)
!= NULL)
{
_cpp_clean_line (r);
else
abort ();
}
- }
+ free (data->defns[i]);
+ }
r->state = old_state;
- free (defn);
- defn = NULL;
+
+ _cpp_restore_pragma_names (r, data->saved_pragmas);
+
+ free (data);
if (deps_restore (r->deps, f, CPP_OPTION (r, restore_pch_deps) ? name : NULL)
!= 0)
if (! _cpp_read_file_entries (r, f))
goto error;
+ if (fread (&counter, sizeof (counter), 1, f) != 1)
+ goto error;
+
+ if (!r->counter)
+ r->counter = counter;
+
return 0;
-
+
error:
cpp_errno (r, CPP_DL_ERROR, "while reading precompiled header");
return -1;