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

Subversion Repositories openrisc

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

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

Line No. Rev Author Line
1 227 jeremybenn
/* Definitions for reading symbol files into GDB.
2
 
3
   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4
   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 (SYMFILE_H)
23
#define SYMFILE_H
24
 
25
/* This file requires that you first include "bfd.h".  */
26
#include "symtab.h"
27
 
28
/* Opaque declarations.  */
29
struct target_section;
30
struct objfile;
31
struct obj_section;
32
struct obstack;
33
struct block;
34
 
35
/* Partial symbols are stored in the psymbol_cache and pointers to
36
   them are kept in a dynamically grown array that is obtained from
37
   malloc and grown as necessary via realloc.  Each objfile typically
38
   has two of these, one for global symbols and one for static
39
   symbols.  Although this adds a level of indirection for storing or
40
   accessing the partial symbols, it allows us to throw away duplicate
41
   psymbols and set all pointers to the single saved instance.  */
42
 
43
struct psymbol_allocation_list
44
{
45
 
46
  /* Pointer to beginning of dynamically allocated array of pointers
47
     to partial symbols.  The array is dynamically expanded as
48
     necessary to accommodate more pointers.  */
49
 
50
  struct partial_symbol **list;
51
 
52
  /* Pointer to next available slot in which to store a pointer to a
53
     partial symbol.  */
54
 
55
  struct partial_symbol **next;
56
 
57
  /* Number of allocated pointer slots in current dynamic array (not
58
     the number of bytes of storage).  The "next" pointer will always
59
     point somewhere between list[0] and list[size], and when at
60
     list[size] the array will be expanded on the next attempt to
61
     store a pointer.  */
62
 
63
  int size;
64
};
65
 
66
/* Define an array of addresses to accommodate non-contiguous dynamic
67
   loading of modules.  This is for use when entering commands, so we
68
   can keep track of the section names until we read the file and can
69
   map them to bfd sections.  This structure is also used by solib.c
70
   to communicate the section addresses in shared objects to
71
   symbol_file_add ().  */
72
 
73
struct section_addr_info
74
{
75
  /* The number of sections for which address information is
76
     available.  */
77
  size_t num_sections;
78
  /* Sections whose names are file format dependent. */
79
  struct other_sections
80
  {
81
    CORE_ADDR addr;
82
    char *name;
83
 
84
    /* SECTINDEX must be valid for associated BFD if ADDR is not zero.  */
85
    int sectindex;
86
  } other[1];
87
};
88
 
89
 
90
/* A table listing the load segments in a symfile, and which segment
91
   each BFD section belongs to.  */
92
struct symfile_segment_data
93
{
94
  /* How many segments are present in this file.  If there are
95
     two, the text segment is the first one and the data segment
96
     is the second one.  */
97
  int num_segments;
98
 
99
  /* If NUM_SEGMENTS is greater than zero, the original base address
100
     of each segment.  */
101
  CORE_ADDR *segment_bases;
102
 
103
  /* If NUM_SEGMENTS is greater than zero, the memory size of each
104
     segment.  */
105
  CORE_ADDR *segment_sizes;
106
 
107
  /* If NUM_SEGMENTS is greater than zero, this is an array of entries
108
     recording which segment contains each BFD section.
109
     SEGMENT_INFO[I] is S+1 if the I'th BFD section belongs to segment
110
     S, or zero if it is not in any segment.  */
111
  int *segment_info;
112
};
113
 
114
/* Structure to keep track of symbol reading functions for various
115
   object file types.  */
116
 
117
struct sym_fns
118
{
119
 
120
  /* BFD flavour that we handle, or (as a special kludge, see
121
     xcoffread.c, (enum bfd_flavour)-1 for xcoff).  */
122
 
123
  enum bfd_flavour sym_flavour;
124
 
125
  /* Initializes anything that is global to the entire symbol table.
126
     It is called during symbol_file_add, when we begin debugging an
127
     entirely new program.  */
128
 
129
  void (*sym_new_init) (struct objfile *);
130
 
131
  /* Reads any initial information from a symbol file, and initializes
132
     the struct sym_fns SF in preparation for sym_read().  It is
133
     called every time we read a symbol file for any reason.  */
134
 
135
  void (*sym_init) (struct objfile *);
136
 
137
  /* sym_read (objfile, symfile_flags) Reads a symbol file into a psymtab
138
     (or possibly a symtab).  OBJFILE is the objfile struct for the
139
     file we are reading.  SYMFILE_FLAGS are the flags passed to
140
     symbol_file_add & co.  */
141
 
142
  void (*sym_read) (struct objfile *, int);
143
 
144
  /* Called when we are finished with an objfile.  Should do all
145
     cleanup that is specific to the object file format for the
146
     particular objfile.  */
147
 
148
  void (*sym_finish) (struct objfile *);
149
 
150
  /* This function produces a file-dependent section_offsets
151
     structure, allocated in the objfile's storage, and based on the
152
     parameter.  The parameter is currently a CORE_ADDR (FIXME!) for
153
     backward compatibility with the higher levels of GDB.  It should
154
     probably be changed to a string, where NULL means the default,
155
     and others are parsed in a file dependent way.  */
156
 
157
  void (*sym_offsets) (struct objfile *, struct section_addr_info *);
158
 
159
  /* This function produces a format-independent description of
160
     the segments of ABFD.  Each segment is a unit of the file
161
     which may be relocated independently.  */
162
 
163
  struct symfile_segment_data *(*sym_segments) (bfd *abfd);
164
 
165
  /* This function should read the linetable from the objfile when
166
     the line table cannot be read while processing the debugging
167
     information.  */
168
 
169
  void (*sym_read_linetable) (void);
170
 
171
  /* Relocate the contents of a debug section SECTP.  The
172
     contents are stored in BUF if it is non-NULL, or returned in a
173
     malloc'd buffer otherwise.  */
174
 
175
  bfd_byte *(*sym_relocate) (struct objfile *, asection *sectp, bfd_byte *buf);
176
 
177
  /* Finds the next struct sym_fns.  They are allocated and
178
     initialized in whatever module implements the functions pointed
179
     to; an initializer calls add_symtab_fns to add them to the global
180
     chain.  */
181
 
182
  struct sym_fns *next;
183
 
184
};
185
 
186
extern struct section_addr_info *
187
           build_section_addr_info_from_objfile (const struct objfile *objfile);
188
 
189
extern void relative_addr_info_to_section_offsets
190
  (struct section_offsets *section_offsets, int num_sections,
191
   struct section_addr_info *addrs);
192
 
193
extern void addr_info_make_relative (struct section_addr_info *addrs,
194
                                     bfd *abfd);
195
 
196
/* The default version of sym_fns.sym_offsets for readers that don't
197
   do anything special.  */
198
 
199
extern void default_symfile_offsets (struct objfile *objfile,
200
                                     struct section_addr_info *);
201
 
202
/* The default version of sym_fns.sym_segments for readers that don't
203
   do anything special.  */
204
 
205
extern struct symfile_segment_data *default_symfile_segments (bfd *abfd);
206
 
207
/* The default version of sym_fns.sym_relocate for readers that don't
208
   do anything special.  */
209
 
210
extern bfd_byte *default_symfile_relocate (struct objfile *objfile,
211
                                           asection *sectp, bfd_byte *buf);
212
 
213
extern void extend_psymbol_list (struct psymbol_allocation_list *,
214
                                 struct objfile *);
215
 
216
/* Add any kind of symbol to a psymbol_allocation_list.  */
217
 
218
/* #include "demangle.h" */
219
 
220
extern const
221
struct partial_symbol *add_psymbol_to_list (char *, int, int, domain_enum,
222
                                            enum address_class,
223
                                            struct psymbol_allocation_list *,
224
                                            long, CORE_ADDR,
225
                                            enum language, struct objfile *);
226
 
227
extern void init_psymbol_list (struct objfile *, int);
228
 
229
extern void sort_pst_symbols (struct partial_symtab *);
230
 
231
extern struct symtab *allocate_symtab (char *, struct objfile *);
232
 
233
extern void add_symtab_fns (struct sym_fns *);
234
 
235
/* This enum encodes bit-flags passed as ADD_FLAGS parameter to
236
   syms_from_objfile, symbol_file_add, etc.  */
237
 
238
enum symfile_add_flags
239
  {
240
    /* Be chatty about what you are doing.  */
241
    SYMFILE_VERBOSE = 1 << 1,
242
 
243
    /* This is the main symbol file (as opposed to symbol file for dynamically
244
       loaded code).  */
245
    SYMFILE_MAINLINE = 1 << 2,
246
 
247
    /* Do not call breakpoint_re_set when adding this symbol file.  */
248
    SYMFILE_DEFER_BP_RESET = 1 << 3
249
  };
250
 
251
extern void syms_from_objfile (struct objfile *,
252
                               struct section_addr_info *,
253
                               struct section_offsets *, int, int);
254
 
255
extern void new_symfile_objfile (struct objfile *, int);
256
 
257
extern struct objfile *symbol_file_add (char *, int,
258
                                        struct section_addr_info *, int);
259
 
260
extern struct objfile *symbol_file_add_from_bfd (bfd *, int,
261
                                                 struct section_addr_info *,
262
                                                 int);
263
 
264
extern void symbol_file_add_separate (bfd *, int, struct objfile *);
265
 
266
extern char *find_separate_debug_file_by_debuglink (struct objfile *);
267
 
268
/* Create a new section_addr_info, with room for NUM_SECTIONS.  */
269
 
270
extern struct section_addr_info *alloc_section_addr_info (size_t
271
                                                          num_sections);
272
 
273
/* Build (allocate and populate) a section_addr_info struct from an
274
   existing section table.  */
275
 
276
extern struct section_addr_info
277
  *build_section_addr_info_from_section_table (const struct target_section
278
                                               *start,
279
                                               const struct target_section
280
                                               *end);
281
 
282
/* Free all memory allocated by
283
   build_section_addr_info_from_section_table.  */
284
 
285
extern void free_section_addr_info (struct section_addr_info *);
286
 
287
 
288
extern struct partial_symtab *start_psymtab_common (struct objfile *,
289
                                                    struct section_offsets *,
290
                                                    const char *, CORE_ADDR,
291
                                                    struct partial_symbol **,
292
                                                    struct partial_symbol **);
293
 
294
/* Make a copy of the string at PTR with SIZE characters in the symbol
295
   obstack (and add a null character at the end in the copy).  Returns
296
   the address of the copy.  */
297
 
298
extern char *obsavestring (const char *, int, struct obstack *);
299
 
300
/* Concatenate strings S1, S2 and S3; return the new string.  Space is
301
   found in the OBSTACKP  */
302
 
303
extern char *obconcat (struct obstack *obstackp, const char *, const char *,
304
                       const char *);
305
 
306
                        /*   Variables   */
307
 
308
/* If non-zero, shared library symbols will be added automatically
309
   when the inferior is created, new libraries are loaded, or when
310
   attaching to the inferior.  This is almost always what users will
311
   want to have happen; but for very large programs, the startup time
312
   will be excessive, and so if this is a problem, the user can clear
313
   this flag and then add the shared library symbols as needed.  Note
314
   that there is a potential for confusion, since if the shared
315
   library symbols are not loaded, commands like "info fun" will *not*
316
   report all the functions that are actually present.  */
317
 
318
extern int auto_solib_add;
319
 
320
/* For systems that support it, a threshold size in megabytes.  If
321
   automatically adding a new library's symbol table to those already
322
   known to the debugger would cause the total shared library symbol
323
   size to exceed this threshhold, then the shlib's symbols are not
324
   added.  The threshold is ignored if the user explicitly asks for a
325
   shlib to be added, such as when using the "sharedlibrary" command.  */
326
 
327
extern int auto_solib_limit;
328
 
329
/* From symfile.c */
330
 
331
extern void set_initial_language (void);
332
 
333
extern struct partial_symtab *allocate_psymtab (const char *,
334
                                                struct objfile *);
335
 
336
extern void discard_psymtab (struct partial_symtab *);
337
 
338
extern void find_lowest_section (bfd *, asection *, void *);
339
 
340
extern bfd *symfile_bfd_open (char *);
341
 
342
extern bfd *bfd_open_maybe_remote (const char *);
343
 
344
extern int get_section_index (struct objfile *, char *);
345
 
346
/* Utility functions for overlay sections: */
347
extern enum overlay_debugging_state
348
{
349
  ovly_off,
350
  ovly_on,
351
  ovly_auto
352
} overlay_debugging;
353
extern int overlay_cache_invalid;
354
 
355
/* Return the "mapped" overlay section containing the PC.  */
356
extern struct obj_section *find_pc_mapped_section (CORE_ADDR);
357
 
358
/* Return any overlay section containing the PC (even in its LMA
359
   region).  */
360
extern struct obj_section *find_pc_overlay (CORE_ADDR);
361
 
362
/* Return true if the section is an overlay.  */
363
extern int section_is_overlay (struct obj_section *);
364
 
365
/* Return true if the overlay section is currently "mapped".  */
366
extern int section_is_mapped (struct obj_section *);
367
 
368
/* Return true if pc belongs to section's VMA.  */
369
extern CORE_ADDR pc_in_mapped_range (CORE_ADDR, struct obj_section *);
370
 
371
/* Return true if pc belongs to section's LMA.  */
372
extern CORE_ADDR pc_in_unmapped_range (CORE_ADDR, struct obj_section *);
373
 
374
/* Map an address from a section's LMA to its VMA.  */
375
extern CORE_ADDR overlay_mapped_address (CORE_ADDR, struct obj_section *);
376
 
377
/* Map an address from a section's VMA to its LMA.  */
378
extern CORE_ADDR overlay_unmapped_address (CORE_ADDR, struct obj_section *);
379
 
380
/* Convert an address in an overlay section (force into VMA range).  */
381
extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
382
 
383
/* Load symbols from a file.  */
384
extern void symbol_file_add_main (char *args, int from_tty);
385
 
386
/* Clear GDB symbol tables.  */
387
extern void symbol_file_clear (int from_tty);
388
 
389
/* Default overlay update function.  */
390
extern void simple_overlay_update (struct obj_section *);
391
 
392
extern bfd_byte *symfile_relocate_debug_section (struct objfile *, asection *,
393
                                                 bfd_byte *);
394
 
395
extern int symfile_map_offsets_to_segments (bfd *,
396
                                            struct symfile_segment_data *,
397
                                            struct section_offsets *,
398
                                            int, const CORE_ADDR *);
399
struct symfile_segment_data *get_symfile_segment_data (bfd *abfd);
400
void free_symfile_segment_data (struct symfile_segment_data *data);
401
 
402
/* From dwarf2read.c */
403
 
404
extern int dwarf2_has_info (struct objfile *);
405
 
406
extern void dwarf2_build_psymtabs (struct objfile *);
407
extern void dwarf2_build_frame_info (struct objfile *);
408
 
409
void dwarf2_free_objfile (struct objfile *);
410
 
411
/* From mdebugread.c */
412
 
413
/* Hack to force structures to exist before use in parameter list.  */
414
struct ecoff_debug_hack
415
{
416
  struct ecoff_debug_swap *a;
417
  struct ecoff_debug_info *b;
418
};
419
 
420
extern void mdebug_build_psymtabs (struct objfile *,
421
                                   const struct ecoff_debug_swap *,
422
                                   struct ecoff_debug_info *);
423
 
424
extern void elfmdebug_build_psymtabs (struct objfile *,
425
                                      const struct ecoff_debug_swap *,
426
                                      asection *);
427
 
428
#endif /* !defined(SYMFILE_H) */

powered by: WebSVN 2.1.0

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