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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [macrotab.h] - Diff between revs 227 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

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

powered by: WebSVN 2.1.0

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