memstate.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_MEMSTATE__
#define __CPUI_MEMSTATE__

#include "pcoderaw.hh"
#include "loadimage.hh"


class MemoryBank {
  friend class MemoryPageOverlay;
  friend class MemoryHashOverlay;
  int4 wordsize;        
  int4 pagesize;        
  AddrSpace *space;     
protected:
  virtual void insert(uintb addr,uintb val)=0; 
  virtual uintb find(uintb addr) const=0; 
  virtual void getPage(uintb addr,uint1 *res,int4 skip,int4 size) const; 
  virtual void setPage(uintb addr,const uint1 *val,int4 skip,int4 size); 
public:
  MemoryBank(AddrSpace *spc,int4 ws,int4 ps); 
  virtual ~MemoryBank(void) {}
  int4 getWordSize(void) const; 
  int4 getPageSize(void) const; 
  AddrSpace *getSpace(void) const; 
  
  void setValue(uintb offset,int4 size,uintb val); 
  uintb getValue(uintb offset,int4 size) const; 
  void setChunk(uintb offset,int4 size,const uint1 *val); 
  void getChunk(uintb offset,int4 size,uint1 *res) const; 
  static uintb constructValue(const uint1 *ptr,int4 size,bool bigendian); 
  static void deconstructValue(uint1 *ptr,uintb val,int4 size,bool bigendian); 
};

inline int4 MemoryBank::getWordSize(void) const

{
  return wordsize;
}

inline int4 MemoryBank::getPageSize(void) const

{
  return pagesize;
}

inline AddrSpace *MemoryBank::getSpace(void) const

{
  return space;
}

class MemoryImage : public MemoryBank {
  LoadImage *loader;        
protected:
  virtual void insert(uintb addr,uintb val) {
    throw LowlevelError("Writing to read-only MemoryBank"); } 
  virtual uintb find(uintb addr) const; 
  virtual void getPage(uintb addr,uint1 *res,int4 skip,int4 size) const; 
public:
  MemoryImage(AddrSpace *spc,int4 ws,int4 ps,LoadImage *ld); 
};

class MemoryPageOverlay : public MemoryBank {
  MemoryBank *underlie;     
  map<uintb,uint1 *> page;  
protected:
  virtual void insert(uintb addr,uintb val); 
  virtual uintb find(uintb addr) const; 
  virtual void getPage(uintb addr,uint1 *res,int4 skip,int4 size) const; 
  virtual void setPage(uintb addr,const uint1 *val,int4 skip,int4 size); 
public:
  MemoryPageOverlay(AddrSpace *spc,int4 ws,int4 ps,MemoryBank *ul); 
  virtual ~MemoryPageOverlay(void);
};

class MemoryHashOverlay : public MemoryBank {
  MemoryBank *underlie;     
  int4 alignshift;      
  uintb collideskip;        
  vector<uintb> address;    
  vector<uintb> value;      
protected:
  virtual void insert(uintb addr,uintb val); 
  virtual uintb find(uintb addr) const; 
public:
  MemoryHashOverlay(AddrSpace *spc,int4 ws,int4 ps,int4 hashsize,MemoryBank *ul); 
};

class Translate;        // Forward declaration

class MemoryState {
protected:
  Translate *trans;     
  vector<MemoryBank *> memspace; 
public:
  MemoryState(Translate *t);    
  ~MemoryState(void) {}
  Translate *getTranslate(void) const; 
  void setMemoryBank(MemoryBank *bank); 
  MemoryBank *getMemoryBank(AddrSpace *spc) const; 
  void setValue(AddrSpace *spc,uintb off,int4 size,uintb cval); 
  uintb getValue(AddrSpace *spc,uintb off,int4 size) const; 
  void setValue(const string &nm,uintb cval); 
  uintb getValue(const string &nm) const; 
  void setValue(const VarnodeData *vn,uintb cval); 
  uintb getValue(const VarnodeData *vn) const; 
  void getChunk(uint1 *res,AddrSpace *spc,uintb off,int4 size) const; 
  void setChunk(const uint1 *val,AddrSpace *spc,uintb off,int4 size); 
};

inline MemoryState::MemoryState(Translate *t)

{
  trans = t;
}

inline Translate *MemoryState::getTranslate(void) const

{
  return trans;
}

inline void MemoryState::setValue(const VarnodeData *vn,uintb cval)

{
  setValue(vn->space,vn->offset,vn->size,cval);
}

inline uintb MemoryState::getValue(const VarnodeData *vn) const

{
  return getValue(vn->space,vn->offset,vn->size);
}

 #endif