userop.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_USEROP__
#define __CPUI_USEROP__
 
#include "typeop.hh"
 
class UserPcodeOp {
protected:
  string name;          
  int4 useropindex;     
  Architecture *glb;        
public:
  UserPcodeOp(Architecture *g,const string &nm,int4 ind) {
    name = nm; useropindex = ind; glb = g; }            
  const string &getName(void) const { return name; }        
  int4 getIndex(void) const { return useropindex; }     
  virtual ~UserPcodeOp(void) {}                 
 
  virtual string getOperatorName(const PcodeOp *op) const {
    return name; }
 
  virtual void restoreXml(const Element *el)=0;
};
 
class UnspecializedPcodeOp : public UserPcodeOp {
public:
  UnspecializedPcodeOp(Architecture *g,const string &nm,int4 ind)
    : UserPcodeOp(g,nm,ind) {}      
  virtual void restoreXml(const Element *el) {}
};
 
class InjectedUserOp : public UserPcodeOp {
  uint4 injectid;           
public:
  InjectedUserOp(Architecture *g,const string &nm,int4 ind,int4 injid)
    : UserPcodeOp(g,nm,ind) { injectid = injid; }   
  uint4 getInjectId(void) const { return injectid; }    
  virtual void restoreXml(const Element *el);
};
 
class VolatileOp : public UserPcodeOp {
protected:
  static string appendSize(const string &base,int4 size);   
public:
  VolatileOp(Architecture *g,const string &nm,int4 ind)
    : UserPcodeOp(g,nm,ind) { }                 
};
 
class VolatileReadOp : public VolatileOp {
public:
  VolatileReadOp(Architecture *g,const string &nm,int4 ind)
    : VolatileOp(g,nm,ind) {}                   
  virtual string getOperatorName(const PcodeOp *op) const;
  virtual void restoreXml(const Element *el);
};
 
class VolatileWriteOp : public VolatileOp {
public:
  VolatileWriteOp(Architecture *g,const string &nm,int4 ind)
    : VolatileOp(g,nm,ind) {}                   
  virtual string getOperatorName(const PcodeOp *op) const;
  virtual void restoreXml(const Element *el);
};
 
class TermPatternOp : public UserPcodeOp {
public:
  TermPatternOp(Architecture *g,const string &nm,int4 ind) : UserPcodeOp(g,nm,ind) {}   
  virtual int4 getNumVariableTerms(void) const=0;       
 
  virtual bool unify(Funcdata &data,PcodeOp *op,vector<Varnode *> &bindlist) const=0;
 
  virtual uintb execute(const vector<uintb> &input) const=0;
};
 
struct OpFollow {
  OpCode opc;           
  uintb val;            
  int4 slot;            
  OpFollow(void) {}     
  void restoreXml(const Element *el);   
};
 
class SegmentOp : public TermPatternOp {
  AddrSpace *spc;       
  int4 injectId;        
  int4 baseinsize;      
  int4 innerinsize;     
  bool supportsfarpointer;  
  VarnodeData constresolve; 
public:
  SegmentOp(Architecture *g,const string &nm,int4 ind);     
  AddrSpace *getSpace(void) const { return spc; }       
  bool hasFarPointerSupport(void) const { return supportsfarpointer; }  
  int4 getBaseSize(void) const { return baseinsize; }       
  int4 getInnerSize(void) const { return innerinsize; }     
  const VarnodeData &getResolve(void) const { return constresolve; }    
  virtual int4 getNumVariableTerms(void) const { if (baseinsize!=0) return 2; return 1; }
  virtual bool unify(Funcdata &data,PcodeOp *op,vector<Varnode *> &bindlist) const;
  virtual uintb execute(const vector<uintb> &input) const;
  virtual void restoreXml(const Element *el);
};
 
class JumpAssistOp : public UserPcodeOp {
  int4 index2case;      
  int4 index2addr;      
  int4 defaultaddr;     
  int4 calcsize;        
public:
  JumpAssistOp(Architecture *g);    
  int4 getIndex2Case(void) const { return index2case; }     
  int4 getIndex2Addr(void) const { return index2addr; }     
  int4 getDefaultAddr(void) const { return defaultaddr; }   
  int4 getCalcSize(void) const { return calcsize; }     
  virtual void restoreXml(const Element *el);
};
 
class UserOpManage {
  vector<UserPcodeOp *> useroplist; 
  map<string,UserPcodeOp *> useropmap;  
  vector<SegmentOp *> segmentop;    
  VolatileReadOp *vol_read;     
  VolatileWriteOp *vol_write;       
  void registerOp(UserPcodeOp *op); 
public:
  UserOpManage(void);           
  ~UserOpManage(void);          
  void initialize(Architecture *glb);   
  void setDefaults(Architecture *glb);  
  int4 numSegmentOps(void) const { return segmentop.size(); }   
 
  UserPcodeOp *getOp(int4 i) const {
    if (i>=useroplist.size()) return (UserPcodeOp *)0;
    return useroplist[i];
  }
 
  UserPcodeOp *getOp(const string &nm) const;                   
 
  SegmentOp *getSegmentOp(int4 i) const {
    if (i>=segmentop.size()) return (SegmentOp *)0;
    return segmentop[i];
  }
 
  VolatileReadOp *getVolatileRead(void) const { return vol_read; }      
  VolatileWriteOp *getVolatileWrite(void) const { return vol_write; }       
  void parseSegmentOp(const Element *el,Architecture *glb);         
  void parseVolatile(const Element *el,Architecture *glb);          
  void parseCallOtherFixup(const Element *el,Architecture *glb);        
  void parseJumpAssist(const Element *el,Architecture *glb);            
  void manualCallOtherFixup(const string &useropname,const string &outname,
                const vector<string> &inname,const string &snippet,Architecture *glb);
};
 
#endif