OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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