emulate.hh

Go to the documentation of this file.

/* ###
 * IP: GHIDRA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef __CPUI_EMULATE__
#define __CPUI_EMULATE__
 
#include "memstate.hh"
#include "translate.hh"
 
class Emulate;          // Forward declaration
 
class BreakTable {
public:
  virtual ~BreakTable(void) {};
 
  virtual void setEmulate(Emulate *emu)=0;
 
  virtual bool doPcodeOpBreak(PcodeOpRaw *curop)=0;
 
  virtual bool doAddressBreak(const Address &addr)=0;
};
 
class BreakCallBack {
protected:
  Emulate *emulate;     
public:
  BreakCallBack(void);      
  virtual ~BreakCallBack(void) {}
  virtual bool pcodeCallback(PcodeOpRaw *op); 
  virtual bool addressCallback(const Address &addr); 
  void setEmulate(Emulate *emu); 
};
 
inline BreakCallBack::BreakCallBack(void)
 
{
  emulate = (Emulate *)0;
}
 
inline bool BreakCallBack::pcodeCallback(PcodeOpRaw *op)
 
{
  return true;
}
 
inline bool BreakCallBack::addressCallback(const Address &addr)
 
{
  return true;
}
 
inline void BreakCallBack::setEmulate(Emulate *emu)
 
{
  emulate = emu;
}
 
class BreakTableCallBack : public BreakTable {
  Emulate *emulate;     
  Translate *trans;     
  map<Address,BreakCallBack *> addresscallback; 
  map<uintb,BreakCallBack *> pcodecallback; 
public:
  BreakTableCallBack(Translate *t); 
  void registerPcodeCallback(const string &nm,BreakCallBack *func); 
  void registerAddressCallback(const Address &addr,BreakCallBack *func); 
  virtual void setEmulate(Emulate *emu); 
  virtual bool doPcodeOpBreak(PcodeOpRaw *curop); 
  virtual bool doAddressBreak(const Address &addr); 
};
 
inline BreakTableCallBack::BreakTableCallBack(Translate *t)
 
{
  emulate = (Emulate *)0;
  trans = t;
}
 
class Emulate {
protected:
  bool emu_halted;      
  OpBehavior *currentBehave;    
  virtual void executeUnary(void)=0; 
  virtual void executeBinary(void)=0; 
  virtual void executeLoad(void)=0; 
  virtual void executeStore(void)=0; 
 
  virtual void executeBranch(void)=0;
 
  virtual bool executeCbranch(void)=0;
  virtual void executeBranchind(void)=0; 
  virtual void executeCall(void)=0; 
  virtual void executeCallind(void)=0; 
  virtual void executeCallother(void)=0; 
  virtual void executeMultiequal(void)=0; 
  virtual void executeIndirect(void)=0; 
  virtual void executeSegmentOp(void)=0; 
  virtual void executeCpoolRef(void)=0; 
  virtual void executeNew(void)=0; 
  virtual void fallthruOp(void)=0; 
public:
  Emulate(void) { emu_halted = true; currentBehave = (OpBehavior *)0; } 
  virtual ~Emulate(void) {}
  void setHalt(bool val);   
  bool getHalt(void) const; 
  virtual void setExecuteAddress(const Address &addr)=0; 
  virtual Address getExecuteAddress(void) const=0; 
  void executeCurrentOp(void); 
};
 
inline void Emulate::setHalt(bool val)
 
{
  emu_halted = val;
}
 
inline bool Emulate::getHalt(void) const
 
{
  return emu_halted;
}
 
 
class EmulateMemory : public Emulate {
protected:
  MemoryState *memstate;    
  PcodeOpRaw *currentOp;    
  virtual void executeUnary(void);
  virtual void executeBinary(void);
  virtual void executeLoad(void);
  virtual void executeStore(void);
  virtual void executeBranch(void);
  virtual bool executeCbranch(void);
  virtual void executeBranchind(void);
  virtual void executeCall(void);
  virtual void executeCallind(void);
  virtual void executeCallother(void);
  virtual void executeMultiequal(void);
  virtual void executeIndirect(void);
  virtual void executeSegmentOp(void);
  virtual void executeCpoolRef(void);
  virtual void executeNew(void);
public:
  EmulateMemory(MemoryState *mem) { memstate = mem; currentOp = (PcodeOpRaw *)0; }
  MemoryState *getMemoryState(void) const; 
};
 
inline MemoryState *EmulateMemory::getMemoryState(void) const
 
{
  return memstate;
}
 
class PcodeEmitCache : public PcodeEmit {
  vector<PcodeOpRaw *> &opcache;    
  vector<VarnodeData *> &varcache;  
  const vector<OpBehavior *> &inst; 
  uintm uniq;               
  VarnodeData *createVarnode(const VarnodeData *var);   
public:
  PcodeEmitCache(vector<PcodeOpRaw *> &ocache,vector<VarnodeData *> &vcache,
         const vector<OpBehavior *> &in,uintb uniqReserve); 
  virtual void dump(const Address &addr,OpCode opc,VarnodeData *outvar,VarnodeData *vars,int4 isize);
};
 
class EmulatePcodeCache : public EmulateMemory {
  Translate *trans;     
  vector<PcodeOpRaw *> opcache; 
  vector<VarnodeData *> varcache;   
  vector<OpBehavior *> inst;    
  BreakTable *breaktable;   
  Address current_address;  
  bool instruction_start;   
  int4 current_op;      
  int4 instruction_length;  
  void clearCache(void);    
  void createInstruction(const Address &addr); 
  void establishOp(void);
protected:
  virtual void fallthruOp(void); 
  virtual void executeBranch(void); 
  virtual void executeCallother(void); 
public:
  EmulatePcodeCache(Translate *t,MemoryState *s,BreakTable *b); 
  ~EmulatePcodeCache(void);
  bool isInstructionStart(void) const; 
  int4 numCurrentOps(void) const; 
  int4 getCurrentOpIndex(void) const; 
  PcodeOpRaw *getOpByIndex(int4 i) const; 
  virtual void setExecuteAddress(const Address &addr); 
  virtual Address getExecuteAddress(void) const; 
  void executeInstruction(void); 
};
 
inline bool EmulatePcodeCache::isInstructionStart(void) const
 
{
  return instruction_start;
}
 
inline int4 EmulatePcodeCache::numCurrentOps(void) const
 
{
  return opcache.size();
}
 
inline int4 EmulatePcodeCache::getCurrentOpIndex(void) const
 
{
  return current_op;
}
 
inline PcodeOpRaw *EmulatePcodeCache::getOpByIndex(int4 i) const
 
{
  return opcache[i];
}
 
inline Address EmulatePcodeCache::getExecuteAddress(void) const
 
{
  return current_address;
}
 
#endif