From ac81dc9ae9a27d0597a19c3944a738180fb218ec Mon Sep 17 00:00:00 2001 From: Hermann Seib Date: Thu, 13 Oct 2022 09:33:42 +0200 Subject: [PATCH] REG directive added --- Dasm6309.cpp | 87 +++++++++++++++++++++---------- Dasm6309.h | 16 ++++++ Dasm6500.cpp | 31 ++++++++--- Dasm6500.h | 13 ++++- Dasm6800.cpp | 29 ++++++++--- Dasm6800.h | 18 +++++-- Dasm68000.cpp | 88 +++++++++++++++++++++++++------- Dasm68000.h | 29 +++++++++++ Dasm6801.cpp | 15 +++++- Dasm6801.h | 7 +++ Dasm6809.cpp | 136 ++++++++++++++++++++++++++++--------------------- Dasm6809.h | 17 ++++++- Dasm68HC11.cpp | 20 ++++++-- Dasm68HC11.h | 7 +++ DasmAvr8.cpp | 33 +++++++++++- DasmAvr8.h | 47 ++++++++++++++++- Disassembler.h | 16 ++++++ dasmfw.cpp | 18 ++++++- dasmfw.h | 2 +- dasmfw.htm | 3 ++ history.txt | 3 +- 21 files changed, 499 insertions(+), 136 deletions(-) diff --git a/Dasm6309.cpp b/Dasm6309.cpp index 0bb7b0c..2d818ed 100644 --- a/Dasm6309.cpp +++ b/Dasm6309.cpp @@ -265,10 +265,19 @@ CMatrixEntry Dasm6309::h6309_codes11[256] = {_ill ,_nom}, {_ill ,_nom}, {_ill ,_nom}, {_ill ,_nom}, /* FC..FF */ }; -static const char *h6309_exg_tfr[] = +const int Dasm6309::bit_r[] = { _cc, _a, _b, _unkr }; + +const int Dasm6309::block_r[] = + { + _d, _x, _y, _u, _s, _unkr, _unkr, _unkr, + _unkr, _unkr, _unkr, _unkr, _unkr, _unkr, _unkr, _unkr + }; + + +const int Dasm6309::h6309_exg_tfr[] = { - "D", "X", "Y", "U", "S", "PC","W" ,"V", - "A", "B", "CC","DP","0", "0", "E", "F" + _d, _x, _y, _u, _s, _pc, _w, _v, + _a, _b, _cc, _dp, _reg0, _reg0, _e, _f }; /*****************************************************************************/ @@ -359,6 +368,20 @@ OpCode Dasm6309::opcodes[mnemo6309_count - mnemo6809_count] = { "FQB", Data }, /* _fqb */ }; +/*****************************************************************************/ +/* regnames : additional register names over 6809 */ +/*****************************************************************************/ + +const char *Dasm6309::regnames[reg6309_count - reg6809_count] = + { + "E", /* _e */ + "F", /* _f */ + "V", /* _v */ + "W", /* _w */ + "MD", /* _md */ + "0", /* _reg0 */ + }; + /*****************************************************************************/ /* Dasm6309 : constructor */ /*****************************************************************************/ @@ -371,9 +394,13 @@ codes10 = h6309_codes10; codes11 = h6309_codes11; exg_tfr = h6309_exg_tfr; +int i; mnemo.resize(mnemo6309_count); /* set up additional mnemonics */ -for (int i = 0; i < mnemo6309_count - mnemo6809_count; i++) +for (i = 0; i < mnemo6309_count - mnemo6809_count; i++) mnemo[mnemo6809_count + i] = opcodes[i]; +regname.resize(reg6309_count); /* set up additional register names */ +for (i = 0; i < reg6309_count - reg6809_count; i++) + regname[reg6809_count + i] = regnames[i]; } /*****************************************************************************/ @@ -494,31 +521,37 @@ if (T & 0x80) switch (T & 0x1F) { case 0x07: - buf = MnemoCase(sformat("E,%c", R)); + buf = MnemoCase(sformat("%s,%s", + regname[_e].c_str(), regname[R].c_str())); break; case 0x17: - buf = MnemoCase(sformat("[E,%c]", R)); + buf = MnemoCase(sformat("[%s,%s]", + regname[_e].c_str(), regname[R].c_str())); break; case 0x0A: - buf = MnemoCase(sformat("F,%c",R)); + buf = MnemoCase(sformat("%s,%s", + regname[_f].c_str(), regname[R].c_str())); break; case 0x1A: - buf = MnemoCase(sformat("[F,%c]",R)); + buf = MnemoCase(sformat("[s,%s]", + regname[_f].c_str(), regname[R].c_str())); break; case 0x0E: - buf = MnemoCase(sformat("W,%c",R)); + buf = MnemoCase(sformat("%s,%s", + regname[_w].c_str(), regname[R].c_str())); break; case 0x1E: - buf = MnemoCase(sformat("[W,%c]",R)); + buf = MnemoCase(sformat("[%s,%s]", + regname[_w].c_str(), regname[R].c_str())); break; default: switch (T) { case 0x8F: - buf = MnemoCase(sformat(",W")); + buf = "," + MnemoCase(regname[_w]); break; case 0x90: - buf = MnemoCase(sformat("[,W]")); + buf = MnemoCase(sformat("[,%s]", regname[_w].c_str())); break; case 0xAF: { @@ -526,7 +559,7 @@ if (T & 0x80) lbl = bGetLabel ? NULL : FindLabel(PC, Const); W = GetUWord(PC); string slbl = lbl ? lbl->GetText() : Label2String(W, 4, bGetLabel, PC); - buf = sformat("%s,%s", slbl.c_str(), MnemoCase("W").c_str()); + buf = sformat("%s,%s", slbl.c_str(), MnemoCase(regname[_w]).c_str()); PC += 2; } break; @@ -536,21 +569,21 @@ if (T & 0x80) lbl = bGetLabel ? NULL : FindLabel(PC, Const); W = GetUWord(PC); string slbl = lbl ? lbl->GetText() : Label2String(W, 4, bGetLabel, PC); - buf = sformat("[%s,%s]", slbl.c_str(),MnemoCase("W").c_str()); + buf = sformat("[%s,%s]", slbl.c_str(),MnemoCase(regname[_w]).c_str()); PC += 2; } break; case 0xCF: - buf = MnemoCase(sformat(",W++")); + buf = MnemoCase(sformat(",%s++", regname[_w].c_str())); break; case 0xD0: - buf = MnemoCase(sformat("[,W++]")); + buf = MnemoCase(sformat("[,%s++]", regname[_w].c_str())); break; case 0xEF: - buf = MnemoCase(sformat(",--W")); + buf = MnemoCase(sformat(",--%s", regname[_w].c_str())); break; case 0xF0: - buf = MnemoCase(sformat("[,--W]")); + buf = MnemoCase(sformat("[,--%s]", regname[_w].c_str())); break; default: return Dasm6809::IndexString(smnemo, pc); @@ -815,7 +848,7 @@ switch (mode) /* which mode is this? */ if (forceDirectAddr || GetForcedAddr(PC)) AddForced(smnemo, slbl, false); sparm = sformat("%s,%d,%s,%s", - MnemoCase(bit_r[M >> 6]).c_str(), + MnemoCase(regname[bit_r[M >> 6]]).c_str(), (M >> 3) & 7, snum.c_str(), slbl.c_str()); @@ -826,29 +859,29 @@ switch (mode) /* which mode is this? */ case _t1: /* Block Transfer r0+,r1+ */ T = GetUByte(PC++); sparm = sformat("%s+,%s+", - MnemoCase(block_r[T >> 4]).c_str(), - MnemoCase(block_r[T & 0xF]).c_str()); + MnemoCase(regname[block_r[T >> 4]]).c_str(), + MnemoCase(regname[block_r[T & 0xF]]).c_str()); break; case _t2: /* Block Transfer r0-,r1- */ T = GetUByte(PC++); sparm = sformat("%s-,%s-", - MnemoCase(block_r[T >> 4]).c_str(), - MnemoCase(block_r[T & 0xF]).c_str()); + MnemoCase(regname[block_r[T >> 4]]).c_str(), + MnemoCase(regname[block_r[T & 0xF]]).c_str()); break; case _t3: /* Block Transfer r0+,r1 */ T = GetUByte(PC++); sparm = sformat("%s+,%s", - MnemoCase(block_r[T >> 4]).c_str(), - MnemoCase(block_r[T & 0xF]).c_str()); + MnemoCase(regname[block_r[T >> 4]]).c_str(), + MnemoCase(regname[block_r[T & 0xF]]).c_str()); break; case _t4: /* Block Transfer r0,r1+ */ T = GetUByte(PC++); sparm = sformat("%s,%s+", - MnemoCase(block_r[T >> 4]).c_str(), - MnemoCase(block_r[T & 0xF]).c_str()); + MnemoCase(regname[block_r[T >> 4]]).c_str(), + MnemoCase(regname[block_r[T & 0xF]]).c_str()); break; case _iml: /* immediate 32-bit */ diff --git a/Dasm6309.h b/Dasm6309.h index 410aec8..235ad45 100644 --- a/Dasm6309.h +++ b/Dasm6309.h @@ -157,10 +157,26 @@ class Dasm6309 : public Dasm6809 mnemo6309_count }; + enum Reg6309 + { + _e = reg6809_count, + _f, + _v, + _w, + _md, + _reg0, /* not really a register, but hey... */ + + reg6309_count + }; + static CMatrixEntry h6309_codes[256]; static CMatrixEntry h6309_codes10[256]; static CMatrixEntry h6309_codes11[256]; static OpCode opcodes[mnemo6309_count - mnemo6809_count]; + static const char *regnames[reg6309_count - reg6809_count]; + static const int h6309_exg_tfr[]; + static const int bit_r[]; + static const int block_r[]; protected: virtual adr_t IndexParse(int MI, adr_t pc, adr_t instaddr = NO_ADDRESS); diff --git a/Dasm6500.cpp b/Dasm6500.cpp index 9601d20..4bc1303 100644 --- a/Dasm6500.cpp +++ b/Dasm6500.cpp @@ -238,6 +238,19 @@ OpCode Dasm650X::opcodes[mnemo6500_count] = { "TYA", Data }, /* _tya */ }; +/*****************************************************************************/ +/* regnames : 6500 register names array for initialization */ +/*****************************************************************************/ + +const char *Dasm650X::regnames[reg6500_count] = + { + "A", /* _a */ + "X", /* _x */ + "Y", /* _y */ + "P", /* _p */ + "PC", /* _pc */ + }; + /*****************************************************************************/ /* Dasm650X : constructor */ /*****************************************************************************/ @@ -261,6 +274,10 @@ mnemo.resize(mnemo6500_count); /* set up mnemonics table */ for (int i = 0; i < mnemo6500_count; i++) mnemo[i] = opcodes[i]; +regname.resize(reg6500_count); /* set up register name table */ +for (int i = 0; i < reg6500_count; i++) + regname[i] = regnames[i]; + // set up options table // class uses one generic option setter/getter pair (not mandatory) #if 0 @@ -923,7 +940,7 @@ switch (mode) /* which mode is this? */ break; case _acc: /* accumulator */ if (accparm) - sparm = MnemoCase("A"); + sparm = MnemoCase(regname[_a]); break; case _imm: /* immediate byte */ @@ -959,13 +976,13 @@ switch (mode) /* which mode is this? */ else // if no direct page, this can't be interpreted as a label sparm = (lbl ? lbl->GetText() : Number2String(T, 2, PC)); if (mode == _zpx) - sparm += MnemoCase(",X"); + sparm += "," + MnemoCase(regname[_x]); else if (mode == _zpy) - sparm += MnemoCase(",Y"); + sparm += "," + MnemoCase(regname[_y]); else if (mode == _idx) - sparm = "(" + sparm + MnemoCase(",X)"); + sparm = "(" + sparm + "," + MnemoCase(regname[_x]) + ")"; else if (mode == _idy) - sparm = "(" + sparm + MnemoCase("),Y"); + sparm = "(" + sparm + ")," + MnemoCase(regname[_y]); PC++; } break; @@ -994,9 +1011,9 @@ switch (mode) /* which mode is this? */ AddForced(smnemo, slbl, true); sparm = slbl; if (mode == _abx) - sparm += MnemoCase(",X"); + sparm += "," + MnemoCase(regname[_x]); else if (mode == _aby) - sparm += MnemoCase(",Y"); + sparm += "," + MnemoCase(regname[_y]); else if (mode == _ind) sparm = "(" + sparm + ")"; PC += 2; diff --git a/Dasm6500.h b/Dasm6500.h index bbd744e..64b773e 100644 --- a/Dasm6500.h +++ b/Dasm6500.h @@ -207,12 +207,21 @@ class Dasm650X : mnemo6500_count }; + enum Reg6500 + { + _a, + _x, + _y, + _p, + _pc, + reg6500_count + }; + static CMatrixEntry m6500_codes[256]; CMatrixEntry *codes; - static const char *bit_r[]; - static const char *block_r[]; static OpCode opcodes[mnemo6500_count]; + static const char *regnames[reg6500_count]; adr_t dirpage; bool useConvenience; diff --git a/Dasm6800.cpp b/Dasm6800.cpp index 7340c12..1973a12 100644 --- a/Dasm6800.cpp +++ b/Dasm6800.cpp @@ -126,13 +126,6 @@ CMatrixEntry Dasm6800::m6800_codes[256] = {_ill ,_nom}, {_ill ,_nom}, {_ldx ,_ext}, {_stx ,_ext}, /* FC..FF */ }; -const char *Dasm6800::bit_r[] = {"CC","A","B","??"}; - -const char *Dasm6800::block_r[] = - { - "D","X","Y","U","S","?","?","?","?","?","?","?","?","?","?","?" - }; - /*****************************************************************************/ /* opcodes : 6800 opcodes array for initialization */ /*****************************************************************************/ @@ -269,6 +262,21 @@ OpCode Dasm6800::opcodes[mnemo6800_count] = { "LSRD", Data }, /* _lsrd */ }; +/*****************************************************************************/ +/* regnames : 6800 register names array for initialization */ +/*****************************************************************************/ + +const char *Dasm6800::regnames[reg6800_count] = + { + "?", /* _unk */ + "A", /* _a */ + "B", /* _b */ + "X", /* _x */ + "S", /* _s */ + "PC", /* _pc */ + "CC", /* _cc */ + }; + /*****************************************************************************/ /* Dasm6800 : constructor */ /*****************************************************************************/ @@ -294,10 +302,15 @@ useDPLabels = false; textDirectAddr = "p-<"; textExtendedAddr = "p->"; +int i; mnemo.resize(mnemo6800_count); /* set up mnemonics table */ -for (int i = 0; i < mnemo6800_count; i++) +for (i = 0; i < mnemo6800_count; i++) mnemo[i] = opcodes[i]; +regname.resize(reg6800_count); /* set up register name table */ +for (i = 0; i < reg6800_count; i++) + regname[i] = regnames[i]; + // set up options table // class uses one generic option setter/getter pair (not mandatory) AddOption("conv", "{off|on}\tUse convenience macros", diff --git a/Dasm6800.h b/Dasm6800.h index df2fe5e..5aa1b79 100644 --- a/Dasm6800.h +++ b/Dasm6800.h @@ -126,7 +126,7 @@ class Dasm6800 : virtual string Address2String(adr_t addr, int bus = BusCode) { (void)bus; return sformat("$%04X", addr); } virtual adr_t FetchInstructionDetails(adr_t PC, uint8_t &instpg, uint8_t &instb, uint8_t &mode, int &mnemoIndex); - virtual string GetIx8IndexReg(uint8_t instpg) { (void)instpg; return MnemoCase(",X"); } + virtual string GetIx8IndexReg(uint8_t instpg) { (void)instpg; return "," + MnemoCase(regname[_x]); } virtual bool SetConvenience(uint8_t instpg, uint16_t u2, string &smnemo, adr_t &PC); void AddForced(string &smnemo, string &sparm, bool bExtended = true); @@ -281,12 +281,24 @@ class Dasm6800 : mnemo6800_count }; + enum Reg6800 + { + _unkr, + _a, + _b, + _x, + _s, + _pc, + _cc, + + reg6800_count + }; + static CMatrixEntry m6800_codes[256]; CMatrixEntry *codes; - static const char *bit_r[]; - static const char *block_r[]; static OpCode opcodes[mnemo6800_count]; + static const char *regnames[reg6800_count]; adr_t dirpage; bool useConvenience; diff --git a/Dasm68000.cpp b/Dasm68000.cpp index 469ba9a..d165124 100644 --- a/Dasm68000.cpp +++ b/Dasm68000.cpp @@ -347,6 +347,35 @@ OpCode Dasm68000::opcodes[mnemo68000_count] = { "RMB", Data }, /* _rmb */ }; +/*****************************************************************************/ +/* regnames : 68000 register names array for initialization */ +/*****************************************************************************/ + +const char *Dasm68000::regnames[reg68000_count] = + { + "?", /* _unkr */ + "A0", /* _a0 */ + "A1", /* _a1 */ + "A2", /* _a2 */ + "A3", /* _a3 */ + "A4", /* _a4 */ + "A5", /* _a5 */ + "A6", /* _a6 */ + "A7", /* _a7 */ + "D0", /* _d0 */ + "D1", /* _d1 */ + "D2", /* _d2 */ + "D3", /* _d3 */ + "D4", /* _d4 */ + "D5", /* _d5 */ + "D6", /* _d6 */ + "D7", /* _d7 */ + "PC", /* _pc */ + "CCR", /* _ccr */ + "SR", /* _sr */ + "USP", /* _usp */ + }; + /*****************************************************************************/ /* Dasm68000 : constructor */ /*****************************************************************************/ @@ -380,6 +409,9 @@ int i, j; mnemo.resize(mnemo68000_count); /* set up mnemonics table */ for (i = 0; i < mnemo68000_count; i++) mnemo[i] = opcodes[i]; +regname.resize(reg68000_count); /* set up register name table */ +for (i = 0; i < reg68000_count; i++) + regname[i] = regnames[i]; /* set up instruction table */ otIndex = new uint8_t[65536]; for (i = optblSize - 1; i > 0; i--) @@ -1853,8 +1885,7 @@ return len; const char *Dasm68000::GetAddrReg(int i) { -static const char *regs[] = { "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7" }; -return regs[i & 7]; +return regname[_a0 + (i & 7)].c_str(); } /*****************************************************************************/ @@ -1863,8 +1894,7 @@ return regs[i & 7]; const char *Dasm68000::GetDataReg(int i) { -static const char *regs[] = { "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7" }; -return regs[i & 7]; +return regname[_d0 + (i & 7)].c_str(); } /*****************************************************************************/ @@ -1879,6 +1909,27 @@ static const string sizes[] = { ".B", ".W", ".L", return sizes[sizeCode & 7].c_str(); } +/*****************************************************************************/ +/* GetEffectiveAddressRegNum : returns reg# for EA */ +/*****************************************************************************/ + +int Dasm68000::GetEffectiveAddressRegNum + ( + uint16_t ea + ) +{ +int mode = (ea & 0x38) >> 3; +int reg = ea & 0x7; +switch (mode) + { + case 0: + return _d0 + reg; + case 1: + return _a0 + reg; + } /* end of switch mode */ +return -1; +} + /*****************************************************************************/ /* DisassembleEffectiveAddress : disassemble the EA part of an instruction */ /*****************************************************************************/ @@ -1994,7 +2045,7 @@ switch(mode) a1 = (int32_t)addr + displacement; s = sformat("%s(%s)", Label2String(a1, GetBusWidth() / 4, bGetLabel, addr).c_str(), - MnemoCase("PC").c_str()); + MnemoCase(regname[_pc]).c_str()); addr += 2; break; case 3: @@ -2006,13 +2057,13 @@ switch(mode) if (displacement & 0x8000) s = sformat("%s(%s,%s%s)", /* address reg is index reg */ Label2String(a1, GetBusWidth() / 4, bGetLabel, addr).c_str(), - MnemoCase("PC").c_str(), + MnemoCase(regname[_pc]).c_str(), MnemoCase(GetAddrReg(index_reg)).c_str(), MnemoCase(sExtLong).c_str()); else s = sformat("%s(%s,%s%s)", /* data reg is index reg */ Label2String(a1, GetBusWidth() / 4, bGetLabel, addr).c_str(), - MnemoCase("PC").c_str(), + MnemoCase(regname[_pc]).c_str(), MnemoCase(GetDataReg(index_reg)).c_str(), MnemoCase(sExtWord).c_str()); addr += 2; @@ -2454,14 +2505,7 @@ if (e_a.size() > 2 && e_a.substr(e_a.size() - 2) == sExtShort) if (smnemo.size() > 2 && smnemo[smnemo.size() - 2] != '.') { - bool gas = (asmtype == "gas"); - int critsz = 2 + gas; - int regnam = 0 + gas; - int regnum = 1 + gas; - if ((int)e_a.size() == critsz && - (!gas || e_a[0] == '%') && - (toupper(e_a[regnam]) == 'A' || toupper(e_a[regnam]) == 'D') && - isdigit(e_a[regnum])) + if (GetEffectiveAddressRegNum(dest) >= 0) ; // smnemo += sExtLong; else smnemo += sExtByte; @@ -2647,7 +2691,7 @@ if (e_a.size() > 2 && e_a[e_a.size() - 2] == '.') } uint16_t mt = code & 0x0600; -const char *reg = (mt == 0x0200 || mt == 0x0400) ? "CCR" : "SR"; +string reg = regname[(mt == 0x0200 || mt == 0x0400) ? _ccr : _sr]; sparm = (code & 0x400) ? sformat("%s,%s", e_a.c_str(), MnemoCase(reg).c_str()) : sformat("%s,%s", MnemoCase(reg).c_str(), e_a.c_str()); @@ -2661,7 +2705,7 @@ adr_t Dasm68000::DisassembleOptype27(adr_t instaddr, adr_t addr, uint16_t code, uint16_t data = GetUWord(addr); sparm = sformat("#%s,%s", Number2String(data, 4, addr).c_str(), - MnemoCase((code & 0x40) ? "SR" : "CCR").c_str()); + MnemoCase(regname[(code & 0x40) ? _sr : _ccr]).c_str()); addr += 2; return addr; } @@ -2670,8 +2714,14 @@ adr_t Dasm68000::DisassembleOptype28(adr_t instaddr, adr_t addr, uint16_t code, { (void)instaddr; (void)optable_index; (void)smnemo; // MOVE USP -sparm = MnemoCase(sformat((code & 0x08) ? "USP,%s" : "%s,USP", - GetAddrReg(code & 0x07))); +if (code & 0x08) + sparm = MnemoCase(sformat("%s,%s", + regname[_usp].c_str(), + GetAddrReg(code & 0x07))); +else + sparm = MnemoCase(sformat("%s,%s", + GetAddrReg(code & 0x07), + regname[_usp].c_str())); return addr; } diff --git a/Dasm68000.h b/Dasm68000.h index e6227fc..9aab013 100644 --- a/Dasm68000.h +++ b/Dasm68000.h @@ -291,9 +291,37 @@ class Dasm68000 : { optblSize = 143 }; + enum Reg68000 + { + _unkr, + _a0, + _a1, + _a2, + _a3, + _a4, + _a5, + _a6, + _a7, + _d0, + _d1, + _d2, + _d3, + _d4, + _d5, + _d6, + _d7, + _pc, + _ccr, + _sr, + _usp, + + reg68000_count + }; + static OpDef OpTable[optblSize]; static OpCode opcodes[mnemo68000_count]; uint8_t *otIndex; + static const char *regnames[reg68000_count]; #if 1 string asmtype; /* assembler type */ #else @@ -341,6 +369,7 @@ class Dasm68000 : virtual const char *GetAddrReg(int i); virtual const char *GetDataReg(int i); virtual const char *GetSizeSuffix(int sizeCode); + virtual int GetEffectiveAddressRegNum(uint16_t ea); virtual adr_t DisassembleEffectiveAddress(adr_t instaddr, adr_t addr, string &s, uint16_t ea, int16_t index, int op_mode); virtual adr_t DisassembleOptype01(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); virtual adr_t DisassembleOptype02(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); diff --git a/Dasm6801.cpp b/Dasm6801.cpp index 7ef4fb7..5c055bd 100644 --- a/Dasm6801.cpp +++ b/Dasm6801.cpp @@ -141,6 +141,15 @@ OpCode Dasm6801::opcodes[mnemo6801_count - mnemo6800_count] = { "SUBD", Data }, /* _subd */ }; +/*****************************************************************************/ +/* regnames : additional register names over 6800 */ +/*****************************************************************************/ + +const char *Dasm6801::regnames[reg6801_count - reg6800_count] = + { + "D", /* _d */ + }; + /*****************************************************************************/ /* Dasm6801 : constructor */ /*****************************************************************************/ @@ -150,8 +159,12 @@ Dasm6801::Dasm6801(Application *pApp) { codes = m6801_codes; mnemo.resize(mnemo6801_count); /* set up additional mnemonics */ -for (int i = 0; i < mnemo6801_count - mnemo6800_count; i++) +int i; +for (i = 0; i < mnemo6801_count - mnemo6800_count; i++) mnemo[mnemo6800_count + i] = opcodes[i]; +regname.resize(reg6801_count); /* set up additional register names */ +for (i = 0; i < reg6801_count - reg6800_count; i++) + regname[reg6800_count + i] = regnames[i]; } /*****************************************************************************/ diff --git a/Dasm6801.h b/Dasm6801.h index 6f3ca9f..5d7aa26 100644 --- a/Dasm6801.h +++ b/Dasm6801.h @@ -63,9 +63,16 @@ class Dasm6801 : public Dasm6800 mnemo6801_count }; + enum Reg6801 + { + _d = reg6800_count, + + reg6801_count + }; static CMatrixEntry m6801_codes[256]; static OpCode opcodes[mnemo6801_count - mnemo6800_count]; + static const char *regnames[reg6801_count - reg6800_count]; }; #endif // __Dasm6801_h_defined__ diff --git a/Dasm6809.cpp b/Dasm6809.cpp index 6580b38..5d724b3 100644 --- a/Dasm6809.cpp +++ b/Dasm6809.cpp @@ -339,13 +339,13 @@ CMatrixEntry Dasm6809::m6809_codes11[256] = }; -static const char *m6809_exg_tfr[] = +const int Dasm6809::m6809_exg_tfr[] = { - "D", "X", "Y", "U", "S", "PC","??","??", - "A", "B", "CC","DP","??","??","??","??" + _d, _x, _y, _u, _s, _pc, _unkr, _unkr, + _a, _b, _cc, _dp, _unkr, _unkr, _unkr, _unkr }; -const char Dasm6809::reg[] = { 'X', 'Y', 'U', 'S' }; +const int Dasm6809::reg[] = { _x, _y, _u, _s }; /*****************************************************************************/ /* opcodes : additional opcodes over 6800 */ @@ -426,6 +426,19 @@ OpCode Dasm6809::opcodes[mnemo6809_count - mnemo6800_count] = }; +/*****************************************************************************/ +/* regnames : additional register names over 6800 */ +/*****************************************************************************/ + +const char *Dasm6809::regnames[reg6809_count - reg6800_count] = + { + "D", /* _d */ + "Y", /* _y */ + "U", /* _u */ + "DP", /* _dp */ + "PCR", /* _pcr */ + }; + /*****************************************************************************/ /* Dasm6809 : constructor */ /*****************************************************************************/ @@ -441,8 +454,9 @@ os9Patch = false; os9Comments = false; os9ModHeader = false; useFlex = false; +int i; mnemo.resize(mnemo6809_count); /* set up additional mnemonics */ -for (int i = 0; i < mnemo6809_count - mnemo6800_count; i++) +for (i = 0; i < mnemo6809_count - mnemo6800_count; i++) mnemo[mnemo6800_count + i] = opcodes[i]; mnemo[_lda].mne = "LDA"; /* adjust slight mnemo differences */ mnemo[_ldb].mne = "LDB"; @@ -450,6 +464,9 @@ mnemo[_sta].mne = "STA"; mnemo[_stb].mne = "STB"; mnemo[_ora].mne = "ORA"; mnemo[_orb].mne = "ORB"; +regname.resize(reg6809_count); /* set up additional register names */ +for (i = 0; i < reg6809_count - reg6800_count; i++) + regname[reg6800_count + i] = regnames[i]; // set up options table // class uses one generic option setter/getter pair (not mandatory) @@ -1372,13 +1389,13 @@ adr_t Dasm6809::IndexParse(int mnemoIndex, adr_t pc, adr_t instaddr) uint8_t T; uint16_t W; uint16_t Wrel; -char R; +// char R; adr_t PC = pc; bool bSetLabel = true; Label *lbl; T = GetUByte(PC++); -R = reg[(T >> 5) & 0x03]; +// R = reg[(T >> 5) & 0x03]; if (T & 0x80) { @@ -1535,7 +1552,7 @@ else lbl->SetUsed(); } -(void)R; // unused ATM - keep gcc happy +// (void)R; // unused ATM - keep gcc happy return PC; } @@ -1561,19 +1578,19 @@ if (T & 0x80) switch (T & 0x1F) { case 0x00: - buf = MnemoCase(sformat(",%c+", R)); + buf = MnemoCase(sformat(",%s+", regname[R].c_str())); break; case 0x01: - buf = MnemoCase(sformat(",%c++", R)); + buf = MnemoCase(sformat(",%s++", regname[R].c_str())); break; case 0x02: - buf = MnemoCase(sformat(",-%c", R)); + buf = MnemoCase(sformat(",-%s", regname[R].c_str())); break; case 0x03: - buf = MnemoCase(sformat(",--%c", R)); + buf = MnemoCase(sformat(",--%s", regname[R].c_str())); break; case 0x04: - buf = MnemoCase(sformat(",%c", R)); + buf = MnemoCase(sformat(",%s", regname[R].c_str())); if (GetRelative(PC - 1)) { bGetLabel = !IsConst(PC - 1); @@ -1583,10 +1600,12 @@ if (T & 0x80) } break; case 0x05: - buf = MnemoCase(sformat("B,%c", R)); + buf = MnemoCase(sformat("%s,%s", + regname[_b].c_str(), regname[R].c_str())); break; case 0x06: - buf = MnemoCase(sformat("A,%c", R)); + buf = MnemoCase(sformat("%s,%s", + regname[_a].c_str(), regname[R].c_str())); break; case 0x08: bGetLabel = !IsConst(PC); @@ -1601,7 +1620,7 @@ if (T & 0x80) bool bFwd = IsForwardRef(W, bGetLabel, PC); buf = sformat(bFwd ? "<%s,%s" : "%s,%s", slbl.c_str(), - MnemoCase(R).c_str()); + MnemoCase(regname[R]).c_str()); } else { @@ -1609,7 +1628,7 @@ if (T & 0x80) // DefLabels are output before the code, so they ARE defined and need no < // buf = sformat((lbl && Wrel >= PC - 1) ? "<%s,%s" : "%s,%s", slbl.c_str(), MnemoCase(R)).c_str()); buf = sformat((lbl && Wrel >= PC - 1) ? "%s,%s" : "%s,%s", - slbl.c_str(), MnemoCase(R).c_str()); + slbl.c_str(), MnemoCase(regname[R]).c_str()); } PC++; break; @@ -1621,7 +1640,7 @@ if (T & 0x80) if ((Wrel != W) || FindLabel(Wrel)) { string slbl = lbl ? lbl->GetText() : Label2String(W, 4, bGetLabel, PC); - buf = sformat("%s,%s", slbl.c_str(), MnemoCase(R).c_str()); + buf = sformat("%s,%s", slbl.c_str(), MnemoCase(regname[R]).c_str()); if (((W < 0x80) || (W >= 0xff80)) && forceExtendedAddr) //buf = ">" + buf; AddForced(smnemo, buf, true); @@ -1634,27 +1653,29 @@ if (T & 0x80) #if 1 slbl = lbl ? lbl->GetText() : SignedNumber2String((int)(short)W, 4, PC); AddForced(smnemo, slbl, true); - buf = sformat("%s,%s", slbl.c_str(), MnemoCase(R).c_str()); + buf = sformat("%s,%s", slbl.c_str(), MnemoCase(regname[R]).c_str()); #else - buf = sformat(">%s,%s", slbl.c_str(), MnemoCase(R).c_str()); + buf = sformat(">%s,%s", slbl.c_str(), MnemoCase(regname[R]).c_str()); #endif } else { slbl = lbl ? lbl->GetText() : Number2String((uint16_t)(int)(short)W, 4, PC); /* RB: this was "signed_string" */ - buf = sformat("%s,%s", slbl.c_str(), MnemoCase(R).c_str()); + buf = sformat("%s,%s", slbl.c_str(), MnemoCase(regname[R]).c_str()); } } PC += 2; break; case 0x0B: - buf = MnemoCase(sformat("D,%c", R)); + buf = MnemoCase(sformat("%s,%s", regname[_d].c_str(), regname[R].c_str())); break; case 0x0C: T = GetUByte(PC); bGetLabel = !IsConst(PC); #if 0 - sprintf(buf,"$%s,PC",signed_string((int)(char)T, 2, (word)PC)); + sprintf(buf,"$%s,%s", + signed_string((int)(char)T, 2, (word)PC), + regname[_pc].c_str()); #else if (bGetLabel) { @@ -1662,7 +1683,7 @@ if (T & 0x80) bGetLabel, PC); if (((char)T > 0) && forceDirectAddr) AddForced(smnemo, slbl, false); - buf = slbl + MnemoCase(",PCR"); + buf = slbl + "," + MnemoCase(regname[_pcr]); } else { @@ -1670,7 +1691,7 @@ if (T & 0x80) string slbl = lbl ? lbl->GetText() : Number2String((uint16_t)(int)(char)T, 2, PC); if (((char)T > 0) && forceDirectAddr) AddForced(smnemo, slbl, false); - buf = slbl + MnemoCase(",PC"); + buf = slbl + "," + MnemoCase(regname[_pc]); } #endif PC++; @@ -1687,26 +1708,26 @@ if (T & 0x80) #if 1 AddForced(smnemo, slbl, true); #else - buf = sformat(">%s", slbl.c_str()) + MnemoCase(",PCR"); + buf = sformat(">%s", slbl.c_str()) + "," + MnemoCase(regname[_pcr]); else #endif - buf = sformat("%s", slbl.c_str()) + MnemoCase(",PCR"); + buf = slbl + "," + MnemoCase(regname[_pcr]); } break; case 0x11: - buf = MnemoCase(sformat("[,%c++]", R)); + buf = MnemoCase(sformat("[,%s++]", regname[R].c_str())); break; case 0x13: - buf = MnemoCase(sformat("[,--%c]", R)); + buf = MnemoCase(sformat("[,--%s]", regname[R].c_str())); break; case 0x14: - buf = MnemoCase(sformat("[,%c]", R)); + buf = MnemoCase(sformat("[,%s]", regname[R].c_str())); break; case 0x15: - buf = MnemoCase(sformat("[B,%c]", R)); + buf = MnemoCase(sformat("[%s,%s]", regname[_b].c_str(), regname[R].c_str())); break; case 0x16: - buf = MnemoCase(sformat("[A,%c]", R)); + buf = MnemoCase(sformat("[%s,%s]", regname[_a].c_str(), regname[R].c_str())); break; case 0x18: { @@ -1715,7 +1736,7 @@ if (T & 0x80) string slbl = lbl ? lbl->GetText() : Number2String(T, 2, PC); buf = sformat("[%s,%s]", slbl.c_str(), - MnemoCase(R).c_str()); + MnemoCase(regname[R]).c_str()); PC++; } break; @@ -1725,12 +1746,13 @@ if (T & 0x80) lbl = bGetLabel ? NULL : FindLabel(PC, Const); W = GetUWord(PC); string slbl = lbl ? lbl->GetText() : Label2String(W, 4, bGetLabel, PC); - buf = sformat("[%s,%s]", slbl.c_str(), MnemoCase(R).c_str()); + buf = sformat("[%s,%s]", slbl.c_str(), MnemoCase(regname[R]).c_str()); PC += 2; } break; case 0x1B: - buf = MnemoCase(sformat("[D,%c]", R)); + buf = MnemoCase(sformat("[%s,%s]", + regname[_d].c_str(), regname[R].c_str())); break; case 0x1C: { @@ -1743,7 +1765,7 @@ if (T & 0x80) bGetLabel, PC); if (((char)T > 0) && forceDirectAddr) AddForced(smnemo, slbl, false); - buf = slbl + MnemoCase(",PCR"); + buf = slbl + "," + MnemoCase(regname[_pcr]); } else { @@ -1751,7 +1773,7 @@ if (T & 0x80) string slbl = lbl ? lbl->GetText() : Number2String((uint16_t)(int)(char)T, 2, PC); if (((char)T > 0) && forceDirectAddr) AddForced(smnemo, slbl, false); - buf = slbl + MnemoCase(",PC"); + buf = slbl + "," + MnemoCase(regname[_pc].c_str()); } buf = "[" + buf + "]"; PC++; @@ -1759,7 +1781,7 @@ if (T & 0x80) lbl = FindLabel(PC, Const); T = GetUByte(PC); string slbl = lbl ? lbl->GetText() : Number2String(T, 2, PC); - buf = sformat("[%s,PC]", slbl.c_str()); + buf = sformat("[%s,%s]", slbl.c_str(), regname[_pc].c_str()); PC++; #endif } @@ -1777,16 +1799,16 @@ if (T & 0x80) #if 1 AddForced(smnemo, slbl, true); #else - buf = sformat("[>%s,%s]", slbl.c_str(), MnemoCase("PCR").c_str()); + buf = sformat("[>%s,%s]", slbl.c_str(), MnemoCase(regname[_pcr]).c_str()); else #endif - buf = sformat("[%s,%s]", slbl.c_str(), MnemoCase("PCR").c_str()); + buf = sformat("[%s,%s]", slbl.c_str(), MnemoCase(regname[_pcr]).c_str()); #else bGetLabel = !IsConst(PC); lbl = bGetLabel ? NULL : FindLabel(PC, Const); W = GetUWord(PC); string slbl = lbl ? lbl->GetText() : Label2String(W, 4, bGetLabel, PC); - buf = sformat("[%s,PC]", slbl.c_str()); + buf = sformat("[%s,%s]", slbl.c_str(), regname[_pc].c_str()); PC += 2; #endif } @@ -1797,7 +1819,7 @@ if (T & 0x80) case 0x1A: case 0x0E: case 0x1E: - buf = "???"; + buf = MnemoCase(regname[_unkr]); break; default: @@ -1811,7 +1833,7 @@ if (T & 0x80) PC += 2; } else - buf = "???"; + buf = MnemoCase(regname[_unkr]); break; } @@ -1828,13 +1850,13 @@ else { lbl = bGetLabel ? NULL : FindLabel(PC - 1, Const); string slbl = lbl ? lbl->GetText() : Label2String((uint16_t)c, 4, bGetLabel, PC - 1); - buf = sformat("%s,%s", slbl.c_str(), MnemoCase(R).c_str()); + buf = sformat("%s,%s", slbl.c_str(), MnemoCase(regname[R]).c_str()); } else { lbl = FindLabel(PC - 1, Const); string slbl = lbl ? lbl->GetText() : SignedNumber2String(c, 2, PC - 1); - buf = sformat("%s,%s", slbl.c_str(), MnemoCase(R).c_str()); + buf = sformat("%s,%s", slbl.c_str(), MnemoCase(regname[R]).c_str()); } } @@ -1979,8 +2001,8 @@ switch (mode) /* which mode is this? */ { T = GetUByte(PC++); sparm = sformat("%s,%s", - MnemoCase(exg_tfr[T >> 4]).c_str(), - MnemoCase(exg_tfr[T & 0xF]).c_str()); + MnemoCase(regname[exg_tfr[T >> 4]]).c_str(), + MnemoCase(regname[exg_tfr[T & 0xF]]).c_str()); } break; @@ -1992,31 +2014,31 @@ switch (mode) /* which mode is this? */ // buf[0] = '\0'; T = GetUByte(PC++); if (T & 0x80) - sparm += MnemoCase("PC,"); + sparm += MnemoCase(regname[_pc]) + ","; if (T & 0x40) { if (mode == _r2) - sparm += MnemoCase("U,"); + sparm += MnemoCase(regname[_u]) + ","; else if (mode == _r3) - sparm += MnemoCase("S,"); + sparm += MnemoCase(regname[_s]) + ","; } if (T&0x20) - sparm += MnemoCase("Y,"); + sparm += MnemoCase(regname[_y]) + ","; if (T & 0x10) - sparm += MnemoCase("X,"); + sparm += MnemoCase(regname[_x]) + ","; if (T & 0x08) - sparm += MnemoCase("DP,"); + sparm += MnemoCase(regname[_dp]) + ","; if ((T & 0x06) == 0x06) - sparm += MnemoCase("D,"); + sparm += MnemoCase(regname[_d]) + ","; else { if (T & 0x04) - sparm += MnemoCase("B,"); + sparm += MnemoCase(regname[_b]) + ","; if (T & 0x02) - sparm += MnemoCase("A,"); + sparm += MnemoCase(regname[_a]) + ","; } if (T & 0x01) - sparm += MnemoCase("CC,"); + sparm += MnemoCase(regname[_cc]) + ","; if (sparm.size()) sparm = sparm.substr(0, sparm.size() - 1); } diff --git a/Dasm6809.h b/Dasm6809.h index 30f9599..a1c972a 100644 --- a/Dasm6809.h +++ b/Dasm6809.h @@ -333,16 +333,29 @@ class Dasm6809 : public Dasm6800 mnemo6809_count }; + enum Reg6809 + { + _d = reg6800_count, + _y, + _u, + _dp, + _pcr, /* not really a register, but hey... */ + + reg6809_count + }; + static CMatrixEntry m6809_codes[256]; static CMatrixEntry m6809_codes10[256]; static CMatrixEntry m6809_codes11[256]; static OpCode opcodes[mnemo6809_count - mnemo6800_count]; + static const char *regnames[reg6809_count - reg6800_count]; + static const int m6809_exg_tfr[]; static const char *os9_codes[0x100]; CMatrixEntry *codes10; CMatrixEntry *codes11; - const char **exg_tfr; - static const char reg[]; + const int *exg_tfr; + static const int reg[]; bool os9Patch; bool os9Comments; diff --git a/Dasm68HC11.cpp b/Dasm68HC11.cpp index 91217e6..4cd5ad3 100644 --- a/Dasm68HC11.cpp +++ b/Dasm68HC11.cpp @@ -364,6 +364,16 @@ OpCode Dasm68HC11::opcodes[mnemo68HC11_count - mnemo6801_count] = { "XGDY", Data }, /* _xgdy */ }; +/*****************************************************************************/ +/* regnames : additional register names over 6800 */ +/*****************************************************************************/ + +const char *Dasm68HC11::regnames[reg68HC11_count - reg6801_count] = + { + "Y", /* _y */ + }; + + /*****************************************************************************/ /* Dasm68HC11 : constructor */ /*****************************************************************************/ @@ -376,9 +386,13 @@ codes18 = m68hc11_codes18; codes1a = m68hc11_codes1a; codescd = m68hc11_codescd; boppcom = false; // A09 can't handle commas as bitop parameter delimiter yet +int i; mnemo.resize(mnemo68HC11_count); /* set up additional mnemonics */ -for (int i = 0; i < mnemo68HC11_count - mnemo6801_count; i++) +for (i = 0; i < mnemo68HC11_count - mnemo6801_count; i++) mnemo[mnemo6801_count + i] = opcodes[i]; +regname.resize(reg6801_count); /* set up additional register names */ +for (i = 0; i < reg68HC11_count - reg6801_count; i++) + regname[reg6801_count + i] = regnames[i]; // set up options table // class uses one generic option setter/getter pair (not mandatory) AddOption("boppcom", "{off|on}\tbit operation parameter comma delimiter", @@ -538,8 +552,8 @@ return PC; string Dasm68HC11::GetIx8IndexReg(uint8_t instpg) { if (instpg == 0x18 || instpg == 0xCD) - return MnemoCase(",Y"); -return MnemoCase(",X"); + return "," + MnemoCase(regname[_y]); +return "," + MnemoCase(regname[_x]); } /*****************************************************************************/ diff --git a/Dasm68HC11.h b/Dasm68HC11.h index 3e1d513..4a306a8 100644 --- a/Dasm68HC11.h +++ b/Dasm68HC11.h @@ -87,12 +87,19 @@ class Dasm68HC11 : public Dasm6801 mnemo68HC11_count }; + enum Reg6801 + { + _y = reg6801_count, + + reg68HC11_count + }; static CMatrixEntry m68hc11_codes[256]; static CMatrixEntry m68hc11_codes18[256]; static CMatrixEntry m68hc11_codes1a[256]; static CMatrixEntry m68hc11_codescd[256]; static OpCode opcodes[mnemo68HC11_count - mnemo6801_count]; + static const char *regnames[reg68HC11_count - reg6801_count]; CMatrixEntry *codes18; CMatrixEntry *codes1a; diff --git a/DasmAvr8.cpp b/DasmAvr8.cpp index c7c1ad0..dc8a6a0 100644 --- a/DasmAvr8.cpp +++ b/DasmAvr8.cpp @@ -417,6 +417,8 @@ highaddr[BusEEPROM] = 0xffff; bool bOK = Disassembler::Setup(); +SetupRegnames(avr_gcc); /* initial register name setup */ + busnames[BusData] = "Data"; busnames[BusIO] = "IO"; busnames[BusEEPROM] = "EEPROM"; @@ -424,6 +426,29 @@ busnames[BusEEPROM] = "EEPROM"; return bOK; } +/*****************************************************************************/ +/* SetupRegnames : set up register names */ +/*****************************************************************************/ + +void DasmAvr8::SetupRegnames(bool newAvrGcc) +{ +static const char *reghdr[] = { "R", "r" }; +if (!regname.size()) + { + regname.resize(regAvr8_count); /* assure space for reg names */ + regname[_x] = "X"; + regname[_y] = "Y"; + regname[_z] = "Z"; + } +for (int i = _r0; i <= _r31; i++) /* set up R0..R31 */ + { + string regnameold = sformat("%s%d", reghdr[avr_gcc], i); + if (!regname[i].size() || + regname[i] == regnameold) + regname[i] = sformat("%s%d", reghdr[newAvrGcc], i); + } +} + /*****************************************************************************/ /* InfoHelp : print disassembler-specific info file help */ /*****************************************************************************/ @@ -669,11 +694,15 @@ else if (lname == "avr-gcc") { _d_string, { ".db", ".ascii" } }, { _d_stringz, { ".db", ".asciz" } }, }; + for (size_t i = 0; i < _countof(smne); i++) + { + if (mnemo[smne[i].idx].mne == smne[i].txt[avr_gcc]) + mnemo[smne[i].idx].mne = smne[i].txt[bnValue]; + } + SetupRegnames(bnValue); avr_gcc = bnValue; if (!dbalignchg) dbalign = !avr_gcc; - for (size_t i = 0; i < _countof(smne); i++) - mnemo[smne[i].idx].mne = smne[i].txt[avr_gcc]; return bIsBool ? 1 : 0; } diff --git a/DasmAvr8.h b/DasmAvr8.h index 8308417..b1d1f60 100644 --- a/DasmAvr8.h +++ b/DasmAvr8.h @@ -303,10 +303,11 @@ class DasmAvr8 : { return sformat("0x%0*x", (busbits[bus] + 3) / 4, addr); } string RegName(int regnum, bool with_label = true) { - static const char *reghdr[] = { "R", "r" }; + // static const char *reghdr[] = { "R", "r" }; if (with_label && CurRegLabel[regnum].size()) return CurRegLabel[regnum]; - return MnemoCase(sformat("%s%d", reghdr[avr_gcc], regnum)); + // return MnemoCase(sformat("%s%d", reghdr[avr_gcc], regnum)); + return MnemoCase(regname[regnum]); } string IORegName(adr_t addr) { @@ -390,6 +391,7 @@ class DasmAvr8 : return flags; } int DisassembleString(adr_t addr, adr_t end, uint32_t flags, string &s, int maxparmlen, int bus = BusCode); + virtual void SetupRegnames(bool newAvrGcc = false); protected: // Enumeration for all types of AVR operands @@ -567,6 +569,47 @@ class DasmAvr8 : mnemoAvr8_count }; + enum RegAvr8 + { + _r0, + _r1, + _r2, + _r3, + _r4, + _r5, + _r6, + _r7, + _r8, + _r9, + _r10, + _r11, + _r12, + _r13, + _r14, + _r15, + _r16, + _r17, + _r18, + _r19, + _r20, + _r21, + _r22, + _r23, + _r24, + _r25, + _r26, + _r27, + _r28, + _r29, + _r30, + _r31, + _x, + _y, + _z, + + regAvr8_count + }; + static OpCode opcodes[mnemoAvr8_count]; static avrInstructionInfo AVR_Instruction_Set[]; vector highaddr; diff --git a/Disassembler.h b/Disassembler.h index 4c5bb81..ad8477d 100644 --- a/Disassembler.h +++ b/Disassembler.h @@ -931,6 +931,21 @@ class Disassembler } return false; } + virtual bool RegRename(string oldReg, string newReg) + { + // not exactly beautiful, but there's no guarantee that mnemonics are sorted + // and setting up a hash table for that would be overkill, so iterate through the list + string oldup = uppercase(oldReg); + for (size_t i = 0; i < regname.size(); i++) + { + if (uppercase(regname[i]) == oldup) + { + regname[i] = newReg; + return true; + } + } + return false; + } protected: static const Endian prgEndian; @@ -972,6 +987,7 @@ class Disassembler uint32_t disassemblyFlagMask; vector mnemo; + vector regname; }; diff --git a/dasmfw.cpp b/dasmfw.cpp index 9a1cc47..3f4a753 100644 --- a/dasmfw.cpp +++ b/dasmfw.cpp @@ -1277,6 +1277,7 @@ enum InfoCmd infoUnphase, /* UNPHASE addr[-addr] */ // mnemonic renaming infoMnemo, /* MNEMO org ren */ + infoReg, /* REG org ren */ // handled outside disassembler engine: infoInclude, /* INCLUDE infofilename */ @@ -1377,6 +1378,7 @@ static struct /* structure to convert key to type */ { "UNPHASE", infoUnphase }, // mnemonic renaming { "MNEMO", infoMnemo }, + { "REG", infoReg }, // handled outside disassembler engine: { "INCLUDE", infoInclude }, @@ -1948,13 +1950,22 @@ do break; case infoMnemo : /* MNEMO org ren */ + case infoReg : /* REG org ren */ { string org; idx = value.find_first_of(" \t"); if (idx == value.npos) idx = value.size(); org = value.substr(0, idx); value = triminfo(value.substr(idx)); - pDasm->MnemoRename(org, value); + switch (cmdType) + { + case infoMnemo : + pDasm->MnemoRename(org, value); + break; + case infoReg : + pDasm->RegRename(org, value); + break; + } } break; @@ -2649,6 +2660,8 @@ printf("\t (like WORD, but adds target labels if necessary)\n "\tinsert text: INSERT [AFTER] addr[-addr] embedded line\n" "\tinclude label file: INCLUDE filename\n" "\tload binary file: FILE filename [baseaddr]\n" + "\trename a mnemonic: MNEMO old new\n" + "\trename a register: REG old new\n" "\tdefine a text: TEXT name [content]\n" "\tstop parsing: END\n" ); @@ -2730,6 +2743,9 @@ printf("RMB addr[-addr]\n" "RPATCHDW addr [word]*\n" "RPATCHF addr [float]*\n" + "MNEMO old new\n" + "REG old new\n" + "TEXT name [content]\n" "END\n" diff --git a/dasmfw.h b/dasmfw.h index 0dbaca0..81f7fec 100644 --- a/dasmfw.h +++ b/dasmfw.h @@ -59,7 +59,7 @@ using namespace std; /* Global definitions */ /*****************************************************************************/ -#define DASMFW_VERSION "0.33" +#define DASMFW_VERSION "0.34" // set these to int64_t once 64bit processors become part of the framework typedef uint32_t cadr_t; /* container for maximal code address*/ diff --git a/dasmfw.htm b/dasmfw.htm index ce0783d..e58d654 100644 --- a/dasmfw.htm +++ b/dasmfw.htm @@ -270,6 +270,9 @@

Disassembler Options

commonly used ORG addr, you can add mnemo org \*=$(parm) to the info file (the backslash is necessary since dasmfw would think this is the start of a comment in the info file otherwise). +
reg org repl
+
can be used to redefine any register name the disassembler emits. The list of register names is + disassembler-dependent, of course, but the underlying logic is implemented for all of them.

The following options are disassembler-specific; some are only available for specific disassemblers. If in doubt, invoking dasmfw with the command line diff --git a/history.txt b/history.txt index bf4b9f2..c1a6962 100644 --- a/history.txt +++ b/history.txt @@ -87,4 +87,5 @@ v0.30 2022-06-06 Updates to 6502 disassembler v0.31 2022-06-08 Added mnemo info file directive Added boppcom option for 68HC11 v0.32 2022-10-10 begin and end options didn't work as intended; they should now. -v0.33 2022-10-11 Added some features to the mnemo directive \ No newline at end of file +v0.33 2022-10-11 Added some features to the mnemo directive +v0.34 2022-10-13 reg directive added \ No newline at end of file