Subversion Repositories or1k

/*

 * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved.

 *

 * This software may be freely used, copied, modified, and distributed

 * provided that the above copyright notice is preserved in all copies of the

 * software.

 */

/*

 * ARM symbolic debugger toolbox interface

 */

/*

 * RCS $Revision: 1.2 $

 * Checkin $Date: 2003-08-15 01:06:10 $

 */

/* Minor points of uncertainty are indicated by a question mark in the

   LH margin.

   Wherever an interface is required to iterate over things of some class,

   I prefer something of the form  EnumerateXXs(..., XXProc *p, void *arg)

   which results in a call of p(xx, arg) for each xx, rather than something

   of the form

     for (xxh = StartIterationOverXXs(); (xx = Next(xxh)) != 0; ) { ... }

     EndIterationOverXXs(xxh);

   Others may disagree.

   (Each XXProc returns an Error value: if this is not Err_OK, iteration

   stops immediately and the EnumerateXXs function returns that value).

   ptrace has been retired as of insufficient utility.  If such fuctionality is

   required, it can be constructed using breakpoints.

   The file form of all name fields in debug areas is in-line, with a length

   byte and no terminator.  The debugger toolbox makes an in-store translation,

   where the strings are out of line (the namep variant in asdfmt.h) and have a

   terminating zero byte: the pointer is to the first character of the string

   with the length byte at ...->n.namep[-1].

 */

#ifndef armdbg__h

#define armdbg__h

#include <stddef.h>

#include "host.h"

#include "msg.h"

typedef unsigned32 ARMaddress;

typedef unsigned32 ARMword;

typedef unsigned16 ARMhword;

#include "dbg_conf.h"

#include "dbg_rdi.h"

#ifdef __cplusplus

extern "C"

{

#endif

typedef unsigned char Dbg_Byte;

typedef int Dbg_Error;

typedef struct Dbg_MCState Dbg_MCState;

/* A representation of the state of the target.  The structure is not revealed.

   A pointer to one of these is returned by Dbg_Initialise(), is passed to all

   toolbox calls which refer to the state of the target, and is discarded

   by Dbg_Finalise().

   Nothing in the toolbox itself precludes there being multiple targets, each

   with its own state.

 */

/* Most toolbox interfaces return an error status.  Only a few of the status

   values are expected to be interesting to clients and defined here; the

   rest are private (but a textual form can be produced by ErrorToChars()).

 */

#define Error_OK 0

/* Partitioning of the error code space: errors below Dbg_Error_Base are RDI

   errors (as defined in dbg_rdi.h). Codes above Dbg_Error_Limit are

   available to clients, who may impose some further structure.

 */

#define Dbg_Error_Base 0x1000

#define Dbg_Error_Limit 0x2000

#define DbgError(n) ((Dbg_Error)(Dbg_Error_Base+(n)))

#define Dbg_Err_OK Error_OK

#define Dbg_Err_Interrupted             DbgError(1)

#define Dbg_Err_Overflow                DbgError(2)

#define Dbg_Err_FileNotFound            DbgError(3)

#define Dbg_Err_ActivationNotPresent    DbgError(4)

#define Dbg_Err_OutOfHeap               DbgError(5)

#define Dbg_Err_TypeNotSimple           DbgError(6)

#define Dbg_Err_BufferFull              DbgError(7)

#define Dbg_Err_AtStackBase             DbgError(8)

#define Dbg_Err_AtStackTop              DbgError(9)

#define Dbg_Err_DbgTableFormat          DbgError(10)

#define Dbg_Err_NotVariable             DbgError(11)

#define Dbg_Err_NoSuchBreakPoint        DbgError(12)

#define Dbg_Err_NoSuchWatchPoint        DbgError(13)

#define Dbg_Err_FileLineNotFound        DbgError(14)

#define Dbg_Err_DbgTableVersion         DbgError(15)

#define Dbg_Err_NoSuchPath              DbgError(16)

#define Dbg_Err_StateChanged            DbgError(17)

#define Dbg_Err_SoftInitialiseError     DbgError(18)

#define Dbg_Err_CoProRegNotWritable     DbgError(19)

#define Dbg_Err_NotInHistory            DbgError(20)

#define Dbg_Err_ContextSyntax           DbgError(21)

#define Dbg_Err_ContextNoLine           DbgError(22)

#define Dbg_Err_ContextTwoLines         DbgError(23)

#define Dbg_Err_VarReadOnly             DbgError(24)

#define Dbg_Err_FileNewerThanImage      DbgError(25)

#define Dbg_Err_NotFound                DbgError(26)

   /* functions which evaluate expressions may return this value, to indicate

      that execution became suspended within a function called in the debugee */

/* Functions returning characters take a BufDesc argument, with fields buffer

   and bufsize being input arguments describing the buffer to be filled, and

   filled being set on return to the number of bytes written to the buffer

   (omitting the terminating 0).

 */

typedef struct Dbg_BufDesc Dbg_BufDesc;

typedef void Dbg_BufferFullProc(Dbg_BufDesc *bd);

struct Dbg_BufDesc {

    char *buffer;

    size_t size,

           filled;

    Dbg_BufferFullProc *p;

    void *arg;

};

#define Dbg_InitBufDesc(bd, buf, bytes) \

    ((bd).buffer = (buf), (bd).size = (bytes), (bd).filled = 0,\

     (bd).p = NULL, (bd).arg = NULL)

#define Dbg_InitBufDesc_P(bd, buf, bytes, fn, a) \

    ((bd).buffer = (buf), (bd).size = (bytes), (bd).filled = 0,\

     (bd).p = (fn), (bd).arg = (a))

Dbg_Error Dbg_StringToBuf(Dbg_BufDesc *buf, char const *s);

Dbg_Error Dbg_BufPrintf(Dbg_BufDesc *buf, char const *form, ...);

#ifdef NLS

Dbg_Error Dbg_MsgToBuf(Dbg_BufDesc *buf, msg_t t);

Dbg_Error Dbg_BufMsgPrintf(Dbg_BufDesc *buf, msg_t form, ...);

#else

#define Dbg_MsgToBuf Dbg_StringToBuf

#define Dbg_BufMsgPrintf Dbg_BufPrintf

#endif

Dbg_Error Dbg_CharToBuf(Dbg_BufDesc *buf, int ch);

int Dbg_CIStrCmp(char const *s1, char const *s2);

/* Case-independent string comparison, interface as for strcmp */

int Dbg_CIStrnCmp(char const *s1, char const *s2, size_t n);

/* Case-independent string comparison, interface as for strncmp */

void Dbg_ErrorToChars(Dbg_MCState *state, Dbg_Error err, Dbg_BufDesc *buf);

typedef int Dbg_RDIResetCheckProc(int);

/* Type of a function to be called after each RDI operation performed by the

   toolbox, with the status from the operation as argument.  The value returned

   is treated as the status.  (The intent is to allow the toolbox's client to

   take special action to handle RDIDbg_Error_Reset).

 */

typedef struct Dbg_CoProDesc Dbg_CoProDesc;

typedef Dbg_Error Dbg_CoProFoundProc(Dbg_MCState *state, int cpno, Dbg_CoProDesc const *cpd);

/* Type of a function to be called when the shape of a coprocessor is discovered

   by enquiry of the target or agent (via RequestCoProDesc)

 */

typedef struct RDIProcVec RDIProcVec;

Dbg_Error Dbg_RequestReset(Dbg_MCState *);

Dbg_Error Dbg_Initialise(

    Dbg_ConfigBlock *config, Dbg_HostosInterface const *i,

    Dbg_RDIResetCheckProc *checkreset, Dbg_CoProFoundProc *coprofound,

    RDIProcVec const *rdi, Dbg_MCState **statep);

/* values in config are updated if they call for default values */

void Dbg_Finalise(Dbg_MCState *state, bool targetdead);

typedef struct {

    char name[16];

    RDI_MemDescr md;

    RDI_MemAccessStats a;

} Dbg_MemStats;

/*--------------------------------------------------------------------------*/

/* Symbol table management.

   The structure of a Dbg_SymTable is not revealed.  It is created by

   Dbg_ReadSymbols() or by Dbg_LoadFile(), and associated with the argument

   Dbg_MCState.

   Many symbol tables may be concurrently active.

   A Dbg_SymTable is removed either explicitly (by call to Dbg_DeleteSymbols)

   or implicitly when a symbol table for an overlapping address range is read.

   There is a pre-defined symbol table containing entries for ARM registers,

   co-processor registers and the like.

 */

typedef struct Dbg_SymTable Dbg_SymTable;

typedef struct Dbg_ImageFragmentDesc {

    ARMaddress base, limit;

} Dbg_ImageFragmentDesc;

typedef enum {

    Dbg_Lang_None,

    Dbg_Lang_C,

    Dbg_Lang_Pascal,

    Dbg_Lang_Fortran,

    Dbg_Lang_Asm,

    Dbg_Lang_Cpp

} Dbg_Lang;

typedef struct Dbg_ImageDesc {

    Dbg_Lang lang;

    int executable;

    ARMaddress robase, rolimit, rwbase, rwlimit;

    int nfrags;

    Dbg_ImageFragmentDesc *fragments;

    char *name;

} Dbg_ImageDesc;

Dbg_ImageDesc *Dbg_ImageAreas(Dbg_SymTable *st);

Dbg_SymTable *Dbg_LastImage(Dbg_MCState *state);

Dbg_SymTable *Dbg_NewSymTable(Dbg_MCState *state, const char *name);

Dbg_Error Dbg_ReadSymbols(Dbg_MCState *state, const char *filename, Dbg_SymTable **st);

/* Just read the symbols from the named image.  <st> is set to the allocated

   symbol table.

?  Maybe we could usefully allow other formats than AIF images to describe

   the symbols (eg) of shared libraries

 */

typedef struct Dbg_SymInfo {

    int isize;

    ARMaddress addr;

    char *name;

} Dbg_SymInfo;

Dbg_SymInfo *Dbg_AsmSym(Dbg_SymTable *st, ARMaddress addr);

int32 Dbg_AsmAddr(Dbg_SymTable *st, int32 line);

int32 Dbg_AsmLine(Dbg_SymTable *st, ARMaddress addr);

int32 Dbg_AsmLinesInRange(Dbg_SymTable *st, ARMaddress start, ARMaddress end);

Dbg_Error Dbg_LoadFile(Dbg_MCState *state, const char *filename, Dbg_SymTable **st);

/* load the image into target memory, and read its symbols.  <st> is set to

   the allocated symbol table.

   A null filename reloads the most recently loaded file (and rereads its

   symbols).

   Loading an image leaves breakpoints unchanged.  If a client wishes

   otherwise, it must remove the breakpoints explicitly.

*/

Dbg_Error Dbg_CallGLoadFile(Dbg_MCState *state, const char *filename, Dbg_SymTable **st);

typedef void Dbg_ImageLoadProc(Dbg_MCState *, Dbg_SymTable *);

Dbg_Error Dbg_OnImageLoad(Dbg_MCState *, Dbg_ImageLoadProc *);

/* Register function to be called back whenever an image is loaded, or symbols

 * for an image read. (To allow multiple toolbox clients to coexist).

 */

Dbg_Error Dbg_LoadAgent(Dbg_MCState *state, const char *filename);

/* Load a debug agent, and start it.

   Symbols in the image for the agent are ignored.

*/

Dbg_Error Dbg_RelocateSymbols(Dbg_SymTable *st, ARMaddress reloc);

/* add <reloc> to the value of all symbols in <st> describing absolute memory

   locations.  The intent is to allow the symbols in a load-time relocating

   image (for example) to be useful.

 */

Dbg_Error Dbg_DeleteSymbols(Dbg_MCState *state, Dbg_SymTable **st);

typedef enum Dbg_LLSymType {

    llst_code,

    llst_code16,

    llst_data,

    llst_const,

    llst_unknown,

    llst_max

} Dbg_LLSymType;

/* Since AIF images contain no type information for low-level symbols, this

   classification is only a guess, and some symbols describing constants will

   incorrectly be described as code or data.

 */

typedef Dbg_Error Dbg_SymProc(

    Dbg_MCState *state,

    const char *symbol, Dbg_LLSymType symtype, ARMaddress value,

    void *arg);

Dbg_Error Dbg_EnumerateLowLevelSymbols(

    Dbg_MCState *state, const char *match, Dbg_SymProc *p,

    void *arg);

/* Call  p(name, value)  for each low level symbol in the tables of <state>

   whose name matches the regular expression <match> (a NULL <match> matches

   any name).  Symbols are enumerated in no particular order.

 */

/*--------------------------------------------------------------------------*/

/* Functions are provided here to allow quick mass access to register values

   for display.  There is no comparable need for quick mass update, so writing

   should be via Assign().

 */

typedef struct Dbg_RegSet {

    ARMword

        user[15],

        pc,

        psr,

        fiq[7],

        spsr_fiq,

        irq[2],

        spsr_irq,

        svc[2],

        spsr_svc,

        abort[2],

        spsr_abort,

        undef[2],

        spsr_undef;

} Dbg_RegSet;

/* bits in the modemask argument for ReadRegisters */

#define Dbg_MM_User     1

#define Dbg_MM_FIQ      2

#define Dbg_MM_IRQ      4

#define Dbg_MM_SVC      8

#define Dbg_MM_Abort 0x10

#define Dbg_MM_Undef 0x20

#define Dbg_MM_System 0x40

Dbg_Error Dbg_ReadRegisters(Dbg_MCState *state, Dbg_RegSet *regs, int modemask);

Dbg_Error Dbg_WriteRegister(Dbg_MCState *state, int rno, int modemask, ARMword val);

int Dbg_StringToMode(const char *name);

int Dbg_ModeToModeMask(ARMword mode);

/* Some implementations of the FP instruction set keep FP values loaded into

   registers in their unconverted format, converting only when necessary.

   Some RDI implementations deliver these values uninterpreted.

   (For the rest, register values will always have type F_Extended).

 */

typedef enum { F_Single, F_Double, F_Extended, F_Packed, /* fpe340 values */

               F_Internal,                               /* new fpe : mostly as extended */

               F_None } Dbg_FPType;

typedef struct { ARMword w[3]; } Dbg_TargetExtendedVal;

typedef struct { ARMword w[3]; } Dbg_TargetPackedVal;

typedef struct { ARMword w[2]; } Dbg_TargetDoubleVal;

typedef struct { ARMword w[1]; } Dbg_TargetFloatVal;

typedef union { Dbg_TargetExtendedVal e; Dbg_TargetPackedVal p;

                Dbg_TargetDoubleVal d; Dbg_TargetFloatVal f; } Dbg_TargetFPVal;

#define TargetSizeof_Extended 12

#define TargetSizeof_Packed   12

#define TargetSizeof_Double   8

#define TargetSizeof_Float    4

typedef struct Dbg_FPRegVal {

     Dbg_FPType type;

     Dbg_TargetFPVal v;

} Dbg_FPRegVal;

typedef struct Dbg_FPRegSet {

    Dbg_FPRegVal f[8];

    ARMword fpsr, fpcr;

} Dbg_FPRegSet;

Dbg_Error Dbg_ReadFPRegisters(Dbg_MCState *state, Dbg_FPRegSet *regs);

Dbg_Error Dbg_WriteFPRegisters(Dbg_MCState *state, int32 mask, Dbg_FPRegSet *regs);

Dbg_Error Dbg_FPRegToDouble(DbleBin *d, Dbg_FPRegVal const *f);

/* Converts from a FP register value (in any format) to a double with

   approximately the same value (or returns Dbg_Err_Overflow)

 */

void Dbg_DoubleToFPReg(Dbg_FPRegVal *f, DbleBin const *d);

/* Converts the double <d> to a Dbg_FPRegVal with type F_Extended */

/*--------------------------------------------------------------------------*/

#include "dbg_cp.h"

Dbg_Error Dbg_DescribeCoPro(Dbg_MCState *state, int cpnum, Dbg_CoProDesc *p);

Dbg_Error Dbg_DescribeCoPro_RDI(Dbg_MCState *state, int cpnum, Dbg_CoProDesc *p);

Dbg_Error Dbg_ReadCPRegisters(Dbg_MCState *state, int cpnum, ARMword *regs);

Dbg_Error Dbg_WriteCPRegisters(Dbg_MCState *state, int cpnum, int32 mask, ARMword *regs);

/*--------------------------------------------------------------------------*/

Dbg_Error Dbg_ReadWords(

    Dbg_MCState *state,

    ARMword *words, ARMaddress addr, unsigned count);

/* Reads a number of (32-bit) words from target store.  The values are in host

   byte order; if they are also to be interpreted as bytes Dbg_SwapByteOrder()

   must be called to convert to target byte order.

 */

Dbg_Error Dbg_WriteWords(

    Dbg_MCState *state,

    ARMaddress addr, const ARMword *words, unsigned count);

/* Writes a number of (32-bit) words to target store.  The values are in host

   byte order (if what is being written is actually a byte string it must be

   converted by Dbg_SwapByteOrder()).

 */

Dbg_Error Dbg_ReadHalf(Dbg_MCState *state, ARMhword *val, ARMaddress addr);

Dbg_Error Dbg_WriteHalf(Dbg_MCState *state, ARMaddress addr, ARMword val);

Dbg_Error Dbg_ReadBytes(Dbg_MCState *state, Dbg_Byte *val, ARMaddress addr, unsigned count);

Dbg_Error Dbg_WriteBytes(Dbg_MCState *state, ARMaddress addr, const Dbg_Byte *val, unsigned count);

void Dbg_HostWords(Dbg_MCState *state, ARMword *words, unsigned wordcount);

/* (A noop unless host and target bytesexes differ) */

ARMword Dbg_HostWord(Dbg_MCState *state, ARMword v);

ARMhword Dbg_HostHalf(Dbg_MCState *state, ARMword v);

/*--------------------------------------------------------------------------*/

/* Types describing various aspects of position within code.

   There are rather a lot of these, in the interests of describing precisely

   what fields must be present (rather than having a single type with many

   fields which may or may not be valid according to context).

 */

typedef struct Dbg_LLPos {

    Dbg_SymTable *st;

    char *llsym;

    ARMaddress offset;

} Dbg_LLPos;

typedef struct Dbg_File {

    Dbg_SymTable *st;

    char *file;

} Dbg_File;

typedef struct Dbg_Line {

    unsigned32 line;      /* linenumber in the file */

    unsigned16 statement, /* within the line (1-based) */

               charpos;   /* ditto */

} Dbg_Line;

/* As an output value from toolbox functions, both statement and charpos are set

   if the version of the debugger tables for the section concerned permits.

   On input, <charpos> is used only if <statement> is 0 (in which case, if

   <charpos> is non-0, Dbg_Err_DbgTableVersion is returned if the version of

   the debugger tables concerned is too early.

 */

typedef struct Dbg_FilePos {

    Dbg_File f;

    Dbg_Line line;

} Dbg_FilePos;

typedef struct Dbg_ProcDesc {

    Dbg_File f;

    char *name;

} Dbg_ProcDesc;

typedef struct Dbg_ProcPos {

    Dbg_ProcDesc p;

    Dbg_Line line;

} Dbg_ProcPos;

/* Support for conversions between position representations */

Dbg_Error Dbg_ProcDescToLine(Dbg_MCState *state, Dbg_ProcDesc *proc, Dbg_Line *line);

/* If proc->f.file is null (and there is just one function proc->name), it is

   updated to point to the name of the file containing (the start of)

   proc->name.

 */

Dbg_Error Dbg_FilePosToProc(Dbg_MCState *state, const Dbg_FilePos *pos, char **procname);

/* Conversions from position representations to and from code addresses */

Dbg_Error Dbg_AddressToProcPos(

    Dbg_MCState *state, ARMaddress addr,

    Dbg_ProcPos *pos);

Dbg_Error Dbg_AddressToLLPos(

    Dbg_MCState *state, ARMaddress addr,

    Dbg_LLPos *pos, Dbg_LLSymType *res_type, int system_names);

Dbg_Error Dbg_ProcPosToAddress(

    Dbg_MCState *state, const Dbg_ProcPos *pos,

    ARMaddress *res);

Dbg_Error Dbg_LLPosToAddress(

    Dbg_MCState *state, const Dbg_LLPos *pos,

    ARMaddress *res);

typedef struct {

    ARMaddress start, end;

} Dbg_AddressRange;

typedef Dbg_Error Dbg_AddressRangeProc(void *arg, int32 first, int32 last, Dbg_AddressRange const *range);

Dbg_Error Dbg_MapAddressRangesForFileRange(

    Dbg_MCState *state,

    Dbg_SymTable *st, const char *f, int32 first, int32 last, Dbg_AddressRangeProc *p, void *arg);

typedef struct Dbg_Environment Dbg_Environment;

/* A Dbg_Environment describes the context required to make sense of a variable

   name and access its value.  Its format is not revealed.  Dbg_Environment

   values are allocated by Dbg_NewEnvironment() and discarded by

   Dbg_DeleteEnvironment().

 */

Dbg_Environment *Dbg_NewEnvironment(Dbg_MCState *state);

void Dbg_DeleteEnvironment(Dbg_MCState *state, Dbg_Environment *env);

Dbg_Error Dbg_StringToEnv(

    Dbg_MCState *state, char *str, Dbg_Environment *resenv,

    int forcontext, Dbg_Environment const *curenv);

Dbg_Error Dbg_ProcPosToEnvironment(

    Dbg_MCState *state, const Dbg_ProcPos *pos, int activation,

    const Dbg_Environment *current, Dbg_Environment *res);

/* Conversion from a position representation to an Dbg_Environment (as required

   to access variable values).  Only a Dbg_ProcPos argument here; other

   representations need to be converted first.

   Returns <res> describing the <activation>th instance of the function

   described by <pos>, up from the stack base if <activation> is negative,

   else down from <current>.

   If this function returns Dbg_Err_ActivationNotPresent, the result

   Dbg_Environment is still valid for accessing non-auto variables.

 */

typedef struct Dbg_DeclSpec Dbg_DeclSpec;

Dbg_Error Dbg_EnvToProcItem(

    Dbg_MCState *state, Dbg_Environment const *env, Dbg_DeclSpec *proc);

Dbg_Error Dbg_ContainingEnvironment(

    Dbg_MCState *state, const Dbg_Environment *context, Dbg_Environment *res);

/* Set <res> to describe the containing function, file if <context> is within

   a top-level function (or error if <context> already describes a file).

 */

/*--------------------------------------------------------------------------*/

/* ASD debug table pointers are not by themselves sufficient description,

   since there's an implied section context.  Hence the DeclSpec and TypeSpec

   structures.

 */

#ifndef Dbg_TypeSpec_Defined

struct Dbg_DeclSpec { void *a; };

#ifdef CALLABLE_COMPILER

typedef void *Dbg_TypeSpec;

/* The intention here is to give an alternative definition for Dbg_BasicType

   which follows.

 */

#define Dbg_T_Void      xDbg_T_Void

#define Dbg_T_Bool      xDbg_T_Bool

#define Dbg_T_SByte     xDbg_T_SByte

#define Dbg_T_SHalf     xDbg_T_Half

#define Dbg_T_SWord     xDbg_T_SWord

#define Dbg_T_UByte     xDbg_T_UByte

#define Dbg_T_UHalf     xDbg_T_UHalf

#define Dbg_T_UWord     xDbg_T_UWord

#define Dbg_T_Float     xDbg_T_Float

#define Dbg_T_Double    xDbg_T_Double

#define Dbg_T_LDouble   xDbg_T_LDouble

#define Dbg_T_Complex   xDbg_T_Complex

#define Dbg_T_DComplex  xDbg_T_DComplex

#define Dbg_T_String    xDbg_T_String

#define Dbg_T_Function  xDbg_T_Function

#define Dbg_BasicType   xDbg_BaiscType

#define Dbg_PrimitiveTypeToTypeSpec xDbg_PrimitiveTypeToTypeSpec

#else

/* We want a Dbg_TypeSpec to be a an opaque type, but of known size (so the

   toolbox's clients can allocate the store to hold one); unfortunately, we

   can do this only by having one definition for the toolbox's clients and

   one (elsewhere) for the toolbox itself.

 */

typedef struct Dbg_TypeSpec Dbg_TypeSpec;

struct Dbg_TypeSpec { void *a; int32 b; };

#endif /* CALLABLE_COMPILER */

typedef enum {

    Dbg_T_Void,

    Dbg_T_Bool,

    Dbg_T_SByte,

    Dbg_T_SHalf,

    Dbg_T_SWord,

    Dbg_T_UByte,

    Dbg_T_UHalf,

    Dbg_T_UWord,

    Dbg_T_Float,

    Dbg_T_Double,

    Dbg_T_LDouble,

    Dbg_T_Complex,

    Dbg_T_DComplex,

    Dbg_T_String,

    Dbg_T_Function

} Dbg_BasicType;

#endif

void Dbg_PrimitiveTypeToTypeSpec(Dbg_TypeSpec *ts, Dbg_BasicType t);

bool Dbg_TypeIsIntegral(Dbg_TypeSpec const *ts);

bool Dbg_TypeIsPointer(Dbg_TypeSpec const *ts);

bool Dbg_TypeIsFunction(Dbg_TypeSpec const *ts);

bool Dbg_PruneType(Dbg_TypeSpec *tsres, Dbg_TypeSpec const *ts);

/* Return to tsres a version of ts which has been pruned by the removal of all

   toplevel typedefs. Result is YES if the result has changed.

 */

typedef Dbg_Error Dbg_FileProc(Dbg_MCState *state, const char *name, const Dbg_DeclSpec *procdef, void *arg);

Dbg_Error Dbg_EnumerateFiles(Dbg_MCState *state, Dbg_SymTable *st, Dbg_FileProc *p, void *arg);

/* The top level for a high level enumerate.  Lower levels are performed by

   EnumerateDeclarations (below).

 */

typedef enum {

    ds_Invalid,

    ds_Type,

    ds_Var,

    ds_Proc,

    ds_Enum,

    ds_Function,

    ds_Label

} Dbg_DeclSort;

Dbg_DeclSort Dbg_SortOfDeclSpec(Dbg_DeclSpec const *decl);

char *Dbg_NameOfDeclSpec(Dbg_DeclSpec const *decl);

Dbg_TypeSpec Dbg_TypeSpecOfDeclSpec(Dbg_DeclSpec const *decl);

typedef enum {

    cs_None,

    cs_Extern,

    cs_Static,

    cs_Auto,

    cs_Reg,

    cs_Var,

    cs_Farg,

    cs_Fcarg,

    cs_Local,

    cs_Filtered,

    cs_Globalreg

} Dbg_StgClass;

Dbg_StgClass Dbg_StgClassOfDeclSpec(Dbg_DeclSpec const *decl);

bool Dbg_VarsAtSameAddress(Dbg_DeclSpec const *d1, Dbg_DeclSpec const *d2);

bool Dbg_VarsDecribedForDeclSpec(Dbg_DeclSpec const *decl);

int Dbg_ArgCountOfDeclSpec(Dbg_DeclSpec const *decl);

typedef struct Dbg_DComplex { DbleBin r, i; } Dbg_DComplex;

typedef union Dbg_ConstantVal {

    int32 l;

    unsigned32 u;

    DbleBin d;

    Dbg_DComplex fc;

    ARMaddress a;

    char *s;

} Dbg_ConstantVal;

typedef struct Dbg_Constant {

    Dbg_TypeSpec type;

    Dbg_ConstantVal val;

} Dbg_Constant;

typedef enum Dbg_ValueSort {

    vs_register,

    vs_store,

    vs_constant,

    vs_local,

    vs_filtered,

    vs_none,

    vs_error

} Dbg_ValueSort;

/* vs_local allows the use of symbol table entries to describe entities within

   the debugger's own address space, accessed in the same way as target

   variables.

   vs_filtered describes entities which may be read or written only via an

   access function (eg r15)

 */

#define fpr_base 16

/* There's only one register ValueSort (reflecting asd table StgClass);

   fp register n is encoded as register n+fpr_base.

 */

typedef struct Dbg_Value Dbg_Value;

typedef Dbg_Error Dbg_AccessFn(Dbg_MCState *state, int write, Dbg_Value *self, Dbg_Constant *c);

/* <write> == 0: read a vs_filtered value, updating the value self.

   <write> == 1: update a vs_filtered value, with the value described by c.

   <self> allows use of the same Dbg_AccessFn for several different entities

   (using different val.f.id fields).

 */

typedef Dbg_Error Dbg_FormatFn(int decode, char *b, ARMword *valp, void *formatarg);

typedef struct { Dbg_AccessFn *f; int id; } Dbg_AccessFnRec;

struct Dbg_Value {

    Dbg_TypeSpec type;

    Dbg_ValueSort sort;

    Dbg_FormatFn *formatp;