Apple-2-Tools/regs
1
0
Fork 0
mirror of https://github.com/mrkite/regs.git synced 2025-02-16 20:31:24 +00:00
Code Issues Projects Releases Wiki Activity

started on map file

Browse Source
This commit is contained in:
Sean 2020-02-16 22:18:50 -07:00
parent 0a3879f4a9
commit 6c456df3be
6 changed files with 170 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

175
disasm.c
View File

@ -83,6 +83,7 @@ void disassemble(uint8_t *data, size_t len, Map *map) {
const char *inst = opcodes[opcode].inst;
Address mode = opcodes[opcode].address;
OpType type = opcodes[opcode].type;
if (smart || dos8) {
mode = DB;
@ -101,6 +102,8 @@ void disassemble(uint8_t *data, size_t len, Map *map) {
width--;
}
addr += width;
flags &= IsFlags; // clear changed flags
MapFlags oldFlags = flags;
for (int i = 0; i < width; i++) {
printf(" %02x", start[i]);
@ -115,13 +118,26 @@ void disassemble(uint8_t *data, size_t len, Map *map) {
const char *comments = NULL;
uint8_t oprlen = 0;
uint8_t oper = 0;
switch (mode) {
case IMP:
break;
case IMM:
printf("#$%02x", *ptr++);
oper = *ptr++;
printf("#$%02x", oper);
oprlen = 4;
if (opcode == 0xe2) {
flags |= oper & IsFlags;
} else if (opcode == 0xc2) {
flags &= ~oper;
}
if ((flags ^ oldFlags) & IsX8) {
flags |= IsX8Changed;
}
if ((flags ^ oldFlags) & IsM8) {
flags |= IsM8Changed;
}
break;
case IMMM:
if (flags & (IsEmu | IsM8)) {
@ -154,8 +170,13 @@ void disassemble(uint8_t *data, size_t len, Map *map) {
break;
case ABS:
val = r16(ptr); ptr += 2;
printf("$%04x", val);
oprlen = 5;
if (type == JUMP || type == CALL) {
val |= addr & 0xff0000; // K
} else {
val |= flags & 0xff0000; // B
}
printf("$%02x/%04x", val >> 16, val & 0xffff);
oprlen = 8;
comments = addressLookup(val, map);
break;
case ABL:
@ -166,14 +187,24 @@ void disassemble(uint8_t *data, size_t len, Map *map) {
break;
case ABX:
val = r16(ptr); ptr += 2;
printf("$%04x, x", val);
oprlen = 8;
if (type == JUMP || type == CALL) {
val |= addr & 0xff0000; // K
} else {
val |= flags & 0xff0000; // B
}
printf("$%02x/%04x, x", val >> 16, val & 0xffff);
oprlen = 11;
comments = addressLookup(val, map);
break;
case ABY:
val = r16(ptr); ptr += 2;
printf("$%04x, y", val);
oprlen = 8;
if (type == JUMP || type == CALL) {
val |= addr & 0xff0000; // K
} else {
val |= flags & 0xff0000; // B
}
printf("$%02x/%04x, y", val >> 16, val & 0xffff);
oprlen = 11;
comments = addressLookup(val, map);
break;
case ABLX:
@ -184,8 +215,13 @@ void disassemble(uint8_t *data, size_t len, Map *map) {
break;
case AIX:
val = r16(ptr); ptr += 2;
printf("($%04x, x)", val);
oprlen = 10;
if (type == JUMP || type == CALL) {
val |= addr & 0xff0000; // K
} else {
val |= flags & 0xff0000; // B
}
printf("($%02x/%04x, x)", val >> 16, val & 0xffff);
oprlen = 13;
comments = addressLookup(val, map);
break;
case ZP:
@ -206,8 +242,13 @@ void disassemble(uint8_t *data, size_t len, Map *map) {
break;
case IND:
val = r16(ptr); ptr += 2;
printf("($%04x)", val);
oprlen = 7;
if (type == JUMP || type == CALL) {
val |= addr & 0xff0000; // K
} else {
val |= flags & 0xff0000; // B
}
printf("($%02x/%04x)", val >> 16, val & 0xffff);
oprlen = 10;
comments = addressLookup(val, map);
break;
case INZ:
@ -268,6 +309,7 @@ void disassemble(uint8_t *data, size_t len, Map *map) {
break;
}
if (smart) {
comments = smartportLookup(opcode);
smart = false;
@ -281,6 +323,58 @@ void disassemble(uint8_t *data, size_t len, Map *map) {
dos16 = false;
}
// track plb
if (opcode == 0xab) { // plb, was it previously a9 xx 48?
bool bset = false;
ptr -= 4;
uint8_t lda = *ptr++;
uint8_t b = *ptr++;
uint8_t pha = *ptr++;
ptr++;
if (lda == 0xa9 && pha == 0x48) {
flags &= 0xffff;
flags |= b << 16; // set B
bset = true;
}
if (!bset) {
ptr -= 2;
uint8_t phk = *ptr++;
ptr++;
if (phk == 0x4b) {
flags &= 0xffff;
flags |= addr & 0xff0000; // B = K
bset = true;
}
}
if (!bset) {
ptr -= 7;
uint8_t lda = *ptr++;
uint8_t b = r16(ptr); ptr += 2;
ptr += 2; // sep #20
uint8_t pha = *ptr++;
ptr++;
if (lda == 0xa9 && pha == 0x48) {
flags &= 0xffff;
flags |= b << 16; // set B
bset = true;
}
}
}
if (opcode == 0x18) {
if (*ptr == 0xfb) { // clc xce = 16 bit mode
flags &= 0xffffff ^ IsEmu;
}
}
if (opcode == 0x38) {
if (*ptr == 0xfb) { // sec xce = 8 bit mode
flags |= IsEmu;
}
}
if ((flags ^ oldFlags) & IsEmu) {
flags |= IsEmuChanged;
}
if (opcode == 0xa2) { // ldx
if (*ptr == 0x22) { // jsl
if (r24(ptr + 1) == 0xe10000) { // jsl el/0000
@ -302,42 +396,41 @@ void disassemble(uint8_t *data, size_t len, Map *map) {
}
}
if (flags & (IsEmuChanged | IsM8Changed | IsX8Changed)) {
for (int i = oprlen; i < 16; i++) {
printf(" ");
}
printf("; ");
}
if (flags & IsEmuChanged) {
if (flags & IsEmu) {
printf(" 8-bit mode");
} else {
printf(" 16-bit mode");
}
}
if (flags & IsM8Changed) {
if (flags & IsM8) {
printf(" a.b");
} else {
printf(" a.w");
}
}
if (flags & IsX8Changed) {
if (flags & IsX8) {
printf(" x.b");
} else {
printf(" x.w");
}
}
if (comments != NULL) {
for (int i = oprlen; i < 16; i++) {
printf(" ");
}
printf("; %s", comments);
}
uint16_t nextFlags = map->mem[addr - map->minMemory];
if (((flags ^ nextFlags) & (IsEmu | IsM8 | IsX8)) && comments == NULL &&
(nextFlags & IsOpcode)) {
for (int i = oprlen; i < 16; i++) {
printf(" ");
}
printf(";");
if ((flags ^ nextFlags) & IsEmu) {
if (nextFlags & IsEmu) {
printf(" 8-bit mode");
} else {
printf(" 16-bit mode");
}
}
if ((flags ^ nextFlags) & IsM8) {
if (nextFlags & IsM8) {
printf(" a.b");
} else {
printf(" a.w");
}
}
if ((flags ^ nextFlags) & IsX8) {
if (nextFlags & IsX8) {
printf(" x.b");
} else {
printf(" x.w");
}
}
}
printf("\n");
} else {
uint32_t dlen = 0;

6
map.h
View File

@ -13,7 +13,11 @@ typedef enum {
IsOperand = 0x04,
IsX8 = 0x10,
IsM8 = 0x20,
IsEmu = 0x100
IsEmu = 0x100,
IsFlags = 0xff013f,
IsX8Changed = 0x200,
IsM8Changed = 0x400,
IsEmuChanged = 0x2000,
} MapFlags;
typedef struct Rule {

25
src/map.cc Normal file
View File

@ -0,0 +1,25 @@
/** @copyright 2020 Sean Kasun */
#include "map.h"
#include <string>
#include <fstream>
Map::Map(const char *filename, uint32_t org, uint32_t flags) {
std::string mapname = filename;
mapname += ".regs";
std::ifstream f(mapname, std::ios::in | std::ios::binary | std::ios::ate);
if (!f.is_open()) {
Symbol symbol;
symbol.org = org;
symbol.flags = flags;
symbols.push_back(symbol);
return;
}
std::streamoff len = f.tellg();
char *data = new char[len + 1];
f.seekg(0, std::ios::beg);
f.read(data, len);
f.close();
data[len] = 0;
ConfigFile c(data, len);
}

2
src/map.h
View File

@ -6,5 +6,5 @@
class Map {
public:
Map(const char *filename, uint32_t org, int32_t flags);
Map(const char *filename, uint32_t org, uint32_t flags);
};

6
src/omf.cc
View File

@ -1,5 +1,6 @@
/** @copyright 2020 Sean Kasun */
#include "omf.h"
#include <set>
OMF::OMF(const Map &map) : map(map) {
}
@ -10,6 +11,8 @@ bool OMF::load(const char *filename) {
if (!isOMF()) {
Segment seg;
seg.bytecnt = handle->length;
seg.kind = 0; // code
seg.mapped = map.org;
segments.push_back(seg);
} else {
if (!loadSegments()) {
@ -105,7 +108,7 @@ bool OMF::mapSegments() {
return true;
}
// use a memory map that denotes runs of available ram
std::vector<uint32_t> memory;
std::set<uint32_t> memory;
memory.push_back(0x10000); // min
memory.push_back(0xf80000); // max
// first map any segments that know where they belong
@ -138,7 +141,6 @@ bool OMF::mapSegments() {
if (seg.mapped < memory[0]) { // below the minimum
memory[0] = seg.mapped; // calc new min
}
std::sort(memory.begin(), memory.end());
}
}

1
src/omf.h
View File

@ -3,6 +3,7 @@
#include "handle.h"
#include "map.h"
#include <vector>
struct Segment {
int32_t bytecnt;