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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [macrotab.h] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Interface to C preprocessor macro tables for GDB.
2
   Copyright (C) 2002, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
3
   Contributed by Red Hat, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
 
20
#ifndef MACROTAB_H
21
#define MACROTAB_H
22
 
23
struct obstack;
24
struct bcache;
25
 
26
/* How do we represent a source location?  I mean, how should we
27
   represent them within GDB; the user wants to use all sorts of
28
   ambiguous abbreviations, like "break 32" and "break foo.c:32"
29
   ("foo.c" may have been #included into several compilation units),
30
   but what do we disambiguate those things to?
31
 
32
   - Answer 1: "Filename and line number."  (Or column number, if
33
   you're picky.)  That's not quite good enough.  For example, the
34
   same source file can be #included into several different
35
   compilation units --- which #inclusion do you mean?
36
 
37
   - Answer 2: "Compilation unit, filename, and line number."  This is
38
   a pretty good answer; GDB's `struct symtab_and_line' basically
39
   embodies this representation.  But it's still ambiguous; what if a
40
   given compilation unit #includes the same file twice --- how can I
41
   set a breakpoint on line 12 of the fifth #inclusion of "foo.c"?
42
 
43
   - Answer 3: "Compilation unit, chain of #inclusions, and line
44
   number."  This is analogous to the way GCC reports errors in
45
   #include files:
46
 
47
        $ gcc -c base.c
48
        In file included from header2.h:8,
49
                         from header1.h:3,
50
                         from base.c:5:
51
        header3.h:1: parse error before ')' token
52
        $
53
 
54
   GCC tells you exactly what path of #inclusions led you to the
55
   problem.  It gives you complete information, in a way that the
56
   following would not:
57
 
58
        $ gcc -c base.c
59
        header3.h:1: parse error before ')' token
60
        $
61
 
62
   Converting all of GDB to use this is a big task, and I'm not really
63
   suggesting it should be a priority.  But this module's whole
64
   purpose is to maintain structures describing the macro expansion
65
   process, so I think it's appropriate for us to take a little care
66
   to do that in a complete fashion.
67
 
68
   In this interface, the first line of a file is numbered 1, not 0.
69
   This is the same convention the rest of GDB uses.  */
70
 
71
 
72
/* A table of all the macro definitions for a given compilation unit.  */
73
struct macro_table;
74
 
75
/* The definition of a single macro.  */
76
struct macro_definition;
77
 
78
/* A source file that participated in a compilation unit --- either a
79
   main file, or an #included file.  If a file is #included more than
80
   once, the presence of the `included_from' and `included_at_line'
81
   members means that we need to make one instance of this structure
82
   for each #inclusion.  Taken as a group, these structures form a
83
   tree mapping the #inclusions that contributed to the compilation
84
   unit, with the main source file as its root.
85
 
86
   Beware --- not every source file mentioned in a compilation unit's
87
   symtab structures will appear in the #inclusion tree!  As of Oct
88
   2002, GCC does record the effect of #line directives in the source
89
   line info, but not in macro info.  This means that GDB's symtabs
90
   (built from the former, among other things) may mention filenames
91
   that the #inclusion tree (built from the latter) doesn't have any
92
   record of.  See macroscope.c:sal_macro_scope for how to accomodate
93
   this.
94
 
95
   It's worth noting that libcpp has a simpler way of representing all
96
   this, which we should consider switching to.  It might even be
97
   suitable for ordinary non-macro line number info.
98
 
99
   Suppose you take your main source file, and after each line
100
   containing an #include directive you insert the text of the
101
   #included file.  The result is a big file that pretty much
102
   corresponds to the full text the compiler's going to see.  There's
103
   a one-to-one correspondence between lines in the big file and
104
   per-inclusion lines in the source files.  (Obviously, #include
105
   directives that are #if'd out don't count.  And you'll need to
106
   append a newline to any file that doesn't end in one, to avoid
107
   splicing the last #included line with the next line of the
108
   #including file.)
109
 
110
   Libcpp calls line numbers in this big imaginary file "logical line
111
   numbers", and has a data structure called a "line map" that can map
112
   logical line numbers onto actual source filenames and line numbers,
113
   and also tell you the chain of #inclusions responsible for any
114
   particular logical line number.  Basically, this means you can pass
115
   around a single line number and some kind of "compilation unit"
116
   object and you get nice, unambiguous source code locations that
117
   distinguish between multiple #inclusions of the same file, etc.
118
 
119
   Pretty neat, huh?  */
120
 
121
struct macro_source_file
122
{
123
 
124
  /* The macro table for the compilation unit this source location is
125
     a part of.  */
126
  struct macro_table *table;
127
 
128
  /* A source file --- possibly a header file.  */
129
  const char *filename;
130
 
131
  /* The location we were #included from, or zero if we are the
132
     compilation unit's main source file.  */
133
  struct macro_source_file *included_by;
134
 
135
  /* If `included_from' is non-zero, the line number in that source
136
     file at which we were included.  */
137
  int included_at_line;
138
 
139
  /* Head of a linked list of the source files #included by this file;
140
     our children in the #inclusion tree.  This list is sorted by its
141
     elements' `included_at_line' values, which are unique.  (The
142
     macro splay tree's ordering function needs this property.)  */
143
  struct macro_source_file *includes;
144
 
145
  /* The next file #included by our `included_from' file; our sibling
146
     in the #inclusion tree.  */
147
  struct macro_source_file *next_included;
148
};
149
 
150
 
151
/* Create a new, empty macro table.  Allocate it in OBSTACK, or use
152
   xmalloc if OBSTACK is zero.  Use BCACHE to store all macro names,
153
   arguments, definitions, and anything else that might be the same
154
   amongst compilation units in an executable file; if BCACHE is zero,
155
   don't cache these things.
156
 
157
   Note that, if either OBSTACK or BCACHE are non-zero, then removing
158
   information from the table may leak memory.  Neither obstacks nor
159
   bcaches really allow you to remove information, so although we can
160
   update the data structure to record the change, we can't free the
161
   old data.  At the moment, since we only provide obstacks and
162
   bcaches for macro tables for symtabs, this isn't a problem; only
163
   odd debugging information makes a definition and then deletes it at
164
   the same source location (although 'gcc -DFOO -UFOO -DFOO=2' does
165
   do that in GCC 4.1.2.).  */
166
struct macro_table *new_macro_table (struct obstack *obstack,
167
                                     struct bcache *bcache);
168
 
169
 
170
/* Free TABLE, and any macro definitions, source file structures,
171
   etc. it owns.  This will raise an internal error if TABLE was
172
   allocated on an obstack, or if it uses a bcache.  */
173
void free_macro_table (struct macro_table *table);
174
 
175
 
176
/* Set FILENAME as the main source file of TABLE.  Return a source
177
   file structure describing that file; if we record the #definition
178
   of macros, or the #inclusion of other files into FILENAME, we'll
179
   use that source file structure to indicate the context.
180
 
181
   The "main source file" is the one that was given to the compiler;
182
   all other source files that contributed to the compilation unit are
183
   #included, directly or indirectly, from this one.
184
 
185
   The macro table makes its own copy of FILENAME; the caller is
186
   responsible for freeing FILENAME when it is no longer needed.  */
187
struct macro_source_file *macro_set_main (struct macro_table *table,
188
                                          const char *filename);
189
 
190
 
191
/* Return the main source file of the macro table TABLE.  */
192
struct macro_source_file *macro_main (struct macro_table *table);
193
 
194
/* Mark the macro table TABLE so that macros defined in this table can
195
   be redefined without error.  Note that it invalid to call this if
196
   TABLE is allocated on an obstack.  */
197
void macro_allow_redefinitions (struct macro_table *table);
198
 
199
 
200
/* Record a #inclusion.
201
   Record in SOURCE's macro table that, at line number LINE in SOURCE,
202
   we #included the file INCLUDED.  Return a source file structure we
203
   can use for symbols #defined or files #included into that.  If we've
204
   already created a source file structure for this #inclusion, return
205
   the same structure we created last time.
206
 
207
   The first line of the source file has a line number of 1, not 0.
208
 
209
   The macro table makes its own copy of INCLUDED; the caller is
210
   responsible for freeing INCLUDED when it is no longer needed.  */
211
struct macro_source_file *macro_include (struct macro_source_file *source,
212
                                         int line,
213
                                         const char *included);
214
 
215
 
216
/* Find any source file structure for a file named NAME, either
217
   included into SOURCE, or SOURCE itself.  Return zero if we have
218
   none.  NAME is only the final portion of the filename, not the full
219
   path.  e.g., `stdio.h', not `/usr/include/stdio.h'.  If NAME
220
   appears more than once in the inclusion tree, return the
221
   least-nested inclusion --- the one closest to the main source file.  */
222
struct macro_source_file *(macro_lookup_inclusion
223
                           (struct macro_source_file *source,
224
                            const char *name));
225
 
226
 
227
/* Record an object-like #definition (i.e., one with no parameter list).
228
   Record in SOURCE's macro table that, at line number LINE in SOURCE,
229
   we #defined a preprocessor symbol named NAME, whose replacement
230
   string is REPLACEMENT.  This function makes copies of NAME and
231
   REPLACEMENT; the caller is responsible for freeing them.  */
232
void macro_define_object (struct macro_source_file *source, int line,
233
                          const char *name, const char *replacement);
234
 
235
 
236
/* Record an function-like #definition (i.e., one with a parameter list).
237
 
238
   Record in SOURCE's macro table that, at line number LINE in SOURCE,
239
   we #defined a preprocessor symbol named NAME, with ARGC arguments
240
   whose names are given in ARGV, whose replacement string is REPLACEMENT.  If
241
   the macro takes a variable number of arguments, then ARGC should be
242
   one greater than the number of named arguments, and ARGV[ARGC-1]
243
   should be the string "...".  This function makes its own copies of
244
   NAME, ARGV, and REPLACEMENT; the caller is responsible for freeing
245
   them.  */
246
void macro_define_function (struct macro_source_file *source, int line,
247
                            const char *name, int argc, const char **argv,
248
                            const char *replacement);
249
 
250
 
251
/* Record an #undefinition.
252
   Record in SOURCE's macro table that, at line number LINE in SOURCE,
253
   we removed the definition for the preprocessor symbol named NAME.  */
254
void macro_undef (struct macro_source_file *source, int line,
255
                  const char *name);
256
 
257
/* Different kinds of macro definitions.  */
258
enum macro_kind
259
{
260
  macro_object_like,
261
  macro_function_like
262
};
263
 
264
 
265
/* A preprocessor symbol definition.  */
266
struct macro_definition
267
{
268
  /* The table this definition lives in.  */
269
  struct macro_table *table;
270
 
271
  /* What kind of macro it is.  */
272
  ENUM_BITFIELD (macro_kind) kind : 1;
273
 
274
  /* If `kind' is `macro_function_like', the number of arguments it
275
     takes, and their names.  The names, and the array of pointers to
276
     them, are in the table's bcache, if it has one.  */
277
  int argc : 31;
278
  const char * const *argv;
279
 
280
  /* The replacement string (body) of the macro.  This is in the
281
     table's bcache, if it has one.  */
282
  const char *replacement;
283
};
284
 
285
 
286
/* Return a pointer to the macro definition for NAME in scope at line
287
   number LINE of SOURCE.  If LINE is -1, return the definition in
288
   effect at the end of the file.  The macro table owns the structure;
289
   the caller need not free it.  Return zero if NAME is not #defined
290
   at that point.  */
291
struct macro_definition *(macro_lookup_definition
292
                          (struct macro_source_file *source,
293
                           int line, const char *name));
294
 
295
 
296
/* Return the source location of the definition for NAME in scope at
297
   line number LINE of SOURCE.  Set *DEFINITION_LINE to the line
298
   number of the definition, and return a source file structure for
299
   the file.  Return zero if NAME has no definition in scope at that
300
   point, and leave *DEFINITION_LINE unchanged.  */
301
struct macro_source_file *(macro_definition_location
302
                           (struct macro_source_file *source,
303
                            int line,
304
                            const char *name,
305
                            int *definition_line));
306
 
307
/* Callback function when walking a macro table.  NAME is the name of
308
   the macro, and DEFINITION is the definition.  USER_DATA is an
309
   arbitrary pointer which is passed by the caller to macro_for_each
310
   or macro_for_each_in_scope.  */
311
typedef void (*macro_callback_fn) (const char *name,
312
                                   const struct macro_definition *definition,
313
                                   void *user_data);
314
 
315
/* Call the function FN for each macro in the macro table TABLE.
316
   USER_DATA is passed, untranslated, to FN.  */
317
void macro_for_each (struct macro_table *table, macro_callback_fn fn,
318
                     void *user_data);
319
 
320
/* Call the function FN for each macro that is visible in a given
321
   scope.  The scope is represented by FILE and LINE.  USER_DATA is
322
   passed, untranslated, to FN.  */
323
void macro_for_each_in_scope (struct macro_source_file *file, int line,
324
                              macro_callback_fn fn,
325
                              void *user_data);
326
 
327
 
328
#endif /* MACROTAB_H */

powered by: WebSVN 2.1.0

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