FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add first preprocessor macro-expansion files.

Browse source 
* macroexp.c, macroexp.h, macrotab.c, macrotab.h: New files.
* Makefile.in (SFILES): Add macrotab.c, macroexp.c.
(splay_tree_h, macroexp_h, macrotab_h): New variable.
(HFILES_NO_SRCDIR): Add macrotab.h, macroexp.h.
(COMMON_OBS): Add macrotab.o, macroexp.o.
(macroexp.o, macrotab.o): New rules.
This commit is contained in:
Jim Blandy 2002-05-13 18:13:07 +00:00
parent 6d53172289
commit ec2bcbe754
6 changed files with 2437 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

10
gdb/ChangeLog
View file

@ -1,3 +1,13 @@
2002-05-13 Jim Blandy <jimb@redhat.com>
Add first preprocessor macro-expansion files.
* macroexp.c, macroexp.h, macrotab.c, macrotab.h: New files.
* Makefile.in (SFILES): Add macrotab.c, macroexp.c.
(splay_tree_h, macroexp_h, macrotab_h): New variable.
(HFILES_NO_SRCDIR): Add macrotab.h, macroexp.h.
(COMMON_OBS): Add macrotab.o, macroexp.o.
(macroexp.o, macrotab.o): New rules.
2002-05-13 Andrew Cagney <ac131313@redhat.com>
* config/m88k/tm-m88k.h: Update copyright.

11
gdb/Makefile.in
View file

@ -539,6 +539,7 @@ SFILES = ax-general.c ax-gdb.c bcache.c blockframe.c breakpoint.c \
m2-exp.y m2-lang.c m2-typeprint.c m2-valprint.c main.c maint.c \
memattr.c mem-break.c minsyms.c mipsread.c nlmread.c objfiles.c \
p-exp.y p-lang.c p-typeprint.c p-valprint.c parse.c \
macrotab.c macroexp.c \
printcmd.c remote.c remote-nrom.c scm-exp.c scm-lang.c \
scm-valprint.c source.c stabsread.c stack.c symfile.c \
symmisc.c symtab.c linespec.c target.c thread.c top.c tracepoint.c \
@ -571,6 +572,7 @@ dis_asm_h = $(INCLUDE_DIR)/dis-asm.h
remote-sim_h = $(INCLUDE_DIR)/remote-sim.h
demangle_h = $(INCLUDE_DIR)/demangle.h
obstack_h = $(INCLUDE_DIR)/obstack.h
splay_tree_h = $(INCLUDE_DIR)/splay-tree.h
readline_headers = \
$(READLINE_SRC)/chardefs.h \
@ -634,6 +636,8 @@ inf_loop_h = inf-loop.h
inferior_h = inferior.h $(breakpoint_h)
language_h = language.h
linespec_h = linespec.h
macroexp_h = macroexp.h
macrotab_h = macrotab.h $(obstack_h) $(bcache_h)
memattr_h = memattr.h
monitor_h = monitor.h
objfiles_h = objfiles.h
@ -672,6 +676,7 @@ HFILES_NO_SRCDIR = bcache.h buildsym.h call-cmds.h coff-solib.h defs.h \
gdb-stabs.h $(inferior_h) language.h minimon.h monitor.h \
objfiles.h parser-defs.h serial.h solib.h \
symfile.h stabsread.h target.h terminal.h typeprint.h xcoffsolib.h \
macrotab.h macroexp.h \
c-lang.h ch-lang.h f-lang.h \
jv-lang.h \
m2-lang.h p-lang.h \
@ -714,6 +719,7 @@ COMMON_OBS = version.o blockframe.o breakpoint.o findvar.o regcache.o \
source.o values.o eval.o valops.o valarith.o valprint.o printcmd.o \
symtab.o symfile.o symmisc.o linespec.o infcmd.o infrun.o \
expprint.o environ.o stack.o thread.o \
macrotab.o macroexp.o \
event-loop.o event-top.o inf-loop.o completer.o \
gdbarch.o arch-utils.o gdbtypes.o copying.o $(DEPFILES) \
memattr.o mem-break.o target.o parse.o language.o $(YYOBJ) buildsym.o \
@ -2124,6 +2130,11 @@ linespec.o: linespec.c $(linespec_h) $(defs_h) $(frame_h) $(value_h) \
$(objfiles_h) $(symfile_h) $(completer_h) $(symtab_h) \
$(demangle_h) $(command_h) $(cp_abi_h)
macroexp.o: macroexp.c $(defs_h) $(macrotab_h)
macrotab.o: macrotab.c $(defs_h) $(obstack_h) $(objfiles_h) $(symtab_h) \
$(macrotab_h) $(splay_tree_h) gdb_assert.h $(bcache_h)
target.o: target.c $(bfd_h) $(defs_h) $(gdbcmd_h) $(inferior_h) \
$(objfiles_h) $(symfile_h) $(target_h) $(gdb_string_h) $(regcache_h)

1169
gdb/macroexp.c Normal file
View file

File diff suppressed because it is too large Load diff

90
gdb/macroexp.h Normal file
View file

@ -0,0 +1,90 @@
/* Interface to C preprocessor macro expansion for GDB.
Copyright 2002 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
This file is part of GDB.
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 Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#ifndef MACROEXP_H
#define MACROEXP_H
/* A function for looking up preprocessor macro definitions. Return
the preprocessor definition of NAME in scope according to BATON, or
zero if NAME is not defined as a preprocessor macro.
The caller must not free or modify the definition returned. It is
probably unwise for the caller to hold pointers to it for very
long; it probably lives in some objfile's obstacks. */
typedef struct macro_definition *(macro_lookup_ftype) (const char *name,
void *baton);
/* Expand any preprocessor macros in SOURCE, and return the expanded
text. Use LOOKUP_FUNC and LOOKUP_FUNC_BATON to find identifiers'
preprocessor definitions. SOURCE is a null-terminated string. The
result is a null-terminated string, allocated using xmalloc; it is
the caller's responsibility to free it. */
char *macro_expand (const char *source,
macro_lookup_ftype *lookup_func,
void *lookup_func_baton);
/* Expand all preprocessor macro references that appear explicitly in
SOURCE, but do not expand any new macro references introduced by
that first level of expansion. Use LOOKUP_FUNC and
LOOKUP_FUNC_BATON to find identifiers' preprocessor definitions.
SOURCE is a null-terminated string. The result is a
null-terminated string, allocated using xmalloc; it is the caller's
responsibility to free it. */
char *macro_expand_once (const char *source,
macro_lookup_ftype *lookup_func,
void *lookup_func_baton);
/* If the null-terminated string pointed to by *LEXPTR begins with a
macro invocation, return the result of expanding that invocation as
a null-terminated string, and set *LEXPTR to the next character
after the invocation. The result is completely expanded; it
contains no further macro invocations.
Otherwise, if *LEXPTR does not start with a macro invocation,
return zero, and leave *LEXPTR unchanged.
Use LOOKUP_FUNC and LOOKUP_BATON to find macro definitions.
If this function returns a string, the caller is responsible for
freeing it, using xfree.
We need this expand-one-token-at-a-time interface in order to
accomodate GDB's C expression parser, which may not consume the
entire string. When the user enters a command like
(gdb) break *func+20 if x == 5
the parser is expected to consume `func+20', and then stop when it
sees the "if". But of course, "if" appearing in a character string
or as part of a larger identifier doesn't count. So you pretty
much have to do tokenization to find the end of the string that
needs to be macro-expanded. Our C/C++ tokenizer isn't really
designed to be called by anything but the yacc parser engine. */
char *macro_expand_next (char **lexptr,
macro_lookup_ftype *lookup_func,
void *lookup_baton);
#endif /* MACROEXP_H */

862
gdb/macrotab.c Normal file
View file

@ -0,0 +1,862 @@
/* C preprocessor macro tables for GDB.
Copyright 2002 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
This file is part of GDB.
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 Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include "defs.h"
#include "obstack.h"
#include "splay-tree.h"
#include "symtab.h"
#include "symfile.h"
#include "objfiles.h"
#include "macrotab.h"
#include "gdb_assert.h"
#include "bcache.h"
#include "complaints.h"
/* The macro table structure. */
struct macro_table
{
/* The obstack this table's data should be allocated in, or zero if
we should use xmalloc. */
struct obstack *obstack;
/* The bcache we should use to hold macro names, argument names, and
definitions, or zero if we should use xmalloc. */
struct bcache *bcache;
/* The main source file for this compilation unit --- the one whose
name was given to the compiler. This is the root of the
#inclusion tree; everything else is #included from here. */
struct macro_source_file *main_source;
/* The table of macro definitions. This is a splay tree (an ordered
binary tree that stays balanced, effectively), sorted by macro
name. Where a macro gets defined more than once (presumably with
an #undefinition in between), we sort the definitions by the
order they would appear in the preprocessor's output. That is,
if `a.c' #includes `m.h' and then #includes `n.h', and both
header files #define X (with an #undef somewhere in between),
then the definition from `m.h' appears in our splay tree before
the one from `n.h'.
The splay tree's keys are `struct macro_key' pointers;
the values are `struct macro_definition' pointers.
The splay tree, its nodes, and the keys and values are allocated
in obstack, if it's non-zero, or with xmalloc otherwise. The
macro names, argument names, argument name arrays, and definition
strings are all allocated in bcache, if non-zero, or with xmalloc
otherwise. */
splay_tree definitions;
};
/* Allocation and freeing functions. */
/* Allocate SIZE bytes of memory appropriately for the macro table T.
This just checks whether T has an obstack, or whether its pieces
should be allocated with xmalloc. */
static void *
macro_alloc (int size, struct macro_table *t)
{
if (t->obstack)
return obstack_alloc (t->obstack, size);
else
return xmalloc (size);
}
static void
macro_free (void *object, struct macro_table *t)
{
gdb_assert (! t->obstack);
xfree (object);
}
/* If the macro table T has a bcache, then cache the LEN bytes at ADDR
there, and return the cached copy. Otherwise, just xmalloc a copy
of the bytes, and return a pointer to that. */
static const void *
macro_bcache (struct macro_table *t, const void *addr, int len)
{
if (t->bcache)
return bcache (addr, len, t->bcache);
else
{
void *copy = xmalloc (len);
memcpy (copy, addr, len);
return copy;
}
}
/* If the macro table T has a bcache, cache the null-terminated string
S there, and return a pointer to the cached copy. Otherwise,
xmalloc a copy and return that. */
static const char *
macro_bcache_str (struct macro_table *t, const char *s)
{
return (char *) macro_bcache (t, s, strlen (s) + 1);
}
/* Free a possibly bcached object OBJ. That is, if the macro table T
has a bcache, it's an error; otherwise, xfree OBJ. */
void
macro_bcache_free (struct macro_table *t, void *obj)
{
gdb_assert (! t->bcache);
xfree (obj);
}
/* Macro tree keys, w/their comparison, allocation, and freeing functions. */
/* A key in the splay tree. */
struct macro_key
{
/* The table we're in. We only need this in order to free it, since
the splay tree library's key and value freeing functions require
that the key or value contain all the information needed to free
themselves. */
struct macro_table *table;
/* The name of the macro. This is in the table's bcache, if it has
one. */
const char *name;
/* The source file and line number where the definition's scope
begins. This is also the line of the definition itself. */
struct macro_source_file *start_file;
int start_line;
/* The first source file and line after the definition's scope.
(That is, the scope does not include this endpoint.) If end_file
is zero, then the definition extends to the end of the
compilation unit. */
struct macro_source_file *end_file;
int end_line;
};
/* Return the #inclusion depth of the source file FILE. This is the
number of #inclusions it took to reach this file. For the main
source file, the #inclusion depth is zero; for a file it #includes
directly, the depth would be one; and so on. */
static int
inclusion_depth (struct macro_source_file *file)
{
int depth;
for (depth = 0; file->included_by; depth++)
file = file->included_by;
return depth;
}
/* Compare two source locations (from the same compilation unit).
This is part of the comparison function for the tree of
definitions.
LINE1 and LINE2 are line numbers in the source files FILE1 and
FILE2. Return a value:
- less than zero if {LINE,FILE}1 comes before {LINE,FILE}2,
- greater than zero if {LINE,FILE}1 comes after {LINE,FILE}2, or
- zero if they are equal.
When the two locations are in different source files --- perhaps
one is in a header, while another is in the main source file --- we
order them by where they would appear in the fully pre-processed
sources, where all the #included files have been substituted into
their places. */
static int
compare_locations (struct macro_source_file *file1, int line1,
struct macro_source_file *file2, int line2)
{
/* We want to treat positions in an #included file as coming *after*
the line containing the #include, but *before* the line after the
include. As we walk up the #inclusion tree toward the main
source file, we update fileX and lineX as we go; includedX
indicates whether the original position was from the #included
file. */
int included1 = 0;
int included2 = 0;
/* If a file is zero, that means "end of compilation unit." Handle
that specially. */
if (! file1)
{
if (! file2)
return 0;
else
return 1;
}
else if (! file2)
return -1;
/* If the two files are not the same, find their common ancestor in
the #inclusion tree. */
if (file1 != file2)
{
/* If one file is deeper than the other, walk up the #inclusion
chain until the two files are at least at the same *depth*.
Then, walk up both files in synchrony until they're the same
file. That file is the common ancestor. */
int depth1 = inclusion_depth (file1);
int depth2 = inclusion_depth (file2);
/* Only one of these while loops will ever execute in any given
case. */
while (depth1 > depth2)
{
line1 = file1->included_at_line;
file1 = file1->included_by;
included1 = 1;
depth1--;
}
while (depth2 > depth1)
{
line2 = file2->included_at_line;
file2 = file2->included_by;
included2 = 1;
depth2--;
}
/* Now both file1 and file2 are at the same depth. Walk toward
the root of the tree until we find where the branches meet. */
while (file1 != file2)
{
line1 = file1->included_at_line;
file1 = file1->included_by;
/* At this point, we know that the case the includedX flags
are trying to deal with won't come up, but we'll just
maintain them anyway. */
included1 = 1;
line2 = file2->included_at_line;
file2 = file2->included_by;
included2 = 1;
/* Sanity check. If file1 and file2 are really from the
same compilation unit, then they should both be part of
the same tree, and this shouldn't happen. */
gdb_assert (file1 && file2);
}
}
/* Now we've got two line numbers in the same file. */
if (line1 == line2)
{
/* They can't both be from #included files. Then we shouldn't
have walked up this far. */
gdb_assert (! included1 || ! included2);
/* Any #included position comes after a non-#included position
with the same line number in the #including file. */
if (included1)
return 1;
else if (included2)
return -1;
else
return 0;
}
else
return line1 - line2;
}
/* Compare a macro key KEY against NAME, the source file FILE, and
line number LINE.
Sort definitions by name; for two definitions with the same name,
place the one whose definition comes earlier before the one whose
definition comes later.
Return -1, 0, or 1 if key comes before, is identical to, or comes
after NAME, FILE, and LINE. */
static int
key_compare (struct macro_key *key,
const char *name, struct macro_source_file *file, int line)
{
int names = strcmp (key->name, name);
if (names)
return names;
return compare_locations (key->start_file, key->start_line,
file, line);
}
/* The macro tree comparison function, typed for the splay tree
library's happiness. */
static int
macro_tree_compare (splay_tree_key untyped_key1,
splay_tree_key untyped_key2)
{
struct macro_key *key1 = (struct macro_key *) untyped_key1;
struct macro_key *key2 = (struct macro_key *) untyped_key2;
return key_compare (key1, key2->name, key2->start_file, key2->start_line);
}
/* Construct a new macro key node for a macro in table T whose name is
NAME, and whose scope starts at LINE in FILE; register the name in
the bcache. */
static struct macro_key *
new_macro_key (struct macro_table *t,
const char *name,
struct macro_source_file *file,
int line)
{
struct macro_key *k = macro_alloc (sizeof (*k), t);
memset (k, 0, sizeof (*k));
k->table = t;
k->name = macro_bcache_str (t, name);
k->start_file = file;
k->start_line = line;
k->end_file = 0;
return k;
}
static void
macro_tree_delete_key (void *untyped_key)
{
struct macro_key *key = (struct macro_key *) untyped_key;
macro_bcache_free (key->table, (char *) key->name);
macro_free (key, key->table);
}
/* Building and querying the tree of #included files. */
/* Allocate and initialize a new source file structure. */
static struct macro_source_file *
new_source_file (struct macro_table *t,
const char *filename)
{
/* Get space for the source file structure itself. */
struct macro_source_file *f = macro_alloc (sizeof (*f), t);
memset (f, 0, sizeof (*f));
f->table = t;
f->filename = macro_bcache_str (t, filename);
f->includes = 0;
return f;
}
/* Free a source file, and all the source files it #included. */
static void
free_macro_source_file (struct macro_source_file *src)
{
struct macro_source_file *child, *next_child;
/* Free this file's children. */
for (child = src->includes; child; child = next_child)
{
next_child = child->next_included;
free_macro_source_file (child);
}
macro_bcache_free (src->table, (char *) src->filename);
macro_free (src, src->table);
}
struct macro_source_file *
macro_set_main (struct macro_table *t,
const char *filename)
{
/* You can't change a table's main source file. What would that do
to the tree? */
gdb_assert (! t->main_source);
t->main_source = new_source_file (t, filename);
return t->main_source;
}
struct macro_source_file *
macro_main (struct macro_table *t)
{
gdb_assert (t->main_source);
return t->main_source;
}
struct macro_source_file *
macro_include (struct macro_source_file *source,
int line,
const char *included)
{
struct macro_source_file *new;
struct macro_source_file **link;
/* Find the right position in SOURCE's `includes' list for the new
file. Scan until we find the first file we shouldn't follow ---
which is therefore the file we should directly precede --- or
reach the end of the list. */
for (link = &source->includes;
*link && line < (*link)->included_at_line;
link = &(*link)->next_included)
;
/* Did we find another file already #included at the same line as
the new one? */
if (*link && line == (*link)->included_at_line)
{
/* This means the compiler is emitting bogus debug info. (GCC
circa March 2002 did this.) It also means that the splay
tree ordering function, macro_tree_compare, will abort,
because it can't tell which #inclusion came first. But GDB
should tolerate bad debug info. So:
First, squawk. */
static struct complaint bogus_inclusion_line = {
"both `%s' and `%s' allegedly #included at %s:%d", 0, 0
};
complain (&bogus_inclusion_line,
included, (*link)->filename, source->filename, line);
/* Now, choose a new, unoccupied line number for this
#inclusion, after the alleged #inclusion line. */
while (*link && line == (*link)->included_at_line)
{
/* This line number is taken, so try the next line. */
line++;
link = &(*link)->next_included;
}
}
/* At this point, we know that LINE is an unused line number, and
*LINK points to the entry an #inclusion at that line should
precede. */
new = new_source_file (source->table, included);
new->included_by = source;
new->included_at_line = line;
new->next_included = *link;
*link = new;
return new;
}
struct macro_source_file *
macro_lookup_inclusion (struct macro_source_file *source, const char *name)
{
/* Is SOURCE itself named NAME? */
if (! strcmp (name, source->filename))
return source;
/* The filename in the source structure is probably a full path, but
NAME could be just the final component of the name. */
{
int name_len = strlen (name);
int src_name_len = strlen (source->filename);
/* We do mean < here, and not <=; if the lengths are the same,
then the strcmp above should have triggered, and we need to
check for a slash here. */
if (name_len < src_name_len
&& source->filename[src_name_len - name_len - 1] == '/'
&& ! strcmp (name, source->filename + src_name_len - name_len))
return source;
}
/* It's not us. Try all our children, and return the lowest. */
{
struct macro_source_file *child;
struct macro_source_file *best = 0;
int best_depth;
for (child = source->includes; child; child = child->next_included)
{
struct macro_source_file *result
= macro_lookup_inclusion (child, name);
if (result)
{
int result_depth = inclusion_depth (result);
if (! best || result_depth < best_depth)
{
best = result;
best_depth = result_depth;
}
}
}
return best;
}
}
/* Registering and looking up macro definitions. */
/* Construct a definition for a macro in table T. Cache all strings,
and the macro_definition structure itself, in T's bcache. */
static struct macro_definition *
new_macro_definition (struct macro_table *t,
enum macro_kind kind,
int argc, const char **argv,
const char *replacement)
{
struct macro_definition *d = macro_alloc (sizeof (*d), t);
memset (d, 0, sizeof (*d));
d->table = t;
d->kind = kind;
d->replacement = macro_bcache_str (t, replacement);
if (kind == macro_function_like)
{
int i;
const char **cached_argv;
int cached_argv_size = argc * sizeof (*cached_argv);
/* Bcache all the arguments. */
cached_argv = alloca (cached_argv_size);
for (i = 0; i < argc; i++)
cached_argv[i] = macro_bcache_str (t, argv[i]);
/* Now bcache the array of argument pointers itself. */
d->argv = macro_bcache (t, cached_argv, cached_argv_size);
d->argc = argc;
}
/* We don't bcache the entire definition structure because it's got
a pointer to the macro table in it; since each compilation unit
has its own macro table, you'd only get bcache hits for identical
definitions within a compilation unit, which seems unlikely.
"So, why do macro definitions have pointers to their macro tables
at all?" Well, when the splay tree library wants to free a
node's value, it calls the value freeing function with nothing
but the value itself. It makes the (apparently reasonable)
assumption that the value carries enough information to free
itself. But not all macro tables have bcaches, so not all macro
definitions would be bcached. There's no way to tell whether a
given definition is bcached without knowing which table the
definition belongs to. ... blah. The thing's only sixteen
bytes anyway, and we can still bcache the name, args, and
definition, so we just don't bother bcaching the definition
structure itself. */
return d;
}
/* Free a macro definition. */
static void
macro_tree_delete_value (void *untyped_definition)
{
struct macro_definition *d = (struct macro_definition *) untyped_definition;
struct macro_table *t = d->table;
if (d->kind == macro_function_like)
{
int i;
for (i = 0; i < d->argc; i++)
macro_bcache_free (t, (char *) d->argv[i]);
macro_bcache_free (t, (char **) d->argv);
}
macro_bcache_free (t, (char *) d->replacement);
macro_free (d, t);
}
/* Find the splay tree node for the definition of NAME at LINE in
SOURCE, or zero if there is none. */
static splay_tree_node
find_definition (const char *name,
struct macro_source_file *file,
int line)
{
struct macro_table *t = file->table;
splay_tree_node n;
/* Construct a macro_key object, just for the query. */
struct macro_key query;
query.name = name;
query.start_file = file;
query.start_line = line;
query.end_file = 0;
n = splay_tree_lookup (t->definitions, (splay_tree_key) &query);
if (! n)
{
/* It's okay for us to do two queries like this: the real work
of the searching is done when we splay, and splaying the tree
a second time at the same key is a constant time operation.
If this still bugs you, you could always just extend the
splay tree library with a predecessor-or-equal operation, and
use that. */
splay_tree_node pred = splay_tree_predecessor (t->definitions,
(splay_tree_key) &query);
if (pred)
{
/* Make sure this predecessor actually has the right name.
We just want to search within a given name's definitions. */
struct macro_key *found = (struct macro_key *) pred->key;
if (! strcmp (found->name, name))
n = pred;
}
}
if (n)
{
struct macro_key *found = (struct macro_key *) n->key;
/* Okay, so this definition has the right name, and its scope
begins before the given source location. But does its scope
end after the given source location? */
if (compare_locations (file, line, found->end_file, found->end_line) < 0)
return n;
else
return 0;
}
else
return 0;
}
/* If NAME already has a definition in scope at LINE in FILE, and
return the key. Otherwise, return zero. */
static struct macro_key *
check_for_redefinition (struct macro_source_file *source, int line,
const char *name)
{
splay_tree_node n = find_definition (name, source, line);
/* This isn't really right. There's nothing wrong with redefining a
macro if the new replacement list is the same as the old one. */
if (n)
{
struct macro_key *found_key = (struct macro_key *) n->key;
static struct complaint macro_redefined = {
"macro `%s' redefined at %s:%d;"
"original definition at %s:%d", 0, 0
};
complain (&macro_redefined, name,
source->filename, line,
found_key->start_file->filename,
found_key->start_line);
return found_key;
}
else
return 0;
}
void
macro_define_object (struct macro_source_file *source, int line,
const char *name, const char *replacement)
{
struct macro_table *t = source->table;
struct macro_key *k;
struct macro_definition *d;
k = check_for_redefinition (source, line, name);
/* If we're redefining a symbol, and the existing key would be
identical to our new key, then the splay_tree_insert function
will try to delete the old definition. When the definition is
living on an obstack, this isn't a happy thing.
Since this only happens in the presence of questionable debug
info, we just ignore all definitions after the first. The only
case I know of where this arises is in GCC's output for
predefined macros, and all the definitions are the same in that
case. */
if (k && ! key_compare (k, name, source, line))
return;
k = new_macro_key (t, name, source, line);
d = new_macro_definition (t, macro_object_like, 0, 0, replacement);
splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d);
}
void
macro_define_function (struct macro_source_file *source, int line,
const char *name, int argc, const char **argv,
const char *replacement)
{
struct macro_table *t = source->table;
struct macro_key *k;
struct macro_definition *d;
k = check_for_redefinition (source, line, name);
/* See comments about duplicate keys in macro_define_object. */
if (k && ! key_compare (k, name, source, line))
return;
/* We should also check here that all the argument names in ARGV are
distinct. */
k = new_macro_key (t, name, source, line);
d = new_macro_definition (t, macro_function_like, argc, argv, replacement);
splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d);
}
void
macro_undef (struct macro_source_file *source, int line,
const char *name)
{
splay_tree_node n = find_definition (name, source, line);
if (n)
{
/* This function is the only place a macro's end-of-scope
location gets set to anything other than "end of the
compilation unit" (i.e., end_file is zero). So if this macro
already has its end-of-scope set, then we're probably seeing
a second #undefinition for the same #definition. */
struct macro_key *key = (struct macro_key *) n->key;
if (key->end_file)
{
static struct complaint double_undef = {
"macro '%s' is #undefined twice, at %s:%d and %s:%d",
0, 0
};
complain (&double_undef, name, source->filename, line,
key->end_file->filename, key->end_line);
}
/* Whatever the case, wipe out the old ending point, and
make this the ending point. */
key->end_file = source;
key->end_line = line;
}
else
{
/* According to the ISO C standard, an #undef for a symbol that
has no macro definition in scope is ignored. So we should
ignore it too. */
#if 0
static struct complaint no_macro_to_undefine = {
"no definition for macro `%s' in scope to #undef at %s:%d",
0, 0
};
complain (&no_macro_to_undefine, name, source->filename, line);
#endif
}
}
struct macro_definition *
macro_lookup_definition (struct macro_source_file *source,
int line, const char *name)
{
splay_tree_node n = find_definition (name, source, line);
if (n)
return (struct macro_definition *) n->value;
else
return 0;
}
struct macro_source_file *
macro_definition_location (struct macro_source_file *source,
int line,
const char *name,
int *definition_line)
{
splay_tree_node n = find_definition (name, source, line);
if (n)
{
struct macro_key *key = (struct macro_key *) n->key;
*definition_line = key->start_line;
return key->start_file;
}
else
return 0;
}
/* Creating and freeing macro tables. */
struct macro_table *
new_macro_table (struct obstack *obstack,
struct bcache *b)
{
struct macro_table *t;
/* First, get storage for the `struct macro_table' itself. */
if (obstack)
t = obstack_alloc (obstack, sizeof (*t));
else
t = xmalloc (sizeof (*t));
memset (t, 0, sizeof (*t));
t->obstack = obstack;
t->bcache = b;
t->main_source = 0;
t->definitions = (splay_tree_new_with_allocator
(macro_tree_compare,
((splay_tree_delete_key_fn) macro_tree_delete_key),
((splay_tree_delete_value_fn) macro_tree_delete_value),
((splay_tree_allocate_fn) macro_alloc),
((splay_tree_deallocate_fn) macro_free),
t));
return t;
}
void
free_macro_table (struct macro_table *table)
{
/* Free the source file tree. */
free_macro_source_file (table->main_source);
/* Free the table of macro definitions. */
splay_tree_delete (table->definitions);
}

295
gdb/macrotab.h Normal file
View file

@ -0,0 +1,295 @@
/* Interface to C preprocessor macro tables for GDB.
Copyright 2002 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
This file is part of GDB.
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 Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#ifndef MACROTAB_H
#define MACROTAB_H
#include "obstack.h"
#include "bcache.h"
/* How do we represent a source location? I mean, how should we
represent them within GDB; the user wants to use all sorts of
ambiguous abbreviations, like "break 32" and "break foo.c:32"
("foo.c" may have been #included into several compilation units),
but what do we disambiguate those things to?
- Answer 1: "Filename and line number." (Or column number, if
you're picky.) That's not quite good enough. For example, the
same source file can be #included into several different
compilation units --- which #inclusion do you mean?
- Answer 2: "Compilation unit, filename, and line number." This is
a pretty good answer; GDB's `struct symtab_and_line' basically
embodies this representation. But it's still ambiguous; what if a
given compilation unit #includes the same file twice --- how can I
set a breakpoint on line 12 of the fifth #inclusion of "foo.c"?
- Answer 3: "Compilation unit, chain of #inclusions, and line
number." This is analogous to the way GCC reports errors in
#include files:
$ gcc -c base.c
In file included from header2.h:8,
from header1.h:3,
from base.c:5:
header3.h:1: parse error before ')' token
$
GCC tells you exactly what path of #inclusions led you to the
problem. It gives you complete information, in a way that the
following would not:
$ gcc -c base.c
header3.h:1: parse error before ')' token
$
Converting all of GDB to use this is a big task, and I'm not really
suggesting it should be a priority. But this module's whole
purpose is to maintain structures describing the macro expansion
process, so I think it's appropriate for us to take a little care
to do that in a complete fashion.
In this interface, the first line of a file is numbered 1, not 0.
This is the same convention the rest of GDB uses. */
/* A table of all the macro definitions for a given compilation unit. */
struct macro_table;
/* A source file that participated in a compilation unit --- either a
main file, or an #included file. If a file is #included more than
once, the presence of the `included_from' and `included_at_line'
members means that we need to make one instance of this structure
for each #inclusion. Taken as a group, these structures form a
tree mapping the #inclusions that contributed to the compilation
unit, with the main source file as its root.
It's worth noting that libcpp has a simpler way of representing all
this, which we should consider switching to. It might even be
suitable for ordinary non-macro line number info.
Suppose you take your main source file, and after each line
containing an #include directive you insert the text of the
#included file. The result is a big file that pretty much
corresponds to the full text the compiler's going to see. There's
a one-to-one correspondence between lines in the big file and
per-inclusion lines in the source files. (Obviously, #include
directives that are #if'd out don't count. And you'll need to
append a newline to any file that doesn't end in one, to avoid
splicing the last #included line with the next line of the
#including file.)
Libcpp calls line numbers in this big imaginary file "logical line
numbers", and has a data structure called a "line map" that can map
logical line numbers onto actual source filenames and line numbers,
and also tell you the chain of #inclusions responsible for any
particular logical line number. Basically, this means you can pass
around a single line number and some kind of "compilation unit"
object and you get nice, unambiguous source code locations that
distinguish between multiple #inclusions of the same file, etc.
Pretty neat, huh? */
struct macro_source_file
{
/* The macro table for the compilation unit this source location is
a part of. */
struct macro_table *table;
/* A source file --- possibly a header file. */
const char *filename;
/* The location we were #included from, or zero if we are the
compilation unit's main source file. */
struct macro_source_file *included_by;
/* If `included_from' is non-zero, the line number in that source
file at which we were included. */
int included_at_line;
/* Head of a linked list of the source files #included by this file;
our children in the #inclusion tree. This list is sorted by its
elements' `included_at_line' values, which are unique. (The
macro splay tree's ordering function needs this property.) */
struct macro_source_file *includes;
/* The next file #included by our `included_from' file; our sibling
in the #inclusion tree. */
struct macro_source_file *next_included;
};
/* Create a new, empty macro table. Allocate it in OBSTACK, or use
xmalloc if OBSTACK is zero. Use BCACHE to store all macro names,
arguments, definitions, and anything else that might be the same
amongst compilation units in an executable file; if BCACHE is zero,
don't cache these things.
Note that, if either OBSTACK or BCACHE are non-zero, then you
should only ever add information the macro table --- you should
never remove things from it. You'll get an error if you try. At
the moment, since we only provide obstacks and bcaches for macro
tables for symtabs, this restriction makes a nice sanity check.
Obstacks and bcaches are pretty much grow-only structures anyway.
However, if we find that it's occasionally useful to delete things
even from the symtab's tables, and the storage leak isn't a
problem, this restriction could be lifted. */
struct macro_table *new_macro_table (struct obstack *obstack,
struct bcache *bcache);
/* Free TABLE, and any macro definitions, source file structures,
etc. it owns. This will raise an internal error if TABLE was
allocated on an obstack, or if it uses a bcache. */
void free_macro_table (struct macro_table *table);
/* Set FILENAME as the main source file of TABLE. Return a source
file structure describing that file; if we record the #definition
of macros, or the #inclusion of other files into FILENAME, we'll
use that source file structure to indicate the context.
The "main source file" is the one that was given to the compiler;
all other source files that contributed to the compilation unit are
#included, directly or indirectly, from this one.
The macro table makes its own copy of FILENAME; the caller is
responsible for freeing FILENAME when it is no longer needed. */
struct macro_source_file *macro_set_main (struct macro_table *table,
const char *filename);
/* Return the main source file of the macro table TABLE. */
struct macro_source_file *macro_main (struct macro_table *table);
/* Record a #inclusion.
Record in SOURCE's macro table that, at line number LINE in SOURCE,
we #included the file INCLUDED. Return a source file structure we
can use for symbols #defined or files #included into that. If we've
already created a source file structure for this #inclusion, return
the same structure we created last time.
The first line of the source file has a line number of 1, not 0.
The macro table makes its own copy of INCLUDED; the caller is
responsible for freeing INCLUDED when it is no longer needed. */
struct macro_source_file *macro_include (struct macro_source_file *source,
int line,
const char *included);
/* Find any source file structure for a file named NAME, either
included into SOURCE, or SOURCE itself. Return zero if we have
none. NAME is only the final portion of the filename, not the full
path. e.g., `stdio.h', not `/usr/include/stdio.h'. If NAME
appears more than once in the inclusion tree, return the
least-nested inclusion --- the one closest to the main source file. */
struct macro_source_file *(macro_lookup_inclusion
(struct macro_source_file *source,
const char *name));
/* Record an object-like #definition (i.e., one with no parameter list).
Record in SOURCE's macro table that, at line number LINE in SOURCE,
we #defined a preprocessor symbol named NAME, whose replacement
string is REPLACEMENT. This function makes copies of NAME and
REPLACEMENT; the caller is responsible for freeing them. */
void macro_define_object (struct macro_source_file *source, int line,
const char *name, const char *replacement);
/* Record an function-like #definition (i.e., one with a parameter list).
Record in SOURCE's macro table that, at line number LINE in SOURCE,
we #defined a preprocessor symbol named NAME, with ARGC arguments
whose names are given in ARGV, whose replacement string is REPLACEMENT. If
the macro takes a variable number of arguments, then ARGC should be
one greater than the number of named arguments, and ARGV[ARGC-1]
should be the string "...". This function makes its own copies of
NAME, ARGV, and REPLACEMENT; the caller is responsible for freeing
them. */
void macro_define_function (struct macro_source_file *source, int line,
const char *name, int argc, const char **argv,
const char *replacement);
/* Record an #undefinition.
Record in SOURCE's macro table that, at line number LINE in SOURCE,
we removed the definition for the preprocessor symbol named NAME. */
void macro_undef (struct macro_source_file *source, int line,
const char *name);
/* Different kinds of macro definitions. */
enum macro_kind
{
macro_object_like,
macro_function_like
};
/* A preprocessor symbol definition. */
struct macro_definition
{
/* The table this definition lives in. */
struct macro_table *table;
/* What kind of macro it is. */
enum macro_kind kind;
/* If `kind' is `macro_function_like', the number of arguments it
takes, and their names. The names, and the array of pointers to
them, are in the table's bcache, if it has one. */
int argc;
const char * const *argv;
/* The replacement string (body) of the macro. This is in the
table's bcache, if it has one. */
const char *replacement;
};
/* Return a pointer to the macro definition for NAME in scope at line
number LINE of SOURCE. If LINE is -1, return the definition in
effect at the end of the file. The macro table owns the structure;
the caller need not free it. Return zero if NAME is not #defined
at that point. */
struct macro_definition *(macro_lookup_definition
(struct macro_source_file *source,
int line, const char *name));
/* Return the source location of the definition for NAME in scope at
line number LINE of SOURCE. Set *DEFINITION_LINE to the line
number of the definition, and return a source file structure for
the file. Return zero if NAME has no definition in scope at that
point, and leave *DEFINITION_LINE unchanged. */
struct macro_source_file *(macro_definition_location
(struct macro_source_file *source,
int line,
const char *name,
int *definition_line));
#endif /* MACROTAB_H */