702 lines
26 KiB
C
702 lines
26 KiB
C
|
/* debug.h -- Describe generic debugging information.
|
||
|
|
Copyright (C) 1995 Free Software Foundation, Inc.
|
||
|
|
Written by Ian Lance Taylor <ian@cygnus.com>.
|
||
|
|
|
||
|
|
This file is part of GNU Binutils.
|
||
|
|
|
||
|
|
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. */
|
||
|
|
|
||
|
|
#ifndef DEBUG_H
|
||
|
|
#define DEBUG_H
|
||
|
|
|
||
|
|
/* This header file describes a generic debugging information format.
|
||
|
|
We may eventually have readers which convert different formats into
|
||
|
|
this generic format, and writers which write it out. The initial
|
||
|
|
impetus for this was writing a convertor from stabs to HP IEEE-695
|
||
|
|
debugging format. */
|
||
|
|
|
||
|
|
/* Different kinds of types. */
|
||
|
|
|
||
|
|
enum debug_type_kind
|
||
|
|
{
|
||
|
|
/* Indirect via a pointer. */
|
||
|
|
DEBUG_KIND_INDIRECT,
|
||
|
|
/* Void. */
|
||
|
|
DEBUG_KIND_VOID,
|
||
|
|
/* Integer. */
|
||
|
|
DEBUG_KIND_INT,
|
||
|
|
/* Floating point. */
|
||
|
|
DEBUG_KIND_FLOAT,
|
||
|
|
/* Complex. */
|
||
|
|
DEBUG_KIND_COMPLEX,
|
||
|
|
/* Boolean. */
|
||
|
|
DEBUG_KIND_BOOL,
|
||
|
|
/* Struct. */
|
||
|
|
DEBUG_KIND_STRUCT,
|
||
|
|
/* Union. */
|
||
|
|
DEBUG_KIND_UNION,
|
||
|
|
/* Class. */
|
||
|
|
DEBUG_KIND_CLASS,
|
||
|
|
/* Union class (can this really happen?). */
|
||
|
|
DEBUG_KIND_UNION_CLASS,
|
||
|
|
/* Enumeration type. */
|
||
|
|
DEBUG_KIND_ENUM,
|
||
|
|
/* Pointer. */
|
||
|
|
DEBUG_KIND_POINTER,
|
||
|
|
/* Function. */
|
||
|
|
DEBUG_KIND_FUNCTION,
|
||
|
|
/* Reference. */
|
||
|
|
DEBUG_KIND_REFERENCE,
|
||
|
|
/* Range. */
|
||
|
|
DEBUG_KIND_RANGE,
|
||
|
|
/* Array. */
|
||
|
|
DEBUG_KIND_ARRAY,
|
||
|
|
/* Set. */
|
||
|
|
DEBUG_KIND_SET,
|
||
|
|
/* Based pointer. */
|
||
|
|
DEBUG_KIND_OFFSET,
|
||
|
|
/* Method. */
|
||
|
|
DEBUG_KIND_METHOD,
|
||
|
|
/* Const qualified type. */
|
||
|
|
DEBUG_KIND_CONST,
|
||
|
|
/* Volatile qualified type. */
|
||
|
|
DEBUG_KIND_VOLATILE,
|
||
|
|
/* Named type. */
|
||
|
|
DEBUG_KIND_NAMED,
|
||
|
|
/* Tagged type. */
|
||
|
|
DEBUG_KIND_TAGGED
|
||
|
|
};
|
||
|
|
|
||
|
|
/* Different kinds of variables. */
|
||
|
|
|
||
|
|
enum debug_var_kind
|
||
|
|
{
|
||
|
|
/* A global variable. */
|
||
|
|
DEBUG_GLOBAL,
|
||
|
|
/* A static variable. */
|
||
|
|
DEBUG_STATIC,
|
||
|
|
/* A local static variable. */
|
||
|
|
DEBUG_LOCAL_STATIC,
|
||
|
|
/* A local variable. */
|
||
|
|
DEBUG_LOCAL,
|
||
|
|
/* A register variable. */
|
||
|
|
DEBUG_REGISTER
|
||
|
|
};
|
||
|
|
|
||
|
|
/* Different kinds of function parameters. */
|
||
|
|
|
||
|
|
enum debug_parm_kind
|
||
|
|
{
|
||
|
|
/* A stack based parameter. */
|
||
|
|
DEBUG_PARM_STACK,
|
||
|
|
/* A register parameter. */
|
||
|
|
DEBUG_PARM_REG,
|
||
|
|
/* A stack based reference parameter. */
|
||
|
|
DEBUG_PARM_REFERENCE,
|
||
|
|
/* A register reference parameter. */
|
||
|
|
DEBUG_PARM_REF_REG
|
||
|
|
};
|
||
|
|
|
||
|
|
/* Different kinds of visibility. */
|
||
|
|
|
||
|
|
enum debug_visibility
|
||
|
|
{
|
||
|
|
/* A public field (e.g., a field in a C struct). */
|
||
|
|
DEBUG_VISIBILITY_PUBLIC,
|
||
|
|
/* A protected field. */
|
||
|
|
DEBUG_VISIBILITY_PROTECTED,
|
||
|
|
/* A private field. */
|
||
|
|
DEBUG_VISIBILITY_PRIVATE,
|
||
|
|
/* A field which should be ignored. */
|
||
|
|
DEBUG_VISIBILITY_IGNORE
|
||
|
|
};
|
||
|
|
|
||
|
|
/* A type. */
|
||
|
|
|
||
|
|
typedef struct debug_type *debug_type;
|
||
|
|
|
||
|
|
#define DEBUG_TYPE_NULL ((debug_type) NULL)
|
||
|
|
|
||
|
|
/* A field in a struct or union. */
|
||
|
|
|
||
|
|
typedef struct debug_field *debug_field;
|
||
|
|
|
||
|
|
#define DEBUG_FIELD_NULL ((debug_field) NULL)
|
||
|
|
|
||
|
|
/* A base class for an object. */
|
||
|
|
|
||
|
|
typedef struct debug_baseclass *debug_baseclass;
|
||
|
|
|
||
|
|
#define DEBUG_BASECLASS_NULL ((debug_baseclass) NULL)
|
||
|
|
|
||
|
|
/* A method of an object. */
|
||
|
|
|
||
|
|
typedef struct debug_method *debug_method;
|
||
|
|
|
||
|
|
#define DEBUG_METHOD_NULL ((debug_method) NULL)
|
||
|
|
|
||
|
|
/* The arguments to a method function of an object. These indicate
|
||
|
|
which method to run. */
|
||
|
|
|
||
|
|
typedef struct debug_method_variant *debug_method_variant;
|
||
|
|
|
||
|
|
#define DEBUG_METHOD_VARIANT_NULL ((debug_method_variant) NULL)
|
||
|
|
|
||
|
|
/* This structure is passed to debug_write. It holds function
|
||
|
|
pointers that debug_write will call based on the accumulated
|
||
|
|
debugging information. */
|
||
|
|
|
||
|
|
struct debug_write_fns
|
||
|
|
{
|
||
|
|
/* This is called at the start of each new compilation unit with the
|
||
|
|
name of the main file in the new unit. */
|
||
|
|
boolean (*start_compilation_unit) PARAMS ((PTR, const char *));
|
||
|
|
|
||
|
|
/* This is called at the start of each source file within a
|
||
|
|
compilation unit, before outputting any global information for
|
||
|
|
that file. The argument is the name of the file. */
|
||
|
|
boolean (*start_source) PARAMS ((PTR, const char *));
|
||
|
|
|
||
|
|
/* Each writer must keep a stack of types. */
|
||
|
|
|
||
|
|
/* Push an empty type onto the type stack. This type can appear if
|
||
|
|
there is a reference to a type which is never defined. */
|
||
|
|
boolean (*empty_type) PARAMS ((PTR));
|
||
|
|
|
||
|
|
/* Push a void type onto the type stack. */
|
||
|
|
boolean (*void_type) PARAMS ((PTR));
|
||
|
|
|
||
|
|
/* Push an integer type onto the type stack, given the size and
|
||
|
|
whether it is unsigned. */
|
||
|
|
boolean (*int_type) PARAMS ((PTR, unsigned int, boolean));
|
||
|
|
|
||
|
|
/* Push a floating type onto the type stack, given the size. */
|
||
|
|
boolean (*float_type) PARAMS ((PTR, unsigned int));
|
||
|
|
|
||
|
|
/* Push a complex type onto the type stack, given the size. */
|
||
|
|
boolean (*complex_type) PARAMS ((PTR, unsigned int));
|
||
|
|
|
||
|
|
/* Push a boolean type onto the type stack, given the size. */
|
||
|
|
boolean (*bool_type) PARAMS ((PTR, unsigned int));
|
||
|
|
|
||
|
|
/* Push an enum type onto the type stack, given a NULL terminated
|
||
|
|
array of names and the associated values. */
|
||
|
|
boolean (*enum_type) PARAMS ((PTR, const char **, bfd_signed_vma *));
|
||
|
|
|
||
|
|
/* Pop the top type on the type stack, and push a pointer to that
|
||
|
|
type onto the type stack. */
|
||
|
|
boolean (*pointer_type) PARAMS ((PTR));
|
||
|
|
|
||
|
|
/* Pop the top type on the type stack, and push a function returning
|
||
|
|
that type onto the type stack. */
|
||
|
|
boolean (*function_type) PARAMS ((PTR));
|
||
|
|
|
||
|
|
/* Pop the top type on the type stack, and push a reference to that
|
||
|
|
type onto the type stack. */
|
||
|
|
boolean (*reference_type) PARAMS ((PTR));
|
||
|
|
|
||
|
|
/* Pop the top type on the type stack, and push a range of that type
|
||
|
|
with the given lower and upper bounds onto the type stack. */
|
||
|
|
boolean (*range_type) PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
|
||
|
|
|
||
|
|
/* Push an array type onto the type stack. The top type on the type
|
||
|
|
stack is the range, and the next type on the type stack is the
|
||
|
|
element type. These should be popped before the array type is
|
||
|
|
pushed. The arguments are the lower bound, the upper bound, and
|
||
|
|
whether the array is a string. */
|
||
|
|
boolean (*array_type) PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma,
|
||
|
|
boolean));
|
||
|
|
|
||
|
|
/* Pop the top type on the type stack, and push a set of that type
|
||
|
|
onto the type stack. The argument indicates whether this set is
|
||
|
|
a bitstring. */
|
||
|
|
boolean (*set_type) PARAMS ((PTR, boolean));
|
||
|
|
|
||
|
|
/* Push an offset type onto the type stack. The top type on the
|
||
|
|
type stack is the target type, and the next type on the type
|
||
|
|
stack is the base type. These should be popped before the offset
|
||
|
|
type is pushed. */
|
||
|
|
boolean (*offset_type) PARAMS ((PTR));
|
||
|
|
|
||
|
|
/* Push a method type onto the type stack. If the second argument
|
||
|
|
is true, the top type on the stack is the class to which the
|
||
|
|
method belongs; otherwise, the class must be determined by the
|
||
|
|
class to which the method is attached. The third argument is the
|
||
|
|
number of argument types; these are pushed onto the type stack in
|
||
|
|
reverse order (the first type popped is the last argument to the
|
||
|
|
method). An argument type of -1 means that no argument in
|
||
|
|
formation is available. The next type on the type stack below
|
||
|
|
the domain and the argument types is the return type of the
|
||
|
|
method. All these types must be poppsed, and then the method
|
||
|
|
type must be pushed. */
|
||
|
|
boolean (*method_type) PARAMS ((PTR, boolean, int));
|
||
|
|
|
||
|
|
/* Pop the top type off the type stack, and push a const qualified
|
||
|
|
version of that type onto the type stack. */
|
||
|
|
boolean (*const_type) PARAMS ((PTR));
|
||
|
|
|
||
|
|
/* Pop the top type off the type stack, and push a volatile
|
||
|
|
qualified version of that type onto the type stack. */
|
||
|
|
boolean (*volatile_type) PARAMS ((PTR));
|
||
|
|
|
||
|
|
/* Start building a struct. This is followed by calls to the
|
||
|
|
struct_field function, and finished by a call to the
|
||
|
|
end_struct_type function. The boolean argument is true for a
|
||
|
|
struct, false for a union. The unsigned int argument is the
|
||
|
|
size. */
|
||
|
|
boolean (*start_struct_type) PARAMS ((PTR, boolean, unsigned int));
|
||
|
|
|
||
|
|
/* Add a field to the struct type currently being built. The type
|
||
|
|
of the field should be popped off the type stack. The arguments
|
||
|
|
are the name, the bit position, the bit size (may be zero if the
|
||
|
|
field is not packed), and the visibility. */
|
||
|
|
boolean (*struct_field) PARAMS ((PTR, const char *, bfd_vma, bfd_vma,
|
||
|
|
enum debug_visibility));
|
||
|
|
|
||
|
|
/* Finish building a struct, and push it onto the type stack. */
|
||
|
|
boolean (*end_struct_type) PARAMS ((PTR));
|
||
|
|
|
||
|
|
/* Start building a class. This is followed by calls to several
|
||
|
|
functions: struct_field, class_static_member, class_baseclass,
|
||
|
|
class_start_method, class_method_variant,
|
||
|
|
class_static_method_variant, and class_end_method. The class is
|
||
|
|
finished by a call to end_class_type. The boolean argument is
|
||
|
|
true for a struct, false for a union. The next argument is the
|
||
|
|
size. The next argument is true if there is a virtual function
|
||
|
|
table; if there is, the next argument is true if the virtual
|
||
|
|
function table can be found in the type itself, and is false if
|
||
|
|
the type of the object holding the virtual function table should
|
||
|
|
be popped from the type stack. */
|
||
|
|
boolean (*start_class_type) PARAMS ((PTR, boolean, unsigned int,
|
||
|
|
boolean, boolean));
|
||
|
|
|
||
|
|
/* Add a static member to the class currently being built. The
|
||
|
|
arguments are the field name, the physical name, and the
|
||
|
|
visibility. */
|
||
|
|
boolean (*class_static_member) PARAMS ((PTR, const char *, const char *,
|
||
|
|
enum debug_visibility));
|
||
|
|
|
||
|
|
/* Add a baseclass to the class currently being built. The type of
|
||
|
|
the baseclass must be popped off the type stack. The arguments
|
||
|
|
are the bit position, whether the class is virtual, and the
|
||
|
|
visibility. */
|
||
|
|
boolean (*class_baseclass) PARAMS ((PTR, bfd_vma, boolean,
|
||
|
|
enum debug_visibility));
|
||
|
|
|
||
|
|
/* Start adding a method to the class currently being built. This
|
||
|
|
is followed by calls to class_method_variant and
|
||
|
|
class_static_method_variant to describe different variants of the
|
||
|
|
method which take different arguments. The method is finished
|
||
|
|
with a call to class_end_method. The argument is the method
|
||
|
|
name. */
|
||
|
|
boolean (*class_start_method) PARAMS ((PTR, const char *));
|
||
|
|
|
||
|
|
/* Describe a variant to the class method currently being built.
|
||
|
|
The type of the variant must be popped off the type stack. The
|
||
|
|
second argument is a string which is either the physical name of
|
||
|
|
the function or describes the argument types; see the comment for
|
||
|
|
debug_make_method variant. The following arguments are the
|
||
|
|
visibility, whether the variant is const, whether the variant is
|
||
|
|
volatile, the offset in the virtual function table, and whether
|
||
|
|
the context is on the type stack (below the variant type). */
|
||
|
|
boolean (*class_method_variant) PARAMS ((PTR, const char *,
|
||
|
|
enum debug_visibility,
|
||
|
|
boolean, boolean,
|
||
|
|
bfd_vma, boolean));
|
||
|
|
|
||
|
|
/* Describe a static variant to the class method currently being
|
||
|
|
built. The arguments are the same as for class_method_variant,
|
||
|
|
except that the last two arguments are omitted. */
|
||
|
|
boolean (*class_static_method_variant) PARAMS ((PTR, const char *,
|
||
|
|
enum debug_visibility,
|
||
|
|
boolean, boolean));
|
||
|
|
|
||
|
|
/* Finish describing a class method. */
|
||
|
|
boolean (*class_end_method) PARAMS ((PTR));
|
||
|
|
|
||
|
|
/* Finish describing a class, and push it onto the type stack. */
|
||
|
|
boolean (*end_class_type) PARAMS ((PTR));
|
||
|
|
|
||
|
|
/* Push a type on the stack which was given a name by an earlier
|
||
|
|
call to typdef. */
|
||
|
|
boolean (*typedef_type) PARAMS ((PTR, const char *));
|
||
|
|
|
||
|
|
/* Push a type on the stack which was given a name by an earlier
|
||
|
|
call to tag. */
|
||
|
|
boolean (*tag_type) PARAMS ((PTR, const char *, enum debug_type_kind));
|
||
|
|
|
||
|
|
/* Pop the type stack, and typedef it to the given name. */
|
||
|
|
boolean (*typdef) PARAMS ((PTR, const char *));
|
||
|
|
|
||
|
|
/* Pop the type stack, and declare it as a tagged struct or union or
|
||
|
|
enum or whatever. */
|
||
|
|
boolean (*tag) PARAMS ((PTR, const char *));
|
||
|
|
|
||
|
|
/* This is called to record a named integer constant. */
|
||
|
|
boolean (*int_constant) PARAMS ((PTR, const char *, bfd_vma));
|
||
|
|
|
||
|
|
/* This is called to record a named floating point constant. */
|
||
|
|
boolean (*float_constant) PARAMS ((PTR, const char *, double));
|
||
|
|
|
||
|
|
/* This is called to record a typed integer constant. The type is
|
||
|
|
popped off the type stack. */
|
||
|
|
boolean (*typed_constant) PARAMS ((PTR, const char *, bfd_vma));
|
||
|
|
|
||
|
|
/* This is called to record a variable. The type is popped off the
|
||
|
|
type stack. */
|
||
|
|
boolean (*variable) PARAMS ((PTR, const char *, enum debug_var_kind,
|
||
|
|
bfd_vma));
|
||
|
|
|
||
|
|
/* Start writing out a function. The return type must be popped off
|
||
|
|
the stack. The boolean is true if the function is global. This
|
||
|
|
is followed by calls to function_parameter, followed by block
|
||
|
|
information. */
|
||
|
|
boolean (*start_function) PARAMS ((PTR, const char *, boolean));
|
||
|
|
|
||
|
|
/* Record a function parameter for the current function. The type
|
||
|
|
must be popped off the stack. */
|
||
|
|
boolean (*function_parameter) PARAMS ((PTR, const char *,
|
||
|
|
enum debug_parm_kind, bfd_vma));
|
||
|
|
|
||
|
|
/* Start writing out a block. There is at least one top level block
|
||
|
|
per function. Blocks may be nested. The argument is the
|
||
|
|
starting address of the block. */
|
||
|
|
boolean (*start_block) PARAMS ((PTR, bfd_vma));
|
||
|
|
|
||
|
|
/* Record line number information for the current block. */
|
||
|
|
boolean (*lineno) PARAMS ((PTR, const char *, unsigned long, bfd_vma));
|
||
|
|
|
||
|
|
/* Finish writing out a block. The argument is the ending address
|
||
|
|
of the block. */
|
||
|
|
boolean (*end_block) PARAMS ((PTR, bfd_vma));
|
||
|
|
|
||
|
|
/* Finish writing out a function. */
|
||
|
|
boolean (*end_function) PARAMS ((PTR));
|
||
|
|
};
|
||
|
|
|
||
|
|
/* Exported functions. */
|
||
|
|
|
||
|
|
/* The first argument to most of these functions is a handle. This
|
||
|
|
handle is returned by the debug_init function. The purpose of the
|
||
|
|
handle is to permit the debugging routines to not use static
|
||
|
|
variables, and hence to be reentrant. This would be useful for a
|
||
|
|
program which wanted to handle two executables simultaneously. */
|
||
|
|
|
||
|
|
/* Return a debugging handle. */
|
||
|
|
|
||
|
|
extern PTR debug_init PARAMS ((void));
|
||
|
|
|
||
|
|
/* Set the source filename. This implicitly starts a new compilation
|
||
|
|
unit. */
|
||
|
|
|
||
|
|
extern boolean debug_set_filename PARAMS ((PTR, const char *));
|
||
|
|
|
||
|
|
/* Append a string to the source filename. */
|
||
|
|
|
||
|
|
extern boolean debug_append_filename PARAMS ((PTR, const char *));
|
||
|
|
|
||
|
|
/* Change source files to the given file name. This is used for
|
||
|
|
include files in a single compilation unit. */
|
||
|
|
|
||
|
|
extern boolean debug_start_source PARAMS ((PTR, const char *));
|
||
|
|
|
||
|
|
/* Record a function definition. This implicitly starts a function
|
||
|
|
block. The debug_type argument is the type of the return value.
|
||
|
|
The boolean indicates whether the function is globally visible.
|
||
|
|
The bfd_vma is the address of the start of the function. Currently
|
||
|
|
the parameter types are specified by calls to
|
||
|
|
debug_record_parameter. */
|
||
|
|
|
||
|
|
extern boolean debug_record_function
|
||
|
|
PARAMS ((PTR, const char *, debug_type, boolean, bfd_vma));
|
||
|
|
|
||
|
|
/* Record a parameter for the current function. */
|
||
|
|
|
||
|
|
extern boolean debug_record_parameter
|
||
|
|
PARAMS ((PTR, const char *, debug_type, enum debug_parm_kind, bfd_vma));
|
||
|
|
|
||
|
|
/* End a function definition. The argument is the address where the
|
||
|
|
function ends. */
|
||
|
|
|
||
|
|
extern boolean debug_end_function PARAMS ((PTR, bfd_vma));
|
||
|
|
|
||
|
|
/* Start a block in a function. All local information will be
|
||
|
|
recorded in this block, until the matching call to debug_end_block.
|
||
|
|
debug_start_block and debug_end_block may be nested. The argument
|
||
|
|
is the address at which this block starts. */
|
||
|
|
|
||
|
|
extern boolean debug_start_block PARAMS ((PTR, bfd_vma));
|
||
|
|
|
||
|
|
/* Finish a block in a function. This matches the call to
|
||
|
|
debug_start_block. The argument is the address at which this block
|
||
|
|
ends. */
|
||
|
|
|
||
|
|
extern boolean debug_end_block PARAMS ((PTR, bfd_vma));
|
||
|
|
|
||
|
|
/* Associate a line number in the current source file and function
|
||
|
|
with a given address. */
|
||
|
|
|
||
|
|
extern boolean debug_record_line PARAMS ((PTR, unsigned long, bfd_vma));
|
||
|
|
|
||
|
|
/* Start a named common block. This is a block of variables that may
|
||
|
|
move in memory. */
|
||
|
|
|
||
|
|
extern boolean debug_start_common_block PARAMS ((PTR, const char *));
|
||
|
|
|
||
|
|
/* End a named common block. */
|
||
|
|
|
||
|
|
extern boolean debug_end_common_block PARAMS ((PTR, const char *));
|
||
|
|
|
||
|
|
/* Record a named integer constant. */
|
||
|
|
|
||
|
|
extern boolean debug_record_int_const PARAMS ((PTR, const char *, bfd_vma));
|
||
|
|
|
||
|
|
/* Record a named floating point constant. */
|
||
|
|
|
||
|
|
extern boolean debug_record_float_const PARAMS ((PTR, const char *, double));
|
||
|
|
|
||
|
|
/* Record a typed constant with an integral value. */
|
||
|
|
|
||
|
|
extern boolean debug_record_typed_const
|
||
|
|
PARAMS ((PTR, const char *, debug_type, bfd_vma));
|
||
|
|
|
||
|
|
/* Record a label. */
|
||
|
|
|
||
|
|
extern boolean debug_record_label
|
||
|
|
PARAMS ((PTR, const char *, debug_type, bfd_vma));
|
||
|
|
|
||
|
|
/* Record a variable. */
|
||
|
|
|
||
|
|
extern boolean debug_record_variable
|
||
|
|
PARAMS ((PTR, const char *, debug_type, enum debug_var_kind, bfd_vma));
|
||
|
|
|
||
|
|
/* Make an indirect type. The first argument is a pointer to the
|
||
|
|
location where the real type will be placed. The second argument
|
||
|
|
is the type tag, if there is one; this may be NULL; the only
|
||
|
|
purpose of this argument is so that debug_get_type_name can return
|
||
|
|
something useful. This function may be used when a type is
|
||
|
|
referenced before it is defined. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_indirect_type
|
||
|
|
PARAMS ((PTR, debug_type *, const char *));
|
||
|
|
|
||
|
|
/* Make a void type. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_void_type PARAMS ((PTR));
|
||
|
|
|
||
|
|
/* Make an integer type of a given size. The boolean argument is true
|
||
|
|
if the integer is unsigned. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_int_type PARAMS ((PTR, unsigned int, boolean));
|
||
|
|
|
||
|
|
/* Make a floating point type of a given size. FIXME: On some
|
||
|
|
platforms, like an Alpha, you probably need to be able to specify
|
||
|
|
the format. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_float_type PARAMS ((PTR, unsigned int));
|
||
|
|
|
||
|
|
/* Make a boolean type of a given size. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_bool_type PARAMS ((PTR, unsigned int));
|
||
|
|
|
||
|
|
/* Make a complex type of a given size. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_complex_type PARAMS ((PTR, unsigned int));
|
||
|
|
|
||
|
|
/* Make a structure type. The second argument is true for a struct,
|
||
|
|
false for a union. The third argument is the size of the struct.
|
||
|
|
The fourth argument is a NULL terminated array of fields. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_struct_type
|
||
|
|
PARAMS ((PTR, boolean, bfd_vma, debug_field *));
|
||
|
|
|
||
|
|
/* Make an object type. The first three arguments after the handle
|
||
|
|
are the same as for debug_make_struct_type. The next arguments are
|
||
|
|
a NULL terminated array of base classes, a NULL terminated array of
|
||
|
|
methods, the type of the object holding the virtual function table
|
||
|
|
if it is not this object, and a boolean which is true if this
|
||
|
|
object has its own virtual function table. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_object_type
|
||
|
|
PARAMS ((PTR, boolean, bfd_vma, debug_field *, debug_baseclass *,
|
||
|
|
debug_method *, debug_type, boolean));
|
||
|
|
|
||
|
|
/* Make an enumeration type. The arguments are a null terminated
|
||
|
|
array of strings, and an array of corresponding values. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_enum_type
|
||
|
|
PARAMS ((PTR, const char **, bfd_signed_vma *));
|
||
|
|
|
||
|
|
/* Make a pointer to a given type. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_pointer_type
|
||
|
|
PARAMS ((PTR, debug_type));
|
||
|
|
|
||
|
|
/* Make a function returning a given type. FIXME: We should be able
|
||
|
|
to record the parameter types. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_function_type PARAMS ((PTR, debug_type));
|
||
|
|
|
||
|
|
/* Make a reference to a given type. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_reference_type PARAMS ((PTR, debug_type));
|
||
|
|
|
||
|
|
/* Make a range of a given type from a lower to an upper bound. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_range_type
|
||
|
|
PARAMS ((PTR, debug_type, bfd_signed_vma, bfd_signed_vma));
|
||
|
|
|
||
|
|
/* Make an array type. The second argument is the type of an element
|
||
|
|
of the array. The third argument is the type of a range of the
|
||
|
|
array. The fourth and fifth argument are the lower and upper
|
||
|
|
bounds, respectively (if the bounds are not known, lower should be
|
||
|
|
0 and upper should be -1). The sixth argument is true if this
|
||
|
|
array is actually a string, as in C. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_array_type
|
||
|
|
PARAMS ((PTR, debug_type, debug_type, bfd_signed_vma, bfd_signed_vma,
|
||
|
|
boolean));
|
||
|
|
|
||
|
|
/* Make a set of a given type. For example, a Pascal set type. The
|
||
|
|
boolean argument is true if this set is actually a bitstring, as in
|
||
|
|
CHILL. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_set_type PARAMS ((PTR, debug_type, boolean));
|
||
|
|
|
||
|
|
/* Make a type for a pointer which is relative to an object. The
|
||
|
|
second argument is the type of the object to which the pointer is
|
||
|
|
relative. The third argument is the type that the pointer points
|
||
|
|
to. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_offset_type
|
||
|
|
PARAMS ((PTR, debug_type, debug_type));
|
||
|
|
|
||
|
|
/* Make a type for a method function. The second argument is the
|
||
|
|
return type, the third argument is the domain, and the fourth
|
||
|
|
argument is a NULL terminated array of argument types. The domain
|
||
|
|
and the argument array may be NULL, in which case this is a stub
|
||
|
|
method and that information is not available. Stabs debugging uses
|
||
|
|
this, and gets the argument types from the mangled name. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_method_type
|
||
|
|
PARAMS ((PTR, debug_type, debug_type, debug_type *));
|
||
|
|
|
||
|
|
/* Make a const qualified version of a given type. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_const_type PARAMS ((PTR, debug_type));
|
||
|
|
|
||
|
|
/* Make a volatile qualified version of a given type. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_volatile_type PARAMS ((PTR, debug_type));
|
||
|
|
|
||
|
|
/* Make an undefined tagged type. For example, a struct which has
|
||
|
|
been mentioned, but not defined. */
|
||
|
|
|
||
|
|
extern debug_type debug_make_undefined_tagged_type
|
||
|
|
PARAMS ((PTR, const char *, enum debug_type_kind));
|
||
|
|
|
||
|
|
/* Make a base class for an object. The second argument is the base
|
||
|
|
class type. The third argument is the bit position of this base
|
||
|
|
class in the object (always 0 unless doing multiple inheritance).
|
||
|
|
The fourth argument is whether this is a virtual class. The fifth
|
||
|
|
argument is the visibility of the base class. */
|
||
|
|
|
||
|
|
extern debug_baseclass debug_make_baseclass
|
||
|
|
PARAMS ((PTR, debug_type, bfd_vma, boolean, enum debug_visibility));
|
||
|
|
|
||
|
|
/* Make a field for a struct. The second argument is the name. The
|
||
|
|
third argument is the type of the field. The fourth argument is
|
||
|
|
the bit position of the field. The fifth argument is the size of
|
||
|
|
the field (it may be zero). The sixth argument is the visibility
|
||
|
|
of the field. */
|
||
|
|
|
||
|
|
extern debug_field debug_make_field
|
||
|
|
PARAMS ((PTR, const char *, debug_type, bfd_vma, bfd_vma,
|
||
|
|
enum debug_visibility));
|
||
|
|
|
||
|
|
/* Make a static member of an object. The second argument is the
|
||
|
|
name. The third argument is the type of the member. The fourth
|
||
|
|
argument is the physical name of the member (i.e., the name as a
|
||
|
|
global variable). The fifth argument is the visibility of the
|
||
|
|
member. */
|
||
|
|
|
||
|
|
extern debug_field debug_make_static_member
|
||
|
|
PARAMS ((PTR, const char *, debug_type, const char *,
|
||
|
|
enum debug_visibility));
|
||
|
|
|
||
|
|
/* Make a method. The second argument is the name, and the third
|
||
|
|
argument is a NULL terminated array of method variants. Each
|
||
|
|
method variant is a method with this name but with different
|
||
|
|
argument types. */
|
||
|
|
|
||
|
|
extern debug_method debug_make_method
|
||
|
|
PARAMS ((PTR, const char *, debug_method_variant *));
|
||
|
|
|
||
|
|
/* Make a method variant. The second argument is either the physical
|
||
|
|
name of the function, or the encoded argument types, depending upon
|
||
|
|
whether the third argument specifies the argument types or not.
|
||
|
|
The third argument is the type of the function. The fourth
|
||
|
|
argument is the visibility. The fifth argument is whether this is
|
||
|
|
a const function. The sixth argument is whether this is a volatile
|
||
|
|
function. The seventh argument is the offset in the virtual
|
||
|
|
function table, if any. The eighth argument is the virtual
|
||
|
|
function context. FIXME: Are the const and volatile arguments
|
||
|
|
necessary? Could we just use debug_make_const_type? The handling
|
||
|
|
of the second argument is biased toward the way that stabs works. */
|
||
|
|
|
||
|
|
extern debug_method_variant debug_make_method_variant
|
||
|
|
PARAMS ((PTR, const char *, debug_type, enum debug_visibility, boolean,
|
||
|
|
boolean, bfd_vma, debug_type));
|
||
|
|
|
||
|
|
/* Make a static method argument. The arguments are the same as for
|
||
|
|
debug_make_method_variant, except that the last two are omitted
|
||
|
|
since a static method can not also be virtual. */
|
||
|
|
|
||
|
|
extern debug_method_variant debug_make_static_method_variant
|
||
|
|
PARAMS ((PTR, const char *, debug_type, enum debug_visibility, boolean,
|
||
|
|
boolean));
|
||
|
|
|
||
|
|
/* Name a type. This returns a new type with an attached name. */
|
||
|
|
|
||
|
|
extern debug_type debug_name_type PARAMS ((PTR, const char *, debug_type));
|
||
|
|
|
||
|
|
/* Give a tag to a type, such as a struct or union. This returns a
|
||
|
|
new type with an attached tag. */
|
||
|
|
|
||
|
|
extern debug_type debug_tag_type PARAMS ((PTR, const char *, debug_type));
|
||
|
|
|
||
|
|
/* Record the size of a given type. */
|
||
|
|
|
||
|
|
extern boolean debug_record_type_size PARAMS ((PTR, debug_type, unsigned int));
|
||
|
|
|
||
|
|
/* Find a tagged type. */
|
||
|
|
|
||
|
|
extern debug_type debug_find_tagged_type
|
||
|
|
PARAMS ((PTR, const char *, enum debug_type_kind));
|
||
|
|
|
||
|
|
/* Get the name of a type. */
|
||
|
|
|
||
|
|
extern const char *debug_get_type_name PARAMS ((PTR, debug_type));
|
||
|
|
|
||
|
|
/* Write out the recorded debugging information. This takes a set of
|
||
|
|
function pointers which are called to do the actual writing. The
|
||
|
|
first PTR is the debugging handle. The second PTR is a handle
|
||
|
|
which is passed to the functions. */
|
||
|
|
|
||
|
|
extern boolean debug_write PARAMS ((PTR, const struct debug_write_fns *, PTR));
|
||
|
|
|
||
|
|
#endif /* DEBUG_H */
|