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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [buildsym.h] - Blame information for rev 294

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Build symbol tables in GDB's internal format.
2
   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1995, 1996,
3
   1997, 1998, 1999, 2000, 2002, 2003, 2007, 2008
4
   Free Software Foundation, Inc.
5
 
6
   This file is part of GDB.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
 
21
#if !defined (BUILDSYM_H)
22
#define BUILDSYM_H 1
23
 
24
struct objfile;
25
struct symbol;
26
struct addrmap;
27
 
28
/* This module provides definitions used for creating and adding to
29
   the symbol table.  These routines are called from various symbol-
30
   file-reading routines.
31
 
32
   They originated in dbxread.c of gdb-4.2, and were split out to
33
   make xcoffread.c more maintainable by sharing code.
34
 
35
   Variables declared in this file can be defined by #define-ing the
36
   name EXTERN to null.  It is used to declare variables that are
37
   normally extern, but which get defined in a single module using
38
   this technique.  */
39
 
40
struct block;
41
 
42
#ifndef EXTERN
43
#define EXTERN extern
44
#endif
45
 
46
#define HASHSIZE 127            /* Size of things hashed via
47
                                   hashname() */
48
 
49
/* Name of source file whose symbol data we are now processing.  This
50
   comes from a symbol of type N_SO. */
51
 
52
EXTERN char *last_source_file;
53
 
54
/* Core address of start of text of current source file.  This too
55
   comes from the N_SO symbol. */
56
 
57
EXTERN CORE_ADDR last_source_start_addr;
58
 
59
/* The list of sub-source-files within the current individual
60
   compilation.  Each file gets its own symtab with its own linetable
61
   and associated info, but they all share one blockvector.  */
62
 
63
struct subfile
64
  {
65
    struct subfile *next;
66
    char *name;
67
    char *dirname;
68
    struct linetable *line_vector;
69
    int line_vector_length;
70
    enum language language;
71
    char *producer;
72
    char *debugformat;
73
    struct symtab *symtab;
74
  };
75
 
76
EXTERN struct subfile *current_subfile;
77
 
78
/* Global variable which, when set, indicates that we are processing a
79
   .o file compiled with gcc */
80
 
81
EXTERN unsigned char processing_gcc_compilation;
82
 
83
/* When set, we are processing a .o file compiled by sun acc.  This is
84
   misnamed; it refers to all stabs-in-elf implementations which use
85
   N_UNDF the way Sun does, including Solaris gcc.  Hopefully all
86
   stabs-in-elf implementations ever invented will choose to be
87
   compatible.  */
88
 
89
EXTERN unsigned char processing_acc_compilation;
90
 
91
/* Count symbols as they are processed, for error messages.  */
92
 
93
EXTERN unsigned int symnum;
94
 
95
/* Record the symbols defined for each context in a list.  We don't
96
   create a struct block for the context until we know how long to
97
   make it.  */
98
 
99
#define PENDINGSIZE 100
100
 
101
struct pending
102
  {
103
    struct pending *next;
104
    int nsyms;
105
    struct symbol *symbol[PENDINGSIZE];
106
  };
107
 
108
/* Here are the three lists that symbols are put on.  */
109
 
110
/* static at top level, and types */
111
 
112
EXTERN struct pending *file_symbols;
113
 
114
/* global functions and variables */
115
 
116
EXTERN struct pending *global_symbols;
117
 
118
/* everything local to lexical context */
119
 
120
EXTERN struct pending *local_symbols;
121
 
122
/* func params local to lexical  context */
123
 
124
EXTERN struct pending *param_symbols;
125
 
126
/* Stack representing unclosed lexical contexts (that will become
127
   blocks, eventually).  */
128
 
129
struct context_stack
130
  {
131
    /* Outer locals at the time we entered */
132
 
133
    struct pending *locals;
134
 
135
    /* Pending func params at the time we entered */
136
 
137
    struct pending *params;
138
 
139
    /* Pointer into blocklist as of entry */
140
 
141
    struct pending_block *old_blocks;
142
 
143
    /* Name of function, if any, defining context */
144
 
145
    struct symbol *name;
146
 
147
    /* PC where this context starts */
148
 
149
    CORE_ADDR start_addr;
150
 
151
    /* Temp slot for exception handling. */
152
 
153
    CORE_ADDR end_addr;
154
 
155
    /* For error-checking matching push/pop */
156
 
157
    int depth;
158
 
159
  };
160
 
161
EXTERN struct context_stack *context_stack;
162
 
163
/* Index of first unused entry in context stack.  */
164
 
165
EXTERN int context_stack_depth;
166
 
167
/* Currently allocated size of context stack.  */
168
 
169
EXTERN int context_stack_size;
170
 
171
/* Non-zero if the context stack is empty.  */
172
#define outermost_context_p() (context_stack_depth == 0)
173
 
174
/* Nonzero if within a function (so symbols should be local, if
175
   nothing says specifically).  */
176
 
177
EXTERN int within_function;
178
 
179
/* List of blocks already made (lexical contexts already closed).
180
   This is used at the end to make the blockvector.  */
181
 
182
struct pending_block
183
  {
184
    struct pending_block *next;
185
    struct block *block;
186
  };
187
 
188
/* Pointer to the head of a linked list of symbol blocks which have
189
   already been finalized (lexical contexts already closed) and which
190
   are just waiting to be built into a blockvector when finalizing the
191
   associated symtab. */
192
 
193
EXTERN struct pending_block *pending_blocks;
194
 
195
 
196
struct subfile_stack
197
  {
198
    struct subfile_stack *next;
199
    char *name;
200
  };
201
 
202
EXTERN struct subfile_stack *subfile_stack;
203
 
204
#define next_symbol_text(objfile) (*next_symbol_text_func)(objfile)
205
 
206
/* Function to invoke get the next symbol.  Return the symbol name. */
207
 
208
EXTERN char *(*next_symbol_text_func) (struct objfile *);
209
 
210
/* Vector of types defined so far, indexed by their type numbers.
211
   Used for both stabs and coff.  (In newer sun systems, dbx uses a
212
   pair of numbers in parens, as in "(SUBFILENUM,NUMWITHINSUBFILE)".
213
   Then these numbers must be translated through the type_translations
214
   hash table to get the index into the type vector.)  */
215
 
216
EXTERN struct type **type_vector;
217
 
218
/* Number of elements allocated for type_vector currently.  */
219
 
220
EXTERN int type_vector_length;
221
 
222
/* Initial size of type vector.  Is realloc'd larger if needed, and
223
   realloc'd down to the size actually used, when completed.  */
224
 
225
#define INITIAL_TYPE_VECTOR_LENGTH      160
226
 
227
extern void add_free_pendings (struct pending *list);
228
 
229
extern void add_symbol_to_list (struct symbol *symbol,
230
                                struct pending **listhead);
231
 
232
extern struct symbol *find_symbol_in_list (struct pending *list,
233
                                           char *name, int length);
234
 
235
extern struct block *finish_block (struct symbol *symbol,
236
                                   struct pending **listhead,
237
                                   struct pending_block *old_blocks,
238
                                   CORE_ADDR start, CORE_ADDR end,
239
                                   struct objfile *objfile);
240
 
241
extern void record_block_range (struct block *,
242
                                CORE_ADDR start, CORE_ADDR end_inclusive);
243
 
244
extern void really_free_pendings (void *dummy);
245
 
246
extern void start_subfile (char *name, char *dirname);
247
 
248
extern void patch_subfile_names (struct subfile *subfile, char *name);
249
 
250
extern void push_subfile (void);
251
 
252
extern char *pop_subfile (void);
253
 
254
extern struct symtab *end_symtab (CORE_ADDR end_addr,
255
                                  struct objfile *objfile, int section);
256
 
257
/* Defined in stabsread.c.  */
258
 
259
extern void scan_file_globals (struct objfile *objfile);
260
 
261
extern void buildsym_new_init (void);
262
 
263
extern void buildsym_init (void);
264
 
265
extern struct context_stack *push_context (int desc, CORE_ADDR valu);
266
 
267
extern struct context_stack *pop_context (void);
268
 
269
extern void record_line (struct subfile *subfile, int line, CORE_ADDR pc);
270
 
271
extern void start_symtab (char *name, char *dirname, CORE_ADDR start_addr);
272
 
273
extern int hashname (char *name);
274
 
275
extern void free_pending_blocks (void);
276
 
277
/* FIXME: Note that this is used only in buildsym.c and dstread.c,
278
   which should be fixed to not need direct access to
279
   record_pending_block. */
280
 
281
extern void record_pending_block (struct objfile *objfile,
282
                                  struct block *block,
283
                                  struct pending_block *opblock);
284
 
285
extern void record_debugformat (char *format);
286
 
287
extern void record_producer (const char *producer);
288
 
289
extern void merge_symbol_lists (struct pending **srclist,
290
                                struct pending **targetlist);
291
 
292
/* The macro table for the compilation unit whose symbols we're
293
   currently reading.  All the symtabs for this CU will point to this.  */
294
EXTERN struct macro_table *pending_macros;
295
 
296
#undef EXTERN
297
 
298
#endif /* defined (BUILDSYM_H) */

powered by: WebSVN 2.1.0

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