action.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_ACTION__
#define __CPUI_ACTION__
 
#include "block.hh"
 
class ActionGroupList {
  friend class ActionDatabase;
  set<string> list;     
public:
  bool contains(const string &nm) const { return (list.find(nm)!=list.end()); }
};
 
class Rule;
 
class Action {
public:
  enum ruleflags {
    rule_repeatapply = 4,   
    rule_onceperfunc = 8,   
    rule_oneactperfunc = 16,    
    rule_debug = 32,        
    rule_warnings_on = 64,  
    rule_warnings_given = 128   
  };
  enum statusflags {
    status_start=1,     
    status_breakstarthit=2, 
    status_repeat=4,        
    status_mid=8,       
    status_end=16,      
    status_actionbreak=32   
  };
  enum breakflags {
    break_start = 1,        
    tmpbreak_start = 2,     
    break_action = 4,       
    tmpbreak_action = 8
  };
protected:
  int4 lcount;          
  int4 count;           
  uint4 status;         
  uint4 breakpoint;     
  uint4 flags;          
  uint4 count_tests;        
  uint4 count_apply;        
  string name;          
  string basegroup;     
  void issueWarning(Architecture *glb); 
  bool checkStartBreak(void);   
  bool checkActionBreak(void);  
  void turnOnWarnings(void) { flags |= rule_warnings_on; }  
  void turnOffWarnings(void) { flags &= ~rule_warnings_on; }    
public:
  Action(uint4 f,const string &nm,const string &g);     
  virtual ~Action(void) {}                  
#ifdef OPACTION_DEBUG
  virtual bool turnOnDebug(const string &nm);           
  virtual bool turnOffDebug(const string &nm);          
#endif
  virtual void printStatistics(ostream &s) const;       
  int4 perform(Funcdata &data);                 
  bool setBreakPoint(uint4 tp,const string &specify);       
  virtual void clearBreakPoints(void);              
  bool setWarning(bool val,const string &specify);      
  bool disableRule(const string &specify);          
  bool enableRule(const string &specify);           
  const string &getName(void) const { return name; }        
  const string &getGroup(void) const { return basegroup; }  
  uint4 getStatus(void) const { return status; }        
  uint4 getNumTests(void) { return count_tests; }       
  uint4 getNumApply(void) { return count_apply; }       
  virtual Action *clone(const ActionGroupList &grouplist) const=0;
  virtual void reset(Funcdata &data);               
  virtual void resetStats(void);                
  virtual int4 apply(Funcdata &data)=0;
  virtual int4 print(ostream &s,int4 num,int4 depth) const; 
  virtual void printState(ostream &s) const;            
  virtual void saveXml(ostream &s) const {}             
  virtual void restoreXml(const Element *el,Funcdata *fd) {}    
  virtual Action *getSubAction(const string &specify);      
  virtual Rule *getSubRule(const string &specify);      
};
 
class ActionGroup : public Action {
protected:
  vector<Action *> list;                
  vector<Action *>::iterator state;         
public:
  ActionGroup(uint4 f,const string &nm) : Action(f,nm,"") {}    
  virtual ~ActionGroup(void);               
  void addAction(Action *ac);               
  virtual void clearBreakPoints(void);
  virtual Action *clone(const ActionGroupList &grouplist) const;
  virtual void reset(Funcdata &data);
  virtual void resetStats(void);
  virtual int4 apply(Funcdata &data);
  virtual int4 print(ostream &s,int4 num,int4 depth) const;
  virtual void printState(ostream &s) const;
  virtual Action *getSubAction(const string &specify);
  virtual Rule *getSubRule(const string &specify);
#ifdef OPACTION_DEBUG
  virtual bool turnOnDebug(const string &nm);
  virtual bool turnOffDebug(const string &nm);
#endif
  virtual void printStatistics(ostream &s) const;
};
 
class ActionRestartGroup : public ActionGroup {
  int4 maxrestarts;         
  int4 curstart;            
public:
  ActionRestartGroup(uint4 f,const string &nm,int4 max) :
    ActionGroup(f,nm) { maxrestarts = max; }    
  virtual Action *clone(const ActionGroupList &grouplist) const;
  virtual void reset(Funcdata &data);
  virtual int4 apply(Funcdata &data);
};
 
class Rule {
public:
  enum typeflags {
    type_disable = 1,       
    rule_debug = 2,     
    warnings_on = 4,        
    warnings_given = 8      
  };
private:
  friend class ActionPool;
  uint4 flags;          
  uint4 breakpoint;     
  string name;          
  string basegroup;     
  uint4 count_tests;        
  uint4 count_apply;        
  void issueWarning(Architecture *glb); 
public:
  Rule(const string &g,uint4 fl,const string &nm);      
  virtual ~Rule(void) {}                    
  const string &getName(void) const { return name; }        
  const string &getGroup(void) const { return basegroup; }  
  uint4 getNumTests(void) { return count_tests; }       
  uint4 getNumApply(void) { return count_apply; }       
  void setBreak(uint4 tp) { breakpoint |= tp; }         
  void clearBreak(uint4 tp) { breakpoint &= ~tp; }      
  void clearBreakPoints(void) { breakpoint = 0; }       
  void turnOnWarnings(void) { flags |= warnings_on; }       
  void turnOffWarnings(void) { flags &= ~warnings_on; }     
  bool isDisabled(void) const { return ((flags & type_disable)!=0); }   
  void setDisable(void) { flags |= type_disable; }      
  void clearDisable(void) { flags &= ~type_disable; }       
  bool checkActionBreak(void);                  
  uint4 getBreakPoint(void) const { return breakpoint; }    
 
  virtual Rule *clone(const ActionGroupList &grouplist) const=0;
  virtual void getOpList(vector<uint4> &oplist) const;      
 
  virtual int4 applyOp(PcodeOp *op,Funcdata &data) { return 0; }
  virtual void reset(Funcdata &data);               
  virtual void resetStats(void);                
  virtual void printStatistics(ostream &s) const;       
#ifdef OPACTION_DEBUG
  virtual bool turnOnDebug(const string &nm);           
  virtual bool turnOffDebug(const string &nm);          
#endif
};
 
class ActionPool : public Action {
  vector<Rule *> allrules;              
  vector<Rule *> perop[CPUI_MAX];           
  PcodeOpTree::const_iterator op_state;         
  int4 rule_index;                  
  int4 processOp(PcodeOp *op,Funcdata &data);       
public:
  ActionPool(uint4 f,const string &nm) : Action(f,nm,"") {} 
  virtual ~ActionPool(void);                
  void addRule(Rule *rl);               
  virtual void clearBreakPoints(void);
  virtual Action *clone(const ActionGroupList &grouplist) const;
  virtual void reset(Funcdata &data);
  virtual void resetStats(void);
  virtual int4 apply(Funcdata &data);
  virtual int4 print(ostream &s,int4 num,int4 depth) const;
  virtual void printState(ostream &s) const;
  virtual Rule *getSubRule(const string &specify);
  virtual void printStatistics(ostream &s) const;
#ifdef OPACTION_DEBUG
  virtual bool turnOnDebug(const string &nm);
  virtual bool turnOffDebug(const string &nm);
#endif
};
 
class ActionDatabase {
  Action *currentact;               
  string currentactname;            
  map<string,ActionGroupList> groupmap;     
  map<string,Action *> actionmap;       
  bool isDefaultGroups;             
  static const char universalname[];        
  void registerAction(const string &nm,Action *act);    
  void buildDefaultGroups(void);        
  Action *getAction(const string &nm) const;                
  Action *deriveAction(const string &baseaction,const string &grp); 
public:
  ActionDatabase(void) { currentact = (Action *)0; isDefaultGroups = false; }   
  ~ActionDatabase(void);                
  void resetDefaults(void);         
  Action *getCurrent(void) const { return currentact; } 
  const string &getCurrentName(void) const { return currentactname; }   
  const ActionGroupList &getGroup(const string &grp) const; 
  Action *setCurrent(const string &actname);        
  Action *toggleAction(const string &grp,const string &basegrp,bool val);   
 
  void setGroup(const string &grp,const char **argv);           
  void cloneGroup(const string &oldname,const string &newname);     
  bool addToGroup(const string &grp,const string &basegroup);       
  bool removeFromGroup(const string &grp,const string &basegroup);  
  void universalAction(Architecture *glb);      
};
 
#endif