mirror of
https://github.com/ksherlock/mpw.git
synced 2024-11-22 15:31:50 +00:00
902 lines
16 KiB
C++
902 lines
16 KiB
C++
/*
|
|
* Copyright (c) 2013, Kelvin W Sherlock
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice, this
|
|
* list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
|
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#include <cstdint>
|
|
#include <cctype>
|
|
#include <cstring>
|
|
#include <cstdlib>
|
|
|
|
#include <signal.h>
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <array>
|
|
#include <unordered_set>
|
|
#include <unordered_map>
|
|
|
|
#include <bitset>
|
|
|
|
#include <readline/readline.h>
|
|
|
|
|
|
#include "loader.h"
|
|
#include "address_map.h"
|
|
|
|
#include "debugger.h"
|
|
|
|
#include <cpu/defs.h>
|
|
#include <cpu/CpuModule.h>
|
|
|
|
#include <macos/traps.h>
|
|
#include <macos/sysequ.h>
|
|
|
|
#include <mpw/mpw.h>
|
|
|
|
namespace {
|
|
|
|
const uint32_t kGlobalSize = 0x10000;
|
|
|
|
bool sigInt = false;
|
|
bool memBreak = false;
|
|
void sigIntHandler(int)
|
|
{
|
|
sigInt = true;
|
|
}
|
|
|
|
AddressMap brkMap; // address breaks
|
|
AddressMap rbrkMap; // read breaks.
|
|
AddressMap wbrkMap; // write breaks.
|
|
ToolMap tbrkMap; // tool breaks.
|
|
|
|
std::unordered_map<std::string, uint32_t> envMap;
|
|
|
|
|
|
void hexdump(const uint8_t *data, ssize_t size, uint32_t address = 0)
|
|
{
|
|
const char *HexMap = "0123456789abcdef";
|
|
|
|
char buffer1[16 * 3 + 1 + 1];
|
|
char buffer2[16 + 1];
|
|
ssize_t offset = 0;
|
|
unsigned i, j;
|
|
|
|
|
|
while(size > 0)
|
|
{
|
|
std::memset(buffer1, ' ', sizeof(buffer1));
|
|
std::memset(buffer2, ' ', sizeof(buffer2));
|
|
|
|
unsigned linelen = (unsigned)std::min(size, (ssize_t)16);
|
|
|
|
|
|
for (i = 0, j = 0; i < linelen; i++)
|
|
{
|
|
unsigned x = data[i];
|
|
buffer1[j++] = HexMap[x >> 4];
|
|
buffer1[j++] = HexMap[x & 0x0f];
|
|
j++;
|
|
if (i == 7) j++;
|
|
|
|
// isascii not part of std:: and may be a macro.
|
|
buffer2[i] = isascii(x) && std::isprint(x) ? x : '.';
|
|
|
|
}
|
|
|
|
buffer1[sizeof(buffer1)-1] = 0;
|
|
buffer2[sizeof(buffer2)-1] = 0;
|
|
|
|
|
|
std::printf("%08x:\t%s\t%s\n", address + (unsigned)offset, buffer1, buffer2);
|
|
offset += 16;
|
|
data += 16;
|
|
size -= 16;
|
|
}
|
|
std::printf("\n");
|
|
}
|
|
|
|
|
|
void printMacsbug(uint32_t pc, uint32_t opcode)
|
|
{
|
|
|
|
unsigned mboffset;
|
|
switch(opcode)
|
|
{
|
|
case 0x4E75: // rts
|
|
case 0x4ED0: // jmp (a0)
|
|
mboffset = 2;
|
|
break;
|
|
case 0x4E74: // rtd #
|
|
mboffset = 4;
|
|
break;
|
|
default:
|
|
return;
|
|
break;
|
|
}
|
|
|
|
|
|
pc += mboffset;
|
|
// check for MacsBug name after rts.
|
|
std::string s;
|
|
unsigned b = Debug::ReadByte(pc);
|
|
if (b > 0x80 && b < 0xa0)
|
|
{
|
|
b -= 0x80;
|
|
pc++;
|
|
s.reserve(b);
|
|
for (unsigned i = 0; i < b; ++i)
|
|
{
|
|
s.push_back(Debug::ReadByte(pc++));
|
|
}
|
|
printf("%s\n", s.c_str());
|
|
}
|
|
// could also be in the form 0x80 \p string.
|
|
|
|
}
|
|
|
|
|
|
// TODO -- state indicator for code/data
|
|
uint32_t disasm(uint32_t pc, uint16_t *op = nullptr)
|
|
{
|
|
|
|
static char strings[4][256];
|
|
|
|
if (pc >= Flags.memorySize)
|
|
{
|
|
if (op) *op = 0;
|
|
return pc;
|
|
}
|
|
|
|
uint16_t opcode = Debug::ReadWord(pc);
|
|
if (op) *op = opcode;
|
|
|
|
if ((opcode & 0xf000) == 0xa000)
|
|
{
|
|
|
|
const char *name;
|
|
|
|
name = TrapName(opcode);
|
|
|
|
if (name)
|
|
{
|
|
printf("$%08X %-51s ; %04X\n", pc, name, opcode);
|
|
}
|
|
else
|
|
{
|
|
printf("$%08X Tool #$%04X ; %04X\n",
|
|
pc, opcode, opcode);
|
|
}
|
|
|
|
pc += 2;
|
|
return pc;
|
|
}
|
|
|
|
for (unsigned j = 0; j < 4; ++j) strings[j][0] = 0;
|
|
|
|
uint32_t newpc = cpuDisOpcode(pc, strings[0], strings[1], strings[2], strings[3]);
|
|
printf("%s %-10s %-40s ; %s\n", strings[0], strings[2], strings[3], strings[1]);
|
|
|
|
printMacsbug(pc, opcode);
|
|
|
|
return newpc;
|
|
}
|
|
|
|
|
|
|
|
bool step(bool trace)
|
|
{
|
|
// return false to break (toolbreak, address break, etc.)
|
|
|
|
uint16_t op;
|
|
memBreak = false;
|
|
|
|
cpuExecuteInstruction();
|
|
|
|
uint32_t pc = cpuGetPC();
|
|
if (trace) disasm(pc, &op);
|
|
else op = Debug::ReadWord(pc);
|
|
|
|
if (Flags.traceMacsbug && !trace)
|
|
printMacsbug(pc, op);
|
|
|
|
// will this also be set by an interrupt?
|
|
if (cpuGetStop())
|
|
{
|
|
if (!trace) disasm(pc);
|
|
printf("CPU stopped\n");
|
|
return false;
|
|
}
|
|
|
|
if (sigInt)
|
|
{
|
|
if (!trace) disasm(pc);
|
|
printf("^C break\n");
|
|
sigInt = false;
|
|
return false;
|
|
}
|
|
|
|
if (memBreak)
|
|
{
|
|
printf("Memory break\n");
|
|
memBreak = false;
|
|
return false;
|
|
}
|
|
|
|
|
|
// check for pc breaks
|
|
if (brkMap.lookup(pc))
|
|
{
|
|
if (!trace) disasm(pc);
|
|
printf("Address break: $%08x\n", pc);
|
|
return false;
|
|
}
|
|
|
|
// todo -- instruction break for rts /rtn
|
|
|
|
// check for toolbreaks.
|
|
if ((op & 0xf000) == 0xa000)
|
|
{
|
|
if (tbrkMap.lookup(op))
|
|
{
|
|
if (!trace) disasm(pc);
|
|
printf("Tool break: $%04x\n", op);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (pc > Flags.memorySize)
|
|
{
|
|
printf("PC out of range\n");
|
|
return false;
|
|
}
|
|
|
|
uint32_t sp = cpuGetAReg(7);
|
|
if (sp < Flags.stackRange.first)
|
|
{
|
|
printf("Stack overflow error\n");
|
|
return false;
|
|
}
|
|
|
|
if (sp > Flags.stackRange.second)
|
|
{
|
|
printf("Stack underflow error\n");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void MemoryLogger(uint32_t address, int size, int readWrite, uint32_t value)
|
|
{
|
|
|
|
if (address < kGlobalSize && Flags.traceGlobals)
|
|
{
|
|
const char *name = GlobalName(address);
|
|
if (!name) name = "unknown";
|
|
|
|
fprintf(stdout, "%-20s %08x - ", name, address);
|
|
if (readWrite)
|
|
{
|
|
fprintf(stdout, " write %d bytes", size);
|
|
switch(size)
|
|
{
|
|
case 1:
|
|
fprintf(stdout, " [%02x]\n", value);
|
|
break;
|
|
case 2:
|
|
fprintf(stdout, " [%04x]\n", value);
|
|
break;
|
|
case 3:
|
|
fprintf(stdout, " [%06x]\n", value);
|
|
break;
|
|
case 4:
|
|
fprintf(stdout, " [%08x]\n", value);
|
|
break;
|
|
default:
|
|
fprintf(stdout, "\n");
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fprintf(stdout, " read %d bytes\n", size);
|
|
}
|
|
}
|
|
|
|
|
|
// check for memory breaks.
|
|
if (readWrite)
|
|
{
|
|
// todo -- what if writing 1 byte 4-bit address?
|
|
// todo -- if not single stepping at time of break, should
|
|
// disasm the prev pc before printing.
|
|
|
|
|
|
if (!wbrkMap.lookup(address)) return;
|
|
|
|
printf("Write $%08x\n", address);
|
|
// todo -- print previous value, old value.
|
|
|
|
memBreak = true;
|
|
}
|
|
else
|
|
{
|
|
if (!rbrkMap.lookup(address)) return;
|
|
|
|
printf("Read $%08x\n", address);
|
|
|
|
memBreak = true;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
#pragma mark - Debugger
|
|
|
|
namespace Debug {
|
|
|
|
uint32_t ReadLong(uint32_t address)
|
|
{
|
|
uint32_t tmp = 0;
|
|
for (unsigned i = 0; i < 4; ++i)
|
|
{
|
|
if (address < Flags.memorySize)
|
|
tmp = (tmp << 8) + Flags.memory[address++];
|
|
}
|
|
|
|
return tmp;
|
|
}
|
|
|
|
|
|
uint16_t ReadWord(uint32_t address)
|
|
{
|
|
uint16_t tmp = 0;
|
|
for (unsigned i = 0; i < 2; ++i)
|
|
{
|
|
if (address < Flags.memorySize)
|
|
tmp = (tmp << 8) + Flags.memory[address++];
|
|
}
|
|
|
|
return tmp;
|
|
}
|
|
|
|
uint8_t ReadByte(uint32_t address)
|
|
{
|
|
if (address < Flags.memorySize)
|
|
return Flags.memory[address];
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
void Help()
|
|
{
|
|
printf("help\n");
|
|
printf("break expression\n");
|
|
printf("step\n");
|
|
printf("continue\n");
|
|
printf("\n");
|
|
printf("print expression\n");
|
|
printf("list expression\n");
|
|
printf("dump expression\n");
|
|
printf("register=expression\n");
|
|
printf("\n");
|
|
printf("registers: a0-7, d0-7, pc, sp, fp, csr\n");
|
|
printf("\n");
|
|
}
|
|
|
|
|
|
void Print(uint32_t data)
|
|
{
|
|
|
|
// 32-bit unsigned int
|
|
printf("$%08x", data);
|
|
|
|
|
|
|
|
// 32-but unsigned
|
|
printf(" %12u", data);
|
|
|
|
// 32-bit signed int
|
|
int32_t negValue = 0;
|
|
if (data & 0x80000000)
|
|
negValue = (int32_t)data;
|
|
|
|
if ((data & 0xffff8000) == 0x8000)
|
|
negValue = (int16_t)data;
|
|
|
|
if (negValue != 0)
|
|
printf(" %12d", negValue);
|
|
else printf(" ");
|
|
|
|
|
|
|
|
|
|
// print binary value
|
|
{
|
|
std::string bins;
|
|
bins.reserve(32);
|
|
|
|
bins.push_back('%');
|
|
|
|
if (data > 0xffff)
|
|
{
|
|
for (unsigned i = 0, mask = 0x80000000; i < 16; ++i, mask >>= 1)
|
|
bins.push_back( data & mask ? '1' : '0');
|
|
}
|
|
|
|
if (data > 0xff)
|
|
{
|
|
for (unsigned i = 0, mask = 0x8000; i < 8; ++i, mask >>= 1)
|
|
bins.push_back( data & mask ? '1' : '0');
|
|
}
|
|
|
|
for (unsigned i = 0, mask = 0x80; i < 8; ++i, mask >>= 1)
|
|
bins.push_back( data & mask ? '1' : '0');
|
|
|
|
|
|
printf(" %33s", bins.c_str());
|
|
}
|
|
|
|
|
|
|
|
// 4-cc code? 2-cc code? 1-cc code?
|
|
char tmp[5];
|
|
int bits = 0;
|
|
tmp[0] = (data >> 24) & 0xff;
|
|
tmp[1] = (data >> 16) & 0xff;
|
|
tmp[2] = (data >> 8) & 0xff;
|
|
tmp[3] = (data >> 0) & 0xff;
|
|
tmp[4] = 0;
|
|
|
|
if (isprint(tmp[0])) bits |= (1 << 0);
|
|
if (isprint(tmp[1])) bits |= (1 << 1);
|
|
if (isprint(tmp[2])) bits |= (1 << 2);
|
|
if (isprint(tmp[3])) bits |= (1 << 3);
|
|
|
|
switch(bits)
|
|
{
|
|
case 0x0f:
|
|
printf(" '%s'", tmp);
|
|
break;
|
|
|
|
case 0x0e:
|
|
if (data <= 0xffffff)
|
|
printf(" '%s'", tmp + 1);
|
|
break;
|
|
|
|
case 0x0c:
|
|
if (data <= 0xffff)
|
|
printf(" '%s'", tmp + 2);
|
|
break;
|
|
|
|
case 0x08:
|
|
if (data <= 0xff)
|
|
printf(" '%s'", tmp + 3);
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
void Dump(uint32_t start, int size)
|
|
{
|
|
// TODO -- if no address, use previous address.
|
|
// TODO -- support range?
|
|
|
|
|
|
if (size <= 0) return;
|
|
|
|
uint32_t end = start + size;
|
|
|
|
if (start >= Flags.memorySize) return;
|
|
|
|
end = std::min(end, Flags.memorySize);
|
|
size = end - start;
|
|
|
|
hexdump(Flags.memory + start, size, start);
|
|
}
|
|
|
|
|
|
|
|
// grr... need separate count/range options.
|
|
void List(uint32_t pc, int count)
|
|
{
|
|
// TODO -- if no address, use previous address.
|
|
if (pc & 0x01)
|
|
{
|
|
printf("address is not aligned: $%08x\n", pc);
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
if (pc >= Flags.memorySize) break;
|
|
pc = disasm(pc);
|
|
}
|
|
}
|
|
|
|
void List(uint32_t pc, uint32_t endpc)
|
|
{
|
|
if (endpc < pc) return;
|
|
|
|
if (pc & 0x01)
|
|
{
|
|
printf("address is not aligned: $%08x\n", pc);
|
|
return;
|
|
}
|
|
|
|
while (pc <= endpc)
|
|
{
|
|
if (pc >= Flags.memorySize) break;
|
|
pc = disasm(pc);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void PrintRegisters()
|
|
{
|
|
char srbits[20];
|
|
|
|
uint16_t sr = cpuGetSR();
|
|
|
|
srbits[0] = sr & (1 << 15) ? 'T' : ' ';
|
|
srbits[1] = sr & (1 << 14) ? 'T' : ' ';
|
|
srbits[2] = sr & (1 << 13) ? 'S' : ' ';
|
|
srbits[3] = sr & (1 << 12) ? 'M' : ' ';
|
|
srbits[4] = ' ';
|
|
srbits[5] = sr & (1 << 10) ? 'I' : ' ';
|
|
srbits[6] = sr & (1 << 9) ? 'I' : ' ';
|
|
srbits[7] = sr & (1 << 8) ? 'I' : ' ';
|
|
srbits[8] = ' ';
|
|
srbits[9] = ' ';
|
|
srbits[10] = ' ';
|
|
srbits[11] = sr & (1 << 4) ? 'X' : ' ';
|
|
srbits[12] = sr & (1 << 3) ? 'N' : ' ';
|
|
srbits[13] = sr & (1 << 2) ? 'Z' : ' ';
|
|
srbits[14] = sr & (1 << 1) ? 'V' : ' ';
|
|
srbits[15] = sr & (1 << 0) ? 'C' : ' ';
|
|
srbits[16] = 0;
|
|
|
|
|
|
printf(" 0 1 2 3 4 5 6 7\n");
|
|
printf("D: %08x %08x %08x %08x %08x %08x %08x %08x\n",
|
|
cpuGetDReg(0), cpuGetDReg(1), cpuGetDReg(2), cpuGetDReg(3),
|
|
cpuGetDReg(4), cpuGetDReg(5), cpuGetDReg(6), cpuGetDReg(7)
|
|
|
|
);
|
|
|
|
printf("A: %08x %08x %08x %08x %08x %08x %08x %08x\n",
|
|
cpuGetAReg(0), cpuGetAReg(1), cpuGetAReg(2), cpuGetAReg(3),
|
|
cpuGetAReg(4), cpuGetAReg(5), cpuGetAReg(6), cpuGetAReg(7)
|
|
);
|
|
|
|
printf("PC: %08X CSR: %04x %s\n", cpuGetPC(), sr, srbits);
|
|
|
|
}
|
|
|
|
|
|
void ToolBreak(int32_t tool)
|
|
{
|
|
|
|
bool remove = false;
|
|
|
|
if (tool < 0)
|
|
{
|
|
tool = -tool;
|
|
remove = true;
|
|
}
|
|
|
|
if (tool >= 0xa000 && tool <= 0xafff)
|
|
{
|
|
if (remove) tbrkMap.remove(tool);
|
|
else tbrkMap.add(tool);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Invalid tool: $%04x\n", tool);
|
|
}
|
|
}
|
|
|
|
void ToolBreak()
|
|
{
|
|
// list all tool breaks.
|
|
|
|
if (!tbrkMap.size())
|
|
{
|
|
printf("No tool breaks\n");
|
|
return;
|
|
}
|
|
|
|
std::vector<unsigned> v;
|
|
v.reserve(tbrkMap.size());
|
|
|
|
for (auto kv : tbrkMap)
|
|
{
|
|
v.push_back(kv.first);
|
|
}
|
|
|
|
std::sort(v.begin(), v.end());
|
|
|
|
for (auto trap : v)
|
|
{
|
|
const char *name = TrapName(trap);
|
|
if (!name) name = "";
|
|
printf("$%04x %s\n", trap, name);
|
|
}
|
|
}
|
|
|
|
void Break(int32_t address)
|
|
{
|
|
// 24-bit only, - address to remove.
|
|
|
|
bool remove = false;
|
|
|
|
if (address < 0)
|
|
{
|
|
address = -address;
|
|
remove = true;
|
|
}
|
|
|
|
// what was I thinking? only allow 24-bit addresses?
|
|
if ((address & 0xff000000) == 0)
|
|
{
|
|
if (remove) brkMap.remove(address);
|
|
else brkMap.add(address);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Invalid address: $%08x\n", address);
|
|
}
|
|
}
|
|
|
|
|
|
void Break()
|
|
{
|
|
// list all tool breaks.
|
|
|
|
if (!brkMap.size())
|
|
{
|
|
printf("No breaks\n");
|
|
return;
|
|
}
|
|
|
|
std::vector<unsigned> v;
|
|
v.reserve(brkMap.size());
|
|
|
|
for (auto kv : brkMap)
|
|
{
|
|
v.push_back(kv.first);
|
|
}
|
|
|
|
std::sort(v.begin(), v.end());
|
|
|
|
for (auto address : v)
|
|
{
|
|
printf("$%08x\n", address);
|
|
}
|
|
}
|
|
|
|
|
|
void ReadBreak()
|
|
{}
|
|
|
|
void WriteBreak()
|
|
{}
|
|
|
|
|
|
|
|
void ReadWriteBreak()
|
|
{
|
|
}
|
|
|
|
|
|
|
|
void ReadBreak(int32_t address)
|
|
{
|
|
// sanity check address?
|
|
|
|
if (address < 0) rbrkMap.remove(-address);
|
|
else rbrkMap.add(address);
|
|
}
|
|
|
|
void WriteBreak(int32_t address)
|
|
{
|
|
// sanity check address?
|
|
if (address < 0) wbrkMap.remove(-address);
|
|
else wbrkMap.add(address);
|
|
}
|
|
|
|
void ReadWriteBreak(int32_t address)
|
|
{
|
|
ReadBreak(address);
|
|
WriteBreak(address);
|
|
}
|
|
|
|
void Step(const Command &cmd)
|
|
{
|
|
// TODO - step n to step specified # of instructions.
|
|
// TODO -- step @address to step until address?
|
|
|
|
// disasm 1 line, execute it.
|
|
|
|
int count = 0;
|
|
if (cmd.argc == 1) count = (int)cmd.argv[0];
|
|
if (count < 1) count = 1;
|
|
|
|
// TODO -- move to common function...
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
if (!step(true)) break;
|
|
}
|
|
}
|
|
|
|
|
|
void Continue(const Command &cmd)
|
|
{
|
|
while (step(false)) ;
|
|
}
|
|
|
|
void SetARegister(unsigned reg, uint32_t value)
|
|
{
|
|
if (reg > 7) return;
|
|
if (reg == 7)
|
|
{
|
|
// sp/7 must be aligned.
|
|
if (value & 0x01)
|
|
{
|
|
fprintf(stderr, "Address is not aligned: $%08x\n", value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (value > Flags.memorySize)
|
|
{
|
|
fprintf(stderr, "Warning: address exceeeds memory size: $%08x\n", value);
|
|
}
|
|
|
|
cpuSetAReg(reg, value);
|
|
}
|
|
|
|
|
|
void SetDRegister(unsigned reg, uint32_t value)
|
|
{
|
|
if (reg > 7) return;
|
|
|
|
cpuSetDReg(reg, value);
|
|
}
|
|
|
|
void SetXRegister(unsigned reg, uint32_t value)
|
|
{
|
|
|
|
if (reg == 0)
|
|
{
|
|
if (value & 0x01)
|
|
{
|
|
fprintf(stderr, "Address is not aligned: $%08x\n", value);
|
|
return;
|
|
}
|
|
if (value > Flags.memorySize)
|
|
{
|
|
fprintf(stderr, "Warning: address exceeeds memory size: $%08x\n", value);
|
|
}
|
|
//cpuSetPC(value);
|
|
cpuInitializeFromNewPC(value);
|
|
return;
|
|
}
|
|
|
|
if (reg == 1)
|
|
{
|
|
cpuSetSR(value & 0xffff);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
uint32_t EnvLookup(const std::string &s)
|
|
{
|
|
auto iter = envMap.find(s);
|
|
if (iter == envMap.end()) return 0;
|
|
return iter->second;
|
|
}
|
|
|
|
|
|
|
|
// TODO -- RUN command - reload, re-initialize, re-execute
|
|
// TODO -- parser calls commands directly (except trace/step/run/etc)
|
|
void Shell()
|
|
{
|
|
char *cp;
|
|
|
|
add_history("!Andy, it still has history!");
|
|
|
|
envMap = LoadTrapFile(MPW::RootDirPathForFile("Traps.text"));
|
|
|
|
// start it up
|
|
printf("MPW Debugger shell\n\n");
|
|
disasm(cpuGetPC());
|
|
|
|
signal(SIGINT, sigIntHandler);
|
|
memorySetLoggingFunc(MemoryLogger);
|
|
|
|
for(;;)
|
|
{
|
|
cp = readline("] ");
|
|
if (!cp)
|
|
{
|
|
printf("\n");
|
|
break; // prompt for exit?
|
|
}
|
|
// parse the command...
|
|
const char *iter = cp;
|
|
while (*iter && isspace(*iter)) ++iter;
|
|
|
|
if (*iter)
|
|
{
|
|
Command cmd;
|
|
std::memset(&cmd, 0, sizeof(cmd));
|
|
if (ParseLine(iter, &cmd))
|
|
{
|
|
switch(cmd.action)
|
|
{
|
|
case cmdNull:
|
|
break;
|
|
|
|
case cmdStep:
|
|
Step(cmd);
|
|
break;
|
|
|
|
case cmdContinue:
|
|
Continue(cmd);
|
|
break;
|
|
|
|
default:
|
|
Help();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// todo -- don't add if same as previous command.
|
|
add_history(cp);
|
|
}
|
|
free(cp);
|
|
}
|
|
|
|
}
|
|
|
|
} // namespace Debugger
|
|
|
|
|