src/debug/debugger.cc

/*
 *      HT Editor
 *      debugger.cc
 *
 *      Copyright (C) 2003 Stefan Weyergraf
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License version 2 as
 *      published by the Free Software Foundation.
 *
 *      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.
 */
#define HAVE_DEBUGGER

#include <stdio.h>

#include "system/display.h"
#include "tools/except.h"
#include "tools/snprintf.h"
#include "tools/debug.h"
#include "debugger.h"
#include "parsehelper.h"
#include "stdfuncs.h"
#include "cpu/cpu.h"

#include "debug/ppcdis.h"

#ifdef HAVE_DEBUGGER
#include "cpu/cpu_generic/ppc_mmu.h"
#endif

/*
 *      A function
 */
SInt64 *Function::evalInteger() const
{
        EvalType type = getReturnType();
        switch (type) {
                case ET_INTEGER: throw NotImplementedException(HERE);
                case ET_FLOAT: {
                        Float *f = evalFloat();
                        SInt64 *i = new SInt64((sint64)f->value);
                        delete f;
                        return i;
                        break;
                }
                case ET_STRING: {
                        String *s = evalString();
                        uint64 u;
                        SInt64 *i;
                        if (s->toInt64(u, 10)) {
                                i = new SInt64(u);
                        } else {
                                i = new SInt64(0);
                        }
                        delete s;
                        return i;
                        break;
                }
                case ET_VARARGS: /* may-not-happen */
                        ASSERT(0);
                        break;
        }
        return NULL;
}

Float *Function::evalFloat() const
{
        EvalType type = getReturnType();
        switch (type) {
                case ET_INTEGER: {
                        SInt64 *u = evalInteger();
                        Float *f = new Float(u->value);
                        delete u;
                        return f;
                }
                case ET_FLOAT: throw NotImplementedException(HERE);
                case ET_STRING: {
                        throw NotImplementedException(HERE);
                        // but it should be
                        break;
                }
                case ET_VARARGS: /* may-not-happen */
                        ASSERT(0);
                        break;
        }
        return NULL;
}

String *Function::evalString() const
{
        EvalType type = getReturnType();
        switch (type) {
                case ET_INTEGER: {
                        SInt64 *u = evalInteger();
                        String *s = new String();
                        s->assignFormat("%qd", u->value);
                        delete u;
                        return s;
                }
                case ET_FLOAT: {
                        Float *f = evalFloat();
                        String *s = new String();
                        s->assignFormat("%f", f->value);
                        delete f;
                        return s;
                }
                case ET_STRING: throw NotImplementedException(HERE);
                case ET_VARARGS: /* may-not-happen */
                        ASSERT(0);
                        break;
        }
        return NULL;
}

uint Function::getArgCount() const
{
        return 0;
}

Function *Function::getArg(uint i) const
{
        throw IllegalArgumentException(HERE);
}

void Function::setArg(uint i, Function *f)
{
        throw IllegalArgumentException(HERE);
}

/*
 *      A constant integer function
 */
SInt64Function::SInt64Function(sint64 v)
{
        value = v;
}

EvalType SInt64Function::getReturnType() const
{
        return ET_INTEGER;
}

SInt64 *SInt64Function::evalInteger() const
{
        return new SInt64(value);
}

/*
 *      A GPR
 */
GPRFunction::GPRFunction(int number)
{
        mNumber = number;
}

EvalType GPRFunction::getReturnType() const
{
        return ET_INTEGER;
}

SInt64 *GPRFunction::evalInteger() const
{
#ifdef HAVE_DEBUGGER
        return new SInt64(gCPU.gpr[mNumber]);
#else
        return NULL;
#endif
}

FPRFunction::FPRFunction(int number)
{
        mNumber = number;
}

EvalType FPRFunction::getReturnType() const
{
        return ET_FLOAT;
}

Float *FPRFunction::evalFloat() const
{
#ifdef HAVE_DEBUGGER
        double_uint64 du = { gCPU.fpr[mNumber] };
        return new Float(du.d);
#else
        return NULL;
#endif
}

UInt32PFunction::UInt32PFunction(uint32 *aValue)
{
        mValue = aValue;
}

EvalType UInt32PFunction::getReturnType() const
{
        return ET_INTEGER;      
}

SInt64 *UInt32PFunction::evalInteger() const
{
        return new SInt64(*mValue);
}

/*
 *      A constant float function
 */
FloatFunction::FloatFunction(double v)
{
        value = v;
}

EvalType FloatFunction::getReturnType() const
{
        return ET_FLOAT;
}

Float *FloatFunction::evalFloat() const
{
        return new Float(value);
}

/*
 *      A constant string function
 */
StringFunction::StringFunction(const byte *str, int len)
: value(str, len)
{
}

EvalType StringFunction::getReturnType() const
{
        return ET_STRING;
}

String *StringFunction::evalString() const
{
        return value.clone();
}

/**
 *      A parametrized function (implementation helper)
 */

PFunction::PFunction()
: mArgs(true)
{
}

uint PFunction::getArgCount() const
{
        return mArgs.count();
}

Function *PFunction::getArg(uint i) const
{
        Function *r = (Function*)mArgs[i];
        if (!r) throw IllegalArgumentException(HERE);
        return r;
}

void PFunction::setArg(uint i, Function *f)
{
        mArgs.forceSetByIdx(i, f);
}

/*
 *      An expression parser
 */

enum protoMatchQuality {
        PMQ_EXACT,
        PMQ_OK,
        PMQ_NOT_OK
};

static bool convertsInto(EvalType from, EvalType to)
{
        switch (from) {
                case ET_INTEGER:
                        return true;
                case ET_FLOAT:
                        return (to != ET_INTEGER);
                case ET_STRING:
                        return (to == ET_STRING);
                case ET_VARARGS:
                        /* may-not-happen */
                        break;
        }
        return false;
}

static protoMatchQuality matchFunctionPrototype(const Enumerator &params, uint count, EvalType *decl)
{
        if (params.count() < count) return PMQ_NOT_OK;
        uint pcount = params.count();
        if (count && (decl[count-1] == ET_VARARGS)) {
                count--;
                pcount = count;
        }
        if (count == pcount) {
                protoMatchQuality r = PMQ_EXACT;
                for (uint i=0; i<count; i++) {
                        Function *f = (Function*)params[i];
                        if (!convertsInto(f->getReturnType(), decl[i])) return PMQ_NOT_OK;
                        if (f->getReturnType() != decl[i]) r = PMQ_OK;
                }
                return r;
        }
        return PMQ_NOT_OK;
}

static Function *matchFunctionByDesc(const String &name, const Enumerator &params, FunctionDesc *descs)
{
        protoMatchQuality bestPMQ = PMQ_NOT_OK;
        FunctionDesc *bestMatch = NULL;
        while (descs->name) {
                if (strcmp(descs->name, name.contentChar()) == 0) {
                        protoMatchQuality pmq = matchFunctionPrototype(params, descs->declparam_count, descs->declparam);
                        if (pmq == PMQ_EXACT) {
                                // if its exact take it immediately
                                bestPMQ = PMQ_EXACT;
                                bestMatch = descs;
                                break;
                        } else if ((bestPMQ == PMQ_NOT_OK) && (pmq == PMQ_OK)) {
                                // try to take the first thats ok
                                bestPMQ = PMQ_OK;
                                bestMatch = descs;
                        }
                }
                descs++;
        }
        if (bestPMQ != PMQ_NOT_OK) {
                Function *r = bestMatch->creator();
                for (uint i=0; i<params.count(); i++) {
                        r->setArg(i, (Function*)params[i]);
                }
                return r;
        }
        return NULL;
}

Watch::Watch(String *aName, Function *aFunc)
{
        mName = aName->clone();
        f = aFunc;
}

Watch::~Watch()
{
        delete mName;
        delete f;
}

int Watch::toString(char *buf, int buflen) const
{
        SInt64 *sint = f->evalInteger();
        String *s = f->evalString();
        int ret = ht_snprintf(buf, buflen, "watch: '%y' = %y (0x%08x)", mName, s, (uint32)sint->value);
        delete sint;
        delete s;
        return ret;
}

Debugger::Debugger()
{
        mWatches = new LinkedList(true);
#ifdef HAVE_DEBUGGER
        savedCPUState = gCPU;
#endif
        mUseColors = true;
}

Debugger::~Debugger()
{
        delete mWatches;
}

Function *Debugger::eval_scalarToFunction(eval_scalar &s)
{
        switch (s.type) {
        case SCALAR_INT:
                return new SInt64Function(s.scalar.integer.value);
        case SCALAR_FLOAT:
                return new FloatFunction(s.scalar.floatnum.value);
        case SCALAR_REG:
                switch (s.scalar.reg.type) {
                case REG_GPR:
                        return new GPRFunction(s.scalar.reg.num);
                case REG_FPR:
                        return new FPRFunction(s.scalar.reg.num);
#ifdef HAVE_DEBUGGER
                case REG_PC:
                        return new UInt32PFunction(&gCPU.pc);
                case REG_LR:
                        return new UInt32PFunction(&gCPU.lr);
                case REG_CR:
                        return new UInt32PFunction(&gCPU.cr);
                case REG_CTR:
                        return new UInt32PFunction(&gCPU.ctr);
                case REG_XER:
                        return new UInt32PFunction(&gCPU.xer);
                case REG_MSR:
                        return new UInt32PFunction(&gCPU.msr);
                case REG_SRR0:
                        return new UInt32PFunction(&gCPU.srr[0]);
                case REG_SRR1:
                        return new UInt32PFunction(&gCPU.srr[1]);
#endif
                }
                break;
        case SCALAR_STR:
                return new StringFunction((byte*)s.scalar.str.value, s.scalar.str.len);
        case SCALAR_FUNCTION: {
                Array p(false);
                for (int i=0; i<s.scalar.function.param_count; i++) {
                        p += eval_scalarToFunction(s.scalar.function.params[i]);
                }
                return matchFunction(s.scalar.function.name, p);
        }
        case SCALAR_EMPTY:
                return NULL;
        case SCALAR_ANY:
        case SCALAR_VARARGS:
                /* may-not-happen */
                break;
        }
        /* may-not-happen */
        ASSERT(0);
        return NULL;
}

Function *Debugger::matchFunction(const String &name, const Enumerator &params)
{
        Function *r = matchFunctionByDesc(name, params, gStdEvalFunctions);
        if (!r) {
                String msg;
                msg.assignFormat("parse/eval: no function matching signature '%y(", &name);
                for (uint i=0; i<params.count(); i++) {
                        Function *f = (Function*)params[i];
                        switch (f->getReturnType()) {
                                case ET_INTEGER:
                                        msg.append("integer");
                                        break;
                                case ET_FLOAT:
                                        msg.append("float");
                                        break;
                                case ET_STRING:
                                        msg.append("string");
                                        break;
                                case ET_VARARGS:
                                        /* may-not-happen */
                                        ASSERT(0);
                                        break;
                        }
                        if (i+1<params.count()) msg.append(",");
                }
                msg.append(")'");
                throw MsgException(msg.contentChar());
        }
        return r;
}

inline static void disasm(uint32 code, uint32 ea, char *result)
{
        PPCDisassembler dis;
        CPU_ADDR addr;
        addr.addr32.offset = ea;
        strcpy(result, dis.str(dis.decode((byte*)&code, 4, addr), 0));
}

void Debugger::dump()
{
#ifdef HAVE_DEBUGGER
        int r = 0;
        const char *hiColor, *loColor;
        if (mUseColors) {
                hiColor = "\e[33;1m";
                loColor = "\e[37;1m";
        } else {
                hiColor = "";
                loColor = "";
        }
        for (int i=0; i<8; i++) {
                for (int j=0; j<4; j++) {
                        ht_printf("r%02d: %s%08x%s ", r, (savedCPUState.gpr[r] != gCPU.gpr[r])?hiColor:loColor , gCPU.gpr[r], loColor);
                        r++;
                }
                ht_printf("\n");
        }
/*      ht_printf("dbatu0: %08x dbatl0: %08x\n", gCPU.dbatu[0], gCPU.dbatl[0]);
        ht_printf("dbatu1: %08x dbatl1: %08x\n", gCPU.dbatu[1], gCPU.dbatl[1]);
        ht_printf("dbatu2: %08x dbatl2: %08x\n", gCPU.dbatu[2], gCPU.dbatl[2]);
        ht_printf("dbatu3: %08x dbatl3: %08x\n", gCPU.dbatu[3], gCPU.dbatl[3]);*/
        ht_printf("cr:  %s%08x%s xer: %s%08x%s lr:  %s%08x%s ctr: %s%08x%s\n", 
        (savedCPUState.cr != gCPU.cr)?hiColor:loColor, gCPU.cr, loColor,
        (savedCPUState.xer != gCPU.xer)?hiColor:loColor, gCPU.xer, loColor,
        (savedCPUState.lr != gCPU.lr)?hiColor:loColor, gCPU.lr, loColor,
        (savedCPUState.ctr != gCPU.ctr)?hiColor:loColor, gCPU.ctr, loColor);
//      ht_printf("msr: %08x sv:    %d srr1: %08x\n", gCPU.msr, (gCPU.msr & MSR_PR) ? 0 : 1, gCPU.srr[1]);
                
        foreach(Watch, w, *mWatches, {
                ht_printf("%y\n", w);
        });

        char disstr[256];
        disasm(gCPU.current_opc, gCPU.pc, disstr);
        ht_printf("@%08x: %08x %s\n", gCPU.pc, gCPU.current_opc, disstr);
        
        if (disstr[0] == 'b') {
                int i = 1;
                while (disstr[i] && disstr[i] != ' ') i++;
                if (disstr[i-1] != 'l') {
                        mForceSinglestep = true;
                }
        }
#endif
}

static void displayFPRs()
{
#if 0
        for (int i=0; i<32; i++) {
                ppc_double dd;
                ppc_fpu_unpack_double(dd, gCPU.fpr[i]);
                double d = ppc_fpu_get_double(dd);
                ht_printf("fr%02d: ", i);
                switch (dd.type) {
                case ppc_fpr_norm:
                        ht_printf("%c%qb * 2^%d = %f", dd.s?'-':'+', &dd.m, dd.e, d);
                        break;
                case ppc_fpr_zero:
                        ht_printf("%c0.0", dd.s?'-':'+');
                        break;
                case ppc_fpr_Inf:
                        ht_printf("%cInf", dd.s?'-':'+');
                        break;
                case ppc_fpr_NaN:               
                        ht_printf("%cNaN", dd.s?'-':'+');
                        break;
                }
                ht_printf("\n");
                ht_printf("   = %qx\n", &gCPU.fpr[i]);
        }
#endif
}

static bool translateAddress(uint32 ea, uint32 &pa, bool error)
{
#ifdef HAVE_DEBUGGER
        if (ppc_effective_to_physical(ea, PPC_MMU_READ|PPC_MMU_NO_EXC|PPC_MMU_SV, pa)) {
                if (error) ht_printf("cant translate effective address %08x\n", ea);
                return false;
        } else {
                return true;
        }
#endif
}

bool Debugger::parse(const String &str)
{
        eval_command s;
        bool ret = false;
        memset(&s, 0, sizeof s);
        if (!eval_parse(&s, str.contentChar())) {
                char *str2;
                int pos;
                if (!get_eval_error(&str2, &pos)) {
                        str2 = "internal error! please report!";
                        pos = 0;
                }
                throw MsgfException("error: %s at %d", str2, pos);
        } else {
                Function *params[3];
                for (int i=0; i<s.paramcount; i++) {
                        params[i] = eval_scalarToFunction(s.param[i]);
                }
                switch (s.type) {
                case COMMAND_NOP: break;
                case COMMAND_PRINT: {
                        String *s = params[0]->evalString();
                        SInt64 *sint = params[0]->evalInteger();
                        ht_printf("= %y (0x%08x)\n", s, sint->value);
                        delete s;
                        delete sint;
                        break;
                }
                case COMMAND_REGS:
                        dump();
                        break;
                case COMMAND_FLOATS: 
                        displayFPRs();
                        break;
                case COMMAND_SETREG: {
                        SInt64 *sint = params[1]->evalInteger();
                        switch (s.param[0].scalar.reg.type) {
#ifdef HAVE_DEBUGGER
                        case REG_GPR:
                                gCPU.gpr[s.param[0].scalar.reg.num] = sint->value;
                                break;
                        case REG_FPR: {
                                Float *f = params[1]->evalFloat();
                                double_uint64 du;
                                du.d = f->value;
                                gCPU.fpr[s.param[0].scalar.reg.num] = du.u;
                                delete f;
                                break;
                        }
                        case REG_PC:
                                gCPU.pc = gCPU.npc = sint->value;
                                break;
                        case REG_CR:
                                gCPU.cr = sint->value;
                                break;
                        case REG_LR:
                                gCPU.lr = sint->value;
                                break;
                        case REG_CTR:
                                gCPU.ctr = sint->value;
                                break;
                        case REG_XER:
                                gCPU.xer = sint->value;
                                break;
                        case REG_MSR:
                                gCPU.msr = sint->value;
                                break;
                        case REG_SRR0:
                                gCPU.srr[0] = sint->value;
                                break;
                        case REG_SRR1:
                                gCPU.srr[1] = sint->value;
                                break;
#endif                          
                        }
                        delete sint;
                        break;
                }
#ifdef HAVE_DEBUGGER
                case COMMAND_LIST_BREAK: 
                        ht_printf("Breakpoint %d at %08x\n", 1, gBreakpoint);
                        ht_printf("Breakpoint %d at %08x\n", 2, gBreakpoint2);
                        break;
                case COMMAND_BREAK: {
                        SInt64 *sint = params[0]->evalInteger();
                        gBreakpoint2 = sint->value;
                        ht_printf("Breakpoint %d at %08x\n", 2, gBreakpoint2);
                        break;
                }
                case COMMAND_STEP:
                        ppc_set_singlestep_nonverbose(true);
                        ret = true;
                        break;
                case COMMAND_NEXT:
                        gBreakpoint = gCPU.npc;
                        if (mForceSinglestep) {
                                ppc_set_singlestep_nonverbose(true);
                        } else {
                                gBreakpoint = gCPU.npc;
                                ppc_set_singlestep_nonverbose(false);
                        }
                        ret = true;
                        break;
                case COMMAND_CONTINUE:
                        ppc_set_singlestep_nonverbose(false);
                        ret = true;
                        break;
                case COMMAND_QUIT:
                        ppc_cpu_stop();
                        ppc_set_singlestep_nonverbose(false);
                        ret = true;
                        break;
#endif
                case COMMAND_E2P: {
                        SInt64 *sint = params[0]->evalInteger();
                        uint32 pa, ea = sint->value;
                        if (translateAddress(ea, pa, true)) {
                                ht_printf("effective: %08x, physical: %08x\n", ea, pa);
                        }
                        delete sint;
                        break;
                }
                case COMMAND_INSPECT_BYTE: {
                        SInt64 *sint = params[0]->evalInteger();
                        uint32 pa, ea = sint->value;
                        uint8 v;
                        if (translateAddress(ea, pa, true)) {
#ifdef HAVE_DEBUGGER
                                if (ppc_read_physical_byte(pa, v)) {
                                        ht_printf("cant read at physical address %08x\n", pa);
                                } else {
                                        ht_printf("@%08x: %02x   (physical: %08x)\n", ea, v, pa);
                                }
#endif
                        }
                        delete sint;
                        break;
                }
                case COMMAND_INSPECT_HALF: {
                        SInt64 *sint = params[0]->evalInteger();
                        uint32 pa, ea = sint->value;
                        uint16 v;
                        if (translateAddress(ea, pa, true)) {
#ifdef HAVE_DEBUGGER
                                if (ppc_read_physical_half(pa, v)) { 
                                        ht_printf("cant read at physical address %08x\n", pa);
                                } else {
                                        ht_printf("@%08x: %04x   (physical: %08x)\n", ea, v, pa);
                                }
#endif                          
                        }
                        delete sint;
                        break;
                }
                case COMMAND_INSPECT_WORD: {
                        SInt64 *sint = params[0]->evalInteger();
                        uint32 pa, ea = sint->value;
                        delete sint;
                        uint32 v;
                        if (translateAddress(ea, pa, true)) {
#ifdef HAVE_DEBUGGER
                                if (ppc_read_physical_word(pa, v)) { 
                                        ht_printf("cant read at physical address %08x\n", pa);
                                } else {
                                        ht_printf("@%08x: %08x   (physical: %08x)\n", ea, v, pa);
                                }
#endif                          
                        }
                        break;
                }
                case COMMAND_INSPECT_DWORD: {
                        SInt64 *sint = params[0]->evalInteger();
                        uint32 pa, ea = sint->value;
                        delete sint;
                        uint64 v;
                        if (translateAddress(ea, pa, true)) {
#ifdef HAVE_DEBUGGER
                                if (ppc_read_physical_dword(pa, v)) { 
                                        ht_printf("cant read at physical address %08x\n", pa);
                                } else {
                                        ht_printf("@%08x: %016x   (physical: %08x)\n", ea, v, pa);
                                }
#endif                          
                        }
                        break;
                }
                case COMMAND_INSPECT_STRING: {
                        SInt64 *sint = params[0]->evalInteger();
                        uint32 pa, ea = sint->value;
                        delete sint;
                        byte *v;
                        if (translateAddress(ea, pa, true)) {
#ifdef HAVE_DEBUGGER
                                if (ppc_direct_physical_memory_handle(pa, v)) { 
                                        ht_printf("cant read at physical address %08x\n", pa);
                                } else {
                                        ht_printf("@%08x: '%s'   (physical: %08x)\n", ea, v, pa);
                                }
#endif                          
                        }
                        break;
                }
                case COMMAND_INSPECT_MEM: {
                        SInt64 *sint = params[0]->evalInteger();
                        uint32 pa, ea = sint->value;
                        uint32 count = 0x100;
                        delete sint;
                        byte v;
                        int x = 0;
                        char buf[80];
                        memset(buf, ' ', sizeof buf);
                        buf[79] = 0;
                        buf[sprintf(buf, "@%08x", ea)] = ' ';
                        while (count) {
                                if (translateAddress(ea, pa, true)) {
#ifdef HAVE_DEBUGGER
                                        if (ppc_read_physical_byte(pa, v)) { 
                                                ht_printf("cant read at physical address %08x\n", pa);
                                                break;
                                        } else {
//                                              ht_printf("@%08x: '%s'   (physical: %08x)\n", ea, v, pa);
                                                sprintf(buf+10+(x%16)*3, "%02x", v);
                                                buf[10+(x%16)*3+2] = ' ';
                                                sprintf(buf+10+16*3+x%16, "%c", (v>=32 && v<=127)?v:' ');
                                                buf[10+16*3+x%16+1] = ' ';
                                        }
#endif                                  
                                } else {
                                        break;
                                }
                                count--;
                                ea++;
                                x++;
                                if (x % 16 == 0) {
                                        ht_printf("%s\n", buf);
                                        memset(buf, ' ', sizeof buf);
                                        buf[79] = 0;
                                        buf[sprintf(buf, "@%08x", ea)] = ' ';
                                }
                        }
                        if (x % 16) ht_printf("%s\n", buf);
                        break;
                }
                case COMMAND_WATCH: {
                        String *name;
                        if (params[1]) {
                                name = params[1]->evalString();
                        } else {
                                name = new String("noname");
                        }
                        mWatches->insert(new Watch(name, eval_scalarToFunction(s.param[0])));
                        break;
                }
                case COMMAND_WATCH_BYTE:
                case COMMAND_WATCH_HALF:
                case COMMAND_WATCH_WORD:
                case COMMAND_WATCH_DWORD:
                case COMMAND_DELETE_WATCH:
                case COMMAND_DUMP:
                case COMMAND_DISASM: {
#ifdef HAVE_DEBUGGER
                        uint32 ea, pa;
                        if (params[0]) {
                                SInt64 *sint;
                                sint = params[0]->evalInteger();
                                ea = sint->value & ~3;
                                delete sint;
                        } else {
                                ea = gCPU.pc;
                        }
                        uint32 count;
                        if (params[1]) {
                                SInt64 *sint;
                                sint = params[1]->evalInteger();
                                count = sint->value;
                                delete sint;
                        } else {
                                count = 16;
                        }
                        while (count) {
                                uint32 opc;
                                if (translateAddress(ea, pa, true)) {
                                        if (ppc_read_physical_word(pa, opc)) {
                                                ht_printf("cant read at physical address %08x\n", pa);
                                                break;
                                        }
                                } else {
                                        break;
                                }
                                char disstr[256];
                                disasm(opc, gCPU.pc, disstr);
                                ht_printf("@%08x: %08x %s\n", ea, opc, disstr);
                                count--;
                                ea+=4;
                        }
#endif                  
                        break;
                }
                case COMMAND_HELP:
                        ht_printf("bist du jeck?\n");
                        break;
                }
                for (int i=0; i<s.paramcount; i++) {
                        delete params[i];
                }
        }
        return ret;
}

void Debugger::enter()
{
        char buf[1024];
        bool quit = false;
        if (mAlwaysShowRegs) dump();

        /*
         *      If current instruction is a branch instruction
         *      which doesnt set LR we force single step
         */
        mForceSinglestep = false;
        char disstr[256];
#ifdef HAVE_DEBUGGER
        disasm(gCPU.current_opc, gCPU.pc, disstr);
#endif                  
        if (disstr[0] == 'b') {
                int i = 1;
                while (disstr[i] && disstr[i] != ' ') i++;
                if (disstr[i-1] != 'l') {
                        mForceSinglestep = true;
                }
        }
#ifdef HAVE_DEBUGGER
        gBreakpoint = 0;
#endif                  
        
        while (!quit) {
                printf("> ");
                fgets(buf, sizeof buf, stdin);
                try {
                        quit = parse(buf);
                } catch (const Exception &e) {
                        String s;
                        ht_printf("%y\n", &e.reason(s));
                        continue;
                }
        }
#ifdef HAVE_DEBUGGER
        savedCPUState = gCPU; 
#endif
}

#include "configparser.h"
void debugger_init_config()
{
        gConfig->acceptConfigEntryString("debugger_exec", false);
}
1	dpavlin	1	/*
2			* HT Editor
3			* debugger.cc
4			*
5			* Copyright (C) 2003 Stefan Weyergraf
6			*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License version 2 as
9			* published by the Free Software Foundation.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19			*/
20			#define HAVE_DEBUGGER
21
22			#include <stdio.h>
23
24			#include "system/display.h"
25			#include "tools/except.h"
26			#include "tools/snprintf.h"
27			#include "tools/debug.h"
28			#include "debugger.h"
29			#include "parsehelper.h"
30			#include "stdfuncs.h"
31			#include "cpu/cpu.h"
32
33			#include "debug/ppcdis.h"
34
35			#ifdef HAVE_DEBUGGER
36			#include "cpu/cpu_generic/ppc_mmu.h"
37			#endif
38
39			/*
40			* A function
41			*/
42			SInt64 *Function::evalInteger() const
43			{
44			EvalType type = getReturnType();
45			switch (type) {
46			case ET_INTEGER: throw NotImplementedException(HERE);
47			case ET_FLOAT: {
48			Float *f = evalFloat();
49			SInt64 *i = new SInt64((sint64)f->value);
50			delete f;
51			return i;
52			break;
53			}
54			case ET_STRING: {
55			String *s = evalString();
56			uint64 u;
57			SInt64 *i;
58			if (s->toInt64(u, 10)) {
59			i = new SInt64(u);
60			} else {
61			i = new SInt64(0);
62			}
63			delete s;
64			return i;
65			break;
66			}
67			case ET_VARARGS: /* may-not-happen */
68			ASSERT(0);
69			break;
70			}
71			return NULL;
72			}
73
74			Float *Function::evalFloat() const
75			{
76			EvalType type = getReturnType();
77			switch (type) {
78			case ET_INTEGER: {
79			SInt64 *u = evalInteger();
80			Float *f = new Float(u->value);
81			delete u;
82			return f;
83			}
84			case ET_FLOAT: throw NotImplementedException(HERE);
85			case ET_STRING: {
86			throw NotImplementedException(HERE);
87			// but it should be
88			break;
89			}
90			case ET_VARARGS: /* may-not-happen */
91			ASSERT(0);
92			break;
93			}
94			return NULL;
95			}
96
97			String *Function::evalString() const
98			{
99			EvalType type = getReturnType();
100			switch (type) {
101			case ET_INTEGER: {
102			SInt64 *u = evalInteger();
103			String *s = new String();
104			s->assignFormat("%qd", u->value);
105			delete u;
106			return s;
107			}
108			case ET_FLOAT: {
109			Float *f = evalFloat();
110			String *s = new String();
111			s->assignFormat("%f", f->value);
112			delete f;
113			return s;
114			}
115			case ET_STRING: throw NotImplementedException(HERE);
116			case ET_VARARGS: /* may-not-happen */
117			ASSERT(0);
118			break;
119			}
120			return NULL;
121			}
122
123			uint Function::getArgCount() const
124			{
125			return 0;
126			}
127
128			Function *Function::getArg(uint i) const
129			{
130			throw IllegalArgumentException(HERE);
131			}
132
133			void Function::setArg(uint i, Function *f)
134			{
135			throw IllegalArgumentException(HERE);
136			}
137
138			/*
139			* A constant integer function
140			*/
141			SInt64Function::SInt64Function(sint64 v)
142			{
143			value = v;
144			}
145
146			EvalType SInt64Function::getReturnType() const
147			{
148			return ET_INTEGER;
149			}
150
151			SInt64 *SInt64Function::evalInteger() const
152			{
153			return new SInt64(value);
154			}
155
156			/*
157			* A GPR
158			*/
159			GPRFunction::GPRFunction(int number)
160			{
161			mNumber = number;
162			}
163
164			EvalType GPRFunction::getReturnType() const
165			{
166			return ET_INTEGER;
167			}
168
169			SInt64 *GPRFunction::evalInteger() const
170			{
171			#ifdef HAVE_DEBUGGER
172			return new SInt64(gCPU.gpr[mNumber]);
173			#else
174			return NULL;
175			#endif
176			}
177
178			FPRFunction::FPRFunction(int number)
179			{
180			mNumber = number;
181			}
182
183			EvalType FPRFunction::getReturnType() const
184			{
185			return ET_FLOAT;
186			}
187
188			Float *FPRFunction::evalFloat() const
189			{
190			#ifdef HAVE_DEBUGGER
191			double_uint64 du = { gCPU.fpr[mNumber] };
192			return new Float(du.d);
193			#else
194			return NULL;
195			#endif
196			}
197
198			UInt32PFunction::UInt32PFunction(uint32 *aValue)
199			{
200			mValue = aValue;
201			}
202
203			EvalType UInt32PFunction::getReturnType() const
204			{
205			return ET_INTEGER;
206			}
207
208			SInt64 *UInt32PFunction::evalInteger() const
209			{
210			return new SInt64(*mValue);
211			}
212
213			/*
214			* A constant float function
215			*/
216			FloatFunction::FloatFunction(double v)
217			{
218			value = v;
219			}
220
221			EvalType FloatFunction::getReturnType() const
222			{
223			return ET_FLOAT;
224			}
225
226			Float *FloatFunction::evalFloat() const
227			{
228			return new Float(value);
229			}
230
231			/*
232			* A constant string function
233			*/
234			StringFunction::StringFunction(const byte *str, int len)
235			: value(str, len)
236			{
237			}
238
239			EvalType StringFunction::getReturnType() const
240			{
241			return ET_STRING;
242			}
243
244			String *StringFunction::evalString() const
245			{
246			return value.clone();
247			}
248
249			/**
250			* A parametrized function (implementation helper)
251			*/
252
253			PFunction::PFunction()
254			: mArgs(true)
255			{
256			}
257
258			uint PFunction::getArgCount() const
259			{
260			return mArgs.count();
261			}
262
263			Function *PFunction::getArg(uint i) const
264			{
265			Function r = (Function)mArgs[i];
266			if (!r) throw IllegalArgumentException(HERE);
267			return r;
268			}
269
270			void PFunction::setArg(uint i, Function *f)
271			{
272			mArgs.forceSetByIdx(i, f);
273			}
274
275			/*
276			* An expression parser
277			*/
278
279			enum protoMatchQuality {
280			PMQ_EXACT,
281			PMQ_OK,
282			PMQ_NOT_OK
283			};
284
285			static bool convertsInto(EvalType from, EvalType to)
286			{
287			switch (from) {
288			case ET_INTEGER:
289			return true;
290			case ET_FLOAT:
291			return (to != ET_INTEGER);
292			case ET_STRING:
293			return (to == ET_STRING);
294			case ET_VARARGS:
295			/* may-not-happen */
296			break;
297			}
298			return false;
299			}
300
301			static protoMatchQuality matchFunctionPrototype(const Enumerator &params, uint count, EvalType *decl)
302			{
303			if (params.count() < count) return PMQ_NOT_OK;
304			uint pcount = params.count();
305			if (count && (decl[count-1] == ET_VARARGS)) {
306			count--;
307			pcount = count;
308			}
309			if (count == pcount) {
310			protoMatchQuality r = PMQ_EXACT;
311			for (uint i=0; i<count; i++) {
312			Function f = (Function)params[i];
313			if (!convertsInto(f->getReturnType(), decl[i])) return PMQ_NOT_OK;
314			if (f->getReturnType() != decl[i]) r = PMQ_OK;
315			}
316			return r;
317			}
318			return PMQ_NOT_OK;
319			}
320
321			static Function matchFunctionByDesc(const String &name, const Enumerator &params, FunctionDesc descs)
322			{
323			protoMatchQuality bestPMQ = PMQ_NOT_OK;
324			FunctionDesc *bestMatch = NULL;
325			while (descs->name) {
326			if (strcmp(descs->name, name.contentChar()) == 0) {
327			protoMatchQuality pmq = matchFunctionPrototype(params, descs->declparam_count, descs->declparam);
328			if (pmq == PMQ_EXACT) {
329			// if its exact take it immediately
330			bestPMQ = PMQ_EXACT;
331			bestMatch = descs;
332			break;
333			} else if ((bestPMQ == PMQ_NOT_OK) && (pmq == PMQ_OK)) {
334			// try to take the first thats ok
335			bestPMQ = PMQ_OK;
336			bestMatch = descs;
337			}
338			}
339			descs++;
340			}
341			if (bestPMQ != PMQ_NOT_OK) {
342			Function *r = bestMatch->creator();
343			for (uint i=0; i<params.count(); i++) {
344			r->setArg(i, (Function*)params[i]);
345			}
346			return r;
347			}
348			return NULL;
349			}
350
351			Watch::Watch(String aName, Function aFunc)
352			{
353			mName = aName->clone();
354			f = aFunc;
355			}
356
357			Watch::~Watch()
358			{
359			delete mName;
360			delete f;
361			}
362
363			int Watch::toString(char *buf, int buflen) const
364			{
365			SInt64 *sint = f->evalInteger();
366			String *s = f->evalString();
367			int ret = ht_snprintf(buf, buflen, "watch: '%y' = %y (0x%08x)", mName, s, (uint32)sint->value);
368			delete sint;
369			delete s;
370			return ret;
371			}
372
373			Debugger::Debugger()
374			{
375			mWatches = new LinkedList(true);
376			#ifdef HAVE_DEBUGGER
377			savedCPUState = gCPU;
378			#endif
379			mUseColors = true;
380			}
381
382			Debugger::~Debugger()
383			{
384			delete mWatches;
385			}
386
387			Function *Debugger::eval_scalarToFunction(eval_scalar &s)
388			{
389			switch (s.type) {
390			case SCALAR_INT:
391			return new SInt64Function(s.scalar.integer.value);
392			case SCALAR_FLOAT:
393			return new FloatFunction(s.scalar.floatnum.value);
394			case SCALAR_REG:
395			switch (s.scalar.reg.type) {
396			case REG_GPR:
397			return new GPRFunction(s.scalar.reg.num);
398			case REG_FPR:
399			return new FPRFunction(s.scalar.reg.num);
400			#ifdef HAVE_DEBUGGER
401			case REG_PC:
402			return new UInt32PFunction(&gCPU.pc);
403			case REG_LR:
404			return new UInt32PFunction(&gCPU.lr);
405			case REG_CR:
406			return new UInt32PFunction(&gCPU.cr);
407			case REG_CTR:
408			return new UInt32PFunction(&gCPU.ctr);
409			case REG_XER:
410			return new UInt32PFunction(&gCPU.xer);
411			case REG_MSR:
412			return new UInt32PFunction(&gCPU.msr);
413			case REG_SRR0:
414			return new UInt32PFunction(&gCPU.srr[0]);
415			case REG_SRR1:
416			return new UInt32PFunction(&gCPU.srr[1]);
417			#endif
418			}
419			break;
420			case SCALAR_STR:
421			return new StringFunction((byte*)s.scalar.str.value, s.scalar.str.len);
422			case SCALAR_FUNCTION: {
423			Array p(false);
424			for (int i=0; i<s.scalar.function.param_count; i++) {
425			p += eval_scalarToFunction(s.scalar.function.params[i]);
426			}
427			return matchFunction(s.scalar.function.name, p);
428			}
429			case SCALAR_EMPTY:
430			return NULL;
431			case SCALAR_ANY:
432			case SCALAR_VARARGS:
433			/* may-not-happen */
434			break;
435			}
436			/* may-not-happen */
437			ASSERT(0);
438			return NULL;
439			}
440
441			Function *Debugger::matchFunction(const String &name, const Enumerator &params)
442			{
443			Function *r = matchFunctionByDesc(name, params, gStdEvalFunctions);
444			if (!r) {
445			String msg;
446			msg.assignFormat("parse/eval: no function matching signature '%y(", &name);
447			for (uint i=0; i<params.count(); i++) {
448			Function f = (Function)params[i];
449			switch (f->getReturnType()) {
450			case ET_INTEGER:
451			msg.append("integer");
452			break;
453			case ET_FLOAT:
454			msg.append("float");
455			break;
456			case ET_STRING:
457			msg.append("string");
458			break;
459			case ET_VARARGS:
460			/* may-not-happen */
461			ASSERT(0);
462			break;
463			}
464			if (i+1<params.count()) msg.append(",");
465			}
466			msg.append(")'");
467			throw MsgException(msg.contentChar());
468			}
469			return r;
470			}
471
472			inline static void disasm(uint32 code, uint32 ea, char *result)
473			{
474			PPCDisassembler dis;
475			CPU_ADDR addr;
476			addr.addr32.offset = ea;
477			strcpy(result, dis.str(dis.decode((byte*)&code, 4, addr), 0));
478			}
479
480			void Debugger::dump()
481			{
482			#ifdef HAVE_DEBUGGER
483			int r = 0;
484			const char hiColor, loColor;
485			if (mUseColors) {
486			hiColor = "\e[33;1m";
487			loColor = "\e[37;1m";
488			} else {
489			hiColor = "";
490			loColor = "";
491			}
492			for (int i=0; i<8; i++) {
493			for (int j=0; j<4; j++) {
494			ht_printf("r%02d: %s%08x%s ", r, (savedCPUState.gpr[r] != gCPU.gpr[r])?hiColor:loColor , gCPU.gpr[r], loColor);
495			r++;
496			}
497			ht_printf("\n");
498			}
499			/* ht_printf("dbatu0: %08x dbatl0: %08x\n", gCPU.dbatu[0], gCPU.dbatl[0]);
500			ht_printf("dbatu1: %08x dbatl1: %08x\n", gCPU.dbatu[1], gCPU.dbatl[1]);
501			ht_printf("dbatu2: %08x dbatl2: %08x\n", gCPU.dbatu[2], gCPU.dbatl[2]);
502			ht_printf("dbatu3: %08x dbatl3: %08x\n", gCPU.dbatu[3], gCPU.dbatl[3]);*/
503			ht_printf("cr: %s%08x%s xer: %s%08x%s lr: %s%08x%s ctr: %s%08x%s\n",
504			(savedCPUState.cr != gCPU.cr)?hiColor:loColor, gCPU.cr, loColor,
505			(savedCPUState.xer != gCPU.xer)?hiColor:loColor, gCPU.xer, loColor,
506			(savedCPUState.lr != gCPU.lr)?hiColor:loColor, gCPU.lr, loColor,
507			(savedCPUState.ctr != gCPU.ctr)?hiColor:loColor, gCPU.ctr, loColor);
508			// ht_printf("msr: %08x sv: %d srr1: %08x\n", gCPU.msr, (gCPU.msr & MSR_PR) ? 0 : 1, gCPU.srr[1]);
509
510			foreach(Watch, w, *mWatches, {
511			ht_printf("%y\n", w);
512			});
513
514			char disstr[256];
515			disasm(gCPU.current_opc, gCPU.pc, disstr);
516			ht_printf("@%08x: %08x %s\n", gCPU.pc, gCPU.current_opc, disstr);
517
518			if (disstr[0] == 'b') {
519			int i = 1;
520			while (disstr[i] && disstr[i] != ' ') i++;
521			if (disstr[i-1] != 'l') {
522			mForceSinglestep = true;
523			}
524			}
525			#endif
526			}
527
528			static void displayFPRs()
529			{
530			#if 0
531			for (int i=0; i<32; i++) {
532			ppc_double dd;
533			ppc_fpu_unpack_double(dd, gCPU.fpr[i]);
534			double d = ppc_fpu_get_double(dd);
535			ht_printf("fr%02d: ", i);
536			switch (dd.type) {
537			case ppc_fpr_norm:
538			ht_printf("%c%qb * 2^%d = %f", dd.s?'-':'+', &dd.m, dd.e, d);
539			break;
540			case ppc_fpr_zero:
541			ht_printf("%c0.0", dd.s?'-':'+');
542			break;
543			case ppc_fpr_Inf:
544			ht_printf("%cInf", dd.s?'-':'+');
545			break;
546			case ppc_fpr_NaN:
547			ht_printf("%cNaN", dd.s?'-':'+');
548			break;
549			}
550			ht_printf("\n");
551			ht_printf(" = %qx\n", &gCPU.fpr[i]);
552			}
553			#endif
554			}
555
556			static bool translateAddress(uint32 ea, uint32 &pa, bool error)
557			{
558			#ifdef HAVE_DEBUGGER
559			if (ppc_effective_to_physical(ea, PPC_MMU_READ\|PPC_MMU_NO_EXC\|PPC_MMU_SV, pa)) {
560			if (error) ht_printf("cant translate effective address %08x\n", ea);
561			return false;
562			} else {
563			return true;
564			}
565			#endif
566			}
567
568			bool Debugger::parse(const String &str)
569			{
570			eval_command s;
571			bool ret = false;
572			memset(&s, 0, sizeof s);
573			if (!eval_parse(&s, str.contentChar())) {
574			char *str2;
575			int pos;
576			if (!get_eval_error(&str2, &pos)) {
577			str2 = "internal error! please report!";
578			pos = 0;
579			}
580			throw MsgfException("error: %s at %d", str2, pos);
581			} else {
582			Function *params[3];
583			for (int i=0; i<s.paramcount; i++) {
584			params[i] = eval_scalarToFunction(s.param[i]);
585			}
586			switch (s.type) {
587			case COMMAND_NOP: break;
588			case COMMAND_PRINT: {
589			String *s = params[0]->evalString();
590			SInt64 *sint = params[0]->evalInteger();
591			ht_printf("= %y (0x%08x)\n", s, sint->value);
592			delete s;
593			delete sint;
594			break;
595			}
596			case COMMAND_REGS:
597			dump();
598			break;
599			case COMMAND_FLOATS:
600			displayFPRs();
601			break;
602			case COMMAND_SETREG: {
603			SInt64 *sint = params[1]->evalInteger();
604			switch (s.param[0].scalar.reg.type) {
605			#ifdef HAVE_DEBUGGER
606			case REG_GPR:
607			gCPU.gpr[s.param[0].scalar.reg.num] = sint->value;
608			break;
609			case REG_FPR: {
610			Float *f = params[1]->evalFloat();
611			double_uint64 du;
612			du.d = f->value;
613			gCPU.fpr[s.param[0].scalar.reg.num] = du.u;
614			delete f;
615			break;
616			}
617			case REG_PC:
618			gCPU.pc = gCPU.npc = sint->value;
619			break;
620			case REG_CR:
621			gCPU.cr = sint->value;
622			break;
623			case REG_LR:
624			gCPU.lr = sint->value;
625			break;
626			case REG_CTR:
627			gCPU.ctr = sint->value;
628			break;
629			case REG_XER:
630			gCPU.xer = sint->value;
631			break;
632			case REG_MSR:
633			gCPU.msr = sint->value;
634			break;
635			case REG_SRR0:
636			gCPU.srr[0] = sint->value;
637			break;
638			case REG_SRR1:
639			gCPU.srr[1] = sint->value;
640			break;
641			#endif
642			}
643			delete sint;
644			break;
645			}
646			#ifdef HAVE_DEBUGGER
647			case COMMAND_LIST_BREAK:
648			ht_printf("Breakpoint %d at %08x\n", 1, gBreakpoint);
649			ht_printf("Breakpoint %d at %08x\n", 2, gBreakpoint2);
650			break;
651			case COMMAND_BREAK: {
652			SInt64 *sint = params[0]->evalInteger();
653			gBreakpoint2 = sint->value;
654			ht_printf("Breakpoint %d at %08x\n", 2, gBreakpoint2);
655			break;
656			}
657			case COMMAND_STEP:
658			ppc_set_singlestep_nonverbose(true);
659			ret = true;
660			break;
661			case COMMAND_NEXT:
662			gBreakpoint = gCPU.npc;
663			if (mForceSinglestep) {
664			ppc_set_singlestep_nonverbose(true);
665			} else {
666			gBreakpoint = gCPU.npc;
667			ppc_set_singlestep_nonverbose(false);
668			}
669			ret = true;
670			break;
671			case COMMAND_CONTINUE:
672			ppc_set_singlestep_nonverbose(false);
673			ret = true;
674			break;
675			case COMMAND_QUIT:
676			ppc_cpu_stop();
677			ppc_set_singlestep_nonverbose(false);
678			ret = true;
679			break;
680			#endif
681			case COMMAND_E2P: {
682			SInt64 *sint = params[0]->evalInteger();
683			uint32 pa, ea = sint->value;
684			if (translateAddress(ea, pa, true)) {
685			ht_printf("effective: %08x, physical: %08x\n", ea, pa);
686			}
687			delete sint;
688			break;
689			}
690			case COMMAND_INSPECT_BYTE: {
691			SInt64 *sint = params[0]->evalInteger();
692			uint32 pa, ea = sint->value;
693			uint8 v;
694			if (translateAddress(ea, pa, true)) {
695			#ifdef HAVE_DEBUGGER
696			if (ppc_read_physical_byte(pa, v)) {
697			ht_printf("cant read at physical address %08x\n", pa);
698			} else {
699			ht_printf("@%08x: %02x (physical: %08x)\n", ea, v, pa);
700			}
701			#endif
702			}
703			delete sint;
704			break;
705			}
706			case COMMAND_INSPECT_HALF: {
707			SInt64 *sint = params[0]->evalInteger();
708			uint32 pa, ea = sint->value;
709			uint16 v;
710			if (translateAddress(ea, pa, true)) {
711			#ifdef HAVE_DEBUGGER
712			if (ppc_read_physical_half(pa, v)) {
713			ht_printf("cant read at physical address %08x\n", pa);
714			} else {
715			ht_printf("@%08x: %04x (physical: %08x)\n", ea, v, pa);
716			}
717			#endif
718			}
719			delete sint;
720			break;
721			}
722			case COMMAND_INSPECT_WORD: {
723			SInt64 *sint = params[0]->evalInteger();
724			uint32 pa, ea = sint->value;
725			delete sint;
726			uint32 v;
727			if (translateAddress(ea, pa, true)) {
728			#ifdef HAVE_DEBUGGER
729			if (ppc_read_physical_word(pa, v)) {
730			ht_printf("cant read at physical address %08x\n", pa);
731			} else {
732			ht_printf("@%08x: %08x (physical: %08x)\n", ea, v, pa);
733			}
734			#endif
735			}
736			break;
737			}
738			case COMMAND_INSPECT_DWORD: {
739			SInt64 *sint = params[0]->evalInteger();
740			uint32 pa, ea = sint->value;
741			delete sint;
742			uint64 v;
743			if (translateAddress(ea, pa, true)) {
744			#ifdef HAVE_DEBUGGER
745			if (ppc_read_physical_dword(pa, v)) {
746			ht_printf("cant read at physical address %08x\n", pa);
747			} else {
748			ht_printf("@%08x: %016x (physical: %08x)\n", ea, v, pa);
749			}
750			#endif
751			}
752			break;
753			}
754			case COMMAND_INSPECT_STRING: {
755			SInt64 *sint = params[0]->evalInteger();
756			uint32 pa, ea = sint->value;
757			delete sint;
758			byte *v;
759			if (translateAddress(ea, pa, true)) {
760			#ifdef HAVE_DEBUGGER
761			if (ppc_direct_physical_memory_handle(pa, v)) {
762			ht_printf("cant read at physical address %08x\n", pa);
763			} else {
764			ht_printf("@%08x: '%s' (physical: %08x)\n", ea, v, pa);
765			}
766			#endif
767			}
768			break;
769			}
770			case COMMAND_INSPECT_MEM: {
771			SInt64 *sint = params[0]->evalInteger();
772			uint32 pa, ea = sint->value;
773			uint32 count = 0x100;
774			delete sint;
775			byte v;
776			int x = 0;
777			char buf[80];
778			memset(buf, ' ', sizeof buf);
779			buf[79] = 0;
780			buf[sprintf(buf, "@%08x", ea)] = ' ';
781			while (count) {
782			if (translateAddress(ea, pa, true)) {
783			#ifdef HAVE_DEBUGGER
784			if (ppc_read_physical_byte(pa, v)) {
785			ht_printf("cant read at physical address %08x\n", pa);
786			break;
787			} else {
788			// ht_printf("@%08x: '%s' (physical: %08x)\n", ea, v, pa);
789			sprintf(buf+10+(x%16)*3, "%02x", v);
790			buf[10+(x%16)*3+2] = ' ';
791			sprintf(buf+10+16*3+x%16, "%c", (v>=32 && v<=127)?v:' ');
792			buf[10+16*3+x%16+1] = ' ';
793			}
794			#endif
795			} else {
796			break;
797			}
798			count--;
799			ea++;
800			x++;
801			if (x % 16 == 0) {
802			ht_printf("%s\n", buf);
803			memset(buf, ' ', sizeof buf);
804			buf[79] = 0;
805			buf[sprintf(buf, "@%08x", ea)] = ' ';
806			}
807			}
808			if (x % 16) ht_printf("%s\n", buf);
809			break;
810			}
811			case COMMAND_WATCH: {
812			String *name;
813			if (params[1]) {
814			name = params[1]->evalString();
815			} else {
816			name = new String("noname");
817			}
818			mWatches->insert(new Watch(name, eval_scalarToFunction(s.param[0])));
819			break;
820			}
821			case COMMAND_WATCH_BYTE:
822			case COMMAND_WATCH_HALF:
823			case COMMAND_WATCH_WORD:
824			case COMMAND_WATCH_DWORD:
825			case COMMAND_DELETE_WATCH:
826			case COMMAND_DUMP:
827			case COMMAND_DISASM: {
828			#ifdef HAVE_DEBUGGER
829			uint32 ea, pa;
830			if (params[0]) {
831			SInt64 *sint;
832			sint = params[0]->evalInteger();
833			ea = sint->value & ~3;
834			delete sint;
835			} else {
836			ea = gCPU.pc;
837			}
838			uint32 count;
839			if (params[1]) {
840			SInt64 *sint;
841			sint = params[1]->evalInteger();
842			count = sint->value;
843			delete sint;
844			} else {
845			count = 16;
846			}
847			while (count) {
848			uint32 opc;
849			if (translateAddress(ea, pa, true)) {
850			if (ppc_read_physical_word(pa, opc)) {
851			ht_printf("cant read at physical address %08x\n", pa);
852			break;
853			}
854			} else {
855			break;
856			}
857			char disstr[256];
858			disasm(opc, gCPU.pc, disstr);
859			ht_printf("@%08x: %08x %s\n", ea, opc, disstr);
860			count--;
861			ea+=4;
862			}
863			#endif
864			break;
865			}
866			case COMMAND_HELP:
867			ht_printf("bist du jeck?\n");
868			break;
869			}
870			for (int i=0; i<s.paramcount; i++) {
871			delete params[i];
872			}
873			}
874			return ret;
875			}
876
877			void Debugger::enter()
878			{
879			char buf[1024];
880			bool quit = false;
881			if (mAlwaysShowRegs) dump();
882
883			/*
884			* If current instruction is a branch instruction
885			* which doesnt set LR we force single step
886			*/
887			mForceSinglestep = false;
888			char disstr[256];
889			#ifdef HAVE_DEBUGGER
890			disasm(gCPU.current_opc, gCPU.pc, disstr);
891			#endif
892			if (disstr[0] == 'b') {
893			int i = 1;
894			while (disstr[i] && disstr[i] != ' ') i++;
895			if (disstr[i-1] != 'l') {
896			mForceSinglestep = true;
897			}
898			}
899			#ifdef HAVE_DEBUGGER
900			gBreakpoint = 0;
901			#endif
902
903			while (!quit) {
904			printf("> ");
905			fgets(buf, sizeof buf, stdin);
906			try {
907			quit = parse(buf);
908			} catch (const Exception &e) {
909			String s;
910			ht_printf("%y\n", &e.reason(s));
911			continue;
912			}
913			}
914			#ifdef HAVE_DEBUGGER
915			savedCPUState = gCPU;
916			#endif
917			}
918
919			#include "configparser.h"
920			void debugger_init_config()
921			{
922			gConfig->acceptConfigEntryString("debugger_exec", false);
923			}