From 306be9a7d9d62842b1fedcb515456d02f72bd7f5 Mon Sep 17 00:00:00 2001 From: Hermann Seib Date: Wed, 27 Jan 2021 20:42:43 +0100 Subject: [PATCH] Added Linux Makefile plus small fixes --- Dasm6301.cpp | 16 +- Dasm6301.h | 4 +- Dasm6309.cpp | 47 +++--- Dasm6309.h | 10 +- Dasm6800.cpp | 111 +++++++------- Dasm6800.h | 44 +++--- Dasm68000.cpp | 299 +++++++++++++++++++++++------------- Dasm68000.h | 148 +++++++++--------- Dasm6801.cpp | 6 +- Dasm6809.cpp | 122 ++++++++++----- Dasm6809.h | 70 ++++----- Dasm68HC11.cpp | 26 ++-- Dasm68HC11.h | 6 +- DasmAvr8.cpp | 102 +++++++------ DasmAvr8.h | 108 ++++++------- Disassembler.cpp | 164 +++++++++++--------- Disassembler.h | 383 ++++++++++++++++++++++++----------------------- Label.h | 36 ++--- Makefile | 25 ++++ Memory.h | 100 ++++++------- dasmfw.cpp | 143 ++++++++++-------- dasmfw.h | 49 +++--- dasmfw.vcproj | 4 + history.txt | 2 + 24 files changed, 1125 insertions(+), 900 deletions(-) create mode 100644 Makefile diff --git a/Dasm6301.cpp b/Dasm6301.cpp index af3e4ad..60b9585 100644 --- a/Dasm6301.cpp +++ b/Dasm6301.cpp @@ -163,9 +163,9 @@ Dasm6301::~Dasm6301(void) /* ParseCode : parse instruction at given memory address for labels */ /*****************************************************************************/ -addr_t Dasm6301::ParseCode +adr_t Dasm6301::ParseCode ( - addr_t addr, + adr_t addr, int bus /* ignored for 6800 and derivates */ ) { @@ -174,7 +174,7 @@ uint16_t W; int MI; const char *I; bool bSetLabel; -addr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I); +adr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I); switch (M) /* which mode is this ? */ { @@ -211,9 +211,9 @@ return PC - addr; /* pass back # processed bytes */ /* DisassembleCode : disassemble code instruction at given memory address */ /*****************************************************************************/ -addr_t Dasm6301::DisassembleCode +adr_t Dasm6301::DisassembleCode ( - addr_t addr, + adr_t addr, string &smnemo, string &sparm, int bus /* ignored for 6800 and derivates */ @@ -221,12 +221,12 @@ addr_t Dasm6301::DisassembleCode { uint8_t O, T, M; uint16_t W; -addr_t Wrel; +adr_t Wrel; int MI; const char *I; bool bGetLabel; Label *lbl; -addr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I, &smnemo); +adr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I, &smnemo); switch (M) /* which mode is this? */ { @@ -242,7 +242,7 @@ switch (M) /* which mode is this? */ if (Wrel) { W = (int)((unsigned char)T) + (uint16_t)Wrel; - sparm += Label2String((addr_t)((int)((unsigned char)T)), 4, + sparm += Label2String((adr_t)((int)((unsigned char)T)), 4, bGetLabel, PC) + GetIx8IndexReg(O); } else if (lbl) diff --git a/Dasm6301.h b/Dasm6301.h index f5748d0..d0a8fc2 100644 --- a/Dasm6301.h +++ b/Dasm6301.h @@ -42,9 +42,9 @@ class Dasm6301 : public Dasm6801 protected: // parse instruction at given memory address for labels - virtual addr_t ParseCode(addr_t addr, int bus = BusCode); + virtual adr_t ParseCode(adr_t addr, int bus = BusCode); // disassemble instruction at given memory address - virtual addr_t DisassembleCode(addr_t addr, string &smnemo, string &sparm, int bus = BusCode); + virtual adr_t DisassembleCode(adr_t addr, string &smnemo, string &sparm, int bus = BusCode); protected: // additional 6309 addressing modes diff --git a/Dasm6309.cpp b/Dasm6309.cpp index bbcf54e..855e614 100644 --- a/Dasm6309.cpp +++ b/Dasm6309.cpp @@ -265,7 +265,7 @@ uint8_t Dasm6309::h6309_codes11[512] = _ill ,_nom, _ill ,_nom, _ill ,_nom, _ill ,_nom, /* FC..FF */ }; -static char *h6309_exg_tfr[] = +static const char *h6309_exg_tfr[] = { "D", "X", "Y", "U", "S", "PC","W" ,"V", "A", "B", "CC","DP","0", "0", "E", "F" @@ -398,7 +398,7 @@ if (bus == BusCode) if (bSetSysVec) { // set up DIV0 system vector - addr_t addr = 0xfff0; + adr_t addr = 0xfff0; MemoryType memType = GetMemType(addr); if (memType != Untyped && /* if system vector loaded */ memType != Const && /* and not defined as constant */ @@ -406,7 +406,7 @@ if (bus == BusCode) { SetMemType(addr, Data); /* that's a data word */ SetCellSize(addr, 2); - addr_t tgtaddr = GetUWord(addr); /* look whether it points to loaded */ + adr_t tgtaddr = GetUWord(addr); /* look whether it points to loaded */ if (GetMemType(tgtaddr) != Untyped) { /* if so, */ SetMemType(tgtaddr, Code); /* that's code there */ @@ -424,12 +424,12 @@ return Dasm6809::InitParse(bus); /* IndexParse : parses index for labels */ /*****************************************************************************/ -addr_t Dasm6309::IndexParse(int MI, addr_t pc) +adr_t Dasm6309::IndexParse(int MI, adr_t pc, adr_t instaddr) { uint8_t T; uint16_t W; char R; -addr_t PC = pc; +adr_t PC = pc; bool bSetLabel = true; T = GetUByte(PC++); @@ -466,20 +466,23 @@ if (T & 0x80) break; } } -return Dasm6809::IndexParse(MI, pc); + +(void)R; // unused ATM + +return Dasm6809::IndexParse(MI, pc, instaddr); } /*****************************************************************************/ /* IndexString : converts index to string */ /*****************************************************************************/ -string Dasm6309::IndexString(addr_t &pc) +string Dasm6309::IndexString(adr_t &pc) { uint8_t T; uint16_t W; char R; string buf; -addr_t PC = pc; +adr_t PC = pc; bool bGetLabel; Label *lbl; @@ -565,9 +568,9 @@ return Dasm6809::IndexString(pc); /* ParseCode : parse instruction at given memory address for labels */ /*****************************************************************************/ -addr_t Dasm6309::ParseCode +adr_t Dasm6309::ParseCode ( - addr_t addr, + adr_t addr, int bus /* ignored for 6800 and derivates */ ) { @@ -576,8 +579,8 @@ uint16_t W; int MI; const char *I; bool bSetLabel; -addr_t dp = GetDirectPage(addr); -addr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I); +adr_t dp = GetDirectPage(addr); +adr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I); #if 1 // speed up things a bit by checking here (would be done in 6809 anyway) @@ -594,7 +597,7 @@ switch (M) /* which mode is this ? */ if (!bSetLabel) SetDefLabelUsed(PC, bus); T = GetUByte(PC); - if (dp >= 0) + if ((sadr_t)dp >= 0) { W = (uint16_t)dp | T; if (bSetLabel) @@ -610,7 +613,7 @@ switch (M) /* which mode is this ? */ T = GetUByte(PC); SetDefLabelUsed(PC); PC++; - PC = IndexParse(MI, PC); + PC = IndexParse(MI, PC, addr); break; case _be: /* Bit Manipulation extended */ @@ -660,10 +663,10 @@ return PC - addr; /* pass back # processed bytes */ /* DisassembleData : disassemble data area at given memory address */ /*****************************************************************************/ -addr_t Dasm6309::DisassembleData +adr_t Dasm6309::DisassembleData ( - addr_t addr, - addr_t end, + adr_t addr, + adr_t end, uint32_t flags, string &smnemo, string &sparm, @@ -674,7 +677,7 @@ addr_t Dasm6309::DisassembleData if (!(flags & SHMF_RMB) && /* if display necessary */ ((flags & 0xff) == 3)) /* and dword-sized */ { - addr_t done; + adr_t done; smnemo = "FQB"; /* assemble as many as possible */ @@ -700,9 +703,9 @@ return Dasm6809::DisassembleData(addr, end, flags, smnemo, sparm, maxparmlen, bu /* DisassembleCode : disassemble code instruction at given memory address */ /*****************************************************************************/ -addr_t Dasm6309::DisassembleCode +adr_t Dasm6309::DisassembleCode ( - addr_t addr, + adr_t addr, string &smnemo, string &sparm, int bus /* ignored for 6800 and derivates */ @@ -713,9 +716,9 @@ uint16_t W; int MI; const char *I; bool bGetLabel; -addr_t dp = GetDirectPage(addr); +adr_t dp = GetDirectPage(addr); Label *lbl; -addr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I, &smnemo); +adr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I, &smnemo); #if 1 // speed up things a bit by checking here (would be done in 6809 anyway) diff --git a/Dasm6309.h b/Dasm6309.h index a892660..becdc70 100644 --- a/Dasm6309.h +++ b/Dasm6309.h @@ -45,11 +45,11 @@ class Dasm6309 : public Dasm6809 protected: // parse instruction at given memory address for labels - virtual addr_t ParseCode(addr_t addr, int bus = BusCode); + virtual adr_t ParseCode(adr_t addr, int bus = BusCode); // disassemble data area at given memory address - virtual addr_t DisassembleData(addr_t addr, addr_t end, uint32_t flags, string &smnemo, string &sparm, int maxparmlen, int bus = BusCode); + virtual adr_t DisassembleData(adr_t addr, adr_t end, uint32_t flags, string &smnemo, string &sparm, int maxparmlen, int bus = BusCode); // disassemble instruction at given memory address - virtual addr_t DisassembleCode(addr_t addr, string &smnemo, string &sparm, int bus = BusCode); + virtual adr_t DisassembleCode(adr_t addr, string &smnemo, string &sparm, int bus = BusCode); protected: // additional 6309 addressing modes @@ -162,8 +162,8 @@ class Dasm6309 : public Dasm6809 static OpCode opcodes[mnemo6309_count - mnemo6809_count]; protected: - virtual addr_t IndexParse(int MI, addr_t pc); - virtual string IndexString(addr_t &pc); + virtual adr_t IndexParse(int MI, adr_t pc, adr_t instaddr = NO_ADDRESS); + virtual string IndexString(adr_t &pc); }; #endif // __Dasm6309_h_defined__ diff --git a/Dasm6800.cpp b/Dasm6800.cpp index b7f7767..ff9418f 100644 --- a/Dasm6800.cpp +++ b/Dasm6800.cpp @@ -126,9 +126,9 @@ uint8_t Dasm6800::m6800_codes[512] = _ill ,_nom, _ill ,_nom, _ldx ,_ext, _stx ,_ext, /* FC..FF */ }; -char *Dasm6800::bit_r[] = {"CC","A","B","??"}; +const char *Dasm6800::bit_r[] = {"CC","A","B","??"}; -char *Dasm6800::block_r[] = +const char *Dasm6800::block_r[] = { "D","X","Y","U","S","?","?","?","?","?","?","?","?","?","?","?" }; @@ -381,7 +381,7 @@ struct SFlexRecord int IsTransferAddress() { return (bSOI == 0x16); } int IsRecord() { return (bSOI == 0x02); } int GetSize() { return bDataLen; } - addr_t GetLoadAddress() { return (((addr_t)(bLoadAddress[0])) << 8) | bLoadAddress[1]; } + adr_t GetLoadAddress() { return (((adr_t)(bLoadAddress[0])) << 8) | bLoadAddress[1]; } uint8_t *GetData() { return bData; } }; #pragma pack() @@ -434,8 +434,8 @@ struct SFlexRecord rec; int nCurPos = ftell(f); int nRecs = 0; bool bExecutable = false; -addr_t fbegin = GetHighestCodeAddr(), fend = GetLowestCodeAddr(); -addr_t i; +adr_t fbegin = GetHighestCodeAddr(), fend = GetLowestCodeAddr(); +adr_t i; int c = fgetc(f); /* fetch first byte to decide */ if (c == EOF) /* whether it may be a FLEX(9) binary*/ @@ -446,8 +446,8 @@ if (c != 0 && c != 0x02 && c != 0x16) while (ReadFlexRecord(f, &rec)) { - addr_t nStart = rec.GetLoadAddress(); - addr_t nEnd = nStart + rec.GetSize() - 1; + adr_t nStart = rec.GetLoadAddress(); + adr_t nEnd = nStart + rec.GetSize() - 1; nRecs++; if (nStart < fbegin) @@ -486,6 +486,9 @@ if (nRecs > 0) end = fend; sLoadType = "FLEX"; } + +(void)bExecutable; // unused ATM - "load" is enough + return (nRecs > 0); } @@ -503,7 +506,7 @@ return LoadFlex(f, sLoadType) || // FLEX9 files need no interleave nor bus /* String2Number : convert a string to a number in all known formats */ /*****************************************************************************/ -bool Dasm6800::String2Number(string s, addr_t &value) +bool Dasm6800::String2Number(string s, adr_t &value) { /* Standard formats for known 680x assemblers : - a character has a leading ' @@ -544,12 +547,14 @@ return Disassembler::String2Number(s, value); string Dasm6800::Number2String ( - addr_t value, + adr_t value, int nDigits, - addr_t addr, + adr_t addr, int bus ) { +(void)bus; + string s; /* Standard formats for known 680x assemblers : @@ -560,10 +565,10 @@ string s; - a hex constant has a leading $ */ -MemoryType memType = GetMemType(addr); +MemAttribute::Type cellType = GetCellType(addr); MemAttribute::Display disp; bool bSigned = false; -if (memType == MemAttribute::CellUntyped) +if (cellType == MemAttribute::CellUntyped) disp = MemAttribute::DefaultDisplay; else { @@ -595,7 +600,7 @@ else if (disp == MemAttribute::Binary) /* if a binary */ } else if (disp == MemAttribute::Hex) /* if hex */ { - addr_t mask = 0; + adr_t mask = 0; for (int i = 0; i < nDigits; i++) mask |= (0x0f << (i * 4)); value &= mask; @@ -615,7 +620,7 @@ else /* otherwise */ } else { - addr_t mask = 0; + adr_t mask = 0; for (int i = 0; i < nDigits; i++) mask |= (0x0f << (i * 4)); value &= mask; @@ -643,7 +648,7 @@ if (bus == BusCode) "NMI", /* fffc */ "RST" /* fffe */ }; - for (addr_t addr = 0xfff8; addr <= GetHighestCodeAddr(); addr+= 2) + for (adr_t addr = 0xfff8; addr <= GetHighestCodeAddr(); addr+= 2) { MemoryType memType = GetMemType(addr); if (memType != Untyped && /* if system vector loaded */ @@ -653,7 +658,7 @@ if (bus == BusCode) SetMemType(addr, Data); /* that's a data word */ SetCellSize(addr, 2); /* look whether it points to loaded */ - addr_t tgtaddr = GetUWord(addr); + adr_t tgtaddr = GetUWord(addr); if (GetMemType(tgtaddr) != Untyped) { /* if so, */ SetMemType(tgtaddr, Code); /* that's code there */ @@ -672,9 +677,9 @@ return Disassembler::InitParse(bus); /* ParseData : parse data at given memory address for labels */ /*****************************************************************************/ -addr_t Dasm6800::ParseData +adr_t Dasm6800::ParseData ( - addr_t addr, + adr_t addr, int bus /* ignored for 6800 and derivates */ ) { @@ -687,7 +692,7 @@ if (!IsConst(addr) && !IsBss(addr)) SetLabelUsed(GetUWord(addr), Code, BusCode, addr); else if (csz == 1 && useDPLabels) /* or BYTE data and using DP labels */ { - addr_t dp = GetDirectPage(addr, bus); + adr_t dp = GetDirectPage(addr, bus); if (dp != NO_ADDRESS) SetLabelUsed(dp | GetUByte(addr), Code, BusCode, addr); } @@ -700,9 +705,9 @@ return csz; /* FetchInstructionDetails : fetch details about current instruction */ /*****************************************************************************/ -addr_t Dasm6800::FetchInstructionDetails +adr_t Dasm6800::FetchInstructionDetails ( - addr_t PC, + adr_t PC, uint8_t &O, uint8_t &T, uint8_t &M, @@ -726,9 +731,9 @@ return PC; /* ParseCode : parse instruction at given memory address for labels */ /*****************************************************************************/ -addr_t Dasm6800::ParseCode +adr_t Dasm6800::ParseCode ( - addr_t addr, + adr_t addr, int bus /* ignored for 6800 and derivates */ ) { @@ -737,7 +742,7 @@ uint16_t W; int MI; const char *I; bool bSetLabel; -addr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I); +adr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I); switch (M) /* which mode is this ? */ { @@ -775,7 +780,7 @@ switch (M) /* which mode is this ? */ if (bSetLabel) { // this isn't really necessary for 6800, but for derived classes - addr_t dp = GetDirectPage(PC); + adr_t dp = GetDirectPage(PC); if (dp == DEFAULT_ADDRESS || dp == NO_ADDRESS) dp = GetDirectPage(addr); if (dp == DEFAULT_ADDRESS) @@ -846,7 +851,7 @@ bool Dasm6800::DisassembleLabel string lbltxt = label->GetText(); if (lbltxt.find_first_of("+-") == string::npos) { - addr_t laddr = label->GetAddress(); + adr_t laddr = label->GetAddress(); if (lbltxt.size() && !GetRelative(laddr, bus)) slabel = lbltxt; else @@ -871,6 +876,7 @@ bool Dasm6800::DisassembleDefLabel int bus ) { +(void)bus; slabel = label->GetText(); smnemo = "EQU"; sparm = label->GetDefinition(); @@ -881,7 +887,7 @@ return true; /* GetDisassemblyFlags : get flags for disassembly of data areas */ /*****************************************************************************/ -uint32_t Dasm6800::GetDisassemblyFlags(addr_t addr, int bus) +uint32_t Dasm6800::GetDisassemblyFlags(adr_t addr, int bus) { uint32_t flags = Disassembler::GetDisassemblyFlags(addr, bus); if (flags & SHMF_TXT) @@ -890,7 +896,7 @@ if (flags & SHMF_TXT) flags &= ~SHMF_TXT; if (useDPLabels) { - addr_t dp = GetDirectPage(addr, bus); + adr_t dp = GetDirectPage(addr, bus); if (dp != NO_ADDRESS) { #if 0 @@ -899,7 +905,7 @@ if (flags & SHMF_TXT) if (!IsConst(addr, bus)) #else // activate this to only match DEFINED labels - addr_t t = dp | GetUByte(addr); + adr_t t = dp | GetUByte(addr); if (!IsConst(addr, bus) && FindLabel(t, Untyped, bus)) #endif @@ -915,10 +921,10 @@ return flags; /* DisassembleData : disassemble data area at given memory address */ /*****************************************************************************/ -addr_t Dasm6800::DisassembleData +adr_t Dasm6800::DisassembleData ( - addr_t addr, - addr_t end, + adr_t addr, + adr_t end, uint32_t flags, string &smnemo, string &sparm, @@ -926,7 +932,7 @@ addr_t Dasm6800::DisassembleData int bus /* ignored for 6800 and derivates */ ) { -addr_t done; +adr_t done; if (flags & SHMF_RMB) /* if reserved memory block */ { @@ -971,7 +977,7 @@ else /* if FCB (hex or binary) */ for (done = addr; done < end; done++) { Label *deflbl = FindLabel(done, Const, bus); - addr_t dp = GetDirectPage(done, bus); + adr_t dp = GetDirectPage(done, bus); string s; if (deflbl) s = deflbl->GetText(); @@ -996,9 +1002,9 @@ return done - addr; /* DisassembleCode : disassemble code instruction at given memory address */ /*****************************************************************************/ -addr_t Dasm6800::DisassembleCode +adr_t Dasm6800::DisassembleCode ( - addr_t addr, + adr_t addr, string &smnemo, string &sparm, int bus /* ignored for 6800 and derivates */ @@ -1006,10 +1012,10 @@ addr_t Dasm6800::DisassembleCode { uint8_t O, T, M; uint16_t W; -addr_t Wrel; +adr_t Wrel; int MI; const char *I; -addr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I, &smnemo); +adr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I, &smnemo); bool bGetLabel; Label *lbl; @@ -1060,7 +1066,7 @@ switch (M) /* which mode is this? */ bGetLabel = !IsConst(PC); lbl = bGetLabel ? NULL : FindLabel(PC, Const, bus); T = GetUByte(PC); - addr_t dp = GetDirectPage(PC); + adr_t dp = GetDirectPage(PC); if (dp == DEFAULT_ADDRESS || dp == NO_ADDRESS) dp = GetDirectPage(addr); if (dp == DEFAULT_ADDRESS) @@ -1088,7 +1094,7 @@ switch (M) /* which mode is this? */ if (bGetLabel) W = (uint16_t)PhaseInner(W, PC); string slbl = lbl ? lbl->GetText() : Label2String(W, 4, bGetLabel, PC); - addr_t dp = GetDirectPage(PC); + adr_t dp = GetDirectPage(PC); if (dp == DEFAULT_ADDRESS || dp == NO_ADDRESS) dp = GetDirectPage(addr); if (dp == DEFAULT_ADDRESS) @@ -1112,7 +1118,7 @@ switch (M) /* which mode is this? */ if (Wrel) { W = (int)((unsigned char)T) + (uint16_t)Wrel; - sparm = Label2String((addr_t)((int)((unsigned char)T)), 4, + sparm = Label2String((adr_t)((int)((unsigned char)T)), 4, bGetLabel, PC) + GetIx8IndexReg(O); } else if (lbl) @@ -1153,9 +1159,9 @@ return PC - addr; /* pass back # processed bytes */ bool Dasm6800::DisassembleChanges ( - addr_t addr, - addr_t prevaddr, - addr_t prevsz, + adr_t addr, + adr_t prevaddr, + adr_t prevsz, bool bAfterLine, vector &changes, int bus @@ -1180,19 +1186,20 @@ if (addr == NO_ADDRESS && prevaddr == NO_ADDRESS) } else // no bus check necessary, there's only one { - addr_t org = DephaseOuter(addr, addr); - addr_t prevorg = DephaseOuter(prevaddr, prevaddr); + adr_t org = DephaseOuter(addr, addr); + adr_t prevorg = DephaseOuter(prevaddr, prevaddr); + (void)org;(void)prevorg; // unused ATM if (addr != prevaddr + prevsz) { if (!bAfterLine) { - TMemory *curPhArea = FindPhase(addr); - TMemory *prevPhArea = FindPhase(prevaddr); + TMemory *curPhArea = FindPhase(addr); + TMemory *prevPhArea = FindPhase(prevaddr); - addr_t prevphase = prevPhArea ? prevPhArea->GetType() : NO_ADDRESS; - addr_t prevphstart = prevPhArea ? prevPhArea->GetStart() : NO_ADDRESS; - addr_t curphase = curPhArea ? curPhArea->GetType() : NO_ADDRESS; - addr_t curphstart = curPhArea ? curPhArea->GetStart() : NO_ADDRESS; + adr_t prevphase = prevPhArea ? prevPhArea->GetType() : NO_ADDRESS; + adr_t prevphstart = prevPhArea ? prevPhArea->GetStart() : NO_ADDRESS; + adr_t curphase = curPhArea ? curPhArea->GetType() : NO_ADDRESS; + adr_t curphstart = curPhArea ? curPhArea->GetStart() : NO_ADDRESS; LineChange chg; changes.push_back(chg); if (prevphase != NO_ADDRESS && prevphstart != curphstart) diff --git a/Dasm6800.h b/Dasm6800.h index d59a91f..e9270d0 100644 --- a/Dasm6800.h +++ b/Dasm6800.h @@ -61,19 +61,19 @@ class Dasm6800 : // return whether big- or little-endian virtual Endian GetEndianness() { return BigEndian; } // return bus width - virtual int GetBusWidth(int bus = BusCode) { return 16; } + virtual int GetBusWidth(int bus = BusCode) { (void)bus; return 16; } // return code bits virtual int GetCodeBits() { return 16; } // return code pointer size in bytes virtual int GetCodePtrSize() { return 2; } // return highest possible code address - virtual caddr_t GetHighestCodeAddr() { return 0xffff; } + virtual cadr_t GetHighestCodeAddr() { return 0xffff; } // return data bits virtual int GetDataBits() { return 8; } // return data pointer size in bytes virtual int GetDataPtrSize() { return 2; } // return highest possible data address - virtual daddr_t GetHighestDataAddr() { return 0xffff; } + virtual dadr_t GetHighestDataAddr() { return 0xffff; } // Options handler protected: @@ -82,42 +82,42 @@ class Dasm6800 : protected: // parse data area for labels - virtual addr_t ParseData(addr_t addr, int bus = BusCode); + virtual adr_t ParseData(adr_t addr, int bus = BusCode); // parse instruction at given memory address for labels - virtual addr_t ParseCode(addr_t addr, int bus = BusCode); + virtual adr_t ParseCode(adr_t addr, int bus = BusCode); // pass back correct mnemonic and parameters for a label virtual bool DisassembleLabel(Label *label, string &slabel, string &smnemo, string &sparm, int bus = BusCode); // pass back correct mnemonic and parameters for a DefLabel virtual bool DisassembleDefLabel(DefLabel *label, string &slabel, string &smnemo, string &sparm, int bus = BusCode); // disassemble data area at given memory address - virtual addr_t DisassembleData(addr_t addr, addr_t end, uint32_t flags, string &smnemo, string &sparm, int maxparmlen, int bus = BusCode); + virtual adr_t DisassembleData(adr_t addr, adr_t end, uint32_t flags, string &smnemo, string &sparm, int maxparmlen, int bus = BusCode); // disassemble instruction at given memory address - virtual addr_t DisassembleCode(addr_t addr, string &smnemo, string &sparm, int bus = BusCode); + virtual adr_t DisassembleCode(adr_t addr, string &smnemo, string &sparm, int bus = BusCode); // Get Flags for disassembly of data areas - virtual uint32_t GetDisassemblyFlags(addr_t addr, int bus = BusCode); + virtual uint32_t GetDisassemblyFlags(adr_t addr, int bus = BusCode); // Get/Set additional cell information - virtual addr_t GetDirectPage(addr_t addr, int bus = BusCode) - { return 0; } - virtual void SetDirectPage(addr_t addr, addr_t dp, int bus = BusCode) - { } + virtual adr_t GetDirectPage(adr_t addr, int bus = BusCode) + { (void)addr; (void)bus; return 0; } + virtual void SetDirectPage(adr_t addr, adr_t dp, int bus = BusCode) + { (void)addr; (void)dp; (void)bus; } public: // Initialize parsing virtual bool InitParse(int bus = BusCode); // pass back disassembler-specific state changes before/after a disassembly line - virtual bool DisassembleChanges(addr_t addr, addr_t prevaddr, addr_t prevsz, bool bAfterLine, vector &changes, int bus = BusCode); + virtual bool DisassembleChanges(adr_t addr, adr_t prevaddr, adr_t prevsz, bool bAfterLine, vector &changes, int bus = BusCode); protected: bool LoadFlex(FILE *f, string &sLoadType); virtual bool LoadFile(string filename, FILE *f, string &sLoadType, int interleave = 1, int bus = BusCode); - virtual bool String2Number(string s, addr_t &value); - virtual string Number2String(addr_t value, int nDigits, addr_t addr, int bus = BusCode); - virtual string Address2String(addr_t addr, int bus = BusCode) - { return sformat("$%04X", addr); } - virtual addr_t FetchInstructionDetails(addr_t PC, uint8_t &O, uint8_t &T, uint8_t &M, uint16_t &W, int &MI, const char *&I, string *smnemo = NULL); - virtual string GetIx8IndexReg(uint8_t O) { return ",X"; } + virtual bool String2Number(string s, adr_t &value); + virtual string Number2String(adr_t value, int nDigits, adr_t addr, int bus = BusCode); + virtual string Address2String(adr_t addr, int bus = BusCode) + { (void)bus; return sformat("$%04X", addr); } + virtual adr_t FetchInstructionDetails(adr_t PC, uint8_t &O, uint8_t &T, uint8_t &M, uint16_t &W, int &MI, const char *&I, string *smnemo = NULL); + virtual string GetIx8IndexReg(uint8_t O) { (void)O; return ",X"; } protected: // 6800 addressing modes @@ -256,10 +256,10 @@ class Dasm6800 : static uint8_t m6800_codes[512]; uint8_t *codes; - static char *bit_r[]; - static char *block_r[]; + static const char *bit_r[]; + static const char *block_r[]; static OpCode opcodes[mnemo6800_count]; - addr_t dirpage; + adr_t dirpage; bool useConvenience; bool useFCC; diff --git a/Dasm68000.cpp b/Dasm68000.cpp index 6d8a040..ffeffff 100644 --- a/Dasm68000.cpp +++ b/Dasm68000.cpp @@ -518,7 +518,7 @@ else // "gen" or anything else /* String2Number : convert a string to a number in all known formats */ /*****************************************************************************/ -bool Dasm68000::String2Number(string s, addr_t &value) +bool Dasm68000::String2Number(string s, adr_t &value) { /* Standard formats for known 680xx assemblers : - a character has a leading ' @@ -559,9 +559,9 @@ return Disassembler::String2Number(s, value); string Dasm68000::Number2String ( - addr_t value, + adr_t value, int nDigits, - addr_t addr, + adr_t addr, int bus ) { @@ -575,15 +575,15 @@ string s; - a hex constant has a leading $ */ -MemoryType memType = GetMemType(addr); +MemAttribute::Type cellType = GetCellType(addr, bus); MemAttribute::Display disp; bool bSigned = false; -if (memType == MemAttribute::CellUntyped) +if (cellType == MemAttribute::CellUntyped) disp = MemAttribute::DefaultDisplay; else { - disp = GetDisplay(addr); - bSigned = IsSigned(addr); + disp = GetDisplay(addr, bus); + bSigned = IsSigned(addr, bus); } if (disp == MemAttribute::DefaultDisplay) @@ -610,7 +610,7 @@ else if (disp == MemAttribute::Binary) /* if a binary */ } else if (disp == MemAttribute::Hex) /* if hex */ { - addr_t mask = 0; + adr_t mask = 0; for (int i = 0; i < nDigits; i++) mask |= (0x0f << (i * 4)); value &= mask; @@ -638,7 +638,7 @@ else /* otherwise */ } else { - addr_t mask = 0; + adr_t mask = 0; for (int i = 0; i < nDigits; i++) mask |= (0x0f << (i * 4)); value &= mask; @@ -663,9 +663,9 @@ return Disassembler::InitParse(bus); /* ParseData : parse data at given memory address for labels */ /*****************************************************************************/ -addr_t Dasm68000::ParseData +adr_t Dasm68000::ParseData ( - addr_t addr, + adr_t addr, int bus ) { @@ -728,15 +728,15 @@ return 0; /* ParseCode : parse instruction at given memory address for labels */ /*****************************************************************************/ -addr_t Dasm68000::ParseCode +adr_t Dasm68000::ParseCode ( - addr_t addr, + adr_t addr, int bus ) { -uint16_t code = GetUWord(addr /*, bus*/); +uint16_t code = GetUWord(addr, bus); int i = otIndex[code]; -addr_t len = 2; /* default to 2 bytes length */ +adr_t len = 2; /* default to 2 bytes length */ switch (OpTable[i].ot) /* parse according to op type */ { case optype_01 : @@ -827,7 +827,7 @@ switch (OpTable[i].ot) /* parse according to op type */ len = ParseOptype29(addr, addr + 2, code, i) - addr; break; default : /* not a valid instruction ? */ - SetInvalidInstruction(addr, 2); /* mark it as such */ + SetInvalidInstruction(addr, 2, bus); /* mark it as such */ break; } @@ -838,10 +838,10 @@ return len; /* ParseEffectiveAddress : parse the EA part of an instruction */ /*****************************************************************************/ -addr_t Dasm68000::ParseEffectiveAddress +adr_t Dasm68000::ParseEffectiveAddress ( - addr_t instaddr, /* address of instruction start */ - addr_t addr, /* current address */ + adr_t instaddr, /* address of instruction start */ + adr_t addr, /* current address */ uint16_t ea, int16_t index, /* index into opcode table */ int op_mode @@ -922,7 +922,7 @@ switch(mode) if (!IsConst(addr)) SetLabelUsed(a1, mt, BusCode, instaddr); a1 = PhaseInner(a1, instaddr); - if ((addr_t)a1 <= GetHighestCodeAddr()) + if ((adr_t)a1 <= GetHighestCodeAddr()) AddRelativeLabel(a1, addr, mt, true, BusCode, instaddr); addr += 4; break; @@ -934,7 +934,7 @@ switch(mode) if (!IsConst(addr)) SetLabelUsed(a1, mt, BusCode, instaddr); a1 = PhaseInner(a1, instaddr); - if ((addr_t)a1 <= GetHighestCodeAddr()) + if ((adr_t)a1 <= GetHighestCodeAddr()) AddRelativeLabel(a1, addr, mt, true, BusCode, instaddr); addr += 2; break; @@ -991,6 +991,11 @@ switch(mode) SetInvalidInstruction(instaddr, 2); break; } /* end of switch mode */ + +(void)index_reg; // these are unused ATM +(void)index_reg_ind; +(void)index_size; + return addr; } @@ -998,23 +1003,29 @@ return addr; /* ParseOptypeXX : parsers for the various 68000 op types */ /*****************************************************************************/ -addr_t Dasm68000::ParseOptype01(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype01(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; +(void)code; +(void)optable_index; + int16_t displacement = GetSWord(addr); /* get displacement */ +(void)displacement; // unused ATM addr += 2; return addr; } -addr_t Dasm68000::ParseOptype02(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype02(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { uint16_t dest_reg = (code >> 9) & 0x07; /* get destination reg */ +(void)dest_reg; // unused ATM uint16_t source = code & 0x3f; /* this is an effective address */ /* calculate effective address */ addr = ParseEffectiveAddress(instaddr, addr, source, optable_index, 0); return addr; } -addr_t Dasm68000::ParseOptype03(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype03(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { uint16_t dest_reg = (code >> 9) & 0x07; uint16_t source = code & 0x3f; /* this is an effective address */ @@ -1037,10 +1048,12 @@ else op_mode = xlate_size(&size, 0); addr = ParseEffectiveAddress(instaddr, addr, source, optable_index, op_mode); +(void)dir; // unused ATM +(void)dest_reg; return addr; } -addr_t Dasm68000::ParseOptype04(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype04(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { int size = (code >> 12) & 0x03; int16_t op_mode = xlate_size(&size, 1); @@ -1053,7 +1066,7 @@ addr = ParseEffectiveAddress(instaddr, addr, dest, optable_index, 0); return addr; } -addr_t Dasm68000::ParseOptype05(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype05(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { // PEA type instructions int16_t source = code & 0x3f; @@ -1061,7 +1074,7 @@ addr = ParseEffectiveAddress(instaddr, addr, source, optable_index, 0); return addr; } -addr_t Dasm68000::ParseOptype06(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype06(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { // ADDQ type instructions @@ -1072,10 +1085,11 @@ int16_t data = (code >> 9) & 0x07; if (data == 0) data = 8; addr = ParseEffectiveAddress(instaddr, addr, dest, optable_index, 0); +(void)op_mode; // unused ATM return addr; } -addr_t Dasm68000::ParseOptype07(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype07(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { // TST type instructions @@ -1084,15 +1098,16 @@ int size = (code >> 6) & 0x03; int16_t op_mode = xlate_size(&size, 0); addr = ParseEffectiveAddress(instaddr, addr, dest, optable_index, 0); +(void)op_mode; // unused ATM return addr; } -addr_t Dasm68000::ParseOptype08(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype08(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { -addr_t startaddr = addr - 2; +adr_t startaddr = addr - 2; // Branches uint16_t displacement = code & 0xff; -addr_t dest; +adr_t dest; bool bSetLabelUsed = !IsConst(startaddr); if (displacement == 0) { @@ -1116,20 +1131,23 @@ AddLabel(dest, mnemo[OpTable[optable_index].mnemo].memType, "", true); return addr; } -addr_t Dasm68000::ParseOptype09(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype09(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; (void)code; (void)optable_index; // UNLINK type instructions int16_t reg = code & 0x07; +(void)reg; // unused ATM return addr; } -addr_t Dasm68000::ParseOptype10(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype10(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; (void)code; (void)optable_index; // RTS type instructions - no arguments return addr; } -addr_t Dasm68000::ParseOptype11(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype11(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { // LSR type instructions @@ -1139,7 +1157,9 @@ if (size < 3) /* register shifts */ int16_t type = (code >> 5) & 0x01; int16_t dest = (code & 0x07); int16_t count = (code >> 9) & 0x07; -#if 0 +#if 1 + (void)type; (void)dest; (void)count; +#else smnemo += GetSizeSuffix(size); if (type) sparm = sformat("%s,%s", GetDataReg(count), GetDataReg(dest)); @@ -1161,18 +1181,20 @@ else /* memory shifts */ return addr; } -addr_t Dasm68000::ParseOptype12(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype12(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; (void)optable_index; // EXT type instruction int16_t op_mode = ((code >> 6) & 0x07) - 1; int16_t reg = code & 0x07; // smnemo += GetSizeSuffix(op_mode); // sparm = GetDataReg(reg); +(void)op_mode; (void)reg; // unused ATM return addr; } -addr_t Dasm68000::ParseOptype13(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype13(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { // ADDI type instruction @@ -1193,11 +1215,13 @@ addr = ParseEffectiveAddress(instaddr, addr, dest, optable_index, 0); // smnemo += GetSizeSuffix(size); // sparm = sformat("#$%x,%s", il_data, e_a); +(void)il_data; // unused ATM return addr; } -addr_t Dasm68000::ParseOptype14(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype14(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; (void)optable_index; // ABCD type instruction int16_t dest = (code >> 9) & 0x07; @@ -1210,10 +1234,12 @@ sparm = (dest_type) ? sformat("-(%s),-(%s)", GetAddrReg(source), GetAddrReg(dest)) : sformat("%s,%s", GetDataReg(source), GetDataReg(dest)); */ +(void)dest; (void)source; (void)dest_type; (void)size; + return addr; } -addr_t Dasm68000::ParseOptype15(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype15(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { // CLR type instruction @@ -1222,10 +1248,11 @@ int size = (code >> 6) & 0x03; addr = ParseEffectiveAddress(instaddr, addr, dest, optable_index, 0); // smnemo += GetSizeSuffix(size); // sparm = e_a; +(void)size; return addr; } -addr_t Dasm68000::ParseOptype16(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype16(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { // CHK type instruction @@ -1233,10 +1260,11 @@ int16_t dest = code & 0x3f; int16_t reg = (code >> 9) & 0x07; addr = ParseEffectiveAddress(instaddr, addr, dest, optable_index, WORD_SIZE); // sparm = sformat("%s,%s", e_a, GetDataReg(reg)); +(void)reg; return addr; } -addr_t Dasm68000::ParseOptype17(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype17(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { // DBcc type instructions @@ -1250,11 +1278,14 @@ AddRelativeLabel(dest, addr, mnemo[OpTable[optable_index].mnemo].memType, true, addr += 2; // sparm = sformat("%s,$%lx", GetDataReg(reg), dest); +(void)reg; return addr; } -addr_t Dasm68000::ParseOptype18(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype18(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; (void)optable_index; + // EXG type instructions int16_t op_mode = (code >> 3) & 0x1f; @@ -1265,8 +1296,10 @@ if (op_mode != 0x08 && return addr; } -addr_t Dasm68000::ParseOptype19(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype19(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; (void)optable_index; + // CMPM type instructions int16_t source = code & 0x07; @@ -1274,10 +1307,11 @@ int16_t dest = (code >> 9) & 0x07; int size = (code >> 6) & 0x03; // smnemo += GetSizeSuffix(size); // sparm = sformat("(%s)+,(%s)+", GetAddrReg(source), GetAddrReg(dest)); +(void)source; (void)dest; (void)size; return addr; } -addr_t Dasm68000::ParseOptype20(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype20(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { // BTST # type instruction @@ -1286,29 +1320,34 @@ int32_t il_data = GetSWord(addr); addr += 2; addr = ParseEffectiveAddress(instaddr, addr, dest, optable_index, 0); // sparm = sformat("#$%x,%s", il_data, e_a); +(void)il_data; return addr; } -addr_t Dasm68000::ParseOptype21(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype21(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { int16_t dest_reg = (code >> 9) & 0x07; int16_t source = code & 0x3f; /* this is an effective address */ addr = ParseEffectiveAddress(instaddr, addr, source, optable_index, 0); // sparm = sformat("%s,%s", GetDataReg(dest_reg), e_a); +(void)dest_reg; return addr; } -addr_t Dasm68000::ParseOptype22(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype22(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; (void)optable_index; + // moveq int16_t data = (int16_t)((char)(code & 0xff)); uint16_t dest_reg = (code >> 9) & 0x07; // sparm = sformat("#$%x,%s", data, GetDataReg(dest_reg)); +(void)data; (void)dest_reg; return addr; } -addr_t Dasm68000::ParseOptype23(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype23(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { // movem @@ -1419,30 +1458,37 @@ else smnemo += GetSizeSuffix(size ? 2 : 1); sparm = sformat("%s,%s", f, d); #endif +(void)size; (void)direction; return addr; } -addr_t Dasm68000::ParseOptype24(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype24(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; (void)optable_index; + // trap int16_t vector = code & 0x0f; // sparm = sformat("#$%x", vector); +(void)vector; return addr; } -addr_t Dasm68000::ParseOptype25(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype25(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; (void)code; (void)optable_index; + // stop uint16_t data = GetUWord(addr); addr += 2; // sparm = sformat("#$%x", data); +(void)data; return addr; } -addr_t Dasm68000::ParseOptype26(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype26(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { // move sr @@ -1453,27 +1499,34 @@ uint16_t mt = code & 0x0600; //sparm = (code & 0x400) ? // sformat("%s,%s", e_a, reg) : // sformat("%s,%s", reg, e_a); - +(void)mt; return addr; } -addr_t Dasm68000::ParseOptype27(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype27(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; (void)code; (void)optable_index; + uint16_t data = GetUWord(addr); addr += 2; //sparm = sformat("#$%x,%s", data, (code & 0x40) ? "SR" : "CCR"); +(void)data; return addr; } -addr_t Dasm68000::ParseOptype28(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype28(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; (void)code; (void)optable_index; + // MOVE USP // sparm = sformat((code & 0x08) ? "USP,%s" : "%s,USP", GetAddrReg(code & 0x7)); return addr; } -addr_t Dasm68000::ParseOptype29(addr_t instaddr, addr_t addr, uint16_t code, int optable_index) +adr_t Dasm68000::ParseOptype29(adr_t instaddr, adr_t addr, uint16_t code, int optable_index) { +(void)instaddr; (void)optable_index; + // MOVEP - move peripheral data int data_reg = (code & 0x0e00) >> 9; int adr_reg = code & 0x07; @@ -1484,6 +1537,7 @@ addr += 2; // sparm = sformat("%s,%x(%s)", GetDataReg(data_reg),displacement, GetAddrReg(adr_reg)); //else // sparm = sformat("%x(%s),%s", displacement, GetAddrReg(adr_reg), GetDataReg(data_reg)); +(void)data_reg; (void)adr_reg; (void)direction; (void)displacement; return addr; } @@ -1503,7 +1557,7 @@ bool Dasm68000::DisassembleLabel string lbltxt = label->GetText(); if (lbltxt.find_first_of("+-") == string::npos) { - addr_t laddr = label->GetAddress(); + adr_t laddr = label->GetAddress(); if (lbltxt.size() && !GetRelative(laddr, bus)) slabel = lbltxt; else @@ -1528,6 +1582,7 @@ bool Dasm68000::DisassembleDefLabel int bus ) { +(void)bus; slabel = label->GetText(); smnemo = "EQU"; sparm = label->GetDefinition(); @@ -1538,10 +1593,10 @@ return true; /* DisassembleData : disassemble data area at given memory address */ /*****************************************************************************/ -addr_t Dasm68000::DisassembleData +adr_t Dasm68000::DisassembleData ( - addr_t addr, - addr_t end, + adr_t addr, + adr_t end, uint32_t flags, string &smnemo, string &sparm, @@ -1549,7 +1604,7 @@ addr_t Dasm68000::DisassembleData int bus /* ignored for 6800 and derivates */ ) { -addr_t done; +adr_t done; if (FindLabel(addr, Const, bus)) flags &= ~SHMF_TXT; @@ -1644,17 +1699,17 @@ return done - addr; /* DisassembleCode : disassemble code instruction at given memory address */ /*****************************************************************************/ -addr_t Dasm68000::DisassembleCode +adr_t Dasm68000::DisassembleCode ( - addr_t addr, + adr_t addr, string &smnemo, string &sparm, int bus /* ignored for 6800 and derivates */ ) { -uint16_t code = GetUWord(addr /*, bus*/); +uint16_t code = GetUWord(addr, bus); int i = otIndex[code]; -addr_t len = 2; /* default to 2 bytes length */ +adr_t len = 2; /* default to 2 bytes length */ smnemo = mnemo[OpTable[i].mnemo].mne; /* initialize mnemonic */ switch (OpTable[i].ot) /* parse according to op type */ { @@ -1798,16 +1853,19 @@ return sizes[sizeCode & 7].c_str(); /* DisassembleEffectiveAddress : disassemble the EA part of an instruction */ /*****************************************************************************/ -addr_t Dasm68000::DisassembleEffectiveAddress +adr_t Dasm68000::DisassembleEffectiveAddress ( - addr_t instaddr, /* address of instruction start */ - addr_t addr, /* current address */ + adr_t instaddr, /* address of instruction start */ + adr_t addr, /* current address */ string &s, /* destination buffer */ uint16_t ea, int16_t index, /* index into opcode table */ int op_mode ) { +(void)instaddr; +(void)index; + int mode; int reg; int32_t displacement; @@ -1963,8 +2021,10 @@ return addr; /* DisassembleOptypeXX : disassemblers for the various 68000 op types */ /*****************************************************************************/ -addr_t Dasm68000::DisassembleOptype01(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype01(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)code; (void)optable_index; (void)smnemo; + int reg = code & 0x07; /* get register number */ int16_t displacement = GetSWord(addr); /* get word displacement */ sparm = sformat("%s,#%s", GetAddrReg(reg), @@ -1973,8 +2033,9 @@ addr += 2; return addr; } -addr_t Dasm68000::DisassembleOptype02(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype02(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)smnemo; // LEA string e_a; /* place to put effective address */ uint16_t dest_reg = (code >> 9) & 0x07; /* get destination reg */ @@ -1990,7 +2051,7 @@ sparm = sformat("%s,%s", e_a.c_str(), GetAddrReg(dest_reg)); return addr; } -addr_t Dasm68000::DisassembleOptype03(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype03(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { uint16_t dest_reg = (code >> 9) & 0x07; uint16_t source = code & 0x3f; /* this is an effective address */ @@ -2029,7 +2090,7 @@ sparm = (!dir) ? return addr; } -addr_t Dasm68000::DisassembleOptype04(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype04(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { string e_a1, e_a2; int size = (code >> 12) & 0x03; @@ -2053,8 +2114,9 @@ sparm = sformat("%s,%s", e_a1.c_str(), e_a2.c_str()); return addr; } -addr_t Dasm68000::DisassembleOptype05(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype05(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)smnemo; // PEA type instructions int16_t source = code & 0x3f; addr = DisassembleEffectiveAddress(instaddr, addr, sparm, source, optable_index, 0); @@ -2062,7 +2124,7 @@ addr = DisassembleEffectiveAddress(instaddr, addr, sparm, source, optable_index, return addr; } -addr_t Dasm68000::DisassembleOptype06(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype06(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { // ADDQ type instructions @@ -2078,10 +2140,11 @@ addr = DisassembleEffectiveAddress(instaddr, addr, e_a, dest, optable_index, 0); smnemo += GetSizeSuffix(size); sparm = sformat("#%s,%s", s_data.c_str(), e_a.c_str()); +(void)op_mode; // unused ATM return addr; } -addr_t Dasm68000::DisassembleOptype07(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype07(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { // TST type instructions @@ -2091,16 +2154,18 @@ int16_t op_mode = xlate_size(&size, 0); addr = DisassembleEffectiveAddress(instaddr, addr, sparm, dest, optable_index, 0); smnemo += GetSizeSuffix(size); +(void)op_mode; // unused ATM return addr; } -addr_t Dasm68000::DisassembleOptype08(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype08(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)optable_index; // branches -addr_t startaddr = addr - 1; +adr_t startaddr = addr - 1; int32_t displacement = code & 0xff; -addr_t dest; +adr_t dest; bool bGetLabel = !IsConst(startaddr); if (displacement == 0) { @@ -2128,8 +2193,9 @@ sparm = Label2String(dest, GetBusWidth() / 4, bGetLabel, startaddr); return addr; } -addr_t Dasm68000::DisassembleOptype09(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype09(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)optable_index; (void)smnemo; // UNLINK type instructions int16_t reg = code & 0x07; @@ -2138,13 +2204,14 @@ sparm = GetAddrReg(reg); return addr; } -addr_t Dasm68000::DisassembleOptype10(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype10(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)code; (void)optable_index; (void)smnemo; (void)sparm; // RTS type instructions - no arguments return addr; } -addr_t Dasm68000::DisassembleOptype11(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype11(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { // LSR type instructions @@ -2175,8 +2242,9 @@ else /* memory shifts */ return addr; } -addr_t Dasm68000::DisassembleOptype12(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype12(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)optable_index; // EXT type instruction int16_t op_mode = ((code >> 6) & 0x07) - 1; @@ -2187,7 +2255,7 @@ sparm = GetDataReg(reg); return addr; } -addr_t Dasm68000::DisassembleOptype13(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype13(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { // ADDI type instruction @@ -2214,8 +2282,9 @@ sparm = sformat("#%s,%s", s_data.c_str(), e_a.c_str()); return addr; } -addr_t Dasm68000::DisassembleOptype14(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype14(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)optable_index; // ABCD type instruction int16_t dest = (code >> 9) & 0x07; @@ -2229,7 +2298,7 @@ sparm = (dest_type) ? return addr; } -addr_t Dasm68000::DisassembleOptype15(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype15(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { // CLR type instruction @@ -2240,8 +2309,9 @@ smnemo += GetSizeSuffix(size); return addr; } -addr_t Dasm68000::DisassembleOptype16(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype16(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)smnemo; // CHK type instruction int16_t dest = code & 0x3f; @@ -2252,8 +2322,9 @@ sparm = sformat("%s,%s", e_a.c_str(), GetDataReg(reg)); return addr; } -addr_t Dasm68000::DisassembleOptype17(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype17(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)optable_index; (void)smnemo; // DBcc type instructions int16_t reg = code & 0x07; @@ -2268,8 +2339,9 @@ addr += 2; return addr; } -addr_t Dasm68000::DisassembleOptype18(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype18(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)optable_index; (void)smnemo; // EXG type instructions int16_t dest = code & 0x07; @@ -2295,8 +2367,9 @@ sparm = sformat("%s,%s", rx, ry); return addr; } -addr_t Dasm68000::DisassembleOptype19(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype19(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)optable_index; // CMPM type instructions int16_t source = code & 0x07; @@ -2307,8 +2380,9 @@ sparm = sformat("(%s)+,(%s)+", GetAddrReg(source), GetAddrReg(dest)); return addr; } -addr_t Dasm68000::DisassembleOptype20(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype20(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)smnemo; // BTST # type instruction int16_t dest = code & 0x3f; @@ -2320,8 +2394,9 @@ sparm = sformat("#%s,%s", s_data.c_str(), e_a.c_str()); return addr; } -addr_t Dasm68000::DisassembleOptype21(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype21(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)smnemo; int16_t dest_reg = (code >> 9) & 0x07; int16_t source = code & 0x3f; /* this is an effective address */ string e_a; @@ -2330,8 +2405,9 @@ sparm = sformat("%s,%s", GetDataReg(dest_reg), e_a.c_str()); return addr; } -addr_t Dasm68000::DisassembleOptype22(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype22(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)optable_index; (void)smnemo; // moveq int16_t data = (int16_t)((char)(code & 0xff)); @@ -2340,7 +2416,7 @@ sparm = sformat("#$%x,%s", data, GetDataReg(dest_reg)); return addr; } -addr_t Dasm68000::DisassembleOptype23(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype23(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { // movem @@ -2456,8 +2532,9 @@ sparm = sformat("%s,%s", f, d); return addr; } -addr_t Dasm68000::DisassembleOptype24(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype24(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)optable_index; (void)smnemo; // trap int16_t vector = code & 0x0f; @@ -2465,8 +2542,9 @@ sparm = sformat("#%s", Number2String(vector, 1, addr - 2).c_str()); return addr; } -addr_t Dasm68000::DisassembleOptype25(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype25(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)code; (void)optable_index; (void)smnemo; // stop uint16_t data = GetUWord(addr); @@ -2475,8 +2553,9 @@ addr += 2; return addr; } -addr_t Dasm68000::DisassembleOptype26(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype26(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)smnemo; // move sr int16_t source = code & 0x3f; @@ -2491,8 +2570,9 @@ sparm = (code & 0x400) ? return addr; } -addr_t Dasm68000::DisassembleOptype27(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype27(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)optable_index; (void)smnemo; uint16_t data = GetUWord(addr); sparm = sformat("#%s,%s", Number2String(data, 4, addr).c_str(), @@ -2501,15 +2581,17 @@ addr += 2; return addr; } -addr_t Dasm68000::DisassembleOptype28(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype28(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)optable_index; (void)smnemo; // MOVE USP sparm = sformat((code & 0x08) ? "USP,%s" : "%s,USP", GetAddrReg(code & 0x07)); return addr; } -addr_t Dasm68000::DisassembleOptype29(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) +adr_t Dasm68000::DisassembleOptype29(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm) { +(void)instaddr; (void)optable_index; (void)smnemo; // MOVEP - move peripheral data int data_reg = (code & 0x0e00) >> 9; int adr_reg = code & 0x07; @@ -2536,9 +2618,9 @@ return addr; bool Dasm68000::DisassembleChanges ( - addr_t addr, - addr_t prevaddr, - addr_t prevsz, + adr_t addr, + adr_t prevaddr, + adr_t prevsz, bool bAfterLine, vector &changes, int bus @@ -2563,19 +2645,19 @@ if (addr == NO_ADDRESS && prevaddr == NO_ADDRESS) } else // no bus check necessary, there's only one { - addr_t org = DephaseOuter(addr, addr); - addr_t prevorg = DephaseOuter(prevaddr, prevaddr); + adr_t org = DephaseOuter(addr, addr); + adr_t prevorg = DephaseOuter(prevaddr, prevaddr); if (addr != prevaddr + prevsz) { if (!bAfterLine) { - TMemory *curPhArea = FindPhase(addr); - TMemory *prevPhArea = FindPhase(prevaddr); + TMemory *curPhArea = FindPhase(addr); + TMemory *prevPhArea = FindPhase(prevaddr); - addr_t prevphase = prevPhArea ? prevPhArea->GetType() : NO_ADDRESS; - addr_t prevphstart = prevPhArea ? prevPhArea->GetStart() : NO_ADDRESS; - addr_t curphase = curPhArea ? curPhArea->GetType() : NO_ADDRESS; - addr_t curphstart = curPhArea ? curPhArea->GetStart() : NO_ADDRESS; + adr_t prevphase = prevPhArea ? prevPhArea->GetType() : NO_ADDRESS; + adr_t prevphstart = prevPhArea ? prevPhArea->GetStart() : NO_ADDRESS; + adr_t curphase = curPhArea ? curPhArea->GetType() : NO_ADDRESS; + adr_t curphstart = curPhArea ? curPhArea->GetStart() : NO_ADDRESS; LineChange chg; changes.push_back(chg); if (prevphase != NO_ADDRESS && prevphstart != curphstart) @@ -2603,6 +2685,7 @@ else // no bus check necessary, there's only one } } } + (void)org; (void)prevorg; // unused ATM } return Disassembler::DisassembleChanges(addr, prevaddr, prevsz, bAfterLine, changes, bus); diff --git a/Dasm68000.h b/Dasm68000.h index 0894f39..83120e5 100644 --- a/Dasm68000.h +++ b/Dasm68000.h @@ -44,19 +44,19 @@ class Dasm68000 : // return whether big- or little-endian virtual Endian GetEndianness() { return BigEndian; } // return bus width - virtual int GetBusWidth(int bus = BusCode) { return 24; } + virtual int GetBusWidth(int bus = BusCode) { (void)bus; return 24; } // return code bits virtual int GetCodeBits() { return 32; } // return code pointer size in bytes virtual int GetCodePtrSize() { return 4; } // return highest possible code address - virtual caddr_t GetHighestCodeAddr() { return 0xffffff; } + virtual cadr_t GetHighestCodeAddr() { return 0xffffff; } // return data bits virtual int GetDataBits() { return 16; } // return data pointer size in bytes virtual int GetDataPtrSize() { return 4; } // return highest possible data address - virtual daddr_t GetHighestDataAddr() { return 0xffffff; } + virtual dadr_t GetHighestDataAddr() { return 0xffffff; } // Options handler protected: @@ -66,29 +66,29 @@ class Dasm68000 : // the real disassembler activities protected: // parse data area for labels - virtual addr_t ParseData(addr_t addr, int bus = BusCode); + virtual adr_t ParseData(adr_t addr, int bus = BusCode); // parse instruction at given memory address for labels - virtual addr_t ParseCode(addr_t addr, int bus = BusCode); + virtual adr_t ParseCode(adr_t addr, int bus = BusCode); // pass back correct mnemonic and parameters for a label virtual bool DisassembleLabel(Label *label, string &slabel, string &smnemo, string &sparm, int bus = BusCode); // pass back correct mnemonic and parameters for a DefLabel virtual bool DisassembleDefLabel(DefLabel *label, string &slabel, string &smnemo, string &sparm, int bus = BusCode); // disassemble data area at given memory address - virtual addr_t DisassembleData(addr_t addr, addr_t end, uint32_t flags, string &smnemo, string &sparm, int maxparmlen, int bus = BusCode); + virtual adr_t DisassembleData(adr_t addr, adr_t end, uint32_t flags, string &smnemo, string &sparm, int maxparmlen, int bus = BusCode); // disassemble instruction at given memory address - virtual addr_t DisassembleCode(addr_t addr, string &smnemo, string &sparm, int bus = BusCode); + virtual adr_t DisassembleCode(adr_t addr, string &smnemo, string &sparm, int bus = BusCode); public: // Initialize parsing virtual bool InitParse(int bus = BusCode); // pass back disassembler-specific state changes before/after a disassembly line - virtual bool DisassembleChanges(addr_t addr, addr_t prevaddr, addr_t prevsz, bool bAfterLine, vector &changes, int bus = BusCode); + virtual bool DisassembleChanges(adr_t addr, adr_t prevaddr, adr_t prevsz, bool bAfterLine, vector &changes, int bus = BusCode); // create hex / ASCII representation of the current area - virtual bool DisassembleHexAsc(addr_t addr, addr_t len, addr_t max, string &sHex, string &sAsc, int bus = BusCode) + virtual bool DisassembleHexAsc(adr_t addr, adr_t len, adr_t max, string &sHex, string &sAsc, int bus = BusCode) { // 68000 displays hex in word-sized quantities instead of bytes sAsc = "\'"; - addr_t i; + adr_t i; for (i = 0; i < len; i++) { uint8_t c = GetUByte(addr + i, bus); @@ -105,10 +105,10 @@ class Dasm68000 : } protected: - virtual bool String2Number(string s, addr_t &value); - virtual string Number2String(addr_t value, int nDigits, addr_t addr, int bus = BusCode); - virtual string Address2String(addr_t addr, int bus = BusCode) - { return sformat("$%06x", addr); } + virtual bool String2Number(string s, adr_t &value); + virtual string Number2String(adr_t value, int nDigits, adr_t addr, int bus = BusCode); + virtual string Address2String(adr_t addr, int bus = BusCode) + { (void)bus; return sformat("$%06x", addr); } protected: enum OpType @@ -301,69 +301,69 @@ class Dasm68000 : protected: virtual void SetAsmType(string &newType); - virtual addr_t ParseEffectiveAddress(addr_t instaddr, addr_t addr, uint16_t ea, int16_t index, int op_mode); - virtual addr_t ParseOptype01(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype02(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype03(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype04(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype05(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype06(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype07(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype08(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype09(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype10(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype11(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype12(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype13(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype14(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype15(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype16(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype17(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype18(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype19(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype20(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype21(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype22(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype23(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype24(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype25(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype26(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype27(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype28(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); - virtual addr_t ParseOptype29(addr_t instaddr, addr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseEffectiveAddress(adr_t instaddr, adr_t addr, uint16_t ea, int16_t index, int op_mode); + virtual adr_t ParseOptype01(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype02(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype03(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype04(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype05(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype06(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype07(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype08(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype09(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype10(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype11(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype12(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype13(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype14(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype15(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype16(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype17(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype18(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype19(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype20(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype21(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype22(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype23(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype24(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype25(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype26(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype27(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype28(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); + virtual adr_t ParseOptype29(adr_t instaddr, adr_t addr, uint16_t code, int optable_index); virtual const char *GetAddrReg(int i); virtual const char *GetDataReg(int i); virtual const char *GetSizeSuffix(int sizeCode); - virtual addr_t DisassembleEffectiveAddress(addr_t instaddr, addr_t addr, string &s, uint16_t ea, int16_t index, int op_mode); - virtual addr_t DisassembleOptype01(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype02(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype03(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype04(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype05(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype06(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype07(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype08(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype09(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype10(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype11(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype12(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype13(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype14(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype15(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype16(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype17(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype18(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype19(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype20(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype21(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype22(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype23(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype24(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype25(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype26(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype27(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype28(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); - virtual addr_t DisassembleOptype29(addr_t instaddr, addr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + 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); + virtual adr_t DisassembleOptype03(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype04(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype05(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype06(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype07(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype08(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype09(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype10(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype11(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype12(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype13(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype14(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype15(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype16(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype17(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype18(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype19(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype20(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype21(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype22(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype23(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype24(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype25(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype26(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype27(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype28(adr_t instaddr, adr_t addr, uint16_t code, int optable_index, string &smnemo, string &sparm); + virtual adr_t DisassembleOptype29(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 e39bf42..f5af164 100644 --- a/Dasm6801.cpp +++ b/Dasm6801.cpp @@ -181,12 +181,12 @@ if (bus == BusCode) "IRQ_ICF", /* fff6 */ "IRQ_EXT", /* fff8 */ }; - for (addr_t addr = 0xfff0; addr <= 0xfff8; addr += 2) + for (adr_t addr = 0xfff0; addr <= 0xfff8; addr += 2) { if (addr == 0xfff8 && /* override IRQ with IRQ_EXT */ GetLabel(addr) == "IRQ") { - addr_t tgtaddr = GetUWord(addr); + adr_t tgtaddr = GetUWord(addr); Label *pLbl = FindLabel(tgtaddr); if (pLbl && pLbl->GetText() == "vec_IRQ") RemoveLabel(addr); @@ -199,7 +199,7 @@ if (bus == BusCode) SetMemType(addr, Data); /* that's a data word */ SetCellSize(addr, 2); /* look whether it points to loaded */ - addr_t tgtaddr = GetUWord(addr); + adr_t tgtaddr = GetUWord(addr); if (GetMemType(tgtaddr) != Untyped) { /* if so, */ SetMemType(tgtaddr, Code); /* that's code there */ diff --git a/Dasm6809.cpp b/Dasm6809.cpp index d1fef7d..5368871 100644 --- a/Dasm6809.cpp +++ b/Dasm6809.cpp @@ -49,7 +49,7 @@ static bool bRegistered = RegisterDisassembler("6809", Create6809); /* os9_codes : OS/9 entry points */ /*****************************************************************************/ -char *Dasm6809::os9_codes[0x100] = +const char *Dasm6809::os9_codes[0x100] = { "F$Link", "F$Load", "F$UnLink", "F$Fork", /* 00..03 */ "F$Wait", "F$Chain", "F$Exit", "F$Mem", /* 04..07 */ @@ -339,13 +339,13 @@ uint8_t Dasm6809::m6809_codes11[512] = }; -static char *m6809_exg_tfr[] = +static const char *m6809_exg_tfr[] = { "D", "X", "Y", "U", "S", "PC","??","??", "A", "B", "CC","DP","??","??","??","??" }; -char Dasm6809::reg[] = { 'X', 'Y', 'U', 'S' }; +const char Dasm6809::reg[] = { 'X', 'Y', 'U', 'S' }; /*****************************************************************************/ /* opcodes : additional opcodes over 6800 */ @@ -526,15 +526,18 @@ bool Dasm6809::ProcessInfo ( string key, /* parsed key */ string value, /* rest of the line */ - addr_t &from, /* from/to (if range given) */ - addr_t &to, - addr_t &step, /* step size */ - vector> &remaps , /* remaps, if necessary */ + adr_t &from, /* from/to (if range given) */ + adr_t &to, + adr_t &step, /* step size */ + vector> &remaps, /* remaps, if necessary */ bool bProcInfo, /* flag whether processing */ int bus, /* target bus for command */ int tgtbus /* target bus for parameters (ign.) */ ) { +(void)remaps; // unused ATM +(void)tgtbus; + if (!bProcInfo || bus != BusCode) /* only if processing code bus... */ return false; @@ -555,14 +558,14 @@ static struct /* structure to convert key to type */ }; InfoCmd cmdType = infoUnknown; -for (int i = 0; i < _countof(sKey); i++) +for (size_t i = 0; i < _countof(sKey); i++) if (key == sKey[i].name) { cmdType = sKey[i].cmdType; break; } if (cmdType == infoUnknown) - return false; + return false; // I KNOW that the parent classes don't do anything else. switch (cmdType) { @@ -572,7 +575,7 @@ switch (cmdType) string::size_type idx = value.find_first_of(" \t"); if (idx == value.npos) idx = value.size(); srange = value.substr(0, idx); - addr_t dp = NO_ADDRESS; + adr_t dp = NO_ADDRESS; value = (idx == value.size()) ? "" : trim(value.substr(idx)); if (value.size() && /* if addr[-addr] dp */ value[0] != '*') @@ -593,20 +596,22 @@ switch (cmdType) } if (from == NO_ADDRESS) dirpage = dp; - else for (addr_t scanned = from; + else for (adr_t scanned = from; scanned >= from && scanned <= to; - scanned++) + scanned += step) SetDirectPage(scanned, dp, bus); } break; case infoUnsetDP : /* UNSETDP [addr[-addr]] */ if (from == NO_ADDRESS) dirpage = 0; - else for (addr_t scanned = from; + else for (adr_t scanned = from; scanned >= from && scanned <= to; - scanned++) + scanned += step) SetDirectPage(scanned, 0, bus); break; + default : // keep gcc happy + break; } return true; } @@ -631,7 +636,7 @@ if (bus == BusCode) "SWI2", /* fff4 */ "FIRQ", /* fff6 */ }; - for (addr_t addr = 0xfff2; addr < 0xfff8; addr += 2) + for (adr_t addr = 0xfff2; addr < 0xfff8; addr += 2) { MemoryType memType = GetMemType(addr); if (memType != Untyped && /* if system vector loaded */ @@ -641,7 +646,7 @@ if (bus == BusCode) SetMemType(addr, Data); /* that's a data word */ SetCellSize(addr, 2); /* look whether it points to loaded */ - addr_t tgtaddr = GetUWord(addr); + adr_t tgtaddr = GetUWord(addr); if (GetMemType(tgtaddr) != Untyped) { /* if so, */ SetMemType(tgtaddr, Code); /* that's code there */ @@ -661,9 +666,9 @@ return Dasm6800::InitParse(bus); /* FetchInstructionDetails : fetch details about current instruction */ /*****************************************************************************/ -addr_t Dasm6809::FetchInstructionDetails +adr_t Dasm6809::FetchInstructionDetails ( - addr_t PC, + adr_t PC, uint8_t &O, uint8_t &T, uint8_t &M, @@ -707,13 +712,14 @@ return PC; /* IndexParse : parses index for labels */ /*****************************************************************************/ -addr_t Dasm6809::IndexParse(int MI, addr_t pc) +#define HMHMHM 0 +adr_t Dasm6809::IndexParse(int MI, adr_t pc, adr_t instaddr) { uint8_t T; uint16_t W; uint16_t Wrel; char R; -addr_t PC = pc; +adr_t PC = pc; bool bSetLabel = true; Label *lbl; @@ -746,7 +752,12 @@ if (T & 0x80) SetDefLabelUsed(PC); T = GetUByte(PC++); if (bSetLabel) +#if HMHMHM + AddRelativeLabel((uint16_t)((int)((char)T) + PC), PC - 1, mnemo[MI].memType, + true, BusCode, instaddr); +#else AddLabel((uint16_t)((int)((char)T) + PC), mnemo[MI].memType, "", true); +#endif break; case 0x08: bSetLabel = !IsConst(PC); @@ -757,14 +768,18 @@ if (T & 0x80) SetDefLabelUsed(PC); W = (uint16_t)((int)((char)T)); Wrel += W; - PC++; // no labels in indirect addressing! // ...except when they are explicitly given in the info file, of course if (bSetLabel && (W != Wrel || /* if it's relative, or label's there*/ FindLabel(Wrel))) +#if 1 + AddRelativeLabel(W, PC, mnemo[MI].memType, true, BusCode, instaddr); +#else AddLabel(Wrel, /* mark it as used */ mnemo[MI].memType, "", true); +#endif + PC++; break; case 0x18: SetDefLabelUsed(PC); @@ -777,7 +792,12 @@ if (T & 0x80) SetCellSize(PC, 2); W = GetUWord(PC); PC += 2; if (bSetLabel) +#if HMHMHM + AddRelativeLabel((uint16_t)(W + PC), PC - 2, mnemo[MI].memType, true, + BusCode, instaddr); +#else AddLabel((uint16_t)(W + PC), mnemo[MI].memType, "", true); +#endif break; case 0x09: bSetLabel = !IsConst(PC); @@ -787,14 +807,18 @@ if (T & 0x80) SetCellSize(PC, 2); W = GetUWord(PC); Wrel += W; - PC += 2; // no labels in indirect addressing! // ...except when they are explicitly given in the info file, of course if (bSetLabel && (W != Wrel || /* if it's relative, or label's there*/ FindLabel(Wrel))) +#if 1 + AddRelativeLabel(W, PC, mnemo[MI].memType, true, BusCode, instaddr); +#else AddLabel(Wrel, /* mark it as used */ mnemo[MI].memType, "", true); +#endif + PC += 2; break; case 0x19: case 0x1D: @@ -804,7 +828,12 @@ if (T & 0x80) SetCellSize(PC, 2); W = GetUWord(PC); PC += 2; if (bSetLabel) +#if HMHMHM + AddRelativeLabel((uint16_t)(W + PC), PC - 2, mnemo[MI].memType, true, + BusCode, instaddr); +#else AddLabel((uint16_t)(W + PC), mnemo[MI].memType, "", true); +#endif break; default: @@ -815,9 +844,14 @@ if (T & 0x80) if (lbl) lbl->SetUsed(); SetCellSize(PC, 2); - W = GetUWord(PC); PC += 2; + W = GetUWord(PC); if (bSetLabel) +#if HMHMHM + AddRelativeLabel(W, PC, mnemo[MI].memType, true, BusCode, instaddr); +#else AddLabel(W, mnemo[MI].memType, "", true); +#endif + PC += 2; } break; } @@ -834,13 +868,19 @@ else lbl = bSetLabel ? NULL : FindLabel(PC - 1, Const); W = (uint16_t)(c + Wrel); if (bSetLabel) +#if HMHMHM + AddRelativeLabel(W, PC - 1, mnemo[MI].memType, true, BusCode, instaddr); +#else AddLabel(W, mnemo[MI].memType, "", true); +#endif } else lbl = FindLabel(PC - 1, Const); if (lbl) lbl->SetUsed(); } + +(void)R; // unused ATM - keep gcc happy return PC; } @@ -848,13 +888,13 @@ return PC; /* IndexString : converts index to string */ /*****************************************************************************/ -string Dasm6809::IndexString(addr_t &pc) +string Dasm6809::IndexString(adr_t &pc) { uint8_t T; uint16_t W, Wrel; char R; string buf; -addr_t PC = pc; +adr_t PC = pc; bool bGetLabel; Label *lbl; @@ -1124,9 +1164,9 @@ return buf; /* ParseCode : parse instruction at given memory address for labels */ /*****************************************************************************/ -addr_t Dasm6809::ParseCode +adr_t Dasm6809::ParseCode ( - addr_t addr, + adr_t addr, int bus /* ignored for 6800 and derivates */ ) { @@ -1136,7 +1176,7 @@ int MI; const char *I; bool bSetLabel; Label *lbl; -addr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I); +adr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I); if ((T == _swi2) && os9Patch) return (PC + 1 - addr); @@ -1144,7 +1184,7 @@ if ((T == _swi2) && os9Patch) switch (M) /* which mode is this ? */ { case _ind: /* indexed */ - PC = IndexParse(MI,PC); + PC = IndexParse(MI, PC, addr); break; case _rew: /* relative word */ @@ -1179,9 +1219,9 @@ return PC - addr; /* pass back # processed bytes */ /* DisassembleCode : disassemble code instruction at given memory address */ /*****************************************************************************/ -addr_t Dasm6809::DisassembleCode +adr_t Dasm6809::DisassembleCode ( - addr_t addr, + adr_t addr, string &smnemo, string &sparm, int bus /* ignored for 6800 and derivates */ @@ -1191,7 +1231,7 @@ uint8_t O, T, M; uint16_t W; int MI; const char *I; -addr_t PC = addr; +adr_t PC = addr; bool bGetLabel; Label *lbl; @@ -1446,9 +1486,9 @@ return PC - addr; /* pass back # processed bytes */ bool Dasm6809::DisassembleChanges ( - addr_t addr, - addr_t prevaddr, - addr_t prevsz, + adr_t addr, + adr_t prevaddr, + adr_t prevsz, bool bAfterLine, vector &changes, int bus @@ -1463,9 +1503,9 @@ if (addr == NO_ADDRESS && prevaddr == NO_ADDRESS) if (!bAfterLine) /* if before the address */ { // report direct page changes - addr_t dpold = + adr_t dpold = (prevaddr == NO_ADDRESS) ? DEFAULT_ADDRESS : GetDirectPage(prevaddr, bus); - addr_t dp = GetDirectPage(addr, bus); + adr_t dp = GetDirectPage(addr, bus); if (!dp && dpold == DEFAULT_ADDRESS) dpold = dp; if (dp != dpold) { @@ -1488,8 +1528,8 @@ void Dasm6809::AddFlexLabels() { static struct { - addr_t from; - addr_t to; + adr_t from; + adr_t to; char const *txt; } FlexLbls[] = { @@ -1595,9 +1635,9 @@ static struct { 0xde1b, 0xde1b, "DDJ_SEEK" }, /* seek to specified track */ }; -for (int i = 0; i < _countof(FlexLbls); i++) +for (size_t i = 0; i < _countof(FlexLbls); i++) { - for (addr_t a = FlexLbls[i].from; a <= FlexLbls[i].to; a++) + for (adr_t a = FlexLbls[i].from; a <= FlexLbls[i].to; a++) { string s(FlexLbls[i].txt); if (a != FlexLbls[i].from) diff --git a/Dasm6809.h b/Dasm6809.h index 92ad169..22eb624 100644 --- a/Dasm6809.h +++ b/Dasm6809.h @@ -38,13 +38,13 @@ struct MemAttribute6809 : public MemAttribute Type cellType = UnsignedInt, Display display = DefaultDisplay, bool breakBefore = false, - addr_t dirpage = DEFAULT_ADDRESS) + adr_t dirpage = DEFAULT_ADDRESS) : MemAttribute(memType, cellSize, bUsed, cellType, display, breakBefore) { SetDirectPage(dirpage); } - addr_t GetDirectPage() { return (dirpage == (int16_t)-1) ? NO_ADDRESS : (dirpage == (int16_t)-2) ? DEFAULT_ADDRESS : (addr_t)dirpage << 8; } - void SetDirectPage(addr_t dp) { dirpage = (int16_t)((dp & 0xff) ? dp : dp >> 8); } + adr_t GetDirectPage() { return (dirpage == (int16_t)-1) ? NO_ADDRESS : (dirpage == (int16_t)-2) ? DEFAULT_ADDRESS : (adr_t)dirpage << 8; } + void SetDirectPage(adr_t dp) { dirpage = (int16_t)((dp & 0xff) ? dp : dp >> 8); } }; /*****************************************************************************/ @@ -57,46 +57,46 @@ class MemAttribute6809Handler : public MemAttributeHandler MemAttribute6809Handler() { } virtual ~MemAttribute6809Handler() { } - virtual bool AddMemory(addr_t addrStart = 0, addr_t memSize = 0, MemoryType memType = Code) + virtual bool AddMemory(adr_t addrStart = 0, adr_t memSize = 0, MemoryType memType = Code) { return attr.AddMemory(addrStart, memSize, memType); } - virtual MemoryType GetMemType(addr_t addr) + virtual MemoryType GetMemType(adr_t addr) { MemAttribute6809 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetMemType() : Untyped; } - virtual void SetMemType(addr_t addr, MemoryType newType = Code) + virtual void SetMemType(adr_t addr, MemoryType newType = Code) { MemAttribute6809 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetMemType(newType); } - virtual bool IsCellUsed(addr_t addr) + virtual bool IsCellUsed(adr_t addr) { MemAttribute6809 *pAttr = attr.getat(addr); return pAttr ? pAttr->IsUsed() : false; } - virtual void SetCellUsed(addr_t addr, bool bUsed = true) + virtual void SetCellUsed(adr_t addr, bool bUsed = true) { MemAttribute6809 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetUsed(bUsed); } - virtual MemAttribute::Type GetCellType(addr_t addr) + virtual MemAttribute::Type GetCellType(adr_t addr) { MemAttribute6809 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetCellType() : MemAttribute6809::CellUntyped; } - virtual void SetCellType(addr_t addr, MemAttribute::Type newType) + virtual void SetCellType(adr_t addr, MemAttribute::Type newType) { MemAttribute6809 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetCellType(newType); } - virtual int GetCellSize(addr_t addr) + virtual int GetCellSize(adr_t addr) { MemAttribute6809 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetSize() : 0; } - virtual void SetCellSize(addr_t addr, int newSize = 1) + virtual void SetCellSize(adr_t addr, int newSize = 1) { MemAttribute6809 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetSize(newSize); } - virtual MemAttribute::Display GetDisplay(addr_t addr) + virtual MemAttribute::Display GetDisplay(adr_t addr) { MemAttribute6809 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetDisplay() : MemAttribute6809::CellUndisplayable; } - virtual void SetDisplay(addr_t addr, MemAttribute::Display newDisp = MemAttribute::DefaultDisplay) + virtual void SetDisplay(adr_t addr, MemAttribute::Display newDisp = MemAttribute::DefaultDisplay) { MemAttribute6809 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetDisplay(newDisp); } - virtual bool GetBreakBefore(addr_t addr) + virtual bool GetBreakBefore(adr_t addr) { MemAttribute6809 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetBreakBefore() : false; } - virtual void SetBreakBefore(addr_t addr, bool bOn = true) + virtual void SetBreakBefore(adr_t addr, bool bOn = true) { MemAttribute6809 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetBreakBefore(bOn); } - virtual bool GetForcedAddr(addr_t addr) + virtual bool GetForcedAddr(adr_t addr) { MemAttribute6809 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetForcedAddr() : false; } - virtual void SetForcedAddr(addr_t addr, bool bOn = true) + virtual void SetForcedAddr(adr_t addr, bool bOn = true) { MemAttribute6809 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetForcedAddr(bOn); } - virtual uint32_t GetDisassemblyFlags(addr_t addr, uint8_t mem, Label *plbl) + virtual uint32_t GetDisassemblyFlags(adr_t addr, uint8_t mem, Label *plbl) { return GetBasicDisassemblyFlags(attr.getat(addr), mem, plbl); } // basic access virtual size_t size() { return (size_t)attr.size(); } - virtual addr_t GetStart(int index) { return attr[index].GetStart(); } + virtual adr_t GetStart(int index) { return attr[index].GetStart(); } virtual size_t size(int index) { return attr[index].size(); } // additional attributes for 6809 - virtual addr_t GetDirectPage(addr_t addr) + virtual adr_t GetDirectPage(adr_t addr) { MemAttribute6809 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetDirectPage() : DEFAULT_ADDRESS; } - virtual void SetDirectPage(addr_t addr, addr_t dp) + virtual void SetDirectPage(adr_t addr, adr_t dp) { MemAttribute6809 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetDirectPage(dp); } protected: TMemoryArray attr; @@ -128,27 +128,27 @@ class Dasm6809 : public Dasm6800 string Get6809Option(string name); // Get/Set additional cell information - virtual addr_t GetDirectPage(addr_t addr, int bus = BusCode) + virtual adr_t GetDirectPage(adr_t addr, int bus = BusCode) { - addr_t dp = memattr[bus] ? ((MemAttribute6809Handler *)memattr[bus])->GetDirectPage(addr) : DEFAULT_ADDRESS; + adr_t dp = memattr[bus] ? ((MemAttribute6809Handler *)memattr[bus])->GetDirectPage(addr) : DEFAULT_ADDRESS; if (dp == DEFAULT_ADDRESS) dp = dirpage; return dp; } - virtual void SetDirectPage(addr_t addr, addr_t dp, int bus = BusCode) + virtual void SetDirectPage(adr_t addr, adr_t dp, int bus = BusCode) { if (memattr[bus]) ((MemAttribute6809Handler *)memattr[bus])->SetDirectPage(addr, dp); } - virtual bool ProcessInfo(string key, string value, addr_t &from, addr_t &to, addr_t &step, vector> &remaps, bool bProcInfo = true, int bus = BusCode, int tgtbus = BusCode); + virtual bool ProcessInfo(string key, string value, adr_t &from, adr_t &to, adr_t &step, vector> &remaps, bool bProcInfo = true, int bus = BusCode, int tgtbus = BusCode); protected: // parse instruction at given memory address for labels - virtual addr_t ParseCode(addr_t addr, int bus = BusCode); + virtual adr_t ParseCode(adr_t addr, int bus = BusCode); // disassemble instruction at given memory address - virtual addr_t DisassembleCode(addr_t addr, string &smnemo, string &sparm, int bus = BusCode); + virtual adr_t DisassembleCode(adr_t addr, string &smnemo, string &sparm, int bus = BusCode); public: virtual bool InitParse(int bus = BusCode); // pass back disassembler-specific state changes before/after a disassembly line - virtual bool DisassembleChanges(addr_t addr, addr_t prevaddr, addr_t prevsz, bool bAfterLine, vector &changes, int bus = BusCode); + virtual bool DisassembleChanges(adr_t addr, adr_t prevaddr, adr_t prevsz, bool bAfterLine, vector &changes, int bus = BusCode); protected: @@ -237,12 +237,12 @@ class Dasm6809 : public Dasm6800 static uint8_t m6809_codes10[512]; static uint8_t m6809_codes11[512]; static OpCode opcodes[mnemo6809_count - mnemo6800_count]; - static char *os9_codes[0x100]; + static const char *os9_codes[0x100]; uint8_t *codes10; uint8_t *codes11; - char **exg_tfr; - static char reg[]; + const char **exg_tfr; + static const char reg[]; bool os9Patch; bool useFlex; @@ -251,9 +251,9 @@ class Dasm6809 : public Dasm6800 // must not be called from constructor! virtual MemAttributeHandler *CreateAttributeHandler() { return new MemAttribute6809Handler; } - virtual addr_t FetchInstructionDetails(addr_t PC, uint8_t &O, uint8_t &T, uint8_t &M, uint16_t &W, int &MI, const char *&I, string *smnemo = NULL); - virtual addr_t IndexParse(int MI, addr_t pc); - virtual string IndexString(addr_t &pc); + virtual adr_t FetchInstructionDetails(adr_t PC, uint8_t &O, uint8_t &T, uint8_t &M, uint16_t &W, int &MI, const char *&I, string *smnemo = NULL); + virtual adr_t IndexParse(int MI, adr_t pc, adr_t instaddr = NO_ADDRESS); + virtual string IndexString(adr_t &pc); void AddFlexLabels(); }; diff --git a/Dasm68HC11.cpp b/Dasm68HC11.cpp index 9a1ff77..9ff046f 100644 --- a/Dasm68HC11.cpp +++ b/Dasm68HC11.cpp @@ -424,7 +424,7 @@ if (bus == BusCode) "CMOF", /* fffc */ "RST", /* fffe */ }; - for (addr_t addr = 0xffd6; addr <= GetHighestCodeAddr(); addr += 2) + for (adr_t addr = 0xffd6; addr <= GetHighestCodeAddr(); addr += 2) { MemoryType memType = GetMemType(addr); if (memType != Untyped && /* if system vector loaded */ @@ -434,7 +434,7 @@ if (bus == BusCode) SetMemType(addr, Data); /* that's a data word */ SetCellSize(addr, 2); /* look whether it points to loaded */ - addr_t tgtaddr = GetUWord(addr); + adr_t tgtaddr = GetUWord(addr); if (GetMemType(tgtaddr) != Untyped) { /* if so, */ SetMemType(tgtaddr, Code); /* that's code there */ @@ -454,9 +454,9 @@ return Disassembler::InitParse(bus); /* FetchInstructionDetails : fetch details about current instruction */ /*****************************************************************************/ -addr_t Dasm68HC11::FetchInstructionDetails +adr_t Dasm68HC11::FetchInstructionDetails ( - addr_t PC, + adr_t PC, uint8_t &O, uint8_t &T, uint8_t &M, @@ -519,9 +519,9 @@ return ",X"; /* ParseCode : parse instruction at given memory address for labels */ /*****************************************************************************/ -addr_t Dasm68HC11::ParseCode +adr_t Dasm68HC11::ParseCode ( - addr_t addr, + adr_t addr, int bus /* ignored for 6800 and derivates */ ) { @@ -530,7 +530,7 @@ uint16_t W; int MI; const char *I; bool bSetLabel; -addr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I); +adr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I); switch (M) /* which mode is this ? */ { @@ -622,9 +622,9 @@ return PC - addr; /* pass back # processed bytes */ /* DisassembleCode : disassemble code instruction at given memory address */ /*****************************************************************************/ -addr_t Dasm68HC11::DisassembleCode +adr_t Dasm68HC11::DisassembleCode ( - addr_t addr, + adr_t addr, string &smnemo, string &sparm, int bus /* ignored for 6800 and derivates */ @@ -632,12 +632,12 @@ addr_t Dasm68HC11::DisassembleCode { uint8_t O, T, M; uint16_t W; -addr_t Wrel; +adr_t Wrel; int MI; const char *I; bool bGetLabel; Label *lbl; -addr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I, &smnemo); +adr_t PC = FetchInstructionDetails(addr, O, T, M, W, MI, I, &smnemo); switch (M) /* which mode is this? */ { @@ -669,7 +669,7 @@ switch (M) /* which mode is this? */ if (Wrel) { W = (int)((unsigned char)T) + (uint16_t)Wrel; - slbl = Label2String((addr_t)((int)((unsigned char)T)), 4, + slbl = Label2String((adr_t)((int)((unsigned char)T)), 4, bGetLabel, PC) + GetIx8IndexReg(O); } else if (lbl) @@ -739,7 +739,7 @@ switch (M) /* which mode is this? */ if (Wrel) { W = (int)((unsigned char)T) + (uint16_t)Wrel; - slbl = Label2String((addr_t)((int)((unsigned char)T)), 4, + slbl = Label2String((adr_t)((int)((unsigned char)T)), 4, bGetLabel, PC) + GetIx8IndexReg(O); } else if (lbl) diff --git a/Dasm68HC11.h b/Dasm68HC11.h index d8cf22d..4626904 100644 --- a/Dasm68HC11.h +++ b/Dasm68HC11.h @@ -94,12 +94,12 @@ class Dasm68HC11 : public Dasm6801 uint8_t *codescd; protected: - virtual addr_t FetchInstructionDetails(addr_t PC, uint8_t &O, uint8_t &T, uint8_t &M, uint16_t &W, int &MI, const char *&I, string *smnemo = NULL); + virtual adr_t FetchInstructionDetails(adr_t PC, uint8_t &O, uint8_t &T, uint8_t &M, uint16_t &W, int &MI, const char *&I, string *smnemo = NULL); virtual string GetIx8IndexReg(uint8_t O); // parse instruction at given memory address for labels - virtual addr_t ParseCode(addr_t addr, int bus = BusCode); + virtual adr_t ParseCode(adr_t addr, int bus = BusCode); // disassemble instruction at given memory address - virtual addr_t DisassembleCode(addr_t addr, string &smnemo, string &sparm, int bus = BusCode); + virtual adr_t DisassembleCode(adr_t addr, string &smnemo, string &sparm, int bus = BusCode); }; diff --git a/DasmAvr8.cpp b/DasmAvr8.cpp index b1745e4..a986a5b 100644 --- a/DasmAvr8.cpp +++ b/DasmAvr8.cpp @@ -456,10 +456,10 @@ bool DasmAvr8::ProcessInfo ( string key, /* parsed key */ string value, /* rest of the line */ - addr_t &from, /* from/to (if range given) */ - addr_t &to, - addr_t &step, /* step size */ - vector> &remaps, /* remaps, if necessary */ + adr_t &from, /* from/to (if range given) */ + adr_t &to, + adr_t &step, /* step size */ + vector> &remaps, /* remaps, if necessary */ bool bProcInfo, /* flag whether processing */ int bus, /* target bus for command */ int tgtbus /* target bus for parameters */ @@ -497,14 +497,14 @@ static struct /* structure to convert key to type */ }; InfoCmd cmdType = infoUnknown; -for (int i = 0; i < _countof(sKey); i++) +for (size_t i = 0; i < _countof(sKey); i++) if (key == sKey[i].name) { cmdType = sKey[i].cmdType; break; } if (cmdType == infoUnknown) - return false; + return false; // we KNOW the parent classes don't do anything else switch (cmdType) { @@ -546,7 +546,7 @@ switch (cmdType) string::size_type idx = value.find_first_of(" \t"); if (idx == value.npos) idx = value.size(); srange = value.substr(0, idx); - addr_t rel = NO_ADDRESS; + adr_t rel = NO_ADDRESS; value = (idx == value.size()) ? "" : trim(value.substr(idx)); if (value.size() && /* if addr[-addr] dp */ value[0] != '*') @@ -579,25 +579,29 @@ switch (cmdType) rt = MemAttributeAvr8::RelLow2; rel *= 2; break; + default : // keep gcc happy + break; } // range check for rel in tgtbus missing. // if (tgtbus != bus) { - addr_t *pmap = remaps[tgtbus].getat(rel); + adr_t *pmap = remaps[tgtbus].getat(rel); if (pmap) rel += *pmap; if (rel < GetLowestBusAddr(tgtbus) || rel > GetHighestBusAddr(tgtbus)) break; } - for (addr_t scanned = from; + for (adr_t scanned = from; scanned >= from && scanned <= to; scanned += step) SetRelative(scanned, rt, rel, tgtbus, bus); } } break; + default : // keep gcc happy + break; } return true; } @@ -610,7 +614,7 @@ int DasmAvr8::SetAvr8Option(string lname, string value) { bool bnValue = true; /* default to "on" */ bool bIsBool = ParseBool(value, bnValue); -addr_t avalue; +adr_t avalue; String2Number(value, avalue); int iValue = atoi(value.c_str()); @@ -667,7 +671,7 @@ else if (lname == "avr-gcc") avr_gcc = bnValue; if (!dbalignchg) dbalign = !avr_gcc; - for (int i = 0; i < _countof(smne); i++) + for (size_t i = 0; i < _countof(smne); i++) mnemo[smne[i].idx].mne = smne[i].txt[avr_gcc]; return bIsBool ? 1 : 0; } @@ -710,8 +714,8 @@ if (!( (c >= '0' && c <= '9') || bool done = false; int nBytes = 0; -addr_t fbegin = GetHighestBusAddr(bus); -addr_t fend = GetLowestBusAddr(bus); +adr_t fbegin = GetHighestBusAddr(bus); +adr_t fend = GetLowestBusAddr(bus); MemoryType memType = GetDefaultMemoryType(bus); // ATMEL Generic Hex files consist of CR+LF-terminated lines @@ -723,7 +727,7 @@ MemoryType memType = GetDefaultMemoryType(bus); while (!done && (nBytes >= 0)) /* while there are lines */ { - addr_t nAddr; + adr_t nAddr; uint16_t value = 0; int i; uint8_t chks = 0; @@ -742,7 +746,7 @@ while (!done && (nBytes >= 0)) /* while there are lines */ break; for (i = 0; i < 2; i++) /* followed by up to 2 bytes of data */ { - addr_t b = GetHex(f, 2); + adr_t b = GetHex(f, 2); if (b == NO_ADDRESS) break; value = (value << 8) | (uint16_t)b; @@ -766,6 +770,8 @@ while (!done && (nBytes >= 0)) /* while there are lines */ ungetc(c, f); else done = true; + + (void)chks; // unused ATM } fseek(f, nCurPos, SEEK_SET); @@ -779,6 +785,7 @@ if (nBytes >= 0) if (nBytes > 0) sLoadType = "Atmel Generic Hex"; + return (nBytes > 0); /* pass back #bytes interpreted */ } @@ -802,7 +809,7 @@ return LoadAtmelGeneric(f, sLoadType, bus) || // ATMEL Generic Hex files need n /* String2Number : convert a string to a number in all known formats */ /*****************************************************************************/ -bool DasmAvr8::String2Number(string s, addr_t &value) +bool DasmAvr8::String2Number(string s, adr_t &value) { /* Standard formats for AVRASM : - a character is enclosed in ' @@ -854,9 +861,9 @@ return Disassembler::String2Number(s, value); string DasmAvr8::Number2String ( - addr_t value, + adr_t value, int nDigits, - addr_t addr, + adr_t addr, int bus ) { @@ -868,7 +875,7 @@ string s; - a hex constant has a leading 0x */ -MemoryType memType = GetMemType(addr, bus); +MemAttribute::Type memType = GetCellType(addr, bus); MemAttribute::Display disp; bool bSigned = false; if (memType == MemAttribute::CellUntyped) @@ -882,7 +889,7 @@ else if (disp == MemAttribute::DefaultDisplay) disp = defaultDisplay; -addr_t rel; +adr_t rel; int relBus; MemAttributeAvr8::RelType rt = GetRelative(addr, rel, relBus, bus); if (rt != MemAttributeAvr8::RelUntyped) @@ -929,6 +936,8 @@ if (rt != MemAttributeAvr8::RelUntyped) (rt == MemAttributeAvr8::RelHighMinus) ? "-" : "", s.c_str()); return s; + default : // keep gcc happy + break; } } } @@ -986,9 +995,9 @@ return Disassembler::InitParse(bus); /* ParseData : parse data at given memory address for labels */ /*****************************************************************************/ -addr_t DasmAvr8::ParseData +adr_t DasmAvr8::ParseData ( - addr_t addr, + adr_t addr, int bus ) { @@ -1010,22 +1019,22 @@ return csz; int DasmAvr8::DisassembleString ( - addr_t addr, - addr_t end, + adr_t addr, + adr_t end, uint32_t flags, string &s, int maxparmlen, int bus ) { -addr_t done; +adr_t done; int sbytes = 0; s = '"'; /* start the game */ for (done = addr; done < end; done++) { /* if this would become too long */ flags = GetDisassemblyTextFlags(done, bus); - addr_t off = done - addr; + adr_t off = done - addr; if (flags & SHMF_TXT) { uint8_t *pc = getat(done, bus); @@ -1084,10 +1093,10 @@ return sbytes; /* DisassembleData : disassemble data area at given memory address */ /*****************************************************************************/ -addr_t DasmAvr8::DisassembleData +adr_t DasmAvr8::DisassembleData ( - addr_t addr, - addr_t end, + adr_t addr, + adr_t end, uint32_t flags, string &smnemo, string &sparm, @@ -1095,7 +1104,7 @@ addr_t DasmAvr8::DisassembleData int bus ) { -addr_t done; +adr_t done; if (flags & SHMF_RMB) /* if reserved memory block */ { @@ -1147,7 +1156,7 @@ else /* if single-byte */ /* assemble as many as possible */ for (done = addr; done < end; done++) { - addr_t off = done - addr; + adr_t off = done - addr; string s; flags = GetDisassemblyTextFlags(done, bus); // a DefLabel inhibits text output @@ -1193,9 +1202,9 @@ return done - addr; /* ParseCode : parse instruction at given memory address for labels */ /*****************************************************************************/ -addr_t DasmAvr8::ParseCode +adr_t DasmAvr8::ParseCode ( - addr_t addr, + adr_t addr, int bus ) { @@ -1270,7 +1279,7 @@ for (i = 0; i < numOperands; i++) break; case OpndData: { - addr_t rel; int relBus; + adr_t rel; int relBus; // if this is relative, make sure a label for the relation is there MemAttributeAvr8::RelType rt = GetRelative(addr, rel, relBus, bus); if (rt != MemAttributeAvr8::RelUntyped) @@ -1286,13 +1295,13 @@ for (i = 0; i < numOperands; i++) // fall thru on purpose case OpndLongAbsAddr: case OpndLongAbsAddrData: - bus = (mnemo[ii->mnemonic].memType != Code) ? BusData : BusCode; + bus = (mnemo[ii->mnemonic].memType == Code) ? (int)BusCode : (int)BusData; if (!IsConst(addr, BusData /*bus*/)) AddRelativeLabel(operand, addr, mnemo[ii->mnemonic].memType, true, bus, addr); break; case OpndBranchAddr: case OpndRelAddr: - bus = (mnemo[ii->mnemonic].memType != Code) ? BusData : BusCode; + bus = (mnemo[ii->mnemonic].memType == Code) ? (int)BusCode : (int)BusData; if (!IsConst(addr, bus)) AddRelativeLabel(operand + addr + 2, addr, mnemo[ii->mnemonic].memType, true, bus, addr); break; @@ -1309,9 +1318,9 @@ return ii->width; /* DisassembleCode : disassemble code instruction at given memory address */ /*****************************************************************************/ -addr_t DasmAvr8::DisassembleCode +adr_t DasmAvr8::DisassembleCode ( - addr_t addr, + adr_t addr, string &smnemo, string &sparm, int bus @@ -1369,7 +1378,6 @@ else if (ii->mnemonic == _and && opnds[0] == opnds[1]) else if (ii->mnemonic == _andi) { int bset = 0; - int32_t chk = opnds[1]; for (int j = 0; j < 8; j++) { if (opnds[1] & (1 << j)) @@ -1451,12 +1459,12 @@ for (i = 0; i < numOperands; i++) case OpndLongAbsAddrData: case OpndLongAbsAddr: sparm += Label2String(operand, 4, true, addr, - (mnemo[ii->mnemonic].memType != Code) ? BusData : BusCode /*bus*/); + (mnemo[ii->mnemonic].memType == Code) ? (int)BusCode : (int)BusData); break; case OpndBranchAddr: case OpndRelAddr: sparm += Label2String(operand + addr + 2, 4, true, addr, - (mnemo[ii->mnemonic].memType != Code) ? BusData : BusCode /*bus*/); + (mnemo[ii->mnemonic].memType == Code) ? (int)BusCode : (int)BusData); break; default: break; @@ -1479,9 +1487,10 @@ bool DasmAvr8::DisassembleLabel int bus ) { +(void)slabel; if (label->GetText().find_first_of("+-") == string::npos) { - addr_t laddr = label->GetAddress(); + adr_t laddr = label->GetAddress(); smnemo = mnemo[(bus == BusIO) ? _d_port : _d_equ].mne; sparm = Label2String(laddr, 4, true, laddr, bus) + sequdelim[avr_gcc] + Address2String(laddr, bus); @@ -1503,6 +1512,7 @@ bool DasmAvr8::DisassembleDefLabel int bus ) { +(void)bus; if (avr_gcc) { // for avr-gcc, it's easier to emit a #define in this case. @@ -1529,9 +1539,9 @@ return true; bool DasmAvr8::DisassembleChanges ( - addr_t addr, - addr_t prevaddr, - addr_t prevsz, + adr_t addr, + adr_t prevaddr, + adr_t prevsz, bool bAfterLine, vector &changes, int bus @@ -1649,7 +1659,7 @@ return Disassembler::DisassembleChanges(addr, prevaddr, prevsz, bAfterLine, chan avrInstructionInfo *DasmAvr8::LookupInstruction(uint16_t opcode) { -for (int i = 0; i < _countof(AVR_Instruction_Set); i++) +for (size_t i = 0; i < _countof(AVR_Instruction_Set); i++) { uint16_t instructionBits = opcode; diff --git a/DasmAvr8.h b/DasmAvr8.h index ee8b4ed..0ed6147 100644 --- a/DasmAvr8.h +++ b/DasmAvr8.h @@ -42,7 +42,7 @@ struct MemAttributeAvr8 : public MemAttribute { unsigned relType: 3; unsigned relBus:3; - addr_t addrRelative; + adr_t addrRelative; enum RelType { @@ -62,15 +62,15 @@ struct MemAttributeAvr8 : public MemAttribute bool breakBefore = false, RelType relType = RelUntyped, int bus = Avr8BusTypes, - addr_t rel = NO_ADDRESS) + adr_t rel = NO_ADDRESS) : MemAttribute(memType, cellSize, bUsed, cellType, display, breakBefore), - relType(relType), addrRelative(rel) + relType(relType), relBus(bus), addrRelative(rel) { } - RelType GetRelative(addr_t &rel, int &bus) + RelType GetRelative(adr_t &rel, int &bus) { rel = addrRelative; bus = relBus; return (RelType)relType; } - void SetRelative(RelType newType = RelUntyped, addr_t rel = NO_ADDRESS, int newBus = Avr8BusTypes) + void SetRelative(RelType newType = RelUntyped, adr_t rel = NO_ADDRESS, int newBus = Avr8BusTypes) { relType = newType; addrRelative = rel; relBus = newBus; } }; @@ -84,47 +84,47 @@ class MemAttributeAvr8Handler : public MemAttributeHandler MemAttributeAvr8Handler() { } virtual ~MemAttributeAvr8Handler() { } - virtual bool AddMemory(addr_t addrStart = 0, addr_t memSize = 0, MemoryType memType = Code) + virtual bool AddMemory(adr_t addrStart = 0, adr_t memSize = 0, MemoryType memType = Code) { return attr.AddMemory(addrStart, memSize, memType); } - virtual MemoryType GetMemType(addr_t addr) + virtual MemoryType GetMemType(adr_t addr) { MemAttributeAvr8 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetMemType() : Untyped; } - virtual void SetMemType(addr_t addr, MemoryType newType = Code) + virtual void SetMemType(adr_t addr, MemoryType newType = Code) { MemAttributeAvr8 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetMemType(newType); } - virtual bool IsCellUsed(addr_t addr) + virtual bool IsCellUsed(adr_t addr) { MemAttributeAvr8 *pAttr = attr.getat(addr); return pAttr ? pAttr->IsUsed() : false; } - virtual void SetCellUsed(addr_t addr, bool bUsed = true) + virtual void SetCellUsed(adr_t addr, bool bUsed = true) { MemAttributeAvr8 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetUsed(bUsed); } - virtual MemAttribute::Type GetCellType(addr_t addr) + virtual MemAttribute::Type GetCellType(adr_t addr) { MemAttributeAvr8 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetCellType() : MemAttributeAvr8::CellUntyped; } - virtual void SetCellType(addr_t addr, MemAttribute::Type newType) + virtual void SetCellType(adr_t addr, MemAttribute::Type newType) { MemAttributeAvr8 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetCellType(newType); } - virtual int GetCellSize(addr_t addr) + virtual int GetCellSize(adr_t addr) { MemAttributeAvr8 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetSize() : 0; } - virtual void SetCellSize(addr_t addr, int newSize = 1) + virtual void SetCellSize(adr_t addr, int newSize = 1) { MemAttributeAvr8 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetSize(newSize); } - virtual MemAttribute::Display GetDisplay(addr_t addr) + virtual MemAttribute::Display GetDisplay(adr_t addr) { MemAttributeAvr8 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetDisplay() : MemAttributeAvr8::CellUndisplayable; } - virtual void SetDisplay(addr_t addr, MemAttribute::Display newDisp = MemAttribute::DefaultDisplay) + virtual void SetDisplay(adr_t addr, MemAttribute::Display newDisp = MemAttribute::DefaultDisplay) { MemAttributeAvr8 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetDisplay(newDisp); } - virtual bool GetBreakBefore(addr_t addr) + virtual bool GetBreakBefore(adr_t addr) { MemAttributeAvr8 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetBreakBefore() : false; } - virtual void SetBreakBefore(addr_t addr, bool bOn = true) + virtual void SetBreakBefore(adr_t addr, bool bOn = true) { MemAttributeAvr8 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetBreakBefore(bOn); } - virtual bool GetForcedAddr(addr_t addr) + virtual bool GetForcedAddr(adr_t addr) { MemAttributeAvr8 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetForcedAddr() : false; } - virtual void SetForcedAddr(addr_t addr, bool bOn = true) + virtual void SetForcedAddr(adr_t addr, bool bOn = true) { MemAttributeAvr8 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetForcedAddr(bOn); } - virtual uint32_t GetDisassemblyFlags(addr_t addr, uint8_t mem, Label *plbl) + virtual uint32_t GetDisassemblyFlags(adr_t addr, uint8_t mem, Label *plbl) { return GetBasicDisassemblyFlags(attr.getat(addr), mem, plbl); } // basic access virtual size_t size() { return (size_t)attr.size(); } - virtual addr_t GetStart(int index) { return attr[index].GetStart(); } + virtual adr_t GetStart(int index) { return attr[index].GetStart(); } virtual size_t size(int index) { return attr[index].size(); } // additional attributes for Avr8 - virtual MemAttributeAvr8::RelType GetRelative(addr_t addr, addr_t &rel, int &bus) + virtual MemAttributeAvr8::RelType GetRelative(adr_t addr, adr_t &rel, int &bus) { MemAttributeAvr8 *pAttr = attr.getat(addr); return pAttr ? pAttr->GetRelative(rel, bus) : MemAttributeAvr8::RelUntyped; } - virtual void SetRelative(addr_t addr, MemAttributeAvr8::RelType newType = MemAttributeAvr8::RelUntyped, addr_t rel = NO_ADDRESS, int newBus = Avr8BusTypes) + virtual void SetRelative(adr_t addr, MemAttributeAvr8::RelType newType = MemAttributeAvr8::RelUntyped, adr_t rel = NO_ADDRESS, int newBus = Avr8BusTypes) { MemAttributeAvr8 *pAttr = attr.getat(addr); if (pAttr) pAttr->SetRelative(newType, rel, newBus); } protected: @@ -140,7 +140,7 @@ class MemAttributeAvr8Handler : public MemAttributeHandler class Avr8RegLabel : public Label { public: - Avr8RegLabel(addr_t addr = 0, string sLabel = "", int nRegNum = 0) + Avr8RegLabel(adr_t addr = 0, string sLabel = "", int nRegNum = 0) : Label(addr, Const, sLabel, true), nRegNum(nRegNum) { } // Attributes @@ -161,12 +161,12 @@ class Avr8RegLabelArray : public TAddrTypeArray Avr8RegLabelArray() : TAddrTypeArray(true) { } - Avr8RegLabel *GetFirst(addr_t addr, Avr8RegLabelArray::iterator &it) + Avr8RegLabel *GetFirst(adr_t addr, Avr8RegLabelArray::iterator &it) { it = find(addr, Const); return it != end() ? (Avr8RegLabel *)(*it) : NULL; } - Avr8RegLabel *GetNext(addr_t addr, Avr8RegLabelArray::iterator &it) + Avr8RegLabel *GetNext(adr_t addr, Avr8RegLabelArray::iterator &it) { it++; return (it != end() && (*it)->GetAddress() == addr) ? (Avr8RegLabel *)(*it) : NULL; @@ -216,7 +216,7 @@ class DasmAvr8 : (bus == BusEEPROM) ? 16 : 0; } // return highest possible bus address - virtual caddr_t GetHighestBusAddr(int bus = BusCode) { return highaddr[bus]; } + virtual cadr_t GetHighestBusAddr(int bus = BusCode) { return highaddr[bus]; } // return the default memory type for a bus (used in loading) virtual MemoryType GetDefaultMemoryType(int bus = BusCode) { return (bus == BusCode) ? Code : Data; } @@ -229,11 +229,11 @@ class DasmAvr8 : // return code pointer size in bytes virtual int GetCodePtrSize() { return 2; } // return highest possible code address - virtual caddr_t GetHighestCodeAddr() { return highaddr[BusCode]; } + virtual cadr_t GetHighestCodeAddr() { return highaddr[BusCode]; } // return data pointer size in bytes virtual int GetDataPtrSize() { return 2; } // return highest possible data address - virtual daddr_t GetHighestDataAddr() { return highaddr[BusData]; } + virtual dadr_t GetHighestDataAddr() { return highaddr[BusData]; } // Setup disassembler after construction virtual bool Setup(); @@ -247,55 +247,55 @@ class DasmAvr8 : string GetAvr8Option(string name); // Get/Set additional cell information - bool IsRelative(addr_t addr, int bus = BusCode) + bool IsRelative(adr_t addr, int bus = BusCode) { - addr_t rel; int relBus; + adr_t rel; int relBus; return memattr[bus] ? (((MemAttributeAvr8Handler *)memattr[bus])->GetRelative(addr, rel, relBus) != MemAttributeAvr8::RelUntyped) : false; } - MemAttributeAvr8::RelType GetRelative(addr_t addr, addr_t &rel, int &relBus, int bus = BusCode) + MemAttributeAvr8::RelType GetRelative(adr_t addr, adr_t &rel, int &relBus, int bus = BusCode) { return memattr[bus] ? ((MemAttributeAvr8Handler *)memattr[bus])->GetRelative(addr, rel, relBus) : MemAttributeAvr8::RelUntyped; } - void SetRelative(addr_t addr, MemAttributeAvr8::RelType newType = MemAttributeAvr8::RelUntyped, addr_t rel = NO_ADDRESS, int relBus = Avr8BusTypes, int bus = BusCode) + void SetRelative(adr_t addr, MemAttributeAvr8::RelType newType = MemAttributeAvr8::RelUntyped, adr_t rel = NO_ADDRESS, int relBus = Avr8BusTypes, int bus = BusCode) { if (memattr[bus]) ((MemAttributeAvr8Handler *)memattr[bus])->SetRelative(addr, newType, rel, relBus); } - virtual bool ProcessInfo(string key, string value, addr_t &from, addr_t &to, addr_t &step, vector> &remaps, bool bProcInfo = true, int bus = BusCode, int tgtbus = BusCode); + virtual bool ProcessInfo(string key, string value, adr_t &from, adr_t &to, adr_t &step, vector> &remaps, bool bProcInfo = true, int bus = BusCode, int tgtbus = BusCode); protected: // parse data area for labels - virtual addr_t ParseData(addr_t addr, int bus = BusCode); + virtual adr_t ParseData(adr_t addr, int bus = BusCode); // parse instruction at given memory address for labels - virtual addr_t ParseCode(addr_t addr, int bus = BusCode); + virtual adr_t ParseCode(adr_t addr, int bus = BusCode); // pass back correct mnemonic and parameters for a label virtual bool DisassembleLabel(Label *label, string &slabel, string &smnemo, string &sparm, int bus = BusCode); // pass back correct mnemonic and parameters for a DefLabel virtual bool DisassembleDefLabel(DefLabel *label, string &slabel, string &smnemo, string &sparm, int bus = BusCode); // disassemble data area at given memory address - virtual addr_t DisassembleData(addr_t addr, addr_t end, uint32_t flags, string &smnemo, string &sparm, int maxparmlen, int bus = BusCode); + virtual adr_t DisassembleData(adr_t addr, adr_t end, uint32_t flags, string &smnemo, string &sparm, int maxparmlen, int bus = BusCode); // disassemble instruction at given memory address - virtual addr_t DisassembleCode(addr_t addr, string &smnemo, string &sparm, int bus = BusCode); + virtual adr_t DisassembleCode(adr_t addr, string &smnemo, string &sparm, int bus = BusCode); public: // Initialize parsing virtual bool InitParse(int bus = BusCode); // pass back disassembler-specific state changes before/after a disassembly line - virtual bool DisassembleChanges(addr_t addr, addr_t prevaddr, addr_t prevsz, bool bAfterLine, vector &changes, int bus = BusCode); + virtual bool DisassembleChanges(adr_t addr, adr_t prevaddr, adr_t prevsz, bool bAfterLine, vector &changes, int bus = BusCode); // Register label handling protected: - bool AddRegLabel(addr_t addr, string sText = "", int nRegNum = 0) + bool AddRegLabel(adr_t addr, string sText = "", int nRegNum = 0) { RegLabels.insert(new Avr8RegLabel(addr, sText, nRegNum)); return true; } - Avr8RegLabel *GetFirstRegLabel(addr_t addr, Avr8RegLabelArray::iterator &it) + Avr8RegLabel *GetFirstRegLabel(adr_t addr, Avr8RegLabelArray::iterator &it) { return RegLabels.GetFirst(addr, it); } - Avr8RegLabel *GetNextRegLabel(addr_t addr, Avr8RegLabelArray::iterator &it) + Avr8RegLabel *GetNextRegLabel(adr_t addr, Avr8RegLabelArray::iterator &it) { return RegLabels.GetNext(addr, it); } protected: bool LoadAtmelGeneric(FILE *f, string &sLoadType, int bus = BusCode); virtual bool LoadFile(string filename, FILE *f, string &sLoadType, int interleave = 1, int bus = BusCode); - virtual bool String2Number(string s, addr_t &value); - virtual string Number2String(addr_t value, int nDigits, addr_t addr, int bus = BusCode); - virtual string Address2String(addr_t addr, int bus = BusCode) + virtual bool String2Number(string s, adr_t &value); + virtual string Number2String(adr_t value, int nDigits, adr_t addr, int bus = BusCode); + virtual string Address2String(adr_t addr, int bus = BusCode) { return sformat("0x%0*x", (busbits[bus] + 3) / 4, addr); } string RegName(int regnum, bool with_label = true) { @@ -304,13 +304,13 @@ class DasmAvr8 : return CurRegLabel[regnum]; return sformat("%s%d", reghdr[avr_gcc], regnum); } - string IORegName(addr_t addr) + string IORegName(adr_t addr) { Label *pLbl = FindLabel(addr, Untyped, BusIO); return (pLbl)? pLbl->GetText() : sformat("0x%02x", addr); } // generate text for an unnamed label - virtual string UnnamedLabel(addr_t addr, bool bCode, int bus = BusCode) + virtual string UnnamedLabel(adr_t addr, bool bCode, int bus = BusCode) { if (bAutoLabel) { @@ -320,13 +320,13 @@ class DasmAvr8 : return s; } - const char *cType; - int bits; + const char *cType = "L"; + int bits = 32; switch (bus) { case BusCode: cType = bCode ? "Z" : "M"; - bits = busbits[bCode ? BusCode : BusData]; + bits = busbits[bCode ? (int)BusCode : (int)BusData]; break; case BusData : // no code here! @@ -366,7 +366,7 @@ class DasmAvr8 : return result; } int32_t DecodeOperand(uint32_t operand, uint8_t operandType); - uint32_t GetDisassemblyTextFlags(addr_t addr, int bus = BusCode) + uint32_t GetDisassemblyTextFlags(adr_t addr, int bus = BusCode) { uint32_t flags = GetDisassemblyFlags(addr, bus); @@ -385,7 +385,7 @@ class DasmAvr8 : } return flags; } - int DisassembleString(addr_t addr, addr_t end, uint32_t flags, string &s, int maxparmlen, int bus = BusCode); + int DisassembleString(adr_t addr, adr_t end, uint32_t flags, string &s, int maxparmlen, int bus = BusCode); protected: // Enumeration for all types of AVR operands @@ -565,7 +565,7 @@ class DasmAvr8 : static OpCode opcodes[mnemoAvr8_count]; static avrInstructionInfo AVR_Instruction_Set[]; - vector highaddr; + vector highaddr; Avr8RegLabelArray RegLabels; string CurRegLabel[32]; bool dbalign, dbalignchg; diff --git a/Disassembler.cpp b/Disassembler.cpp index fa779c8..d09f08a 100644 --- a/Disassembler.cpp +++ b/Disassembler.cpp @@ -26,9 +26,9 @@ /* GetHex : retrieves a hex value in given length from file */ /*****************************************************************************/ -addr_t GetHex(FILE *f, int nChars, uint8_t *pchks) +adr_t GetHex(FILE *f, int nChars, uint8_t *pchks) { -addr_t out = 0; +adr_t out = 0; for (int i = 0; i < nChars; i++) { @@ -98,7 +98,7 @@ if (plbl && plbl->IsUsed()) { // labels containing '+' or '-' are no real labels; they are // references to another label (e.g., "OLBL+4") - string &s = plbl->GetText(); + string const &s = plbl->GetText(); if (s.find('-') == s.npos && s.find('+') == s.npos) wf |= SHMF_BREAK; } @@ -354,8 +354,8 @@ int Disassembler::DisassemblerSetOption(string lname, string value) { // this could be expanded ... "0x" or "$" header come to mind... string lvalue(lowercase(value)); -addr_t ivalue = (addr_t)strtoul(value.c_str(), NULL, 10); -addr_t avalue; +adr_t ivalue = (adr_t)strtoul(value.c_str(), NULL, 10); +adr_t avalue; String2Number(value, avalue); bool bnValue = true; /* default to "on" */ bool bIsBool = ParseBool(value, bnValue); @@ -438,7 +438,9 @@ AddOption("defdisp", "{bin|char|dec|oct|hex|}\tdefault number output format", &Disassembler::DisassemblerSetOption, &Disassembler::DisassemblerGetOption); #endif +#ifdef _DEBUG MemAttribute::Display disp = GetDisplay(); +#endif switch (GetDisplay()) { case MemAttribute::Binary : oval = "bin"; break; @@ -446,6 +448,7 @@ AddOption("defdisp", "{bin|char|dec|oct|hex|}\tdefault number output format", case MemAttribute::Octal : oval = "oct"; break; case MemAttribute::Decimal : oval = "dec"; break; case MemAttribute::Hex : oval = "hex"; break; + default : break; // keep gcc happy } } else if (lname == "begin") oval = (begin == NO_ADDRESS) ? "-1" : sformat("0x%lx", begin); @@ -466,9 +469,9 @@ return oval; bool Disassembler::IsForwardRef ( - addr_t value, + adr_t value, bool bUseLabel, - addr_t addr, + adr_t addr, int bus ) { @@ -478,7 +481,7 @@ if (!bUseLabel) return false; bool bForwardRef = false; -addr_t relative = GetRelative(addr, bus); +adr_t relative = GetRelative(addr, bus); Label *pLbl; MemoryType lblType; if (relative) @@ -489,9 +492,9 @@ if (relative) ((lblType == Code || lblType == Data || lblType == Bss) && relative >= addr); } -addr_t Wrel = (value + relative); -addr_t hiaddr = GetHighestBusAddr(bus) + 1; -addr_t WrelMod = (hiaddr) ? Wrel % hiaddr : Wrel; +adr_t Wrel = (value + relative); +adr_t hiaddr = GetHighestBusAddr(bus) + 1; +adr_t WrelMod = (hiaddr) ? Wrel % hiaddr : Wrel; pLbl = FindLabel(Wrel, Untyped, bus); lblType = pLbl ? pLbl->GetType() : Untyped; bForwardRef |= @@ -515,18 +518,18 @@ return bForwardRef; string Disassembler::Label2String ( - addr_t value, + adr_t value, int nDigits, bool bUseLabel, - addr_t addr, + adr_t addr, int bus ) { string sOut; -addr_t relative = GetRelative(addr, bus); -addr_t Wrel = (value + relative); -addr_t hiaddr = GetHighestBusAddr(bus) + 1; -addr_t WrelMod = (hiaddr) ? Wrel % hiaddr : Wrel; +adr_t relative = GetRelative(addr, bus); +adr_t Wrel = (value + relative); +adr_t hiaddr = GetHighestBusAddr(bus) + 1; +adr_t WrelMod = (hiaddr) ? Wrel % hiaddr : Wrel; // % might not be the best choice under all circumstances, but works for me... // NB: this always uses the LAST found label for this address. @@ -563,7 +566,7 @@ else if (bUseLabel && memType == Code) else if (bUseLabel && memType == Data) sOut = UnnamedLabel(WrelMod, false, bus); else // no label - use ORIGINAL value - sOut = Number2String(value, nDigits, addr, bus).c_str(); + sOut = Number2String(WrelMod, nDigits, addr, bus); if (relative) /* if it's relative addressing */ { @@ -590,7 +593,7 @@ if (relative) /* if it's relative addressing */ sAdd = "+"; /* negative*negative is positive... */ bInvert = false; /* so invert the sign */ /* and make the number positive */ - relative = (addr_t) (-((int32_t)relative)); + relative = (adr_t) (-((int32_t)relative)); } sAdd += Number2String(relative, nDigits, addr, bus); } @@ -620,7 +623,7 @@ return sOut; bool Disassembler::AddLabel ( - addr_t addr, + adr_t addr, MemoryType memType, string sLabel, bool bUsed, @@ -634,7 +637,9 @@ Label *pLbl = GetFirstLabel(addr, it, Untyped, bus); if (pLbl) { bool bHasTxt = !!sLabel.size(); +#if 0 bool bMulti = Labels[bus].HasMultipleDefs(); +#endif bool bInsert = true /*!bMulti*/; do { @@ -691,26 +696,40 @@ return true; // TODO: is that enough? Or does it need 2 busses (for addr and for at)? bool Disassembler::AddRelativeLabel ( - addr_t addr, - addr_t at, + adr_t addr, + adr_t at, MemoryType memType, bool bUsed, int bus, - addr_t craddr, /* cref address */ + adr_t craddr, /* cref address */ int crbus /* cref bus */ ) { -addr_t relative = GetRelative(at, bus); -addr_t addrRel = addr + relative; -addr_t hiaddr = GetHighestBusAddr(bus) + 1; -addr_t addrRelMod = (hiaddr) ? addrRel % hiaddr : addrRel; +(void)bUsed; +adr_t relative = GetRelative(at, bus); +adr_t addrRel = addr + relative; +adr_t hiaddr = GetHighestBusAddr(bus) + 1; +adr_t addrRelMod = (hiaddr) ? addrRel % hiaddr : addrRel; bool rc; if (addrRelMod != addr) { +#if 0 + // add relative if it is not defined. if (AddLabel(relative, memType, "", true, bus) && +#else + // don't add relative if it is not defined. If not, it's a constant. + if (FindLabel(relative, Untyped, bus) && +#endif craddr != NO_ADDRESS) SetLabelUsed(relative, memType, bus, craddr, crbus); +#if 0 + // add label in any case rc = AddLabel(addrRelMod, memType, "", true, bus); +#else + // don't add relative if it is not defined. If not, it's a constant. + // If rel is set but neither label is there, outputs a funny addition... + rc = !!FindLabel(addrRelMod, Untyped, bus); +#endif if (rc && craddr != NO_ADDRESS) SetLabelUsed(addrRelMod, memType, bus, craddr, crbus); } @@ -729,7 +748,7 @@ return rc; Label *Disassembler::FindLabel ( - addr_t addr, + adr_t addr, MemoryType memType, int bus ) @@ -783,7 +802,7 @@ return found; Label *Disassembler::FindPrevNamedLabel ( - addr_t addr, + adr_t addr, MemoryType memType, int bus ) @@ -848,14 +867,14 @@ for (int i = GetLabelCount(bus) - 1; i >= 0; i--) if (!pLbl->IsUsed()) continue; // first, check for +/-nnnn offset - addr_t offs; + adr_t offs; if (p != s.npos && // String2Number(s.substr(p + 1), offs)) sscanf(s.substr(p + 1).c_str(), "%d", &offs) == 1) { - if (s[p] == '+') offs = (addr_t)(-(int32_t)offs); + if (s[p] == '+') offs = (adr_t)(-(int32_t)offs); pLbl->SetUsed(false); - addr_t addaddr = pLbl->GetAddress() + offs; + adr_t addaddr = pLbl->GetAddress() + offs; AddLabel(addaddr, pLbl->GetType(), s.substr(0, p), true, bus); // copy all references to the base label @@ -876,14 +895,14 @@ for (int i = GetLabelCount(bus) - 1; i >= 0; i--) // then, resolve DefLabels without value if (pLbl->IsConst()) { - addr_t addr = pLbl->GetAddress(); + adr_t addr = pLbl->GetAddress(); MemoryType memType = GetMemType(addr, bus); int sz = GetCellSize(addr, bus); if (memType != Untyped && memType != Bss && !IsFloat(addr, bus)) { if (s.size() > 0) { - addr_t value = GetTypedInt(addr, bus); + adr_t value = GetTypedInt(addr, bus); // insert with last found value AddDefLabel(addr, s, @@ -903,9 +922,9 @@ return true; string Disassembler::DefLabel2String ( - addr_t value, + adr_t value, int nDigits, - addr_t addr, + adr_t addr, int bus ) { @@ -926,12 +945,13 @@ return svalue; /* AutoLabel2String : automatic label generation based on previous label */ /*****************************************************************************/ -string Disassembler::AutoLabel2String(addr_t addr, bool bCode, int bus) +string Disassembler::AutoLabel2String(adr_t addr, bool bCode, int bus) { +(void)bCode; // unused ATM Label *pLabel = FindPrevNamedLabel(addr, Untyped /* Const */, bus); if (pLabel) { - addr_t off = addr - pLabel->GetAddress(); + adr_t off = addr - pLabel->GetAddress(); return sformat("O%x_%s", off, pLabel->GetText().c_str()); } return ""; @@ -941,7 +961,7 @@ return ""; /* GetTypedInt : get memory from given address defined by cell type/size */ /*****************************************************************************/ -addr_t Disassembler::GetTypedInt(addr_t addr, int bus) +adr_t Disassembler::GetTypedInt(adr_t addr, int bus) { MemoryType memType = GetMemType(addr, bus); int sz = GetCellSize(addr, bus); @@ -952,7 +972,7 @@ switch (sz) case 1 : return bSigned ? GetSByte(addr, bus) : GetUByte(addr, bus); case 2 : return bSigned ? GetSWord(addr, bus) : GetUWord(addr, bus); case 4 : return bSigned ? GetSDWord(addr, bus) : GetUDWord(addr, bus); -#if (ADDR_T_SIZE >= 8) +#if (ADR_T_SIZE >= 8) case 8 : return bSigned ? GetSQWord(addr, bus) : GetUQWord(addr, bus); #endif default : @@ -964,7 +984,7 @@ switch (sz) /* GetTypedInt : set memory at given address defined by cell type/size */ /*****************************************************************************/ -void Disassembler::SetTypedInt(addr_t value, addr_t addr, int bus) +void Disassembler::SetTypedInt(adr_t value, adr_t addr, int bus) { MemoryType memType = GetMemType(addr, bus); int sz = GetCellSize(addr, bus); @@ -991,7 +1011,7 @@ switch (sz) else SetUDWord(addr, (uint32_t)value, bus); break; -#if (ADDR_T_SIZE >= 8) +#if (ADR_T_SIZE >= 8) case 8 : if (bSigned) SetSQWord(addr, (int64_t)value, bus); @@ -1015,6 +1035,7 @@ bool Disassembler::LoadIntelHex int bus ) { +(void)filename; int nCurPos = ftell(f); int c = 0; @@ -1029,14 +1050,14 @@ if (c != ':') int rectype; bool done = false; int nBytes = 0; -addr_t fbegin = GetHighestBusAddr(bus); -addr_t fend = GetLowestBusAddr(bus); +adr_t fbegin = GetHighestBusAddr(bus); +adr_t fend = GetLowestBusAddr(bus); int segment = 0; /* segment address */ MemoryType memType = GetDefaultMemoryType(bus); while (!done && (nBytes >= 0)) /* while there are lines */ { - addr_t nAddr; + adr_t nAddr; int nBytesOnLine, i; uint8_t chks = 0; if (c != ':') @@ -1070,7 +1091,7 @@ while (!done && (nBytes >= 0)) /* while there are lines */ case 0 : /* data record */ for (i = 0; i 0xff)) /* if illegal byte */ { nBytes = -1; break; } /* return with error */ @@ -1155,6 +1176,7 @@ bool Disassembler::LoadMotorolaHex int bus ) { +(void)filename; int nCurPos = ftell(f); int c = 0; @@ -1168,18 +1190,19 @@ if (c != 'S') bool done = false; int nBytes = 0; -addr_t fbegin = GetHighestBusAddr(bus); -addr_t fend = GetLowestBusAddr(bus); +adr_t fbegin = GetHighestBusAddr(bus); +adr_t fend = GetLowestBusAddr(bus); MemoryType memType = GetDefaultMemoryType(bus); while ((!done) && (nBytes >= 0)) /* while there are lines */ { int nLineType = 0, nBytesOnLine, i; - addr_t nAddr; + adr_t nAddr; uint8_t chks = 0; if (c != 'S') break; - fread(&nLineType, 1, 1, f); /* retrieve line type */ + if (fread(&nLineType, 1, 1, f) != 1) /* retrieve line type */ + { nBytes = -1; break; } /* return with error */ nBytesOnLine = GetHex(f, 2, &chks); /* retrieve # bytes on line */ if (nBytesOnLine < 0) /* if error */ { nBytes = -1; break; } /* return with error */ @@ -1218,7 +1241,7 @@ while ((!done) && (nBytes >= 0)) /* while there are lines */ /* now get the bytes */ for (i = 0; i < nBytesOnLine; i++) { - addr_t tgtaddr = nAddr + (i * interleave); + adr_t tgtaddr = nAddr + (i * interleave); c = GetHex(f, 2, &chks); /* retrieve a byte */ if ((c < 0) || (c > 0xff)) /* if illegal byte */ { nBytes = -1; break; } /* return with error */ @@ -1309,19 +1332,20 @@ bool Disassembler::LoadBinary int bus ) { +(void)filename; int nCurPos = ftell(f); // this logic is required, since reads for other file types might have ended // with an ungetc() call, which could be ruined by the fseek()/ftell() below // if the file is unseekable int c = fgetc(f); /* read first byte from the file */ -addr_t i, off; +adr_t i, off; MemoryType memType = GetDefaultMemoryType(bus); fseek(f, 0, SEEK_END); /* get file length */ off = ftell(f) - nCurPos; fseek(f, nCurPos + 1, SEEK_SET); -if (off > 0 && /* restrict to maximum code size */ +if ((sadr_t)off > 0 && /* restrict to maximum code size */ offset + (off * interleave) > GetHighestBusAddr(bus) + 1) off = ((GetHighestBusAddr(bus) + 1) / interleave) - offset; @@ -1330,32 +1354,32 @@ if (begin == NO_ADDRESS || /* set begin if not specified */ // if (begin < 0 || offset < begin) // we allow begin > offset ! begin = offset; -if (off > 0) /* if file size can be determined */ +if ((sadr_t)off > 0) /* if file size can be determined */ { - if (end == 0) /* set end if not specified */ + if (end == 0 || end < begin) /* set end if not specified */ // if (end < offset + (off * interleave) - 1) - end = offset + (off * interleave) -1; + end = offset + (off * interleave) - 1; if (end > offset && end < offset + (off * interleave) -1) off = (end + 1 - offset + interleave - 1) / interleave; // account for begin > offset scenarios - addr_t memoff = begin > offset ? begin - offset : 0; + adr_t memoff = begin > offset ? begin - offset : 0; AddMemory(begin, /* make sure memory is there */ (off - 1) * interleave + 1 - memoff, memType, 0, bus); } - -for (i = 0; off < 0 || i < off; i++) /* mark area as used */ + /* mark area as used */ +for (i = 0; (sadr_t)off < 0 || i < off; i++) { if (c == EOF) /* if error, abort reading */ { if (off > 0) fseek(f, nCurPos, SEEK_SET); - return off < 0; + return (sadr_t)off < 0; } - addr_t tgtaddr = offset + (i * interleave); + adr_t tgtaddr = offset + (i * interleave); if (tgtaddr >= begin && tgtaddr <= end) { - if (off < 0) /* if reading an unseekable stream */ + if ((sadr_t)off < 0) /* if reading an unseekable stream */ AddMemory(tgtaddr, interleave, /* assure memory */ memType, 0, bus); setat(tgtaddr, (uint8_t)c, bus); /* put byte */ @@ -1416,16 +1440,16 @@ return bOK; /* (i.e., same type for all) */ /*****************************************************************************/ -addr_t Disassembler::GetConsecutiveData +adr_t Disassembler::GetConsecutiveData ( - addr_t addr, + adr_t addr, uint32_t &flags, int maxparmlen, int bus ) { -addr_t end; -addr_t maxaddr = GetHighestBusAddr(bus); +adr_t end; +adr_t maxaddr = GetHighestBusAddr(bus); /* get flags for current byte */ flags = GetDisassemblyFlags(addr, bus) & (~(SHMF_BREAK | /* without break flag */ @@ -1434,9 +1458,9 @@ flags = GetDisassemblyFlags(addr, bus) & // safety fuse - process no more than maxparmlen at a time unless it's // RMB. This may still be too much, but should not be too far off. if (!(flags & SHMF_RMB) && - addr + (addr_t)maxparmlen > addr && - addr + (addr_t)maxparmlen <= maxaddr) - maxaddr = addr + (addr_t)maxparmlen - 1; + addr + (adr_t)maxparmlen > addr && + addr + (adr_t)maxparmlen <= maxaddr) + maxaddr = addr + (adr_t)maxparmlen - 1; for (end = addr + 1; /* find end of block */ end > addr && end <= maxaddr; @@ -1451,7 +1475,7 @@ for (end = addr + 1; /* find end of block */ if (flags & 0xff) /* if not 1-sized, */ { int dsz = (int)(flags & 0xff) + 1; - addr_t rest = (end - addr) % dsz; + adr_t rest = (end - addr) % dsz; if (rest) /* don't use incomplete last item */ end -= rest; if (end == addr) /* if there's nothing left */ diff --git a/Disassembler.h b/Disassembler.h index d1608be..ff7ae26 100644 --- a/Disassembler.h +++ b/Disassembler.h @@ -34,25 +34,25 @@ class MemAttributeHandler public: MemAttributeHandler() { } virtual ~MemAttributeHandler() { } - virtual bool AddMemory(addr_t addrStart = 0, addr_t memSize = 0, MemoryType memType = Code) = 0; - virtual MemoryType GetMemType(addr_t addr) = 0; - virtual void SetMemType(addr_t addr, MemoryType newType = Code) = 0; - virtual bool IsCellUsed(addr_t addr) = 0; - virtual void SetCellUsed(addr_t addr, bool bUsed = true) = 0; - virtual MemAttribute::Type GetCellType(addr_t addr) = 0; - virtual void SetCellType(addr_t addr, MemAttribute::Type newType) = 0; - virtual int GetCellSize(addr_t addr) = 0; - virtual void SetCellSize(addr_t addr, int newSize = 1) = 0; - virtual MemAttribute::Display GetDisplay(addr_t addr) = 0; - virtual void SetDisplay(addr_t addr, MemAttribute::Display newDisp = MemAttribute::DefaultDisplay) = 0; - virtual bool GetBreakBefore(addr_t addr) = 0; - virtual void SetBreakBefore(addr_t addr, bool bOn = true) = 0; - virtual bool GetForcedAddr(addr_t addr) = 0; - virtual void SetForcedAddr(addr_t addr, bool bOn = true) = 0; - virtual uint32_t GetDisassemblyFlags(addr_t addr, uint8_t mem, Label *plbl) = 0; + virtual bool AddMemory(adr_t addrStart = 0, adr_t memSize = 0, MemoryType memType = Code) = 0; + virtual MemoryType GetMemType(adr_t addr) = 0; + virtual void SetMemType(adr_t addr, MemoryType newType = Code) = 0; + virtual bool IsCellUsed(adr_t addr) = 0; + virtual void SetCellUsed(adr_t addr, bool bUsed = true) = 0; + virtual MemAttribute::Type GetCellType(adr_t addr) = 0; + virtual void SetCellType(adr_t addr, MemAttribute::Type newType) = 0; + virtual int GetCellSize(adr_t addr) = 0; + virtual void SetCellSize(adr_t addr, int newSize = 1) = 0; + virtual MemAttribute::Display GetDisplay(adr_t addr) = 0; + virtual void SetDisplay(adr_t addr, MemAttribute::Display newDisp = MemAttribute::DefaultDisplay) = 0; + virtual bool GetBreakBefore(adr_t addr) = 0; + virtual void SetBreakBefore(adr_t addr, bool bOn = true) = 0; + virtual bool GetForcedAddr(adr_t addr) = 0; + virtual void SetForcedAddr(adr_t addr, bool bOn = true) = 0; + virtual uint32_t GetDisassemblyFlags(adr_t addr, uint8_t mem, Label *plbl) = 0; // basic access virtual size_t size() = 0; - virtual addr_t GetStart(int index) = 0; + virtual adr_t GetStart(int index) = 0; virtual size_t size(int index) = 0; }; @@ -82,41 +82,41 @@ class BasicMemAttributeHandler : public MemAttributeHandler virtual ~BasicMemAttributeHandler() { } - virtual bool AddMemory(addr_t addrStart = 0, addr_t memSize = 0, MemoryType memType = Code) + virtual bool AddMemory(adr_t addrStart = 0, adr_t memSize = 0, MemoryType memType = Code) { return attr.AddMemory(addrStart, memSize, memType); } - virtual MemoryType GetMemType(addr_t addr) + virtual MemoryType GetMemType(adr_t addr) { MemAttribute *pAttr = attr.getat(addr); return pAttr ? pAttr->GetMemType() : Untyped; } - virtual void SetMemType(addr_t addr, MemoryType newType = Code) + virtual void SetMemType(adr_t addr, MemoryType newType = Code) { MemAttribute *pAttr = attr.getat(addr); if (pAttr) pAttr->SetMemType(newType); } - virtual bool IsCellUsed(addr_t addr) + virtual bool IsCellUsed(adr_t addr) { MemAttribute *pAttr = attr.getat(addr); return pAttr ? pAttr->IsUsed() : false; } - virtual void SetCellUsed(addr_t addr, bool bUsed = true) + virtual void SetCellUsed(adr_t addr, bool bUsed = true) { MemAttribute *pAttr = attr.getat(addr); if (pAttr) pAttr->SetUsed(bUsed); } - virtual MemAttribute::Type GetCellType(addr_t addr) + virtual MemAttribute::Type GetCellType(adr_t addr) { MemAttribute *pAttr = attr.getat(addr); return pAttr ? pAttr->GetCellType() : MemAttribute::CellUntyped; } - virtual void SetCellType(addr_t addr, MemAttribute::Type newType) + virtual void SetCellType(adr_t addr, MemAttribute::Type newType) { MemAttribute *pAttr = attr.getat(addr); if (pAttr) pAttr->SetCellType(newType); } - virtual int GetCellSize(addr_t addr) + virtual int GetCellSize(adr_t addr) { MemAttribute *pAttr = attr.getat(addr); return pAttr ? pAttr->GetSize() : 0; } - virtual void SetCellSize(addr_t addr, int newSize = 1) + virtual void SetCellSize(adr_t addr, int newSize = 1) { MemAttribute *pAttr = attr.getat(addr); if (pAttr) pAttr->SetSize(newSize); } - virtual MemAttribute::Display GetDisplay(addr_t addr) + virtual MemAttribute::Display GetDisplay(adr_t addr) { MemAttribute *pAttr = attr.getat(addr); return pAttr ? pAttr->GetDisplay() : MemAttribute::CellUndisplayable; } - virtual void SetDisplay(addr_t addr, MemAttribute::Display newDisp = MemAttribute::DefaultDisplay) + virtual void SetDisplay(adr_t addr, MemAttribute::Display newDisp = MemAttribute::DefaultDisplay) { MemAttribute *pAttr = attr.getat(addr); if (pAttr) pAttr->SetDisplay(newDisp); } - virtual bool GetBreakBefore(addr_t addr) + virtual bool GetBreakBefore(adr_t addr) { MemAttribute *pAttr = attr.getat(addr); return pAttr ? pAttr->GetBreakBefore() : false; } - virtual void SetBreakBefore(addr_t addr, bool bOn = true) + virtual void SetBreakBefore(adr_t addr, bool bOn = true) { MemAttribute *pAttr = attr.getat(addr); if (pAttr) pAttr->SetBreakBefore(bOn); } - virtual bool GetForcedAddr(addr_t addr) + virtual bool GetForcedAddr(adr_t addr) { MemAttribute *pAttr = attr.getat(addr); return pAttr ? pAttr->GetForcedAddr() : false; } - virtual void SetForcedAddr(addr_t addr, bool bOn = true) + virtual void SetForcedAddr(adr_t addr, bool bOn = true) { MemAttribute *pAttr = attr.getat(addr); if (pAttr) pAttr->SetForcedAddr(bOn); } - virtual uint32_t GetDisassemblyFlags(addr_t addr, uint8_t mem, Label *plbl) + virtual uint32_t GetDisassemblyFlags(adr_t addr, uint8_t mem, Label *plbl) { return GetBasicDisassemblyFlags(attr.getat(addr), mem, plbl); } // basic access virtual size_t size() { return (size_t)attr.size(); } - virtual addr_t GetStart(int index) { return attr[index].GetStart(); } + virtual adr_t GetStart(int index) { return attr[index].GetStart(); } virtual size_t size(int index) { return attr[index].size(); } protected: @@ -185,11 +185,11 @@ class Disassembler // return bus width virtual int GetBusWidth(int bus = BusCode) = 0; // return lowest address for a bus - virtual addr_t GetLowestBusAddr(int bus = BusCode) - { return 0; } + virtual adr_t GetLowestBusAddr(int bus = BusCode) + { (void)bus; return 0; } // return highest address for a bus - virtual addr_t GetHighestBusAddr(int bus = BusCode) - { return (addr_t)(((addr_t)1 << GetBusWidth(bus)) - 1); } + virtual adr_t GetHighestBusAddr(int bus = BusCode) + { return (adr_t)(((adr_t)1 << GetBusWidth(bus)) - 1); } // return a bus name virtual string GetBusName(int bus = BusCode) { @@ -212,7 +212,7 @@ class Disassembler } // return the default memory type for a bus (used in loading) virtual MemoryType GetDefaultMemoryType(int bus = BusCode) - { return Code; } + { (void)bus; return Code; } // return code bits virtual int GetCodeBits() = 0; @@ -222,15 +222,15 @@ class Disassembler // return code pointer size in bytes virtual int GetCodePtrSize() = 0; // return lowest possible code address - virtual caddr_t GetLowestCodeAddr() { return 0; } + virtual cadr_t GetLowestCodeAddr() { return 0; } // return highest possible code address - virtual caddr_t GetHighestCodeAddr() = 0; + virtual cadr_t GetHighestCodeAddr() = 0; // return data pointer size in bytes virtual int GetDataPtrSize() = 0; // return lowest possible data address - virtual daddr_t GetLowestDataAddr() { return 0; } + virtual dadr_t GetLowestDataAddr() { return 0; } // return highest possible data address - virtual daddr_t GetHighestDataAddr() = 0; + virtual dadr_t GetHighestDataAddr() = 0; // Setup disassembler after construction virtual bool Setup(); @@ -264,21 +264,21 @@ class Disassembler // print disassembler-specific info file help virtual string InfoHelp() { return ""; } // global typed options - addr_t GetBegin() { return begin; } - addr_t GetEnd() { return end; } - addr_t GetOffset() { return offset; } + adr_t GetBegin() { return begin; } + adr_t GetEnd() { return end; } + adr_t GetOffset() { return offset; } int GetBus(int bus) { return busorder[bus]; } // Memory access public: // Add memory area - virtual bool AddMemory(addr_t addrStart = 0, addr_t memSize = 0, MemoryType memType = Code, uint8_t *contents = NULL, int bus = BusCode) + virtual bool AddMemory(adr_t addrStart = 0, adr_t memSize = 0, MemoryType memType = Code, uint8_t *contents = NULL, int bus = BusCode) { if (!memory[bus].AddMemory(addrStart, memSize, memType, contents)) return false; return memattr[bus] && memattr[bus]->AddMemory(addrStart, memSize, memType); } - template T inline getat(addr_t addr, int bus = BusCode) + template T inline getat(adr_t addr, int bus = BusCode) { T val; if (!getat(addr, (uint8_t *)&val, sizeof(val), bus)) @@ -291,12 +291,12 @@ class Disassembler int GetMemAttrArrayCount(int bus = BusCode) { return memattr[bus] ? memattr[bus]->size() : 0; } MemAttributeHandler *GetMemoryAttributeHandler(int bus = BusCode) { return memattr[bus]; } // find memory area index for a given address - addr_t GetMemIndex(addr_t addr, int bus = BusCode) + adr_t GetMemIndex(adr_t addr, int bus = BusCode) { return memory[bus].GetMemIndex(addr); } // get next loaded memory address - addr_t GetNextAddr(addr_t addr, int bus = BusCode) + adr_t GetNextAddr(adr_t addr, int bus = BusCode) { - addr_t nextAddr = addr + 1; + adr_t nextAddr = addr + 1; while (!IsCellUsed(nextAddr, bus)) { uint8_t *pNext = getat(nextAddr, bus); @@ -304,7 +304,7 @@ class Disassembler { for (int i = 0; i < GetMemoryArrayCount(); i++) { - addr_t nextStart = GetMemoryArray(i, bus).GetStart(); + adr_t nextStart = GetMemoryArray(i, bus).GetStart(); if (nextStart > nextAddr) { pNext = getat(nextStart, bus); @@ -322,64 +322,65 @@ class Disassembler } // Get/Set integer memory as defined by cell type / size - addr_t GetTypedInt(addr_t addr, int bus = BusCode); - void SetTypedInt(addr_t value, addr_t addr, int bus = BusCode); + adr_t GetTypedInt(adr_t addr, int bus = BusCode); + void SetTypedInt(adr_t value, adr_t addr, int bus = BusCode); // Get/Set memory byte - int8_t GetSByte(addr_t addr, int bus = BusCode) + int8_t GetSByte(adr_t addr, int bus = BusCode) { return (int8_t)*getat(addr, bus); } - uint8_t GetUByte(addr_t addr, int bus = BusCode) + uint8_t GetUByte(adr_t addr, int bus = BusCode) { uint8_t *pb = getat(addr, bus); return pb ? *pb : 0; } - bool SetSByte(addr_t addr, int8_t val, int bus = BusCode) + bool SetSByte(adr_t addr, int8_t val, int bus = BusCode) { return setat(addr, (uint8_t)val, bus); } - bool SetUByte(addr_t addr, uint8_t val, int bus = BusCode) + bool SetUByte(adr_t addr, uint8_t val, int bus = BusCode) { return setat(addr, val, bus); } // Get/Set memory word - int16_t GetSWord(addr_t addr, int bus = BusCode) + int16_t GetSWord(adr_t addr, int bus = BusCode) { return getat(addr, bus); } - uint16_t GetUWord(addr_t addr, int bus = BusCode) + uint16_t GetUWord(adr_t addr, int bus = BusCode) { return getat(addr, bus); } - bool SetSWord(addr_t addr, int16_t val, int bus = BusCode) + bool SetSWord(adr_t addr, int16_t val, int bus = BusCode) { return setat(addr, (uint8_t *)&val, sizeof(val), bus); } - bool SetUWord(addr_t addr, uint16_t val, int bus = BusCode) + bool SetUWord(adr_t addr, uint16_t val, int bus = BusCode) { return setat(addr, (uint8_t *)&val, sizeof(val), bus); } // Get/Set memory dword - int32_t GetSDWord(addr_t addr, int bus = BusCode) + int32_t GetSDWord(adr_t addr, int bus = BusCode) { return getat(addr, bus); } - uint32_t GetUDWord(addr_t addr, int bus = BusCode) + uint32_t GetUDWord(adr_t addr, int bus = BusCode) { return getat(addr, bus); } - bool SetSDWord(addr_t addr, int32_t val, int bus = BusCode) + bool SetSDWord(adr_t addr, int32_t val, int bus = BusCode) { return setat(addr, (uint8_t *)&val, sizeof(val), bus); } - bool SetUDWord(addr_t addr, uint32_t val, int bus = BusCode) + bool SetUDWord(adr_t addr, uint32_t val, int bus = BusCode) { return setat(addr, (uint8_t *)&val, sizeof(val), bus); } // Get/Set memory qword - int64_t GetSQWord(addr_t addr, int bus = BusCode) + int64_t GetSQWord(adr_t addr, int bus = BusCode) { return getat(addr, bus); } - uint64_t GetUQWord(addr_t addr, int bus = BusCode) + uint64_t GetUQWord(adr_t addr, int bus = BusCode) { return getat(addr, bus); } - bool SetSQWord(addr_t addr, int64_t val, int bus = BusCode) + bool SetSQWord(adr_t addr, int64_t val, int bus = BusCode) { return setat(addr, (uint8_t *)&val, sizeof(val), bus); } - bool SetUQWord(addr_t addr, uint64_t val, int bus = BusCode) + bool SetUQWord(adr_t addr, uint64_t val, int bus = BusCode) { return setat(addr, (uint8_t *)&val, sizeof(val), bus); } // Get/Set 32-bit floating-point IEEE 854 value - float GetFloat(addr_t addr, int bus = BusCode) + float GetFloat(adr_t addr, int bus = BusCode) { return getat(addr, bus); } - bool SetFloat(addr_t addr, float val, int bus = BusCode) + bool SetFloat(adr_t addr, float val, int bus = BusCode) { return setat(addr, (uint8_t *)&val, sizeof(val), bus); } // Get/Set 64-bit floating-point IEEE 854 value - double GetDouble(addr_t addr, int bus = BusCode) + double GetDouble(adr_t addr, int bus = BusCode) { return getat(addr, bus); } - bool SetDouble(addr_t addr, double val, int bus = BusCode) + bool SetDouble(adr_t addr, double val, int bus = BusCode) { return setat(addr, (uint8_t *)&val, sizeof(val), bus); } // Get/set delimited ASCII string - string GetString(addr_t addr, char cTerm = '\0', int bus = BusCode) + string GetString(adr_t addr, char cTerm = '\0', int bus = BusCode) { + (void)bus; string s; char c; - while ((c = (char)getat(addr++)) != cTerm) + while ((c = static_cast(*getat(addr++))) != cTerm) s += c; return s; } - bool SetString(addr_t addr, string s, char cTerm = '\0', int bus = BusCode) + bool SetString(adr_t addr, string s, char cTerm = '\0', int bus = BusCode) { if (setat(addr, (uint8_t *)s.c_str(), s.size(), bus)) return setat(addr + s.size(), (uint8_t)cTerm, bus); @@ -389,39 +390,39 @@ class Disassembler // we'll deal with it in time. // Get/Set cell information - MemoryType GetMemType(addr_t addr, int bus = BusCode) + MemoryType GetMemType(adr_t addr, int bus = BusCode) { return memattr[bus] ? memattr[bus]->GetMemType(addr) : Untyped; } - void SetMemType(addr_t addr, MemoryType newType = Code, int bus = BusCode) + void SetMemType(adr_t addr, MemoryType newType = Code, int bus = BusCode) { if (memattr[bus]) memattr[bus]->SetMemType(addr, newType); } - bool IsCellUsed(addr_t addr, int bus = BusCode) + bool IsCellUsed(adr_t addr, int bus = BusCode) { return memattr[bus] ? memattr[bus]->IsCellUsed(addr) : false; } - void SetCellUsed(addr_t addr, bool bUsed = true, int bus = BusCode) + void SetCellUsed(adr_t addr, bool bUsed = true, int bus = BusCode) { if (memattr[bus]) memattr[bus]->SetCellUsed(addr, bUsed); } - MemAttribute::Type GetCellType(addr_t addr, int bus = BusCode) + MemAttribute::Type GetCellType(adr_t addr, int bus = BusCode) { return memattr[bus] ? memattr[bus]->GetCellType(addr) : MemAttribute::CellUntyped; } - void SetCellType(addr_t addr, MemAttribute::Type newType, int bus = BusCode) + void SetCellType(adr_t addr, MemAttribute::Type newType, int bus = BusCode) { if (memattr[bus]) memattr[bus]->SetCellType(addr, newType); } - int GetCellSize(addr_t addr, int bus = BusCode) + int GetCellSize(adr_t addr, int bus = BusCode) { return memattr[bus] ? memattr[bus]->GetCellSize(addr) : 0; } - void SetCellSize(addr_t addr, int newSize = 1, int bus = BusCode) + void SetCellSize(adr_t addr, int newSize = 1, int bus = BusCode) { if (memattr[bus]) memattr[bus]->SetCellSize(addr, newSize); } - MemAttribute::Display GetDisplay(addr_t addr, int bus = BusCode) + MemAttribute::Display GetDisplay(adr_t addr, int bus = BusCode) { return memattr[bus] ? memattr[bus]->GetDisplay(addr) : MemAttribute::CellUndisplayable; } - void SetDisplay(addr_t addr, MemAttribute::Display newDisp = MemAttribute::DefaultDisplay, int bus = BusCode) + void SetDisplay(adr_t addr, MemAttribute::Display newDisp = MemAttribute::DefaultDisplay, int bus = BusCode) { if (memattr[bus]) memattr[bus]->SetDisplay(addr, newDisp); } - bool GetBreakBefore(addr_t addr, int bus = BusCode) + bool GetBreakBefore(adr_t addr, int bus = BusCode) { return memattr[bus] ? memattr[bus]->GetBreakBefore(addr) : false; } - void SetBreakBefore(addr_t addr, bool bOn = true, int bus = BusCode) + void SetBreakBefore(adr_t addr, bool bOn = true, int bus = BusCode) { if (memattr[bus]) memattr[bus]->SetBreakBefore(addr, bOn); } - bool GetForcedAddr(addr_t addr, int bus = BusCode) + bool GetForcedAddr(adr_t addr, int bus = BusCode) { return memattr[bus] ? memattr[bus]->GetForcedAddr(addr) : false; } - void SetForcedAddr(addr_t addr, bool bOn = true, int bus = BusCode) + void SetForcedAddr(adr_t addr, bool bOn = true, int bus = BusCode) { if (memattr[bus]) memattr[bus]->SetForcedAddr(addr, bOn); } // get/set default cell display format MemAttribute::Display GetDisplay() { return defaultDisplay; } void SetDisplay(MemAttribute::Display newDisp) { defaultDisplay = newDisp; } // Get Flags for disassembly of data areas - virtual uint32_t GetDisassemblyFlags(addr_t addr, int bus = BusCode) + virtual uint32_t GetDisassemblyFlags(adr_t addr, int bus = BusCode) { uint8_t *mem = getat(addr, bus); if (!mem) return 0; @@ -429,60 +430,60 @@ class Disassembler Label *plbl = FindLabel(addr, Untyped, bus); return memattr[bus] ? memattr[bus]->GetDisassemblyFlags(addr, *mem, plbl) : 0; } - void SetInvalidInstruction(addr_t addr, int newSize = 1, int bus = BusCode) + void SetInvalidInstruction(adr_t addr, int newSize = 1, int bus = BusCode) { // this can be called during disassembler parsing to mark an invalid instruction - SetMemType(addr, Const); - SetCellSize(addr, newSize); - SetCellType(addr, MemAttribute::CellUntyped); + SetMemType(addr, Const, bus); + SetCellSize(addr, newSize, bus); + SetCellType(addr, MemAttribute::CellUntyped, bus); } // convenience functionality for the above - bool IsCode(addr_t addr, int bus = BusCode) { return GetMemType(addr, bus) == Code; } - bool IsData(addr_t addr, int bus = BusCode) { return GetMemType(addr, bus) == Data; } - bool IsConst(addr_t addr, int bus = BusCode) { return GetMemType(addr, bus) == Const; } - bool IsBss(addr_t addr, int bus = BusCode) { return GetMemType(addr, bus) == Bss; } - bool IsBinary(addr_t addr, int bus = BusCode) { return GetDisplay(addr, bus) == MemAttribute::Binary; } - bool IsChar(addr_t addr, int bus = BusCode) { return GetDisplay(addr, bus) == MemAttribute::Char; } - bool IsOctal(addr_t addr, int bus = BusCode) { return GetDisplay(addr, bus) == MemAttribute::Octal; } - bool IsDecimal(addr_t addr, int bus = BusCode) { return GetDisplay(addr, bus) == MemAttribute::Decimal; } - bool IsHex(addr_t addr, int bus = BusCode) { MemAttribute::Display disp = GetDisplay(addr, bus); return disp == MemAttribute::DefaultDisplay || disp == MemAttribute::Hex; } - bool IsSigned(addr_t addr, int bus = BusCode) { return GetCellType(addr, bus) == MemAttribute::SignedInt; } - bool IsUnsigned(addr_t addr, int bus = BusCode) { return GetCellType(addr, bus) == MemAttribute::UnsignedInt; } - bool IsFloat(addr_t addr, int bus = BusCode) { return GetCellType(addr, bus) == MemAttribute::Float; } + bool IsCode(adr_t addr, int bus = BusCode) { return GetMemType(addr, bus) == Code; } + bool IsData(adr_t addr, int bus = BusCode) { return GetMemType(addr, bus) == Data; } + bool IsConst(adr_t addr, int bus = BusCode) { return GetMemType(addr, bus) == Const; } + bool IsBss(adr_t addr, int bus = BusCode) { return GetMemType(addr, bus) == Bss; } + bool IsBinary(adr_t addr, int bus = BusCode) { return GetDisplay(addr, bus) == MemAttribute::Binary; } + bool IsChar(adr_t addr, int bus = BusCode) { return GetDisplay(addr, bus) == MemAttribute::Char; } + bool IsOctal(adr_t addr, int bus = BusCode) { return GetDisplay(addr, bus) == MemAttribute::Octal; } + bool IsDecimal(adr_t addr, int bus = BusCode) { return GetDisplay(addr, bus) == MemAttribute::Decimal; } + bool IsHex(adr_t addr, int bus = BusCode) { MemAttribute::Display disp = GetDisplay(addr, bus); return disp == MemAttribute::DefaultDisplay || disp == MemAttribute::Hex; } + bool IsSigned(adr_t addr, int bus = BusCode) { return GetCellType(addr, bus) == MemAttribute::SignedInt; } + bool IsUnsigned(adr_t addr, int bus = BusCode) { return GetCellType(addr, bus) == MemAttribute::UnsignedInt; } + bool IsFloat(adr_t addr, int bus = BusCode) { return GetCellType(addr, bus) == MemAttribute::Float; } // Relative handling public: - bool AddRelative(addr_t addr, addr_t relsize = 1, addr_t *contents = NULL, int bus = BusCode) + bool AddRelative(adr_t addr, adr_t relsize = 1, adr_t *contents = NULL, int bus = BusCode) { return Relatives[bus].AddMemory(addr, relsize, 0, contents); } - addr_t GetRelative(addr_t addr, int bus = BusCode) - { addr_t *paddr = Relatives[bus].getat(addr); return paddr ? *paddr : 0; } - void SetRelative(addr_t addr, addr_t rel, int bus = BusCode) - { addr_t *paddr = Relatives[bus].getat(addr); if (paddr) *paddr = rel; } + adr_t GetRelative(adr_t addr, int bus = BusCode) + { adr_t *paddr = Relatives[bus].getat(addr); return paddr ? *paddr : 0; } + void SetRelative(adr_t addr, adr_t rel, int bus = BusCode) + { adr_t *paddr = Relatives[bus].getat(addr); if (paddr) *paddr = rel; } // Phase handling public: - bool AddPhase(addr_t addr, addr_t phaseSize = 1, addr_t phase = 0, int bus = BusCode) + bool AddPhase(adr_t addr, adr_t phaseSize = 1, adr_t phase = 0, int bus = BusCode) { return Phases[bus].AddMemory(addr, phaseSize, phase); } - TMemory *FindPhase(addr_t addr, int bus = BusCode) + TMemory *FindPhase(adr_t addr, int bus = BusCode) { return Phases[bus].FindMem(addr); } - addr_t GetPhase(addr_t addr, int bus = BusCode) - { TMemory *pArea = FindPhase(addr, bus); return pArea ? pArea->GetType() : NO_ADDRESS; } - void SetPhase(addr_t addr, addr_t phase = NO_ADDRESS, int bus = BusCode) - { addr_t *paddr = Phases[bus].getat(addr); if (paddr) *paddr = phase; } + adr_t GetPhase(adr_t addr, int bus = BusCode) + { TMemory *pArea = FindPhase(addr, bus); return pArea ? pArea->GetType() : NO_ADDRESS; } + void SetPhase(adr_t addr, adr_t phase = NO_ADDRESS, int bus = BusCode) + { adr_t *paddr = Phases[bus].getat(addr); if (paddr) *paddr = phase; } protected: - addr_t PhaseInner(addr_t value, addr_t addr, int bus = BusCode) + adr_t PhaseInner(adr_t value, adr_t addr, int bus = BusCode) { // "phase" an address if it's inside the current range - TMemory *pArea = Phases[bus].FindMem(addr); + TMemory *pArea = Phases[bus].FindMem(addr); if (pArea) { - addr_t phStart = pArea->GetType(); - addr_t phEnd = phStart + pArea->size() - 1; - addr_t offset = pArea->at(addr); - if (value >= phStart && value <= phEnd || offset != NO_ADDRESS) + adr_t phStart = pArea->GetType(); + adr_t phEnd = phStart + pArea->size() - 1; + adr_t offset = pArea->at(addr); + if ((value >= phStart && value <= phEnd) || (offset != NO_ADDRESS)) { - addr_t aStart = pArea->GetStart(); + adr_t aStart = pArea->GetStart(); if (offset == NO_ADDRESS) offset = phStart - aStart; else if (offset == DEFAULT_ADDRESS) @@ -494,18 +495,18 @@ class Disassembler } return value; } - addr_t DephaseOuter(addr_t value, addr_t addr, int bus = BusCode) + adr_t DephaseOuter(adr_t value, adr_t addr, int bus = BusCode) { // "de-phase" an address if it's outside the current range - TMemory *pArea = Phases[bus].FindMem(addr); + TMemory *pArea = Phases[bus].FindMem(addr); if (pArea) { - addr_t aStart = pArea->GetStart(); - addr_t aEnd = pArea->GetEnd(); - addr_t offset = pArea->at(addr); + adr_t aStart = pArea->GetStart(); + adr_t aEnd = pArea->GetEnd(); + adr_t offset = pArea->at(addr); if (value < aStart || value > aEnd || offset != NO_ADDRESS) { - addr_t phStart = pArea->GetType(); + adr_t phStart = pArea->GetType(); if (offset == NO_ADDRESS) offset = aStart - phStart; else if (offset == DEFAULT_ADDRESS) @@ -520,15 +521,15 @@ class Disassembler // Label handling public: - bool AddLabel(addr_t addr, MemoryType memType = Code, string sLabel = "", bool bUsed = false, int bus = BusCode); - bool AddRelativeLabel(addr_t addr, addr_t at, MemoryType memType = Code, bool bUsed = false, int bus = BusCode, addr_t craddr = NO_ADDRESS, int crbus = BusCode); - Label *GetFirstLabel(addr_t addr, LabelArray::iterator &it, MemoryType memType = Untyped, int bus = BusCode) + bool AddLabel(adr_t addr, MemoryType memType = Code, string sLabel = "", bool bUsed = false, int bus = BusCode); + bool AddRelativeLabel(adr_t addr, adr_t at, MemoryType memType = Code, bool bUsed = false, int bus = BusCode, adr_t craddr = NO_ADDRESS, int crbus = BusCode); + Label *GetFirstLabel(adr_t addr, LabelArray::iterator &it, MemoryType memType = Untyped, int bus = BusCode) { return Labels[bus].GetFirst(addr, it, memType); } - Label *GetNextLabel(addr_t addr, LabelArray::iterator &it, MemoryType memType = Untyped, int bus = BusCode) + Label *GetNextLabel(adr_t addr, LabelArray::iterator &it, MemoryType memType = Untyped, int bus = BusCode) { return Labels[bus].GetNext(addr, it, memType); } - Label *FindLabel(addr_t addr, MemoryType memType = Untyped, int bus = BusCode); - Label *FindPrevNamedLabel(addr_t addr, MemoryType memType = Untyped, int bus = BusCode); - void RemoveLabel(addr_t addr, MemoryType memType = Untyped, int bus = BusCode) + Label *FindLabel(adr_t addr, MemoryType memType = Untyped, int bus = BusCode); + Label *FindPrevNamedLabel(adr_t addr, MemoryType memType = Untyped, int bus = BusCode); + void RemoveLabel(adr_t addr, MemoryType memType = Untyped, int bus = BusCode) { LabelArray::iterator p = Labels[bus].find(addr, memType); if (p != Labels[bus].end()) Labels[bus].erase(p); @@ -538,18 +539,18 @@ class Disassembler void RemoveLabelAt(int index, int bus = BusCode) { Labels[bus].erase(Labels[bus].begin() + index); } virtual bool ResolveLabels(int bus = BusCode); // convenience functionality for the above - string GetLabel(addr_t addr, MemoryType memType = Untyped, int bus = BusCode) + string GetLabel(adr_t addr, MemoryType memType = Untyped, int bus = BusCode) { // NB: this returns the LAST label for this address and type! Label *p = FindLabel(addr, memType, bus); return p ? p->GetText() : ""; } - bool IsLabel(addr_t addr, int bus = BusCode) + bool IsLabel(adr_t addr, int bus = BusCode) { // returns whether ANY kind of label is set here return !!FindLabel(addr, Untyped, bus); } - bool IsCLabel(addr_t addr, int bus = BusCode) + bool IsCLabel(adr_t addr, int bus = BusCode) { LabelArray::iterator it; Label *pLabel = GetFirstLabel(addr, it, Untyped, bus); @@ -560,7 +561,7 @@ class Disassembler } return false; } - bool IsDLabel(addr_t addr, int bus = BusCode) + bool IsDLabel(adr_t addr, int bus = BusCode) { LabelArray::iterator it; Label *pLabel = GetFirstLabel(addr, it, Untyped, bus); @@ -571,7 +572,7 @@ class Disassembler } return false; } - bool IsDefLabel(addr_t addr, int bus = BusCode) + bool IsDefLabel(adr_t addr, int bus = BusCode) { LabelArray::iterator it; Label *pLabel = GetFirstLabel(addr, it, Untyped, bus); @@ -582,7 +583,7 @@ class Disassembler } return false; } - bool IsIOLabel(addr_t addr, int bus = BusCode) + bool IsIOLabel(adr_t addr, int bus = BusCode) { LabelArray::iterator it; Label *pLabel = GetFirstLabel(addr, it, Untyped, bus); @@ -593,7 +594,7 @@ class Disassembler } return false; } - bool SetLabelUsed(addr_t addr, MemoryType memType = Code, int bus = BusCode, addr_t ref = NO_ADDRESS, int busref = BusCode) + bool SetLabelUsed(adr_t addr, MemoryType memType = Code, int bus = BusCode, adr_t ref = NO_ADDRESS, int busref = BusCode) { bool bDone = false; LabelArray::iterator it; @@ -610,7 +611,7 @@ class Disassembler } return bDone; } - Label *SetDefLabelUsed(addr_t addr, int bus = BusCode) + Label *SetDefLabelUsed(adr_t addr, int bus = BusCode) { if (SetLabelUsed(addr, Const, bus)) return FindLabel(addr, Const, bus); @@ -619,8 +620,9 @@ class Disassembler // Definition Label handling public: - bool AddDefLabel(addr_t addr, string sLabel = "", string sDefinition = "", MemoryType memType = Code, int bus = BusCode) + bool AddDefLabel(adr_t addr, string sLabel = "", string sDefinition = "", MemoryType memType = Code, int bus = BusCode) { + (void)addr; if (!DefLabels[bus].Find(sLabel)) DefLabels[bus].insert(new DefLabel(DefLabels[bus].size(), memType, @@ -628,7 +630,7 @@ class Disassembler sDefinition)); return true; } - DefLabel *FindDefLabel(addr_t addr, int bus = BusCode) + DefLabel *FindDefLabel(adr_t addr, int bus = BusCode) { return DefLabels[bus].Find(addr); } int GetDefLabelCount(int bus = BusCode) { return DefLabels[bus].size(); } DefLabel *DefLabelAt(int index, int bus = BusCode) { return (DefLabel *)DefLabels[bus].at(index); } @@ -638,18 +640,20 @@ class Disassembler // load a code file; interleave can be >1 for interleaved Low/High EPROM pairs, for example bool Load(string filename, string &sLoadType, int interleave = 1, int bus = BusCode); // process an info file line - virtual bool ProcessInfo(string key, string value, addr_t &from, addr_t &to, addr_t &step, vector> &remaps, bool bProcInfo = true, int bus = BusCode, int tgtbus = BusCode) { return false; } + virtual bool ProcessInfo(string key, string value, adr_t &from, adr_t &to, adr_t &step, vector> &remaps, bool bProcInfo = true, int bus = BusCode, int tgtbus = BusCode) + { (void)key; (void)value; (void)from; (void)to; (void)step; (void)remaps; + (void)bProcInfo; (void)bus; (void)tgtbus; return false; } // the real disassembler activities protected: // parse data area for labels - virtual addr_t ParseData(addr_t addr, int bus = BusCode) = 0; + virtual adr_t ParseData(adr_t addr, int bus = BusCode) = 0; // parse instruction at given memory address for labels - virtual addr_t ParseCode(addr_t addr, int bus = BusCode) = 0; + virtual adr_t ParseCode(adr_t addr, int bus = BusCode) = 0; // disassemble data area at given memory address - virtual addr_t DisassembleData(addr_t addr, addr_t end, uint32_t flags, string &smnemo, string &sparm, int maxparmlen, int bus = BusCode) = 0; + virtual adr_t DisassembleData(adr_t addr, adr_t end, uint32_t flags, string &smnemo, string &sparm, int maxparmlen, int bus = BusCode) = 0; // disassemble instruction at given memory address - virtual addr_t DisassembleCode(addr_t addr, string &smnemo, string &sparm, int bus = BusCode) = 0; + virtual adr_t DisassembleCode(adr_t addr, string &smnemo, string &sparm, int bus = BusCode) = 0; // globally accessible dispatchers for the above public: // Initialize parsing @@ -660,22 +664,24 @@ class Disassembler return true; } // Parse memory area for labels - addr_t Parse(addr_t addr, int bus = BusCode) + adr_t Parse(adr_t addr, int bus = BusCode) { return IsCode(addr, bus) ? ParseCode(addr, bus) : ParseData(addr, bus); } // Disassemble a line in the memory area - addr_t Disassemble(addr_t addr, string &smnemo, string &sparm, int maxparmlen, int bus = BusCode) + adr_t Disassemble(adr_t addr, string &smnemo, string &sparm, int maxparmlen, int bus = BusCode) { if (IsCode(addr, bus)) return DisassembleCode(addr, smnemo, sparm, bus); uint32_t flags = 0; - addr_t end = GetConsecutiveData(addr, flags, maxparmlen, bus); + adr_t end = GetConsecutiveData(addr, flags, maxparmlen, bus); return DisassembleData(addr, end, flags, smnemo, sparm, maxparmlen, bus); } // pass back correct mnemonic and parameters for a label virtual bool DisassembleLabel(Label *label, string &slabel, string &smnemo, string &sparm, int bus = BusCode) - { return false; } // no changes in base implementation + { (void)label; (void)slabel; (void)smnemo; (void)sparm; (void)bus; + return false; } // no changes in base implementation // pass back correct mnemonic and parameters for a DefLabel virtual bool DisassembleDefLabel(DefLabel *label, string &slabel, string &smnemo, string &sparm, int bus = BusCode) - { return false; } // no changes in base implementation + { (void)label; (void)slabel; (void)smnemo; (void)sparm; (void)bus; + return false; } // no changes in base implementation // pass back disassembler-specific state changes before/after a disassembly line struct LineChange { @@ -683,13 +689,14 @@ class Disassembler string oper; string opnds; }; - virtual bool DisassembleChanges(addr_t addr, addr_t prevaddr, addr_t prevsz, bool bAfterLine, vector &changes, int bus = BusCode) - { return changes.size() != 0; } // no additional changes in base implementation + virtual bool DisassembleChanges(adr_t addr, adr_t prevaddr, adr_t prevsz, bool bAfterLine, vector &changes, int bus = BusCode) + { (void)addr; (void)prevaddr; (void)prevsz; (void)bAfterLine; (void)changes; (void)bus; + return changes.size() != 0; } // no additional changes in base implementation // create hex / ASCII representation of the current area - virtual bool DisassembleHexAsc(addr_t addr, addr_t len, addr_t max, string &sHex, string &sAsc, int bus = BusCode) + virtual bool DisassembleHexAsc(adr_t addr, adr_t len, adr_t max, string &sHex, string &sAsc, int bus = BusCode) { sAsc = "\'"; - addr_t i; + adr_t i; for (i = 0; i < len; i++) { uint8_t c = GetUByte(addr + i, bus); @@ -709,19 +716,19 @@ class Disassembler // must not be called from constructor! virtual MemAttributeHandler *CreateAttributeHandler() { return new BasicMemAttributeHandler; } // - TMemory *FindMem(addr_t addr, int bus = BusCode) + TMemory *FindMem(adr_t addr, int bus = BusCode) { return memory[bus].FindMem(addr); } // fetch byte at a given address - uint8_t *getat(addr_t addr, int bus = BusCode) + uint8_t *getat(adr_t addr, int bus = BusCode) { return memory[bus].getat(addr); } // fetch multiple bytes with endianness correction - bool getat(addr_t addr, uint8_t *val, addr_t len, int bus = BusCode) + bool getat(adr_t addr, uint8_t *val, adr_t len, int bus = BusCode) { return memory[bus].getat(addr, val, len, (GetEndianness() != prgEndian)); } // write byte at a given address - bool setat(addr_t addr, uint8_t val, int bus = BusCode) + bool setat(adr_t addr, uint8_t val, int bus = BusCode) { return memory[bus].setat(addr, val); } // write multiple bytes with endianness correction - bool setat(addr_t addr, uint8_t *val, addr_t len, int bus = BusCode) + bool setat(adr_t addr, uint8_t *val, adr_t len, int bus = BusCode) { return memory[bus].setat(addr, val, len, (GetEndianness() != prgEndian)); } // load opened file (overridable for specific file types) @@ -731,7 +738,7 @@ class Disassembler bool LoadBinary(string filename, FILE *f, string &sLoadType, int interleave = 1, int bus = BusCode); // calculate bits needed for an address - int CalcBitsForHighestAddr(addr_t addr) + int CalcBitsForHighestAddr(adr_t addr) { int bits = sizeof(addr) * 8; // this relies on a layout where the highest address @@ -748,13 +755,13 @@ class Disassembler virtual void RecalcBusBits(int bus = BusCode) { busbits[bus] = CalcBitsForHighestAddr(GetHighestBusAddr(bus)); } // calculate consecutive data range (i.e., same type for all) - addr_t GetConsecutiveData(addr_t addr, uint32_t &flags, int maxparmlen, int bus = BusCode); + adr_t GetConsecutiveData(adr_t addr, uint32_t &flags, int maxparmlen, int bus = BusCode); public: // return address bits for a specific bus int BusAddressBits(int bus = BusCode) { return busbits[bus]; } // convert a string to an integer number, (dis)assembler-specific - virtual bool String2Number(string s, addr_t &value) + virtual bool String2Number(string s, adr_t &value) { int base = pbase; s = trim(s); @@ -779,7 +786,7 @@ class Disassembler // return end && !*end; #endif } - virtual int String2Range(string s, addr_t &from, addr_t &to, addr_t &step) + virtual int String2Range(string s, adr_t &from, adr_t &to, adr_t &step) { from = to = NO_ADDRESS; step = 1; @@ -816,9 +823,11 @@ class Disassembler return (sscanf(s.c_str(), "%lf", &value) == 1); } // convert a number to a string - virtual string Number2String(addr_t value, int nDigits, addr_t addr, int bus = BusCode) + virtual string Number2String(adr_t value, int nDigits, adr_t addr, int bus = BusCode) { -#if 0 +#if 1 + (void)nDigits; +#else MemoryType memType = GetMemType(addr); MemAttribute::Display disp; bool bSigned = false; @@ -835,7 +844,7 @@ class Disassembler // Only thing that should always work... return sformat(IsSigned(addr, bus) ? "%d" : "%u", value); } - virtual string SignedNumber2String(saddr_t value, int nDigits, addr_t addr, int bus = BusCode) + virtual string SignedNumber2String(sadr_t value, int nDigits, adr_t addr, int bus = BusCode) { string s; // specialization for things that have to be signed in any case @@ -844,15 +853,15 @@ class Disassembler s = "-"; value = -value; } - return s + Number2String((addr_t)value, nDigits, addr, bus); + return s + Number2String((adr_t)value, nDigits, addr, bus); } - virtual string Address2String(addr_t addr, int bus = BusCode) - { return sformat("%d", addr); } - virtual string Label2String(addr_t value, int nDigits, bool bUseLabel, addr_t addr, int bus = BusCode); - virtual string DefLabel2String(addr_t value, int nDigits, addr_t addr, int bus = BusCode); - virtual string AutoLabel2String(addr_t addr, bool bCode, int bus = BusCode); + virtual string Address2String(adr_t addr, int bus = BusCode) + { (void)bus; return sformat("%d", addr); } + virtual string Label2String(adr_t value, int nDigits, bool bUseLabel, adr_t addr, int bus = BusCode); + virtual string DefLabel2String(adr_t value, int nDigits, adr_t addr, int bus = BusCode); + virtual string AutoLabel2String(adr_t addr, bool bCode, int bus = BusCode); // generate text for an unnamed label - virtual string UnnamedLabel(addr_t addr, bool bCode, int bus = BusCode) + virtual string UnnamedLabel(adr_t addr, bool bCode, int bus = BusCode) { if (bAutoLabel) { @@ -866,7 +875,7 @@ class Disassembler int bits = busbits[bus]; return sformat("%s%0*X", cType, (bits + 3) / 4, addr); } - virtual bool IsForwardRef(addr_t value, bool bUseLabel, addr_t addr, int bus = BusCode); + virtual bool IsForwardRef(adr_t value, bool bUseLabel, adr_t addr, int bus = BusCode); protected: static const Endian prgEndian; @@ -877,13 +886,13 @@ class Disassembler vector memattr; vector Labels; vector DefLabels; - vector> Relatives; - vector> Phases; + vector> Relatives; + vector> Phases; vector busorder; vector busbits; // begin / end / load (i.e., entry point) address - addr_t begin, end, load, offset; + adr_t begin, end, load, offset; // flag whether to honor load address bool bLoadLabel; // flag whether to set system vector labels @@ -906,6 +915,6 @@ class Disassembler }; -addr_t GetHex(FILE *f, int nChars, uint8_t *pchks = NULL); +adr_t GetHex(FILE *f, int nChars, uint8_t *pchks = NULL); #endif // __Disassembler_h_defined__ diff --git a/Label.h b/Label.h index 24fb6fe..9575f30 100644 --- a/Label.h +++ b/Label.h @@ -46,7 +46,7 @@ enum MemoryType class AddrType { public: - AddrType(addr_t addr = 0, MemoryType memType = Code) + AddrType(adr_t addr = 0, MemoryType memType = Code) : addr(addr), memType(memType) { } virtual ~AddrType() { } @@ -84,8 +84,8 @@ class AddrType // Attributes public: - addr_t GetAddress() const { return addr; } - void SetAddress(addr_t newAddr = 0) { addr = newAddr; } + adr_t GetAddress() const { return addr; } + void SetAddress(adr_t newAddr = 0) { addr = newAddr; } // Label Type MemoryType GetType() const { return memType; } void SetType(MemoryType newType = Untyped) { memType = newType; } @@ -107,7 +107,7 @@ class AddrType } protected: - addr_t addr; + adr_t addr; MemoryType memType; }; @@ -202,7 +202,7 @@ class AddrTypeArray : public vector return (*at(mid) > l) ? end() : begin() + mid; } // convenience - find code and/or data labels - iterator find(addr_t addr, MemoryType memType = Untyped, bool bTypeMatch = false) + iterator find(adr_t addr, MemoryType memType = Untyped, bool bTypeMatch = false) { return find(AddrType(addr, memType), bTypeMatch); } // insert into address/type-sorted array iterator insert(AddrType *pNewEl, bool bAfter = true, bool bTypeMatch = false) @@ -211,7 +211,7 @@ class AddrTypeArray : public vector #if 0 // Copying pre-existing element's data is done by template below #endif - int lo, max = size() - 1, hi = max, mid; + int lo, max = size() - 1, hi = max, mid = -1; if (empty() || *pNewEl < *at(0)) it = begin(); else if (*pNewEl > *at(hi)) @@ -341,7 +341,7 @@ template class TAddrTypeArray : public AddrTypeArray class AddrText : public AddrType { public: - AddrText(addr_t addr = 0, MemoryType memType = Code, string stext = "") + AddrText(adr_t addr = 0, MemoryType memType = Code, string stext = "") : AddrType(addr, memType), stext(stext) { } virtual ~AddrText() { } @@ -380,7 +380,7 @@ class Label : public AddrText { public: - Label(addr_t addr = 0, MemoryType memType = Code, string sLabel = "", bool bUsed = false) + Label(adr_t addr = 0, MemoryType memType = Code, string sLabel = "", bool bUsed = false) : AddrText(addr, memType, sLabel), bUsed(bUsed) { } virtual ~Label() { } @@ -389,7 +389,7 @@ class Label : public AddrText public: // Flag whether it is used bool IsUsed() { return bUsed; } - bool SetUsed(bool bSet = true, addr_t ref = NO_ADDRESS, int bus = BusCode) + bool SetUsed(bool bSet = true, adr_t ref = NO_ADDRESS, int bus = BusCode) { bUsed = bSet; if (ref != NO_ADDRESS) @@ -397,7 +397,7 @@ class Label : public AddrText return bSet; } - bool AddRef(addr_t addr, int bus = BusCode) + bool AddRef(adr_t addr, int bus = BusCode) { try { @@ -411,7 +411,7 @@ class Label : public AddrText } size_t RefCount() { return refs.size(); } AddrBus &GetRef(size_t index) { return refs[index]; } - addr_t GetRefAddr(size_t index) { return refs[index].addr; } + adr_t GetRefAddr(size_t index) { return refs[index].addr; } int GetRefBus(size_t index) { return refs[index].bus; } void SortRefs() { @@ -441,12 +441,12 @@ class LabelArray : public TAddrTypeArray