which I need to update the misc. regfile accesses arch/mips/faults.cc: arch/mips/faults.hh: alpha to mips arch/mips/isa/base.isa: add includes arch/mips/isa/bitfields.isa: more bitfields arch/mips/isa/decoder.isa: lots o' lots o' lots o' changes!!!! arch/mips/isa/formats.isa: include cop0.isa arch/mips/isa/formats/basic.isa: fix faults arch/mips/isa/formats/branch.isa: arch/mips/isa/formats/fp.isa: arch/mips/isa/formats/int.isa: arch/mips/isa/formats/mem.isa: arch/mips/isa/formats/noop.isa: arch/mips/isa/formats/trap.isa: arch/mips/isa/formats/unimp.isa: arch/mips/isa/formats/unknown.isa: arch/mips/isa/formats/util.isa: arch/mips/isa/operands.isa: arch/mips/isa_traits.cc: arch/mips/linux_process.cc: merge MIPS-specific comilable/buidable files code into multiarch arch/mips/isa_traits.hh: merge MIPS-specific comilable/buidable files code into multiarch... the miscRegs file accesses i have need to be recoded and everything should build then ... arch/mips/stacktrace.hh: file copied over --HG-- extra : convert_revision : 4a72e14fc5fb0a0d1f8b205dadbbf69636b7fb1f
322 lines
8.7 KiB
C++
322 lines
8.7 KiB
C++
// -*- mode:c++ -*-
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Control transfer instructions
|
|
//
|
|
|
|
output header {{
|
|
|
|
#include <iostream>
|
|
using namespace std;
|
|
|
|
/**
|
|
* Base class for instructions whose disassembly is not purely a
|
|
* function of the machine instruction (i.e., it depends on the
|
|
* PC). This class overrides the disassemble() method to check
|
|
* the PC and symbol table values before re-using a cached
|
|
* disassembly string. This is necessary for branches and jumps,
|
|
* where the disassembly string includes the target address (which
|
|
* may depend on the PC and/or symbol table).
|
|
*/
|
|
class PCDependentDisassembly : public MipsStaticInst
|
|
{
|
|
protected:
|
|
/// Cached program counter from last disassembly
|
|
mutable Addr cachedPC;
|
|
|
|
/// Cached symbol table pointer from last disassembly
|
|
mutable const SymbolTable *cachedSymtab;
|
|
|
|
/// Constructor
|
|
PCDependentDisassembly(const char *mnem, MachInst _machInst,
|
|
OpClass __opClass)
|
|
: MipsStaticInst(mnem, _machInst, __opClass),
|
|
cachedPC(0), cachedSymtab(0)
|
|
{
|
|
}
|
|
|
|
const std::string &
|
|
disassemble(Addr pc, const SymbolTable *symtab) const;
|
|
};
|
|
|
|
/**
|
|
* Base class for branches (PC-relative control transfers),
|
|
* conditional or unconditional.
|
|
*/
|
|
class Branch : public PCDependentDisassembly
|
|
{
|
|
protected:
|
|
/// target address (signed) Displacement .
|
|
int32_t disp;
|
|
|
|
/// Constructor.
|
|
Branch(const char *mnem, MachInst _machInst, OpClass __opClass)
|
|
: PCDependentDisassembly(mnem, _machInst, __opClass),
|
|
disp(OFFSET << 2)
|
|
{
|
|
//If Bit 17 is 1 then Sign Extend
|
|
if ( (disp & 0x00020000) > 0 ) {
|
|
disp |= 0xFFFE0000;
|
|
}
|
|
}
|
|
|
|
Addr branchTarget(Addr branchPC) const;
|
|
|
|
std::string
|
|
generateDisassembly(Addr pc, const SymbolTable *symtab) const;
|
|
};
|
|
|
|
/**
|
|
* Base class for branch likely branches (PC-relative control transfers),
|
|
*/
|
|
class BranchLikely : public PCDependentDisassembly
|
|
{
|
|
protected:
|
|
/// target address (signed) Displacement .
|
|
int32_t disp;
|
|
|
|
/// Constructor.
|
|
BranchLikely(const char *mnem, MachInst _machInst, OpClass __opClass)
|
|
: PCDependentDisassembly(mnem, _machInst, __opClass),
|
|
disp(OFFSET << 2)
|
|
{
|
|
|
|
}
|
|
|
|
Addr branchTarget(Addr branchPC) const;
|
|
|
|
std::string
|
|
generateDisassembly(Addr pc, const SymbolTable *symtab) const;
|
|
};
|
|
|
|
/**
|
|
* Base class for jumps (register-indirect control transfers). In
|
|
* the Mips ISA, these are always unconditional.
|
|
*/
|
|
class Jump : public PCDependentDisassembly
|
|
{
|
|
protected:
|
|
|
|
/// Displacement to target address (signed).
|
|
int32_t disp;
|
|
|
|
uint32_t target;
|
|
|
|
public:
|
|
/// Constructor
|
|
Jump(const char *mnem, MachInst _machInst, OpClass __opClass)
|
|
: PCDependentDisassembly(mnem, _machInst, __opClass),
|
|
disp(JMPTARG << 2)
|
|
{
|
|
}
|
|
|
|
Addr branchTarget(ExecContext *xc) const;
|
|
|
|
std::string
|
|
generateDisassembly(Addr pc, const SymbolTable *symtab) const;
|
|
};
|
|
}};
|
|
|
|
output decoder {{
|
|
Addr
|
|
Branch::branchTarget(Addr branchPC) const
|
|
{
|
|
return branchPC + 4 + disp;
|
|
}
|
|
|
|
Addr
|
|
BranchLikely::branchTarget(Addr branchPC) const
|
|
{
|
|
return branchPC + 4 + disp;
|
|
}
|
|
|
|
Addr
|
|
Jump::branchTarget(ExecContext *xc) const
|
|
{
|
|
Addr NPC = xc->readPC() + 4;
|
|
uint64_t Rb = xc->readIntReg(_srcRegIdx[0]);
|
|
return (Rb & ~3) | (NPC & 1);
|
|
}
|
|
|
|
const std::string &
|
|
PCDependentDisassembly::disassemble(Addr pc,
|
|
const SymbolTable *symtab) const
|
|
{
|
|
if (!cachedDisassembly ||
|
|
pc != cachedPC || symtab != cachedSymtab)
|
|
{
|
|
if (cachedDisassembly)
|
|
delete cachedDisassembly;
|
|
|
|
cachedDisassembly =
|
|
new std::string(generateDisassembly(pc, symtab));
|
|
cachedPC = pc;
|
|
cachedSymtab = symtab;
|
|
}
|
|
|
|
return *cachedDisassembly;
|
|
}
|
|
|
|
std::string
|
|
Branch::generateDisassembly(Addr pc, const SymbolTable *symtab) const
|
|
{
|
|
std::stringstream ss;
|
|
|
|
ccprintf(ss, "%-10s ", mnemonic);
|
|
|
|
// There's only one register arg (RA), but it could be
|
|
// either a source (the condition for conditional
|
|
// branches) or a destination (the link reg for
|
|
// unconditional branches)
|
|
if (_numSrcRegs == 1) {
|
|
printReg(ss, _srcRegIdx[0]);
|
|
ss << ",";
|
|
} else if(_numSrcRegs == 2) {
|
|
printReg(ss, _srcRegIdx[0]);
|
|
ss << ",";
|
|
printReg(ss, _srcRegIdx[1]);
|
|
ss << ",";
|
|
}
|
|
|
|
Addr target = pc + 8 + disp;
|
|
|
|
std::string str;
|
|
if (symtab && symtab->findSymbol(target, str))
|
|
ss << str;
|
|
else
|
|
ccprintf(ss, "0x%x", target);
|
|
|
|
return ss.str();
|
|
}
|
|
|
|
std::string
|
|
BranchLikely::generateDisassembly(Addr pc, const SymbolTable *symtab) const
|
|
{
|
|
std::stringstream ss;
|
|
|
|
ccprintf(ss, "%-10s ", mnemonic);
|
|
|
|
// There's only one register arg (RA), but it could be
|
|
// either a source (the condition for conditional
|
|
// branches) or a destination (the link reg for
|
|
// unconditional branches)
|
|
if (_numSrcRegs > 0) {
|
|
printReg(ss, _srcRegIdx[0]);
|
|
ss << ",";
|
|
}
|
|
else if (_numDestRegs > 0) {
|
|
printReg(ss, _destRegIdx[0]);
|
|
ss << ",";
|
|
}
|
|
|
|
Addr target = pc + 4 + disp;
|
|
|
|
std::string str;
|
|
if (symtab && symtab->findSymbol(target, str))
|
|
ss << str;
|
|
else
|
|
ccprintf(ss, "0x%x", target);
|
|
|
|
return ss.str();
|
|
}
|
|
|
|
std::string
|
|
Jump::generateDisassembly(Addr pc, const SymbolTable *symtab) const
|
|
{
|
|
std::stringstream ss;
|
|
|
|
ccprintf(ss, "%-10s ", mnemonic);
|
|
|
|
if ( mnemonic == "jal" ) {
|
|
Addr npc = pc + 4;
|
|
ccprintf(ss,"0x%x",(npc & 0xF0000000) | disp);
|
|
} else if (_numSrcRegs == 0) {
|
|
std::string str;
|
|
if (symtab && symtab->findSymbol(disp, str))
|
|
ss << str;
|
|
else
|
|
ccprintf(ss, "0x%x", disp);
|
|
} else if (_numSrcRegs == 1) {
|
|
printReg(ss, _srcRegIdx[0]);
|
|
} else if(_numSrcRegs == 2) {
|
|
printReg(ss, _srcRegIdx[0]);
|
|
ss << ",";
|
|
printReg(ss, _srcRegIdx[1]);
|
|
} else {
|
|
panic(">= 3 Source Registers!!!");
|
|
}
|
|
|
|
return ss.str();
|
|
}
|
|
}};
|
|
|
|
def format Branch(code,*flags) {{
|
|
#Add Link Code if Link instruction
|
|
strlen = len(name)
|
|
if name[strlen-2:] == 'al':
|
|
code += 'r31 = NNPC;\n'
|
|
|
|
#Condition code
|
|
code = 'bool cond;\n' + code
|
|
code += 'if (cond) {\n'
|
|
code += ' NNPC = NPC + disp;\n'
|
|
code += '} else {\n'
|
|
code += ' NNPC = NNPC;\n'
|
|
code += '} \n'
|
|
|
|
code += 'cout << hex << "NPC: " << NPC << " + " << disp << " = " << NNPC << endl;'
|
|
|
|
iop = InstObjParams(name, Name, 'Branch', CodeBlock(code),
|
|
('IsDirectControl', 'IsCondControl'))
|
|
|
|
header_output = BasicDeclare.subst(iop)
|
|
decoder_output = BasicConstructor.subst(iop)
|
|
decode_block = BasicDecode.subst(iop)
|
|
exec_output = BasicExecute.subst(iop)
|
|
}};
|
|
|
|
|
|
def format BranchLikely(code,*flags) {{
|
|
#Add Link Code if Link instruction
|
|
strlen = len(name)
|
|
if name[strlen-3:] == 'all':
|
|
code += 'r31 = NNPC;\n'
|
|
|
|
#Condition code
|
|
code = 'bool cond;\n' + code
|
|
code += 'if (cond) {'
|
|
code += 'NNPC = NPC + disp;\n'
|
|
code += '} \n'
|
|
|
|
|
|
iop = InstObjParams(name, Name, 'Branch', CodeBlock(code),
|
|
('IsDirectControl', 'IsCondControl','IsCondDelaySlot'))
|
|
|
|
header_output = BasicDeclare.subst(iop)
|
|
decoder_output = BasicConstructor.subst(iop)
|
|
decode_block = BasicDecode.subst(iop)
|
|
exec_output = BasicExecute.subst(iop)
|
|
}};
|
|
|
|
def format Jump(code,*flags) {{
|
|
#Add Link Code if Link instruction
|
|
strlen = len(name)
|
|
if strlen > 1 and name[1:] == 'al':
|
|
code = 'r31 = NNPC;\n' + code
|
|
|
|
#code += 'if(NNPC == 0x80000638) { NNPC = r31; cout << "SKIPPING JUMP TO SIM_GET_MEM_CONF" << endl;}'
|
|
#code += 'target = NNPC;'
|
|
|
|
iop = InstObjParams(name, Name, 'Jump', CodeBlock(code),\
|
|
('IsIndirectControl', 'IsUncondControl'))
|
|
|
|
header_output = BasicDeclare.subst(iop)
|
|
decoder_output = BasicConstructor.subst(iop)
|
|
decode_block = BasicDecode.subst(iop)
|
|
exec_output = BasicExecute.subst(iop)
|
|
}};
|
|
|
|
|
|
|
|
|