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

Subversion Repositories openrisc_me

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

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

Line No. Rev Author Line
1 24 jeremybenn
/* Symbol table definitions for GDB.
2
 
3
   Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4
   1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008
5
   Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#if !defined (SYMTAB_H)
23
#define SYMTAB_H 1
24
 
25
/* Opaque declarations.  */
26
struct ui_file;
27
struct frame_info;
28
struct symbol;
29
struct obstack;
30
struct objfile;
31
struct block;
32
struct blockvector;
33
struct axs_value;
34
struct agent_expr;
35
 
36
/* Some of the structures in this file are space critical.
37
   The space-critical structures are:
38
 
39
     struct general_symbol_info
40
     struct symbol
41
     struct partial_symbol
42
 
43
   These structures are laid out to encourage good packing.
44
   They use ENUM_BITFIELD and short int fields, and they order the
45
   structure members so that fields less than a word are next
46
   to each other so they can be packed together. */
47
 
48
/* Rearranged: used ENUM_BITFIELD and rearranged field order in
49
   all the space critical structures (plus struct minimal_symbol).
50
   Memory usage dropped from 99360768 bytes to 90001408 bytes.
51
   I measured this with before-and-after tests of
52
   "HEAD-old-gdb -readnow HEAD-old-gdb" and
53
   "HEAD-new-gdb -readnow HEAD-old-gdb" on native i686-pc-linux-gnu,
54
   red hat linux 8, with LD_LIBRARY_PATH=/usr/lib/debug,
55
   typing "maint space 1" at the first command prompt.
56
 
57
   Here is another measurement (from andrew c):
58
     # no /usr/lib/debug, just plain glibc, like a normal user
59
     gdb HEAD-old-gdb
60
     (gdb) break internal_error
61
     (gdb) run
62
     (gdb) maint internal-error
63
     (gdb) backtrace
64
     (gdb) maint space 1
65
 
66
   gdb gdb_6_0_branch  2003-08-19  space used: 8896512
67
   gdb HEAD            2003-08-19  space used: 8904704
68
   gdb HEAD            2003-08-21  space used: 8396800 (+symtab.h)
69
   gdb HEAD            2003-08-21  space used: 8265728 (+gdbtypes.h)
70
 
71
   The third line shows the savings from the optimizations in symtab.h.
72
   The fourth line shows the savings from the optimizations in
73
   gdbtypes.h.  Both optimizations are in gdb HEAD now.
74
 
75
   --chastain 2003-08-21  */
76
 
77
 
78
 
79
/* Define a structure for the information that is common to all symbol types,
80
   including minimal symbols, partial symbols, and full symbols.  In a
81
   multilanguage environment, some language specific information may need to
82
   be recorded along with each symbol. */
83
 
84
/* This structure is space critical.  See space comments at the top. */
85
 
86
struct general_symbol_info
87
{
88
  /* Name of the symbol.  This is a required field.  Storage for the
89
     name is allocated on the objfile_obstack for the associated
90
     objfile.  For languages like C++ that make a distinction between
91
     the mangled name and demangled name, this is the mangled
92
     name.  */
93
 
94
  char *name;
95
 
96
  /* Value of the symbol.  Which member of this union to use, and what
97
     it means, depends on what kind of symbol this is and its
98
     SYMBOL_CLASS.  See comments there for more details.  All of these
99
     are in host byte order (though what they point to might be in
100
     target byte order, e.g. LOC_CONST_BYTES).  */
101
 
102
  union
103
  {
104
    /* The fact that this is a long not a LONGEST mainly limits the
105
       range of a LOC_CONST.  Since LOC_CONST_BYTES exists, I'm not
106
       sure that is a big deal.  */
107
    long ivalue;
108
 
109
    struct block *block;
110
 
111
    gdb_byte *bytes;
112
 
113
    CORE_ADDR address;
114
 
115
    /* for opaque typedef struct chain */
116
 
117
    struct symbol *chain;
118
  }
119
  value;
120
 
121
  /* Since one and only one language can apply, wrap the language specific
122
     information inside a union. */
123
 
124
  union
125
  {
126
    struct cplus_specific
127
    {
128
      /* This is in fact used for C++, Java, and Objective C.  */
129
      char *demangled_name;
130
    }
131
    cplus_specific;
132
  }
133
  language_specific;
134
 
135
  /* Record the source code language that applies to this symbol.
136
     This is used to select one of the fields from the language specific
137
     union above. */
138
 
139
  ENUM_BITFIELD(language) language : 8;
140
 
141
  /* Which section is this symbol in?  This is an index into
142
     section_offsets for this objfile.  Negative means that the symbol
143
     does not get relocated relative to a section.
144
     Disclaimer: currently this is just used for xcoff, so don't
145
     expect all symbol-reading code to set it correctly (the ELF code
146
     also tries to set it correctly).  */
147
 
148
  short section;
149
 
150
  /* The bfd section associated with this symbol. */
151
 
152
  asection *bfd_section;
153
};
154
 
155
extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, asection *);
156
 
157
/* Note that all the following SYMBOL_* macros are used with the
158
   SYMBOL argument being either a partial symbol, a minimal symbol or
159
   a full symbol.  All three types have a ginfo field.  In particular
160
   the SYMBOL_INIT_LANGUAGE_SPECIFIC, SYMBOL_INIT_DEMANGLED_NAME,
161
   SYMBOL_DEMANGLED_NAME macros cannot be entirely substituted by
162
   functions, unless the callers are changed to pass in the ginfo
163
   field only, instead of the SYMBOL parameter.  */
164
 
165
#define DEPRECATED_SYMBOL_NAME(symbol)  (symbol)->ginfo.name
166
#define SYMBOL_VALUE(symbol)            (symbol)->ginfo.value.ivalue
167
#define SYMBOL_VALUE_ADDRESS(symbol)    (symbol)->ginfo.value.address
168
#define SYMBOL_VALUE_BYTES(symbol)      (symbol)->ginfo.value.bytes
169
#define SYMBOL_BLOCK_VALUE(symbol)      (symbol)->ginfo.value.block
170
#define SYMBOL_VALUE_CHAIN(symbol)      (symbol)->ginfo.value.chain
171
#define SYMBOL_LANGUAGE(symbol)         (symbol)->ginfo.language
172
#define SYMBOL_SECTION(symbol)          (symbol)->ginfo.section
173
#define SYMBOL_BFD_SECTION(symbol)      (symbol)->ginfo.bfd_section
174
 
175
#define SYMBOL_CPLUS_DEMANGLED_NAME(symbol)     \
176
  (symbol)->ginfo.language_specific.cplus_specific.demangled_name
177
 
178
/* Initializes the language dependent portion of a symbol
179
   depending upon the language for the symbol. */
180
#define SYMBOL_INIT_LANGUAGE_SPECIFIC(symbol,language) \
181
  (symbol_init_language_specific (&(symbol)->ginfo, (language)))
182
extern void symbol_init_language_specific (struct general_symbol_info *symbol,
183
                                           enum language language);
184
 
185
#define SYMBOL_INIT_DEMANGLED_NAME(symbol,obstack) \
186
  (symbol_init_demangled_name (&(symbol)->ginfo, (obstack)))
187
extern void symbol_init_demangled_name (struct general_symbol_info *symbol,
188
                                        struct obstack *obstack);
189
 
190
#define SYMBOL_SET_NAMES(symbol,linkage_name,len,objfile) \
191
  symbol_set_names (&(symbol)->ginfo, linkage_name, len, objfile)
192
extern void symbol_set_names (struct general_symbol_info *symbol,
193
                              const char *linkage_name, int len,
194
                              struct objfile *objfile);
195
 
196
/* Now come lots of name accessor macros.  Short version as to when to
197
   use which: Use SYMBOL_NATURAL_NAME to refer to the name of the
198
   symbol in the original source code.  Use SYMBOL_LINKAGE_NAME if you
199
   want to know what the linker thinks the symbol's name is.  Use
200
   SYMBOL_PRINT_NAME for output.  Use SYMBOL_DEMANGLED_NAME if you
201
   specifically need to know whether SYMBOL_NATURAL_NAME and
202
   SYMBOL_LINKAGE_NAME are different.  Don't use
203
   DEPRECATED_SYMBOL_NAME at all: instances of that macro should be
204
   replaced by SYMBOL_NATURAL_NAME, SYMBOL_LINKAGE_NAME, or perhaps
205
   SYMBOL_PRINT_NAME.  */
206
 
207
/* Return SYMBOL's "natural" name, i.e. the name that it was called in
208
   the original source code.  In languages like C++ where symbols may
209
   be mangled for ease of manipulation by the linker, this is the
210
   demangled name.  */
211
 
212
#define SYMBOL_NATURAL_NAME(symbol) \
213
  (symbol_natural_name (&(symbol)->ginfo))
214
extern char *symbol_natural_name (const struct general_symbol_info *symbol);
215
 
216
/* Return SYMBOL's name from the point of view of the linker.  In
217
   languages like C++ where symbols may be mangled for ease of
218
   manipulation by the linker, this is the mangled name; otherwise,
219
   it's the same as SYMBOL_NATURAL_NAME.  This is currently identical
220
   to DEPRECATED_SYMBOL_NAME, but please use SYMBOL_LINKAGE_NAME when
221
   appropriate: it conveys the additional semantic information that
222
   you really have thought about the issue and decided that you mean
223
   SYMBOL_LINKAGE_NAME instead of SYMBOL_NATURAL_NAME.  */
224
 
225
#define SYMBOL_LINKAGE_NAME(symbol)     (symbol)->ginfo.name
226
 
227
/* Return the demangled name for a symbol based on the language for
228
   that symbol.  If no demangled name exists, return NULL. */
229
#define SYMBOL_DEMANGLED_NAME(symbol) \
230
  (symbol_demangled_name (&(symbol)->ginfo))
231
extern char *symbol_demangled_name (struct general_symbol_info *symbol);
232
 
233
/* Macro that returns a version of the name of a symbol that is
234
   suitable for output.  In C++ this is the "demangled" form of the
235
   name if demangle is on and the "mangled" form of the name if
236
   demangle is off.  In other languages this is just the symbol name.
237
   The result should never be NULL.  Don't use this for internal
238
   purposes (e.g. storing in a hashtable): it's only suitable for
239
   output.  */
240
 
241
#define SYMBOL_PRINT_NAME(symbol)                                       \
242
  (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
243
 
244
/* Macro that tests a symbol for a match against a specified name string.
245
   First test the unencoded name, then looks for and test a C++ encoded
246
   name if it exists.  Note that whitespace is ignored while attempting to
247
   match a C++ encoded name, so that "foo::bar(int,long)" is the same as
248
   "foo :: bar (int, long)".
249
   Evaluates to zero if the match fails, or nonzero if it succeeds. */
250
 
251
/* Macro that tests a symbol for a match against a specified name
252
   string.  It tests against SYMBOL_NATURAL_NAME, and it ignores
253
   whitespace and trailing parentheses.  (See strcmp_iw for details
254
   about its behavior.)  */
255
 
256
#define SYMBOL_MATCHES_NATURAL_NAME(symbol, name)                       \
257
  (strcmp_iw (SYMBOL_NATURAL_NAME (symbol), (name)) == 0)
258
 
259
/* Macro that returns the name to be used when sorting and searching symbols.
260
   In  C++, Chill, and Java, we search for the demangled form of a name,
261
   and so sort symbols accordingly.  In Ada, however, we search by mangled
262
   name.  If there is no distinct demangled name, then SYMBOL_SEARCH_NAME
263
   returns the same value (same pointer) as SYMBOL_LINKAGE_NAME. */
264
#define SYMBOL_SEARCH_NAME(symbol)                                       \
265
   (symbol_search_name (&(symbol)->ginfo))
266
extern char *symbol_search_name (const struct general_symbol_info *);
267
 
268
/* Analogous to SYMBOL_MATCHES_NATURAL_NAME, but uses the search
269
   name.  */
270
#define SYMBOL_MATCHES_SEARCH_NAME(symbol, name)                        \
271
  (strcmp_iw (SYMBOL_SEARCH_NAME (symbol), (name)) == 0)
272
 
273
/* Classification types for a minimal symbol.  These should be taken as
274
   "advisory only", since if gdb can't easily figure out a
275
   classification it simply selects mst_unknown.  It may also have to
276
   guess when it can't figure out which is a better match between two
277
   types (mst_data versus mst_bss) for example.  Since the minimal
278
   symbol info is sometimes derived from the BFD library's view of a
279
   file, we need to live with what information bfd supplies. */
280
 
281
enum minimal_symbol_type
282
{
283
  mst_unknown = 0,               /* Unknown type, the default */
284
  mst_text,                     /* Generally executable instructions */
285
  mst_data,                     /* Generally initialized data */
286
  mst_bss,                      /* Generally uninitialized data */
287
  mst_abs,                      /* Generally absolute (nonrelocatable) */
288
  /* GDB uses mst_solib_trampoline for the start address of a shared
289
     library trampoline entry.  Breakpoints for shared library functions
290
     are put there if the shared library is not yet loaded.
291
     After the shared library is loaded, lookup_minimal_symbol will
292
     prefer the minimal symbol from the shared library (usually
293
     a mst_text symbol) over the mst_solib_trampoline symbol, and the
294
     breakpoints will be moved to their true address in the shared
295
     library via breakpoint_re_set.  */
296
  mst_solib_trampoline,         /* Shared library trampoline code */
297
  /* For the mst_file* types, the names are only guaranteed to be unique
298
     within a given .o file.  */
299
  mst_file_text,                /* Static version of mst_text */
300
  mst_file_data,                /* Static version of mst_data */
301
  mst_file_bss                  /* Static version of mst_bss */
302
};
303
 
304
/* Define a simple structure used to hold some very basic information about
305
   all defined global symbols (text, data, bss, abs, etc).  The only required
306
   information is the general_symbol_info.
307
 
308
   In many cases, even if a file was compiled with no special options for
309
   debugging at all, as long as was not stripped it will contain sufficient
310
   information to build a useful minimal symbol table using this structure.
311
   Even when a file contains enough debugging information to build a full
312
   symbol table, these minimal symbols are still useful for quickly mapping
313
   between names and addresses, and vice versa.  They are also sometimes
314
   used to figure out what full symbol table entries need to be read in. */
315
 
316
struct minimal_symbol
317
{
318
 
319
  /* The general symbol info required for all types of symbols.
320
 
321
     The SYMBOL_VALUE_ADDRESS contains the address that this symbol
322
     corresponds to.  */
323
 
324
  struct general_symbol_info ginfo;
325
 
326
  /* The info field is available for caching machine-specific
327
     information so it doesn't have to rederive the info constantly
328
     (over a serial line).  It is initialized to zero and stays that
329
     way until target-dependent code sets it.  Storage for any data
330
     pointed to by this field should be allocated on the
331
     objfile_obstack for the associated objfile.  The type would be
332
     "void *" except for reasons of compatibility with older
333
     compilers.  This field is optional.
334
 
335
     Currently, the AMD 29000 tdep.c uses it to remember things it has decoded
336
     from the instructions in the function header, and the MIPS-16 code uses
337
     it to identify 16-bit procedures.  */
338
 
339
  char *info;
340
 
341
  /* Size of this symbol.  end_psymtab in dbxread.c uses this
342
     information to calculate the end of the partial symtab based on the
343
     address of the last symbol plus the size of the last symbol.  */
344
 
345
  unsigned long size;
346
 
347
  /* Which source file is this symbol in?  Only relevant for mst_file_*.  */
348
  char *filename;
349
 
350
  /* Classification type for this minimal symbol.  */
351
 
352
  ENUM_BITFIELD(minimal_symbol_type) type : 8;
353
 
354
  /* Minimal symbols with the same hash key are kept on a linked
355
     list.  This is the link.  */
356
 
357
  struct minimal_symbol *hash_next;
358
 
359
  /* Minimal symbols are stored in two different hash tables.  This is
360
     the `next' pointer for the demangled hash table.  */
361
 
362
  struct minimal_symbol *demangled_hash_next;
363
};
364
 
365
#define MSYMBOL_INFO(msymbol)           (msymbol)->info
366
#define MSYMBOL_SIZE(msymbol)           (msymbol)->size
367
#define MSYMBOL_TYPE(msymbol)           (msymbol)->type
368
 
369
 
370
 
371
/* Represent one symbol name; a variable, constant, function or typedef.  */
372
 
373
/* Different name domains for symbols.  Looking up a symbol specifies a
374
   domain and ignores symbol definitions in other name domains. */
375
 
376
typedef enum domain_enum_tag
377
{
378
  /* UNDEF_DOMAIN is used when a domain has not been discovered or
379
     none of the following apply.  This usually indicates an error either
380
     in the symbol information or in gdb's handling of symbols. */
381
 
382
  UNDEF_DOMAIN,
383
 
384
  /* VAR_DOMAIN is the usual domain.  In C, this contains variables,
385
     function names, typedef names and enum type values. */
386
 
387
  VAR_DOMAIN,
388
 
389
  /* STRUCT_DOMAIN is used in C to hold struct, union and enum type names.
390
     Thus, if `struct foo' is used in a C program, it produces a symbol named
391
     `foo' in the STRUCT_DOMAIN. */
392
 
393
  STRUCT_DOMAIN,
394
 
395
  /* LABEL_DOMAIN may be used for names of labels (for gotos);
396
     currently it is not used and labels are not recorded at all.  */
397
 
398
  LABEL_DOMAIN,
399
 
400
  /* Searching domains. These overlap with VAR_DOMAIN, providing
401
     some granularity with the search_symbols function. */
402
 
403
  /* Everything in VAR_DOMAIN minus FUNCTIONS_-, TYPES_-, and
404
     METHODS_DOMAIN */
405
  VARIABLES_DOMAIN,
406
 
407
  /* All functions -- for some reason not methods, though. */
408
  FUNCTIONS_DOMAIN,
409
 
410
  /* All defined types */
411
  TYPES_DOMAIN,
412
 
413
  /* All class methods -- why is this separated out? */
414
  METHODS_DOMAIN
415
}
416
domain_enum;
417
 
418
/* An address-class says where to find the value of a symbol.  */
419
 
420
enum address_class
421
{
422
  /* Not used; catches errors */
423
 
424
  LOC_UNDEF,
425
 
426
  /* Value is constant int SYMBOL_VALUE, host byteorder */
427
 
428
  LOC_CONST,
429
 
430
  /* Value is at fixed address SYMBOL_VALUE_ADDRESS */
431
 
432
  LOC_STATIC,
433
 
434
  /* Value is in register.  SYMBOL_VALUE is the register number.  */
435
 
436
  LOC_REGISTER,
437
 
438
  /* It's an argument; the value is at SYMBOL_VALUE offset in arglist.  */
439
 
440
  LOC_ARG,
441
 
442
  /* Value address is at SYMBOL_VALUE offset in arglist.  */
443
 
444
  LOC_REF_ARG,
445
 
446
  /* Value is in register number SYMBOL_VALUE.  Just like LOC_REGISTER
447
     except this is an argument.  Probably the cleaner way to handle
448
     this would be to separate address_class (which would include
449
     separate ARG and LOCAL to deal with the frame's arguments
450
     (get_frame_args_address) versus the frame's locals
451
     (get_frame_locals_address), and an is_argument flag.
452
 
453
     For some symbol formats (stabs, for some compilers at least),
454
     the compiler generates two symbols, an argument and a register.
455
     In some cases we combine them to a single LOC_REGPARM in symbol
456
     reading, but currently not for all cases (e.g. it's passed on the
457
     stack and then loaded into a register).  */
458
 
459
  LOC_REGPARM,
460
 
461
  /* Value is in specified register.  Just like LOC_REGPARM except the
462
     register holds the address of the argument instead of the argument
463
     itself. This is currently used for the passing of structs and unions
464
     on sparc and hppa.  It is also used for call by reference where the
465
     address is in a register, at least by mipsread.c.  */
466
 
467
  LOC_REGPARM_ADDR,
468
 
469
  /* Value is a local variable at SYMBOL_VALUE offset in stack frame.  */
470
 
471
  LOC_LOCAL,
472
 
473
  /* Value not used; definition in SYMBOL_TYPE.  Symbols in the domain
474
     STRUCT_DOMAIN all have this class.  */
475
 
476
  LOC_TYPEDEF,
477
 
478
  /* Value is address SYMBOL_VALUE_ADDRESS in the code */
479
 
480
  LOC_LABEL,
481
 
482
  /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
483
     In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
484
     of the block.  Function names have this class. */
485
 
486
  LOC_BLOCK,
487
 
488
  /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
489
     target byte order.  */
490
 
491
  LOC_CONST_BYTES,
492
 
493
  /* Value is arg at SYMBOL_VALUE offset in stack frame. Differs from
494
     LOC_LOCAL in that symbol is an argument; differs from LOC_ARG in
495
     that we find it in the frame (get_frame_locals_address), not in
496
     the arglist (get_frame_args_address).  Added for i960, which
497
     passes args in regs then copies to frame.  */
498
 
499
  LOC_LOCAL_ARG,
500
 
501
  /* Value is at SYMBOL_VALUE offset from the current value of
502
     register number SYMBOL_BASEREG.  This exists mainly for the same
503
     things that LOC_LOCAL and LOC_ARG do; but we need to do this
504
     instead because on 88k DWARF gives us the offset from the
505
     frame/stack pointer, rather than the offset from the "canonical
506
     frame address" used by COFF, stabs, etc., and we don't know how
507
     to convert between these until we start examining prologues.
508
 
509
     Note that LOC_BASEREG is much less general than a DWARF expression.
510
     We don't need the generality (at least not yet), and storing a general
511
     DWARF expression would presumably take up more space than the existing
512
     scheme.  */
513
 
514
  LOC_BASEREG,
515
 
516
  /* Same as LOC_BASEREG but it is an argument.  */
517
 
518
  LOC_BASEREG_ARG,
519
 
520
  /* Value is at fixed address, but the address of the variable has
521
     to be determined from the minimal symbol table whenever the
522
     variable is referenced.
523
     This happens if debugging information for a global symbol is
524
     emitted and the corresponding minimal symbol is defined
525
     in another object file or runtime common storage.
526
     The linker might even remove the minimal symbol if the global
527
     symbol is never referenced, in which case the symbol remains
528
     unresolved.  */
529
 
530
  LOC_UNRESOLVED,
531
 
532
  /* Value is at a thread-specific location calculated by a
533
     target-specific method. This is used only by hppa.  */
534
 
535
  LOC_HP_THREAD_LOCAL_STATIC,
536
 
537
  /* The variable does not actually exist in the program.
538
     The value is ignored.  */
539
 
540
  LOC_OPTIMIZED_OUT,
541
 
542
  /* The variable is static, but actually lives at * (address).
543
   * I.e. do an extra indirection to get to it.
544
   * This is used on HP-UX to get at globals that are allocated
545
   * in shared libraries, where references from images other
546
   * than the one where the global was allocated are done
547
   * with a level of indirection.
548
   */
549
 
550
  LOC_INDIRECT,
551
 
552
  /* The variable's address is computed by a set of location
553
     functions (see "struct symbol_ops" below).  */
554
  LOC_COMPUTED,
555
 
556
  /* Same as LOC_COMPUTED, but for function arguments.  */
557
  LOC_COMPUTED_ARG
558
};
559
 
560
/* The methods needed to implement a symbol class.  These methods can
561
   use the symbol's .aux_value for additional per-symbol information.
562
 
563
   At present this is only used to implement location expressions.  */
564
 
565
struct symbol_ops
566
{
567
 
568
  /* Return the value of the variable SYMBOL, relative to the stack
569
     frame FRAME.  If the variable has been optimized out, return
570
     zero.
571
 
572
     Iff `read_needs_frame (SYMBOL)' is zero, then FRAME may be zero.  */
573
 
574
  struct value *(*read_variable) (struct symbol * symbol,
575
                                  struct frame_info * frame);
576
 
577
  /* Return non-zero if we need a frame to find the value of the SYMBOL.  */
578
  int (*read_needs_frame) (struct symbol * symbol);
579
 
580
  /* Write to STREAM a natural-language description of the location of
581
     SYMBOL.  */
582
  int (*describe_location) (struct symbol * symbol, struct ui_file * stream);
583
 
584
  /* Tracepoint support.  Append bytecodes to the tracepoint agent
585
     expression AX that push the address of the object SYMBOL.  Set
586
     VALUE appropriately.  Note --- for objects in registers, this
587
     needn't emit any code; as long as it sets VALUE properly, then
588
     the caller will generate the right code in the process of
589
     treating this as an lvalue or rvalue.  */
590
 
591
  void (*tracepoint_var_ref) (struct symbol * symbol, struct agent_expr * ax,
592
                              struct axs_value * value);
593
};
594
 
595
/* This structure is space critical.  See space comments at the top. */
596
 
597
struct symbol
598
{
599
 
600
  /* The general symbol info required for all types of symbols. */
601
 
602
  struct general_symbol_info ginfo;
603
 
604
  /* Data type of value */
605
 
606
  struct type *type;
607
 
608
  /* The symbol table containing this symbol.  This is the file
609
     associated with LINE.  */
610
  struct symtab *symtab;
611
 
612
  /* Domain code.  */
613
 
614
  ENUM_BITFIELD(domain_enum_tag) domain : 6;
615
 
616
  /* Address class */
617
  /* NOTE: cagney/2003-11-02: The fields "aclass" and "ops" contain
618
     overlapping information.  By creating a per-aclass ops vector, or
619
     using the aclass as an index into an ops table, the aclass and
620
     ops fields can be merged.  The latter, for instance, would shave
621
     32-bits from each symbol (relative to a symbol lookup, any table
622
     index overhead would be in the noise).  */
623
 
624
  ENUM_BITFIELD(address_class) aclass : 6;
625
 
626
  /* Line number of definition.  FIXME:  Should we really make the assumption
627
     that nobody will try to debug files longer than 64K lines?  What about
628
     machine generated programs? */
629
 
630
  unsigned short line;
631
 
632
  /* Method's for symbol's of this class.  */
633
  /* NOTE: cagney/2003-11-02: See comment above attached to "aclass".  */
634
 
635
  const struct symbol_ops *ops;
636
 
637
  /* Some symbols require additional information to be recorded on a
638
     per- symbol basis.  Stash those values here. */
639
 
640
  union
641
  {
642
    /* Used by LOC_BASEREG and LOC_BASEREG_ARG.  */
643
    short basereg;
644
    /* An arbitrary data pointer.  Note that this data must be
645
       allocated using the same obstack as the symbol itself.  */
646
    /* So far it is only used by LOC_COMPUTED and LOC_COMPUTED_ARG to
647
       find the location location information.  For a LOC_BLOCK symbol
648
       for a function in a compilation unit compiled with DWARF 2
649
       information, this is information used internally by the DWARF 2
650
       code --- specifically, the location expression for the frame
651
       base for this function.  */
652
    /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
653
       to add a magic symbol to the block containing this information,
654
       or to have a generic debug info annotation slot for symbols.  */
655
    void *ptr;
656
  }
657
  aux_value;
658
 
659
  struct symbol *hash_next;
660
};
661
 
662
 
663
#define SYMBOL_DOMAIN(symbol)   (symbol)->domain
664
#define SYMBOL_CLASS(symbol)            (symbol)->aclass
665
#define SYMBOL_TYPE(symbol)             (symbol)->type
666
#define SYMBOL_LINE(symbol)             (symbol)->line
667
#define SYMBOL_SYMTAB(symbol)           (symbol)->symtab
668
#define SYMBOL_BASEREG(symbol)          (symbol)->aux_value.basereg
669
#define SYMBOL_OBJFILE(symbol)          (symbol)->aux_value.objfile
670
#define SYMBOL_OPS(symbol)              (symbol)->ops
671
#define SYMBOL_LOCATION_BATON(symbol)   (symbol)->aux_value.ptr
672
 
673
/* A partial_symbol records the name, domain, and address class of
674
   symbols whose types we have not parsed yet.  For functions, it also
675
   contains their memory address, so we can find them from a PC value.
676
   Each partial_symbol sits in a partial_symtab, all of which are chained
677
   on a  partial symtab list and which points to the corresponding
678
   normal symtab once the partial_symtab has been referenced.  */
679
 
680
/* This structure is space critical.  See space comments at the top. */
681
 
682
struct partial_symbol
683
{
684
 
685
  /* The general symbol info required for all types of symbols. */
686
 
687
  struct general_symbol_info ginfo;
688
 
689
  /* Name space code.  */
690
 
691
  ENUM_BITFIELD(domain_enum_tag) domain : 6;
692
 
693
  /* Address class (for info_symbols) */
694
 
695
  ENUM_BITFIELD(address_class) aclass : 6;
696
 
697
};
698
 
699
#define PSYMBOL_DOMAIN(psymbol) (psymbol)->domain
700
#define PSYMBOL_CLASS(psymbol)          (psymbol)->aclass
701
 
702
 
703
/* Each item represents a line-->pc (or the reverse) mapping.  This is
704
   somewhat more wasteful of space than one might wish, but since only
705
   the files which are actually debugged are read in to core, we don't
706
   waste much space.  */
707
 
708
struct linetable_entry
709
{
710
  int line;
711
  CORE_ADDR pc;
712
};
713
 
714
/* The order of entries in the linetable is significant.  They should
715
   be sorted by increasing values of the pc field.  If there is more than
716
   one entry for a given pc, then I'm not sure what should happen (and
717
   I not sure whether we currently handle it the best way).
718
 
719
   Example: a C for statement generally looks like this
720
 
721
   10   0x100   - for the init/test part of a for stmt.
722
   20   0x200
723
   30   0x300
724
   10   0x400   - for the increment part of a for stmt.
725
 
726
   If an entry has a line number of zero, it marks the start of a PC
727
   range for which no line number information is available.  It is
728
   acceptable, though wasteful of table space, for such a range to be
729
   zero length.  */
730
 
731
struct linetable
732
{
733
  int nitems;
734
 
735
  /* Actually NITEMS elements.  If you don't like this use of the
736
     `struct hack', you can shove it up your ANSI (seriously, if the
737
     committee tells us how to do it, we can probably go along).  */
738
  struct linetable_entry item[1];
739
};
740
 
741
/* How to relocate the symbols from each section in a symbol file.
742
   Each struct contains an array of offsets.
743
   The ordering and meaning of the offsets is file-type-dependent;
744
   typically it is indexed by section numbers or symbol types or
745
   something like that.
746
 
747
   To give us flexibility in changing the internal representation
748
   of these offsets, the ANOFFSET macro must be used to insert and
749
   extract offset values in the struct.  */
750
 
751
struct section_offsets
752
{
753
  CORE_ADDR offsets[1];         /* As many as needed. */
754
};
755
 
756
#define ANOFFSET(secoff, whichone) \
757
   ((whichone == -1) \
758
    ? (internal_error (__FILE__, __LINE__, _("Section index is uninitialized")), -1) \
759
    : secoff->offsets[whichone])
760
 
761
/* The size of a section_offsets table for N sections.  */
762
#define SIZEOF_N_SECTION_OFFSETS(n) \
763
  (sizeof (struct section_offsets) \
764
   + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
765
 
766
/* Each source file or header is represented by a struct symtab.
767
   These objects are chained through the `next' field.  */
768
 
769
struct symtab
770
{
771
 
772
  /* Chain of all existing symtabs.  */
773
 
774
  struct symtab *next;
775
 
776
  /* List of all symbol scope blocks for this symtab.  May be shared
777
     between different symtabs (and normally is for all the symtabs
778
     in a given compilation unit).  */
779
 
780
  struct blockvector *blockvector;
781
 
782
  /* Table mapping core addresses to line numbers for this file.
783
     Can be NULL if none.  Never shared between different symtabs.  */
784
 
785
  struct linetable *linetable;
786
 
787
  /* Section in objfile->section_offsets for the blockvector and
788
     the linetable.  Probably always SECT_OFF_TEXT.  */
789
 
790
  int block_line_section;
791
 
792
  /* If several symtabs share a blockvector, exactly one of them
793
     should be designated the primary, so that the blockvector
794
     is relocated exactly once by objfile_relocate.  */
795
 
796
  int primary;
797
 
798
  /* The macro table for this symtab.  Like the blockvector, this
799
     may be shared between different symtabs --- and normally is for
800
     all the symtabs in a given compilation unit.  */
801
  struct macro_table *macro_table;
802
 
803
  /* Name of this source file.  */
804
 
805
  char *filename;
806
 
807
  /* Directory in which it was compiled, or NULL if we don't know.  */
808
 
809
  char *dirname;
810
 
811
  /* This component says how to free the data we point to:
812
     free_contents => do a tree walk and free each object.
813
     free_nothing => do nothing; some other symtab will free
814
     the data this one uses.
815
     free_linetable => free just the linetable.  FIXME: Is this redundant
816
     with the primary field?  */
817
 
818
  enum free_code
819
  {
820
    free_nothing, free_contents, free_linetable
821
  }
822
  free_code;
823
 
824
  /* A function to call to free space, if necessary.  This is IN
825
     ADDITION to the action indicated by free_code.  */
826
 
827
  void (*free_func)(struct symtab *symtab);
828
 
829
  /* Total number of lines found in source file.  */
830
 
831
  int nlines;
832
 
833
  /* line_charpos[N] is the position of the (N-1)th line of the
834
     source file.  "position" means something we can lseek() to; it
835
     is not guaranteed to be useful any other way.  */
836
 
837
  int *line_charpos;
838
 
839
  /* Language of this source file.  */
840
 
841
  enum language language;
842
 
843
  /* String that identifies the format of the debugging information, such
844
     as "stabs", "dwarf 1", "dwarf 2", "coff", etc.  This is mostly useful
845
     for automated testing of gdb but may also be information that is
846
     useful to the user. */
847
 
848
  char *debugformat;
849
 
850
  /* String of producer version information.  May be zero.  */
851
 
852
  char *producer;
853
 
854
  /* Full name of file as found by searching the source path.
855
     NULL if not yet known.  */
856
 
857
  char *fullname;
858
 
859
  /* Object file from which this symbol information was read.  */
860
 
861
  struct objfile *objfile;
862
 
863
};
864
 
865
#define BLOCKVECTOR(symtab)     (symtab)->blockvector
866
#define LINETABLE(symtab)       (symtab)->linetable
867
 
868
 
869
/* Each source file that has not been fully read in is represented by
870
   a partial_symtab.  This contains the information on where in the
871
   executable the debugging symbols for a specific file are, and a
872
   list of names of global symbols which are located in this file.
873
   They are all chained on partial symtab lists.
874
 
875
   Even after the source file has been read into a symtab, the
876
   partial_symtab remains around.  They are allocated on an obstack,
877
   objfile_obstack.  FIXME, this is bad for dynamic linking or VxWorks-
878
   style execution of a bunch of .o's.  */
879
 
880
struct partial_symtab
881
{
882
 
883
  /* Chain of all existing partial symtabs.  */
884
 
885
  struct partial_symtab *next;
886
 
887
  /* Name of the source file which this partial_symtab defines */
888
 
889
  char *filename;
890
 
891
  /* Full path of the source file.  NULL if not known.  */
892
 
893
  char *fullname;
894
 
895
  /* Directory in which it was compiled, or NULL if we don't know.  */
896
 
897
  char *dirname;
898
 
899
  /* Information about the object file from which symbols should be read.  */
900
 
901
  struct objfile *objfile;
902
 
903
  /* Set of relocation offsets to apply to each section.  */
904
 
905
  struct section_offsets *section_offsets;
906
 
907
  /* Range of text addresses covered by this file; texthigh is the
908
     beginning of the next section. */
909
 
910
  CORE_ADDR textlow;
911
  CORE_ADDR texthigh;
912
 
913
  /* Array of pointers to all of the partial_symtab's which this one
914
     depends on.  Since this array can only be set to previous or
915
     the current (?) psymtab, this dependency tree is guaranteed not
916
     to have any loops.  "depends on" means that symbols must be read
917
     for the dependencies before being read for this psymtab; this is
918
     for type references in stabs, where if foo.c includes foo.h, declarations
919
     in foo.h may use type numbers defined in foo.c.  For other debugging
920
     formats there may be no need to use dependencies.  */
921
 
922
  struct partial_symtab **dependencies;
923
 
924
  int number_of_dependencies;
925
 
926
  /* Global symbol list.  This list will be sorted after readin to
927
     improve access.  Binary search will be the usual method of
928
     finding a symbol within it. globals_offset is an integer offset
929
     within global_psymbols[].  */
930
 
931
  int globals_offset;
932
  int n_global_syms;
933
 
934
  /* Static symbol list.  This list will *not* be sorted after readin;
935
     to find a symbol in it, exhaustive search must be used.  This is
936
     reasonable because searches through this list will eventually
937
     lead to either the read in of a files symbols for real (assumed
938
     to take a *lot* of time; check) or an error (and we don't care
939
     how long errors take).  This is an offset and size within
940
     static_psymbols[].  */
941
 
942
  int statics_offset;
943
  int n_static_syms;
944
 
945
  /* Pointer to symtab eventually allocated for this source file, 0 if
946
     !readin or if we haven't looked for the symtab after it was readin.  */
947
 
948
  struct symtab *symtab;
949
 
950
  /* Pointer to function which will read in the symtab corresponding to
951
     this psymtab.  */
952
 
953
  void (*read_symtab) (struct partial_symtab *);
954
 
955
  /* Information that lets read_symtab() locate the part of the symbol table
956
     that this psymtab corresponds to.  This information is private to the
957
     format-dependent symbol reading routines.  For further detail examine
958
     the various symbol reading modules.  Should really be (void *) but is
959
     (char *) as with other such gdb variables.  (FIXME) */
960
 
961
  char *read_symtab_private;
962
 
963
  /* Non-zero if the symtab corresponding to this psymtab has been readin */
964
 
965
  unsigned char readin;
966
};
967
 
968
/* A fast way to get from a psymtab to its symtab (after the first time).  */
969
#define PSYMTAB_TO_SYMTAB(pst)  \
970
    ((pst) -> symtab != NULL ? (pst) -> symtab : psymtab_to_symtab (pst))
971
 
972
 
973
/* The virtual function table is now an array of structures which have the
974
   form { int16 offset, delta; void *pfn; }.
975
 
976
   In normal virtual function tables, OFFSET is unused.
977
   DELTA is the amount which is added to the apparent object's base
978
   address in order to point to the actual object to which the
979
   virtual function should be applied.
980
   PFN is a pointer to the virtual function.
981
 
982
   Note that this macro is g++ specific (FIXME). */
983
 
984
#define VTBL_FNADDR_OFFSET 2
985
 
986
/* External variables and functions for the objects described above. */
987
 
988
/* See the comment in symfile.c about how current_objfile is used. */
989
 
990
extern struct objfile *current_objfile;
991
 
992
/* True if we are nested inside psymtab_to_symtab. */
993
 
994
extern int currently_reading_symtab;
995
 
996
/* From utils.c.  */
997
extern int demangle;
998
extern int asm_demangle;
999
 
1000
/* symtab.c lookup functions */
1001
 
1002
/* lookup a symbol table by source file name */
1003
 
1004
extern struct symtab *lookup_symtab (const char *);
1005
 
1006
/* lookup a symbol by name (optional block, optional symtab) in language */
1007
 
1008
extern struct symbol *lookup_symbol_in_language (const char *,
1009
                                                 const struct block *,
1010
                                                 const domain_enum,
1011
                                                 enum language,
1012
                                                 int *,
1013
                                                 struct symtab **);
1014
 
1015
/* lookup a symbol by name (optional block, optional symtab)
1016
   in the current language */
1017
 
1018
extern struct symbol *lookup_symbol (const char *, const struct block *,
1019
                                     const domain_enum, int *,
1020
                                     struct symtab **);
1021
 
1022
/* A default version of lookup_symbol_nonlocal for use by languages
1023
   that can't think of anything better to do.  */
1024
 
1025
extern struct symbol *basic_lookup_symbol_nonlocal (const char *,
1026
                                                    const char *,
1027
                                                    const struct block *,
1028
                                                    const domain_enum,
1029
                                                    struct symtab **);
1030
 
1031
/* Some helper functions for languages that need to write their own
1032
   lookup_symbol_nonlocal functions.  */
1033
 
1034
/* Lookup a symbol in the static block associated to BLOCK, if there
1035
   is one; do nothing if BLOCK is NULL or a global block.  */
1036
 
1037
extern struct symbol *lookup_symbol_static (const char *name,
1038
                                            const char *linkage_name,
1039
                                            const struct block *block,
1040
                                            const domain_enum domain,
1041
                                            struct symtab **symtab);
1042
 
1043
/* Lookup a symbol in all files' global blocks (searching psymtabs if
1044
   necessary).  */
1045
 
1046
extern struct symbol *lookup_symbol_global (const char *name,
1047
                                            const char *linkage_name,
1048
                                            const struct block *block,
1049
                                            const domain_enum domain,
1050
                                            struct symtab **symtab);
1051
 
1052
/* Lookup a symbol within the block BLOCK.  This, unlike
1053
   lookup_symbol_block, will set SYMTAB and BLOCK_FOUND correctly, and
1054
   will fix up the symbol if necessary.  */
1055
 
1056
extern struct symbol *lookup_symbol_aux_block (const char *name,
1057
                                               const char *linkage_name,
1058
                                               const struct block *block,
1059
                                               const domain_enum domain,
1060
                                               struct symtab **symtab);
1061
 
1062
/* Lookup a partial symbol.  */
1063
 
1064
extern struct partial_symbol *lookup_partial_symbol (struct partial_symtab *,
1065
                                                     const char *,
1066
                                                     const char *, int,
1067
                                                     domain_enum);
1068
 
1069
/* lookup a symbol by name, within a specified block */
1070
 
1071
extern struct symbol *lookup_block_symbol (const struct block *, const char *,
1072
                                           const char *,
1073
                                           const domain_enum);
1074
 
1075
/* lookup a [struct, union, enum] by name, within a specified block */
1076
 
1077
extern struct type *lookup_struct (char *, struct block *);
1078
 
1079
extern struct type *lookup_union (char *, struct block *);
1080
 
1081
extern struct type *lookup_enum (char *, struct block *);
1082
 
1083
/* from blockframe.c: */
1084
 
1085
/* lookup the function symbol corresponding to the address */
1086
 
1087
extern struct symbol *find_pc_function (CORE_ADDR);
1088
 
1089
/* lookup the function corresponding to the address and section */
1090
 
1091
extern struct symbol *find_pc_sect_function (CORE_ADDR, asection *);
1092
 
1093
/* lookup function from address, return name, start addr and end addr */
1094
 
1095
extern int find_pc_partial_function (CORE_ADDR, char **, CORE_ADDR *,
1096
                                     CORE_ADDR *);
1097
 
1098
extern void clear_pc_function_cache (void);
1099
 
1100
/* from symtab.c: */
1101
 
1102
/* lookup partial symbol table by filename */
1103
 
1104
extern struct partial_symtab *lookup_partial_symtab (const char *);
1105
 
1106
/* lookup partial symbol table by address */
1107
 
1108
extern struct partial_symtab *find_pc_psymtab (CORE_ADDR);
1109
 
1110
/* lookup partial symbol table by address and section */
1111
 
1112
extern struct partial_symtab *find_pc_sect_psymtab (CORE_ADDR, asection *);
1113
 
1114
/* lookup full symbol table by address */
1115
 
1116
extern struct symtab *find_pc_symtab (CORE_ADDR);
1117
 
1118
/* lookup full symbol table by address and section */
1119
 
1120
extern struct symtab *find_pc_sect_symtab (CORE_ADDR, asection *);
1121
 
1122
/* lookup partial symbol by address */
1123
 
1124
extern struct partial_symbol *find_pc_psymbol (struct partial_symtab *,
1125
                                               CORE_ADDR);
1126
 
1127
/* lookup partial symbol by address and section */
1128
 
1129
extern struct partial_symbol *find_pc_sect_psymbol (struct partial_symtab *,
1130
                                                    CORE_ADDR, asection *);
1131
 
1132
extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
1133
 
1134
extern void reread_symbols (void);
1135
 
1136
extern struct type *lookup_transparent_type (const char *);
1137
extern struct type *basic_lookup_transparent_type (const char *);
1138
 
1139
 
1140
/* Macro for name of symbol to indicate a file compiled with gcc. */
1141
#ifndef GCC_COMPILED_FLAG_SYMBOL
1142
#define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
1143
#endif
1144
 
1145
/* Macro for name of symbol to indicate a file compiled with gcc2. */
1146
#ifndef GCC2_COMPILED_FLAG_SYMBOL
1147
#define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
1148
#endif
1149
 
1150
/* Functions for dealing with the minimal symbol table, really a misc
1151
   address<->symbol mapping for things we don't have debug symbols for.  */
1152
 
1153
extern void prim_record_minimal_symbol (const char *, CORE_ADDR,
1154
                                        enum minimal_symbol_type,
1155
                                        struct objfile *);
1156
 
1157
extern struct minimal_symbol *prim_record_minimal_symbol_and_info
1158
  (const char *, CORE_ADDR,
1159
   enum minimal_symbol_type,
1160
   char *info, int section, asection * bfd_section, struct objfile *);
1161
 
1162
extern unsigned int msymbol_hash_iw (const char *);
1163
 
1164
extern unsigned int msymbol_hash (const char *);
1165
 
1166
extern void
1167
add_minsym_to_hash_table (struct minimal_symbol *sym,
1168
                          struct minimal_symbol **table);
1169
 
1170
extern struct minimal_symbol *lookup_minimal_symbol (const char *,
1171
                                                     const char *,
1172
                                                     struct objfile *);
1173
 
1174
extern struct minimal_symbol *lookup_minimal_symbol_text (const char *,
1175
                                                          struct objfile *);
1176
 
1177
struct minimal_symbol *lookup_minimal_symbol_solib_trampoline (const char *,
1178
                                                               struct objfile
1179
                                                               *);
1180
 
1181
extern struct minimal_symbol *lookup_minimal_symbol_by_pc (CORE_ADDR);
1182
 
1183
extern struct minimal_symbol *lookup_minimal_symbol_by_pc_section (CORE_ADDR,
1184
                                                                   asection
1185
                                                                   *);
1186
 
1187
extern struct minimal_symbol
1188
  *lookup_solib_trampoline_symbol_by_pc (CORE_ADDR);
1189
 
1190
extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR);
1191
 
1192
extern void init_minimal_symbol_collection (void);
1193
 
1194
extern struct cleanup *make_cleanup_discard_minimal_symbols (void);
1195
 
1196
extern void install_minimal_symbols (struct objfile *);
1197
 
1198
/* Sort all the minimal symbols in OBJFILE.  */
1199
 
1200
extern void msymbols_sort (struct objfile *objfile);
1201
 
1202
struct symtab_and_line
1203
{
1204
  struct symtab *symtab;
1205
  asection *section;
1206
  /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
1207
 
1208
     information is not available.  */
1209
  int line;
1210
 
1211
  CORE_ADDR pc;
1212
  CORE_ADDR end;
1213
  int explicit_pc;
1214
  int explicit_line;
1215
};
1216
 
1217
extern void init_sal (struct symtab_and_line *sal);
1218
 
1219
struct symtabs_and_lines
1220
{
1221
  struct symtab_and_line *sals;
1222
  int nelts;
1223
};
1224
 
1225
 
1226
 
1227
/* Some types and macros needed for exception catchpoints.
1228
   Can't put these in target.h because symtab_and_line isn't
1229
   known there. This file will be included by breakpoint.c,
1230
   hppa-tdep.c, etc. */
1231
 
1232
/* Enums for exception-handling support */
1233
enum exception_event_kind
1234
{
1235
  EX_EVENT_THROW,
1236
  EX_EVENT_CATCH
1237
};
1238
 
1239
/* Type for returning info about an exception */
1240
struct exception_event_record
1241
{
1242
  enum exception_event_kind kind;
1243
  struct symtab_and_line throw_sal;
1244
  struct symtab_and_line catch_sal;
1245
  /* This may need to be extended in the future, if
1246
     some platforms allow reporting more information,
1247
     such as point of rethrow, type of exception object,
1248
     type expected by catch clause, etc. */
1249
};
1250
 
1251
#define CURRENT_EXCEPTION_KIND       (current_exception_event->kind)
1252
#define CURRENT_EXCEPTION_CATCH_SAL  (current_exception_event->catch_sal)
1253
#define CURRENT_EXCEPTION_CATCH_LINE (current_exception_event->catch_sal.line)
1254
#define CURRENT_EXCEPTION_CATCH_FILE (current_exception_event->catch_sal.symtab->filename)
1255
#define CURRENT_EXCEPTION_CATCH_PC   (current_exception_event->catch_sal.pc)
1256
#define CURRENT_EXCEPTION_THROW_SAL  (current_exception_event->throw_sal)
1257
#define CURRENT_EXCEPTION_THROW_LINE (current_exception_event->throw_sal.line)
1258
#define CURRENT_EXCEPTION_THROW_FILE (current_exception_event->throw_sal.symtab->filename)
1259
#define CURRENT_EXCEPTION_THROW_PC   (current_exception_event->throw_sal.pc)
1260
 
1261
 
1262
/* Given a pc value, return line number it is in.  Second arg nonzero means
1263
   if pc is on the boundary use the previous statement's line number.  */
1264
 
1265
extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
1266
 
1267
/* Same function, but specify a section as well as an address */
1268
 
1269
extern struct symtab_and_line find_pc_sect_line (CORE_ADDR, asection *, int);
1270
 
1271
/* Given a symtab and line number, return the pc there.  */
1272
 
1273
extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
1274
 
1275
extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
1276
                               CORE_ADDR *);
1277
 
1278
extern void resolve_sal_pc (struct symtab_and_line *);
1279
 
1280
/* Given a string, return the line specified by it.  For commands like "list"
1281
   and "breakpoint".  */
1282
 
1283
extern struct symtabs_and_lines decode_line_spec (char *, int);
1284
 
1285
extern struct symtabs_and_lines decode_line_spec_1 (char *, int);
1286
 
1287
/* Symmisc.c */
1288
 
1289
void maintenance_print_symbols (char *, int);
1290
 
1291
void maintenance_print_psymbols (char *, int);
1292
 
1293
void maintenance_print_msymbols (char *, int);
1294
 
1295
void maintenance_print_objfiles (char *, int);
1296
 
1297
void maintenance_info_symtabs (char *, int);
1298
 
1299
void maintenance_info_psymtabs (char *, int);
1300
 
1301
void maintenance_check_symtabs (char *, int);
1302
 
1303
/* maint.c */
1304
 
1305
void maintenance_print_statistics (char *, int);
1306
 
1307
extern void free_symtab (struct symtab *);
1308
 
1309
/* Symbol-reading stuff in symfile.c and solib.c.  */
1310
 
1311
extern struct symtab *psymtab_to_symtab (struct partial_symtab *);
1312
 
1313
extern void clear_solib (void);
1314
 
1315
/* source.c */
1316
 
1317
extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
1318
 
1319
extern void print_source_lines (struct symtab *, int, int, int);
1320
 
1321
extern void forget_cached_source_info (void);
1322
 
1323
extern void select_source_symtab (struct symtab *);
1324
 
1325
extern char **default_make_symbol_completion_list (char *, char *);
1326
extern char **make_symbol_completion_list (char *, char *);
1327
 
1328
extern char **make_file_symbol_completion_list (char *, char *, char *);
1329
 
1330
extern char **make_source_files_completion_list (char *, char *);
1331
 
1332
/* symtab.c */
1333
 
1334
int matching_bfd_sections (asection *, asection *);
1335
 
1336
extern struct partial_symtab *find_main_psymtab (void);
1337
 
1338
extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
1339
 
1340
extern struct symtab_and_line find_function_start_sal (struct symbol *sym,
1341
                                                       int);
1342
 
1343
/* symfile.c */
1344
 
1345
extern void clear_symtab_users (void);
1346
 
1347
extern enum language deduce_language_from_filename (char *);
1348
 
1349
/* symtab.c */
1350
 
1351
extern int in_prologue (CORE_ADDR pc, CORE_ADDR func_start);
1352
 
1353
extern CORE_ADDR skip_prologue_using_sal (CORE_ADDR func_addr);
1354
 
1355
extern struct symbol *fixup_symbol_section (struct symbol *,
1356
                                            struct objfile *);
1357
 
1358
extern struct partial_symbol *fixup_psymbol_section (struct partial_symbol
1359
                                                     *psym,
1360
                                                     struct objfile *objfile);
1361
 
1362
/* Symbol searching */
1363
 
1364
/* When using search_symbols, a list of the following structs is returned.
1365
   Callers must free the search list using free_search_symbols! */
1366
struct symbol_search
1367
{
1368
  /* The block in which the match was found. Could be, for example,
1369
     STATIC_BLOCK or GLOBAL_BLOCK. */
1370
  int block;
1371
 
1372
  /* Information describing what was found.
1373
 
1374
     If symtab abd symbol are NOT NULL, then information was found
1375
     for this match. */
1376
  struct symtab *symtab;
1377
  struct symbol *symbol;
1378
 
1379
  /* If msymbol is non-null, then a match was made on something for
1380
     which only minimal_symbols exist. */
1381
  struct minimal_symbol *msymbol;
1382
 
1383
  /* A link to the next match, or NULL for the end. */
1384
  struct symbol_search *next;
1385
};
1386
 
1387
extern void search_symbols (char *, domain_enum, int, char **,
1388
                            struct symbol_search **);
1389
extern void free_search_symbols (struct symbol_search *);
1390
extern struct cleanup *make_cleanup_free_search_symbols (struct symbol_search
1391
                                                         *);
1392
 
1393
/* The name of the ``main'' function.
1394
   FIXME: cagney/2001-03-20: Can't make main_name() const since some
1395
   of the calling code currently assumes that the string isn't
1396
   const. */
1397
extern void set_main_name (const char *name);
1398
extern /*const */ char *main_name (void);
1399
 
1400
/* Check global symbols in objfile.  */
1401
struct symbol *lookup_global_symbol_from_objfile (const struct objfile *objfile,
1402
                                                  const char *name,
1403
                                                  const char *linkage_name,
1404
                                                  const domain_enum domain,
1405
                                                  struct symtab **symtab);
1406
 
1407
extern struct symtabs_and_lines
1408
expand_line_sal (struct symtab_and_line sal);
1409
 
1410
#endif /* !defined(SYMTAB_H) */

powered by: WebSVN 2.1.0

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