binutils-gdb/gdb/symfile.h

/* Definitions for reading symbol files into GDB.
   Copyright (C) 1990, 1991, 1992  Free Software Foundation, Inc.

This file is part of GDB.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#if !defined (SYMFILE_H)
#define SYMFILE_H

/* This file requires that you first include "bfd.h".  */

struct psymbol_allocation_list {
  struct partial_symbol *list;
  struct partial_symbol *next;
  int size;
};

/* Structure to keep track of symbol reading functions for various
   object file types.  */

struct sym_fns {

  /* is the name, or name prefix, of the BFD "target type" that this
     set of functions handles.  E.g. "a.out" or "sunOs" or "coff" or "elf".  */

  char *sym_name;

  /* counts how many bytes of sym_name should be checked against the
     BFD target type of the file being read.  If an exact match is
     desired, specify the number of characters in sym_name plus 1 for the
     NUL.  If a prefix match is desired, specify the number of characters in
     sym_name.  */

  int sym_namelen;

  /* Initializes anything that is global to the entire symbol table.  It is
     called during symbol_file_add, when we begin debugging an entirely new
     program. */

  void (*sym_new_init) PARAMS ((struct objfile *));

  /* Reads any initial information from a symbol file, and initializes the
     struct sym_fns SF in preparation for sym_read().  It is called every
     time we read a symbol file for any reason. */

  void (*sym_init) PARAMS ((struct objfile *));

  /* sym_read (objfile, addr, mainline)
     Reads a symbol file into a psymtab (or possibly a symtab).
     OBJFILE is the objfile struct for the file we are reading.  ADDR
     is the offset between the file's specified start address and
     its true address in memory.  MAINLINE is 1 if this is the
     main symbol table being read, and 0 if a secondary
     symbol file (e.g. shared library or dynamically loaded file)
     is being read.  */

  void (*sym_read) PARAMS ((struct objfile *, CORE_ADDR, int));

  /* Called when we are finished with an objfile.  Should do all cleanup
     that is specific to the object file format for the particular objfile. */
 
  void (*sym_finish) PARAMS ((struct objfile *));

  /* Finds the next struct sym_fns.  They are allocated and initialized
     in whatever module implements the functions pointed to; an 
     initializer calls add_symtab_fns to add them to the global chain.  */

  struct sym_fns *next;

};

/* Master structure for keeping track of each input file from which
   gdb reads symbols.  One of these is allocated for each such file we
   access, e.g. the exec_file, symbol_file, and any shared library object
   files. */

struct objfile
{

  /* All struct objfile's are chained together by their next pointers.
     The global variable "object_files" points to the first link in this
     chain. */

  struct objfile *next;

  /* The object file's name.  Malloc'd; free it if you free this struct.  */

  char *name;

  /* Some flag bits for this objfile. */

  unsigned short flags;

  /* Each objfile points to a linked list of symtabs derived from this file,
     one symtab structure for each compilation unit (source file).  Each link
     in the symtab list contains a backpointer to this objfile. */

  struct symtab *symtabs;

  /* Each objfile points to a linked list of partial symtabs derived from
     this file, one partial symtab structure for each compilation unit
     (source file). */

  struct partial_symtab *psymtabs;

  /* List of freed partial symtabs, available for re-use */

  struct partial_symtab *free_psymtabs;

  /* The object file's BFD.  Can be null, in which case bfd_open (name) and
     put the result here.  */

  bfd *obfd;

  /* The modification timestamp of the object file, as of the last time
     we read its symbols.  */

  long mtime;

  /* Obstacks to hold objects that should be freed when we load a new symbol
     table from this object file. */

  struct obstack psymbol_obstack;	/* Partial symbols */
  struct obstack symbol_obstack;	/* Full symbols */
  struct obstack type_obstack;		/* Types */

  /* Vectors of all partial symbols read in from file.  The actual data
     is stored in the psymbol_obstack. */

  struct psymbol_allocation_list global_psymbols;
  struct psymbol_allocation_list static_psymbols;

  /* Each file contains a pointer to an array of minimal symbols for all
     global symbols that are defined within the file.  The array is terminated
     by a "null symbol", one that has a NULL pointer for the name and a zero
     value for the address.  This makes it easy to walk through the array
     when passed a pointer to somewhere in the middle of it.  There is also
     a count of the number of symbols, which does include the terminating
     null symbol.  The array itself, as well as all the data that it points
     to, should be allocated on the symbol_obstack for this file. */

  struct minimal_symbol *msymbols;
  int minimal_symbol_count;

  /* For object file formats which don't specify fundamental types, gdb
     can create such types.  For now, it maintains a vector of pointers
     to these internally created fundamental types on a per objfile basis,
     however it really should ultimately keep them on a per-compilation-unit
     basis, to account for linkage-units that consist of a number of
     compilation units that may have different fundamental types, such as
     linking C modules with ADA modules, or linking C modules that are
     compiled with 32-bit ints with C modules that are compiled with 64-bit
     ints (not inherently evil with a smarter linker). */

  struct type **fundamental_types;

  /* The mmalloc() malloc-descriptor for this objfile if we are using
     the memory mapped malloc() package to manage storage for this objfile's
     data.  NULL if we are not. */

  PTR md;

  /* Structure which keeps track of functions that manipulate objfile's
     of the same type as this objfile.  I.E. the function to read partial
     symbols for example.  Note that this structure is in statically
     allocated memory, and is shared by all objfiles that use the
     object module reader of this type. */

  struct sym_fns *sf;

  /* Hook for information which is shared by sym_init and sym_read for
     this objfile.  It is typically a pointer to malloc'd memory.  */

  PTR sym_private;

};

/* Defines for the objfile flag word. */

/* Gdb can arrange to allocate storage for all objects related to a
   particular objfile in a designated section of it's address space,
   managed at a low level by mmap() and using a special version of
   malloc that handles malloc/free/realloc on top of the mmap() interface.
   This allows the "internal gdb state" for a particular objfile to be
   dumped to a gdb state file and subsequently reloaded at a later time. */

#define OBJF_MAPPED	(1 << 0)	/* Objfile data is mmap'd */


extern void
extend_psymbol_list PARAMS ((struct psymbol_allocation_list *,
			     struct objfile *));

/* Add any kind of symbol to a psymbol_allocation_list. */

#define	ADD_PSYMBOL_VT_TO_LIST(NAME,NAMELENGTH,NAMESPACE,CLASS,LIST,VALUE,VT) \
  do {		        						\
    register struct partial_symbol *psym;				\
    if ((LIST).next >= (LIST).list + (LIST).size)			\
	   extend_psymbol_list (&(LIST),objfile);				\
    psym = (LIST).next++;						\
									\
    SYMBOL_NAME (psym) = (char *) obstack_alloc (&objfile->psymbol_obstack,	\
						 (NAMELENGTH) + 1);	\
    memcpy (SYMBOL_NAME (psym), (NAME), (NAMELENGTH));			\
    SYMBOL_NAME (psym)[(NAMELENGTH)] = '\0';				\
    SYMBOL_NAMESPACE (psym) = (NAMESPACE);				\
    SYMBOL_CLASS (psym) = (CLASS);					\
    VT (psym) = (VALUE); 						\
  } while (0);

#ifdef DEBUG

/* Since one arg is a struct, we have to pass in a ptr and deref it (sigh) */

#define	ADD_PSYMBOL_TO_LIST(name, namelength, namespace, class, list, value) \
  add_psymbol_to_list (name, namelength, namespace, class, &list, value)

#define	ADD_PSYMBOL_ADDR_TO_LIST(name, namelength, namespace, class, list, value) \
  add_psymbol_addr_to_list (name, namelength, namespace, class, &list, value)

#else	/* !DEBUG */

/* Add a symbol with an integer value to a psymtab. */

#define ADD_PSYMBOL_TO_LIST(name, namelength, namespace, class, list, value) \
  ADD_PSYMBOL_VT_TO_LIST (name, namelength, namespace, class, list, value, SYMBOL_VALUE)

/* Add a symbol with a CORE_ADDR value to a psymtab. */

#define	ADD_PSYMBOL_ADDR_TO_LIST(name, namelength, namespace, class, list, value)\
  ADD_PSYMBOL_VT_TO_LIST (name, namelength, namespace, class, list, value, SYMBOL_VALUE_ADDRESS)

#endif	/* DEBUG */

			/*   Functions   */

extern void
sort_pst_symbols PARAMS ((struct partial_symtab *));

extern struct symtab *
allocate_symtab PARAMS ((char *, struct objfile *));

extern struct objfile *
allocate_objfile PARAMS ((bfd *, int));

extern void
free_objfile PARAMS ((struct objfile *));

extern void
free_all_objfiles PARAMS ((void));

extern int
free_named_symtabs PARAMS ((char *));

extern void
fill_in_vptr_fieldno PARAMS ((struct type *));

extern void
add_symtab_fns PARAMS ((struct sym_fns *));

extern void
syms_from_objfile PARAMS ((struct objfile *, CORE_ADDR, int, int));

extern struct partial_symtab *
start_psymtab_common PARAMS ((struct objfile *, CORE_ADDR, char *, CORE_ADDR,
			      struct partial_symbol *,
			      struct partial_symbol *));

/* Sorting your symbols for fast lookup or alphabetical printing.  */

extern void
sort_block_syms PARAMS ((struct block *));

extern void
sort_symtab_syms PARAMS ((struct symtab *));

extern void
sort_all_symtab_syms PARAMS ((void));

/* Make a copy of the string at PTR with SIZE characters in the symbol obstack
   (and add a null character at the end in the copy).
   Returns the address of the copy.  */

extern char *
obsavestring PARAMS ((char *, int, struct obstack *));

/* Concatenate strings S1, S2 and S3; return the new string.
   Space is found in the symbol_obstack.  */

extern char *
obconcat PARAMS ((struct obstack *obstackp, const char *, const char *,
		  const char *));

			/*   Variables   */

/* The object file that the main symbol table was loaded from (e.g. the
   argument to the "symbol-file" or "file" command).  */

extern struct objfile *symfile_objfile;

/* Where execution starts in symfile */

extern CORE_ADDR entry_point;

/* Root of object file struct chain.  */

extern struct objfile *object_files;

/* Traverse all object files.  ALL_OBJFILES_SAFE works even if you delete
   the objfile during the traversal.  */

#define	ALL_OBJFILES(obj) \
   for (obj = object_files; 0 != obj; obj = obj->next)

#define	ALL_OBJFILES_SAFE(obj,nxt) \
   for (obj = object_files; obj? (nxt=obj->next, 1): 0; obj = nxt)

/* Support for complaining about things in the symbol file that aren't
   catastrophic.

   Each such thing gets a counter.  The first time we have the problem,
   during a symbol read, we report it.  At the end of symbol reading,
   if verbose, we report how many of each problem we had.  */

struct complaint {
  char *message;
  unsigned counter;
  struct complaint *next;
};

/* Root of the chain of complaints that have at some point been issued. 
   This is used to reset the counters, and/or report the total counts.  */

extern struct complaint complaint_root[1];

/* Functions that handle complaints.  (in symfile.c)  */

extern void
complain PARAMS ((struct complaint *, char *));

extern void
clear_complaints PARAMS ((int sym_reading, int noisy));

/* From symfile.c */

extern struct partial_symtab *
allocate_psymtab PARAMS ((char *, struct objfile *));

/* From minsyms.c */

extern PTR
iterate_over_msymbols PARAMS ((PTR (*func) (struct objfile *,
					    struct minimal_symbol *,
					    PTR arg1, PTR arg2, PTR arg3),
			       PTR arg1, PTR arg2, PTR arg3));

/* From objfiles.c */

extern PTR
iterate_over_objfiles PARAMS ((PTR (*func) (struct objfile *,
					    PTR arg1, PTR arg2, PTR arg3),
			       PTR arg1, PTR arg2, PTR arg3));

extern PTR
iterate_over_symtabs PARAMS ((PTR (*func) (struct objfile *, struct symtab *,
					   PTR arg1, PTR arg2, PTR arg3),
			      PTR arg1, PTR arg2, PTR arg3));

extern PTR 
iterate_over_psymtabs PARAMS ((PTR (*func) (struct objfile *,
					    struct partial_symtab *,
					    PTR arg1, PTR arg2, PTR arg3),
			       PTR arg1, PTR arg2, PTR arg3));

/* From dwarfread.c */

extern void
dwarf_build_psymtabs PARAMS ((int, char *, CORE_ADDR, int, unsigned int,
			      unsigned int, unsigned int, unsigned int,
			      struct objfile *));

#endif	/* !defined(SYMFILE_H) */