Subversion Repositories or1k

/* Build symbol tables in GDB's internal format.

   Copyright 1986-1993, 1996-1999 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., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

#if !defined (BUILDSYM_H)

#define BUILDSYM_H 1

/* This module provides definitions used for creating and adding to

   the symbol table.  These routines are called from various symbol-

   file-reading routines.

   They originated in dbxread.c of gdb-4.2, and were split out to

   make xcoffread.c more maintainable by sharing code.

   Variables declared in this file can be defined by #define-ing the

   name EXTERN to null.  It is used to declare variables that are

   normally extern, but which get defined in a single module using

   this technique.  */

#ifndef EXTERN

#define EXTERN extern

#endif

#define HASHSIZE 127            /* Size of things hashed via

                                   hashname() */

/* Name of source file whose symbol data we are now processing.  This

   comes from a symbol of type N_SO. */

EXTERN char *last_source_file;

/* Core address of start of text of current source file.  This too

   comes from the N_SO symbol. */

EXTERN CORE_ADDR last_source_start_addr;

/* The list of sub-source-files within the current individual

   compilation.  Each file gets its own symtab with its own linetable

   and associated info, but they all share one blockvector.  */

struct subfile

  {

    struct subfile *next;

    char *name;

    char *dirname;

    struct linetable *line_vector;

    int line_vector_length;

    enum language language;

    char *debugformat;

  };

EXTERN struct subfile *subfiles;

EXTERN struct subfile *current_subfile;

/* Global variable which, when set, indicates that we are processing a

   .o file compiled with gcc */

EXTERN unsigned char processing_gcc_compilation;

/* When set, we are processing a .o file compiled by sun acc.  This is

   misnamed; it refers to all stabs-in-elf implementations which use

   N_UNDF the way Sun does, including Solaris gcc.  Hopefully all

   stabs-in-elf implementations ever invented will choose to be

   compatible.  */

EXTERN unsigned char processing_acc_compilation;

/* elz: added this flag to know when a block is compiled with HP

   compilers (cc, aCC). This is necessary because of the macro

   COERCE_FLOAT_TO_DOUBLE defined in tm_hppa.h, which causes a

   coercion of float to double to always occur in parameter passing

   for a function called by gdb (see the function value_arg_coerce in

   valops.c). This is necessary only if the target was compiled with

   gcc, not with HP compilers or with g++ */

EXTERN unsigned char processing_hp_compilation;

/* Count symbols as they are processed, for error messages.  */

EXTERN unsigned int symnum;

/* Record the symbols defined for each context in a list.  We don't

   create a struct block for the context until we know how long to

   make it.  */

#define PENDINGSIZE 100

struct pending

  {

    struct pending *next;

    int nsyms;

    struct symbol *symbol[PENDINGSIZE];

  };

/* Here are the three lists that symbols are put on.  */

/* static at top level, and types */

EXTERN struct pending *file_symbols;

/* global functions and variables */

EXTERN struct pending *global_symbols;

/* everything local to lexical context */

EXTERN struct pending *local_symbols;

/* func params local to lexical  context */

EXTERN struct pending *param_symbols;

/* Stack representing unclosed lexical contexts (that will become

   blocks, eventually).  */

struct context_stack

  {

    /* Outer locals at the time we entered */

    struct pending *locals;

    /* Pending func params at the time we entered */

    struct pending *params;

    /* Pointer into blocklist as of entry */

    struct pending_block *old_blocks;

    /* Name of function, if any, defining context */

    struct symbol *name;

    /* PC where this context starts */

    CORE_ADDR start_addr;

    /* Temp slot for exception handling. */

    CORE_ADDR end_addr;

    /* For error-checking matching push/pop */

    int depth;

  };

EXTERN struct context_stack *context_stack;

/* Index of first unused entry in context stack.  */

EXTERN int context_stack_depth;

/* Currently allocated size of context stack.  */

EXTERN int context_stack_size;

/* Macro "function" for popping contexts from the stack.  Pushing is

   done by a real function, push_context.  This returns a pointer to a

   struct context_stack.  */

#define pop_context() (&context_stack[--context_stack_depth]);

/* Nonzero if within a function (so symbols should be local, if

   nothing says specifically).  */

EXTERN int within_function;

/* List of blocks already made (lexical contexts already closed).

   This is used at the end to make the blockvector.  */

struct pending_block

  {

    struct pending_block *next;

    struct block *block;

  };

/* Pointer to the head of a linked list of symbol blocks which have

   already been finalized (lexical contexts already closed) and which

   are just waiting to be built into a blockvector when finalizing the

   associated symtab. */

EXTERN struct pending_block *pending_blocks;

struct subfile_stack

  {

    struct subfile_stack *next;

    char *name;

  };

EXTERN struct subfile_stack *subfile_stack;

#define next_symbol_text(objfile) (*next_symbol_text_func)(objfile)

/* Function to invoke get the next symbol.  Return the symbol name. */

EXTERN char *(*next_symbol_text_func) (struct objfile *);

/* Vector of types defined so far, indexed by their type numbers.

   Used for both stabs and coff.  (In newer sun systems, dbx uses a

   pair of numbers in parens, as in "(SUBFILENUM,NUMWITHINSUBFILE)".

   Then these numbers must be translated through the type_translations

   hash table to get the index into the type vector.)  */

EXTERN struct type **type_vector;

/* Number of elements allocated for type_vector currently.  */

EXTERN int type_vector_length;

/* Initial size of type vector.  Is realloc'd larger if needed, and

   realloc'd down to the size actually used, when completed.  */

#define INITIAL_TYPE_VECTOR_LENGTH      160

extern void add_free_pendings (struct pending *list);

extern void add_symbol_to_list (struct symbol *symbol,

                                struct pending **listhead);

extern struct symbol *find_symbol_in_list (struct pending *list,

                                           char *name, int length);

extern void finish_block (struct symbol *symbol,

                          struct pending **listhead,

                          struct pending_block *old_blocks,

                          CORE_ADDR start, CORE_ADDR end,

                          struct objfile *objfile);

extern void really_free_pendings (PTR dummy);

extern void start_subfile (char *name, char *dirname);

extern void patch_subfile_names (struct subfile *subfile, char *name);

extern void push_subfile (void);

extern char *pop_subfile (void);

extern struct symtab *end_symtab (CORE_ADDR end_addr,

                                  struct objfile *objfile, int section);

/* Defined in stabsread.c.  */

extern void scan_file_globals (struct objfile *objfile);

extern void buildsym_new_init (void);

extern void buildsym_init (void);

extern struct context_stack *push_context (int desc, CORE_ADDR valu);

extern void record_line (struct subfile *subfile, int line, CORE_ADDR pc);

extern void start_symtab (char *name, char *dirname, CORE_ADDR start_addr);

extern int hashname (char *name);

extern void free_pending_blocks (void);

/* FIXME: Note that this is used only in buildsym.c and dstread.c,

   which should be fixed to not need direct access to

   make_blockvector. */

extern struct blockvector *make_blockvector (struct objfile *objfile);

/* FIXME: Note that this is used only in buildsym.c and dstread.c,

   which should be fixed to not need direct access to

   record_pending_block. */

extern void record_pending_block (struct objfile *objfile,

                                  struct block *block,

                                  struct pending_block *opblock);

extern void record_debugformat (char *format);

extern void merge_symbol_lists (struct pending **srclist,

                                struct pending **targetlist);

#undef EXTERN

#endif /* defined (BUILDSYM_H) */