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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [symtab.h] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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