/*

  Copyright (C) 2000,2001,2002,2005,2006 Silicon Graphics, Inc.  All Rights Reserved.

  Portions Copyright 2007 Sun Microsystems, Inc. All rights reserved.

  This program is free software; you can redistribute it and/or modify it

  under the terms of version 2.1 of the GNU Lesser General Public License

  as published by the Free Software Foundation.

  This program is distributed in the hope that it would be useful, but

  WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

  Further, this software is distributed without any warranty that it is

  free of the rightful claim of any third person regarding infringement

  or the like.  Any license provided herein, whether implied or

  otherwise, applies only to this software file.  Patent licenses, if

  any, provided herein do not apply to combinations of this program with

  other software, or any other product whatsoever.

  You should have received a copy of the GNU Lesser General Public

  License along with this program; if not, write the Free Software

  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301,

  USA.

  Contact information:  Silicon Graphics, Inc., 1500 Crittenden Lane,

  Mountain View, CA 94043, or:

  http://www.sgi.com

  For further information regarding this notice, see:

  http://oss.sgi.com/projects/GenInfo/NoticeExplan

*/

#ifndef _LIBDWARF_H

#define _LIBDWARF_H

#ifdef __cplusplus

extern "C" {

#endif

/*

	libdwarf.h  

	$Revision: 1.88 $ $Date: 2006/04/18 04:46:07 $

	For libdwarf producers and consumers

	The interface is defined as having 8-byte signed and unsigned

	values so it can handle 64-or-32bit target on 64-or-32bit host.

	Addr is the native size: it represents pointers on

	the host machine (not the target!).

	This contains declarations for types and all producer

	and consumer functions.

	Function declarations are written on a single line each here

	so one can use grep  to each declaration in its entirety.

	The declarations are a little harder to read this way, but...

*/

#ifdef __SGI_FAST_LIBELF

struct elf_sgi;

typedef struct elf_sgi* dwarf_elf_handle;

#else

struct Elf;

typedef struct Elf* dwarf_elf_handle;

#endif

#if (_MIPS_SZLONG == 64)

/* Special case for MIPS, so -64 (LP64) build gets simple -long-.

   Non-MIPS LP64 or ILP64 environments should probably ensure

   _MIPS_SZLONG set to 64 everywhere this header is #included.

*/

typedef int             Dwarf_Bool;         /* boolean type */

typedef unsigned long   Dwarf_Off;          /* 4 or 8 byte file offset */

typedef unsigned long   Dwarf_Unsigned;     /* 4 or 8 byte unsigned value */

typedef unsigned short  Dwarf_Half;         /* 2 byte unsigned value */

typedef unsigned char   Dwarf_Small;        /* 1 byte unsigned value */

typedef signed   long   Dwarf_Signed;       /* 4 or 8 byte signed value */

typedef unsigned long   Dwarf_Addr;         /* target memory address */

#else /* 32-bit */

/* This is for ILP32, allowing i/o of 64bit dwarf info.

   Also should be fine for LP64 and ILP64 cases.

*/

typedef int                 Dwarf_Bool;     /* boolean type */

typedef unsigned long long  Dwarf_Off;      /* 8 byte file offset */

typedef unsigned long long  Dwarf_Unsigned; /* 8 byte unsigned value*/

typedef unsigned short      Dwarf_Half;     /* 2 byte unsigned value */

typedef unsigned char       Dwarf_Small;    /* 1 byte unsigned value */

typedef signed   long long  Dwarf_Signed;   /* 8 byte signed value */

typedef unsigned long long  Dwarf_Addr;     /* target memory address */

#endif

typedef void*		Dwarf_Ptr;          /* host machine pointer */

/* Contains info on an uninterpreted block of data

*/

typedef struct {

        Dwarf_Unsigned  bl_len;         /* length of block */

        Dwarf_Ptr       bl_data;        /* uninterpreted data */

	Dwarf_Small     bl_from_loclist; /*non-0 if loclist, else debug_info*/

	Dwarf_Unsigned  bl_section_offset; /* Section (not CU) offset

                                        which 'data' comes from. */

} Dwarf_Block;

/* location record

*/

typedef struct {

        Dwarf_Small     lr_atom;        /* location operation */

        Dwarf_Unsigned  lr_number;      /* operand */

	Dwarf_Unsigned  lr_number2;     /* for OP_BREGx */

	Dwarf_Unsigned  lr_offset;      /* offset in locexpr for OP_BRA etc */

} Dwarf_Loc;

/* location description

*/

typedef struct {

        Dwarf_Addr      ld_lopc;        /* beginning of active range */ 

        Dwarf_Addr      ld_hipc;        /* end of active range */

        Dwarf_Half      ld_cents;       /* count of location records */

        Dwarf_Loc*      ld_s;           /* pointer to list of same */

	Dwarf_Small     ld_from_loclist; 

				      /* non-0 if loclist, else debug_info*/

	Dwarf_Unsigned  ld_section_offset; /* Section (not CU) offset

					where loc-expr begins*/

} Dwarf_Locdesc;

/* Frame description instructions expanded.

*/

typedef struct {

        Dwarf_Small     fp_base_op;

        Dwarf_Small     fp_extended_op;

        Dwarf_Half      fp_register;

	/* Value may be signed, depends on op. 

           Any applicable data_alignment_factor has

           not been applied, this is the  raw offset. */

        Dwarf_Unsigned  fp_offset;

        Dwarf_Off       fp_instr_offset;

} Dwarf_Frame_Op; /* DWARF2 */

typedef struct {

        Dwarf_Small     fp_base_op;

        Dwarf_Small     fp_extended_op;

        Dwarf_Half      fp_register;

	/* Value may be signed, depends on op. 

           Any applicable data_alignment_factor has

           not been applied, this is the  raw offset. */

        Dwarf_Unsigned  fp_offset_or_block_len; 

	Dwarf_Small     *fp_expr_block;

        Dwarf_Off       fp_instr_offset;

} Dwarf_Frame_Op3;  /* DWARF3 and DWARF2 compatible */

/*  ***IMPORTANT NOTE, TARGET DEPENDENCY ****

   DW_REG_TABLE_SIZE must be at least as large as

   the number of registers

   (DW_FRAME_LAST_REG_NUM) as defined in dwarf.h

   Preferably identical to DW_FRAME_LAST_REG_NUM.

   Ensure [0-DW_REG_TABLE_SIZE] does not overlap 

   DW_FRAME_UNDEFINED_VAL or DW_FRAME_SAME_VAL. 

   Also ensure DW_FRAME_REG_INITIAL_VALUE is set to what

   is appropriate to your cpu.

   For various CPUs  DW_FRAME_UNDEFINED_VAL is correct

   as the value for DW_FRAME_REG_INITIAL_VALUE.

   For consumer apps, this can be set dynamically: see

   dwarf_set_frame_rule_table_size();

 */

#ifndef DW_REG_TABLE_SIZE

#define DW_REG_TABLE_SIZE  66

#endif

/* For MIPS, DW_FRAME_SAME_VAL is the correct default value 

   for a frame register value. For other CPUS another value

   may be better, such as DW_FRAME_UNDEFINED_VAL.

   See dwarf_set_frame_rule_table_size

*/

#ifndef DW_FRAME_REG_INITIAL_VALUE

#define DW_FRAME_REG_INITIAL_VALUE DW_FRAME_SAME_VAL

#endif

/* Taken as meaning 'undefined value', this is not

   a column or register number.

   Only present at libdwarf runtime. Never on disk.

   DW_FRAME_* Values present on disk are in dwarf.h

   Ensure this is > DW_REG_TABLE_SIZE.

*/

#define DW_FRAME_UNDEFINED_VAL          1034

/* Taken as meaning 'same value' as caller had, not a column

   or register number

   Only present at libdwarf runtime. Never on disk.

   DW_FRAME_* Values present on disk are in dwarf.h

   Ensure this is > DW_REG_TABLE_SIZE.

*/

#define DW_FRAME_SAME_VAL               1035

/* For DWARF3 interfaces, make the CFA a column with no

   real table number.  This is what should have been done

   for the DWARF2 interfaces.  This actually works for

   both DWARF2 and DWARF3, but see the libdwarf documentation

   on Dwarf_Regtable3 and  dwarf_get_fde_info_for_reg3()

   and  dwarf_get_fde_info_for_all_regs3()  

   Do NOT use this with the older dwarf_get_fde_info_for_reg()

   or dwarf_get_fde_info_for_all_regs() consumer interfaces.

*/

#define DW_FRAME_CFA_COL3               1036

/* The following are all needed to evaluate DWARF3 register rules.

*/

#define DW_EXPR_OFFSET 0  /* DWARF2 only sees this. */

#define DW_EXPR_VAL_OFFSET 1

#define DW_EXPR_EXPRESSION 2

#define DW_EXPR_VAL_EXPRESSION 3

typedef struct Dwarf_Regtable_Entry_s {

	/*  For each index i (naming a hardware register with dwarf number

            i) the following is true and defines the value of that register:

           If dw_regnum is Register DW_FRAME_UNDEFINED_VAL  

	     it is not DWARF register number but

		a place holder indicating the register has no defined value.

           If dw_regnum is Register DW_FRAME_SAME_VAL 

  	     it  is not DWARF register number but

		a place holder indicating the register has the same

                value in the previous frame.

	   DW_FRAME_UNDEFINED_VAL, DW_FRAME_SAME_VAL are

           only present at libdwarf runtime. Never on disk.

           DW_FRAME_* Values present on disk are in dwarf.h

          Otherwise: the register number is a DWARF register number

          (see ABI documents for how this translates to hardware/

           software register numbers in the machine hardware)

	  and the following applies:

          if dw_value_type == DW_EXPR_OFFSET (the only  possible case for dwarf2):

	    If dw_offset_relevant is non-zero, then

	     the value is stored at at the address CFA+N where N is a signed offset. 

	     Rule: Offset(N)

            If dw_offset_relevant is zero, then the value of the register

             is the value of (DWARF) register number dw_regnum.

             Rule: register(F)

          Other values of dw_value_type are an error.

        */

	Dwarf_Small         dw_offset_relevant;

	/* For DWARF2, always 0 */

        Dwarf_Small         dw_value_type; 

	Dwarf_Half          dw_regnum;

	/* The data type here should  the larger of Dwarf_Addr

           and Dwarf_Unsigned and Dwarf_Signed. */

	Dwarf_Addr          dw_offset;

} Dwarf_Regtable_Entry;

typedef struct Dwarf_Regtable_s {

    struct Dwarf_Regtable_Entry_s rules[DW_REG_TABLE_SIZE];

} Dwarf_Regtable;

/* opaque type. Functional interface shown later. */

struct Dwarf_Reg_value3_s;

typedef struct Dwarf_Reg_value3_s Dwarf_Reg_Value3; 

typedef struct Dwarf_Regtable_Entry3_s {

	/*  For each index i (naming a hardware register with dwarf number

            i) the following is true and defines the value of that register:

           If dw_regnum is Register DW_FRAME_UNDEFINED_VAL  

	     it is not DWARF register number but

		a place holder indicating the register has no defined value.

           If dw_regnum is Register DW_FRAME_SAME_VAL 

  	     it  is not DWARF register number but

		a place holder indicating the register has the same

                value in the previous frame.

	   DW_FRAME_UNDEFINED_VAL, DW_FRAME_SAME_VAL are

           only present at libdwarf runtime. Never on disk.

           DW_FRAME_* Values present on disk are in dwarf.h

          Otherwise: the register number is a DWARF register number

          (see ABI documnets for how this translates to hardware/

           software register numbers in the machine hardware)

	  and the following applies:

          if dw_value_type == DW_EXPR_OFFSET (the only  possible case for 

		dwarf2):

	    If dw_offset_relevant is non-zero, then

	     the value is stored at at the address 

	     CFA+N where N is a signed offset. 

	     Rule: Offset(N)

            If dw_offset_relevant is zero, then the value of the register

             is the value of (DWARF) register number dw_regnum.

             Rule: register(R)

          if dw_value_type  == DW_EXPR_VAL_OFFSET

            the  value of this register is CFA +N where N is a signed offset.

            Rule: val_offset(N)

          if dw_value_type  == DW_EXPR_EXPRESSION

	    The value of the register is the value at the address

            computed by evaluating the DWARF expression E.

            Rule: expression(E)

            The expression E byte stream is pointed to by dw_block_ptr.

            The expression length in bytes is given by

            dw_offset_or_block_len.

          if dw_value_type  == DW_EXPR_VAL_EXPRESSION

	    The value of the register is the value

            computed by evaluating the DWARF expression E.

            Rule: val_expression(E)

            The expression E byte stream is pointed to by dw_block_ptr.

            The expression length in bytes is given by

            dw_offset_or_block_len.

          Other values of dw_value_type are an error.

        */

	Dwarf_Small         dw_offset_relevant;

        Dwarf_Small         dw_value_type; 

	Dwarf_Half          dw_regnum;

	Dwarf_Unsigned      dw_offset_or_block_len;

	Dwarf_Ptr           dw_block_ptr;

}Dwarf_Regtable_Entry3;

/* For the DWARF3 version, moved the DW_FRAME_CFA_COL

   out of the array and into its own struct.  

   Having it part of the array is not very easy to work

   with from a portability point of view: changing

   the number for every architecture is a pain (if one fails

   to set it correctly a register rule gets clobbered when

   setting CFA).

   With MIPS it just happened to be easy to use DW_FRAME_CFA_COL.

   rt3_rules and rt3_reg_table_size must be filled in 

    before calling libdwarf.

    Filled in with a pointer to an array (pointer and

    array  set up by the calling application) of rt3_reg_table_size 

    Dwarf_Regtable_Entry3_s structs.   

    libdwarf does not allocate or deallocate space for the

    rules, you must do so.   libdwarf will initialize the

    contents rules array, you do not need to do so (though

    if you choose to initialize the array somehow that is ok:

    libdwarf will overwrite your initializations with its own).

*/

typedef struct Dwarf_Regtable3_s {

    struct Dwarf_Regtable_Entry3_s   rt3_cfa_rule;

    Dwarf_Half                       rt3_reg_table_size;

    struct Dwarf_Regtable_Entry3_s * rt3_rules;

} Dwarf_Regtable3;

/* Use for DW_EPXR_STANDARD., DW_EXPR_VAL_OFFSET. 

   Returns DW_DLV_OK if the value is available.

   If DW_DLV_OK returns the regnum and offset thru the pointers

   (which the consumer must use appropriately). 

*/

int dwarf_frame_get_reg_register(struct Dwarf_Regtable_Entry3_s *reg_in,

	Dwarf_Small *offset_relevant,

	Dwarf_Half *regnum_out,

	Dwarf_Signed *offset_out);

/* Use for DW_EXPR_EXPRESSION, DW_EXPR_VAL_EXPRESSION.

   Returns DW_DLV_OK if the value is available.

   The caller must pass in the address of a valid

   Dwarf_Block (the caller need not initialize it).

*/

int dwarf_frame_get_reg_expression(struct Dwarf_Regtable_Entry3_s *reg_in,

	Dwarf_Block *block_out);

/* for DW_DLC_SYMBOLIC_RELOCATIONS output to caller 

   v2, adding drd_length: some relocations are 4 and

   some 8 bytes (pointers are 8, section offsets 4) in

   some dwarf environments. (MIPS relocations are all one

   size in any given ABI.) Changing drd_type to an unsigned char

   to keep struct size down.

*/

enum Dwarf_Rel_Type {

		dwarf_drt_none, /* should not get to caller */

                dwarf_drt_data_reloc, /* simple normal relocation */

                dwarf_drt_segment_rel, /* special reloc, exceptions*/

                dwarf_drt_first_of_length_pair,/* this and drt_second 

				for .word end - begin

			 	case */

                dwarf_drt_second_of_length_pair

};

typedef struct Dwarf_P_Marker_s * Dwarf_P_Marker;

struct Dwarf_P_Marker_s {

    Dwarf_Unsigned ma_marker;

    Dwarf_Unsigned ma_offset;

};

typedef struct Dwarf_Relocation_Data_s  * Dwarf_Relocation_Data;

struct Dwarf_Relocation_Data_s {

        unsigned char drd_type; /* cast to/from Dwarf_Rel_Type

					  to keep size small in struct */

	unsigned char drd_length; /* length in bytes

			         of data being relocated. 4 for 32bit.

				 8 for 64bit data */

        Dwarf_Unsigned       drd_offset; /* where the data to reloc is */

        Dwarf_Unsigned       drd_symbol_index;

};

typedef struct Dwarf_P_String_Attr_s  * Dwarf_P_String_Attr;

struct Dwarf_P_String_Attr_s {

    Dwarf_Unsigned        sa_offset;  /* Offset of string attribute data */

    Dwarf_Unsigned        sa_nbytes;  

};

/* Opaque types for Consumer Library. */

typedef struct Dwarf_Debug_s*      Dwarf_Debug;

typedef struct Dwarf_Die_s*        Dwarf_Die;

typedef struct Dwarf_Line_s*       Dwarf_Line;

typedef struct Dwarf_Global_s*     Dwarf_Global;

typedef struct Dwarf_Func_s*       Dwarf_Func;

typedef struct Dwarf_Type_s*       Dwarf_Type;

typedef struct Dwarf_Var_s*        Dwarf_Var;

typedef struct Dwarf_Weak_s*       Dwarf_Weak;

typedef struct Dwarf_Error_s*      Dwarf_Error;

typedef struct Dwarf_Attribute_s*  Dwarf_Attribute;

typedef struct Dwarf_Abbrev_s*	   Dwarf_Abbrev;

typedef struct Dwarf_Fde_s*  	   Dwarf_Fde;

typedef struct Dwarf_Cie_s*  	   Dwarf_Cie;

typedef struct Dwarf_Arange_s*	   Dwarf_Arange;

/* Opaque types for Producer Library. */

typedef struct Dwarf_P_Debug_s*	   	Dwarf_P_Debug;

typedef struct Dwarf_P_Die_s*	   	Dwarf_P_Die;

typedef struct Dwarf_P_Attribute_s*	Dwarf_P_Attribute;

typedef struct Dwarf_P_Fde_s*		Dwarf_P_Fde;

typedef struct Dwarf_P_Expr_s*		Dwarf_P_Expr;

typedef Dwarf_Unsigned 		   	Dwarf_Tag;

/* error handler function

*/

typedef void  (*Dwarf_Handler)(Dwarf_Error /*error*/, Dwarf_Ptr /*errarg*/); 

/* 

    Dwarf_dealloc() alloc_type arguments.

    Argument points to:

*/

#define DW_DLA_STRING      	0x01     /* char* */

#define DW_DLA_LOC         	0x02     /* Dwarf_Loc */

#define DW_DLA_LOCDESC     	0x03     /* Dwarf_Locdesc */

#define DW_DLA_ELLIST      	0x04     /* Dwarf_Ellist (not used)*/

#define DW_DLA_BOUNDS      	0x05     /* Dwarf_Bounds (not used) */

#define DW_DLA_BLOCK       	0x06     /* Dwarf_Block */

#define DW_DLA_DEBUG       	0x07     /* Dwarf_Debug */

#define DW_DLA_DIE         	0x08     /* Dwarf_Die */

#define DW_DLA_LINE        	0x09     /* Dwarf_Line */

#define DW_DLA_ATTR        	0x0a     /* Dwarf_Attribute */

#define DW_DLA_TYPE        	0x0b     /* Dwarf_Type  (not used) */

#define DW_DLA_SUBSCR      	0x0c     /* Dwarf_Subscr (not used) */

#define DW_DLA_GLOBAL      	0x0d     /* Dwarf_Global */

#define DW_DLA_ERROR       	0x0e     /* Dwarf_Error */

#define DW_DLA_LIST        	0x0f     /* a list */

#define DW_DLA_LINEBUF     	0x10     /* Dwarf_Line* (not used) */

#define DW_DLA_ARANGE      	0x11     /* Dwarf_Arange */

#define DW_DLA_ABBREV		0x12 	 /* Dwarf_Abbrev */

#define DW_DLA_FRAME_OP		0x13 	 /* Dwarf_Frame_Op */

#define DW_DLA_CIE		0x14	 /* Dwarf_Cie */

#define DW_DLA_FDE		0x15	 /* Dwarf_Fde */

#define DW_DLA_LOC_BLOCK	0x16	 /* Dwarf_Loc Block (not used) */

#define DW_DLA_FRAME_BLOCK	0x17	 /* Dwarf_Frame Block (not used) */

#define DW_DLA_FUNC		0x18	 /* Dwarf_Func */

#define DW_DLA_TYPENAME		0x19	 /* Dwarf_Type */

#define DW_DLA_VAR		0x1a	 /* Dwarf_Var */

#define DW_DLA_WEAK		0x1b	 /* Dwarf_Weak */

#define DW_DLA_ADDR		0x1c	 /* Dwarf_Addr sized entries */

/* The augmenter string for CIE */

#define DW_CIE_AUGMENTER_STRING_V0              "z"

/* dwarf_init() access arguments

*/

#define DW_DLC_READ        0        /* read only access */

#define DW_DLC_WRITE       1        /* write only access */

#define DW_DLC_RDWR        2        /* read/write access NOT SUPPORTED*/

/* dwarf_init() access flag modifiers

*/

#define DW_DLC_SIZE_64     0x40000000 /* 32-bit target */

#define DW_DLC_SIZE_32     0x20000000 /* 64-bit target */

/* dwarf_init() access flag modifiers

*/

#define DW_DLC_ISA_MIPS             0x00000000 /* MIPS target */

#define DW_DLC_ISA_IA64             0x01000000 /* IA64 target */

#define DW_DLC_STREAM_RELOCATIONS   0x02000000 /* old style binary relocs */

#define DW_DLC_SYMBOLIC_RELOCATIONS 0x04000000 /* usable with assem output */

#define DW_DLC_TARGET_BIGENDIAN     0x08000000 /* big    endian target */

#define DW_DLC_TARGET_LITTLEENDIAN  0x00100000 /* little endian target */

#if 0

  /*

   The libdwarf producer interfaces jumble these two semantics together in

   confusing ways.  We *should* have flags like these...

   But changing the code means a lot of diffs.  So for now,

   we leave things as they are 

  */

  #define DW_DLC_SUN_OFFSET32	    0x00010000 /* use 32-bit sec offsets */

  #define DW_DLC_SUN_OFFSET64	    0x00020000 /* use 64-bit sec offsets */

  #define DW_DLC_SUN_POINTER32	    0x00040000 /* use 4 for address_size */

  #define DW_DLC_SUN_POINTER64	    0x00080000 /* use 8 for address_size */

#endif

/* dwarf_pcline() slide arguments

*/

#define DW_DLS_BACKWARD   -1       /* slide backward to find line */

#define DW_DLS_NOSLIDE     0       /* match exactly without sliding */ 

#define DW_DLS_FORWARD     1       /* slide forward to find line */

/* libdwarf error numbers

*/

#define DW_DLE_NE          0     /* no error */ 

#define DW_DLE_VMM         1     /* dwarf format/library version mismatch */

#define DW_DLE_MAP         2     /* memory map failure */

#define DW_DLE_LEE         3     /* libelf error */

#define DW_DLE_NDS         4     /* no debug section */

#define DW_DLE_NLS         5     /* no line section */