condexe.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 __CONDEXE__
#define __CONDEXE__

#include "funcdata.hh"

class ConditionMarker {
  PcodeOp *initop;      
  Varnode *basevn;      
  Varnode *boolvn;      
  Varnode *bool2vn;     
  Varnode *bool3vn;     
  PcodeOp *binaryop;        

  bool matchflip;       
  int4 state;           
  PcodeOp *opstate[2];      
  bool flipstate[2];        
  int4 slotstate[2];        
  bool multion;         
  bool binon;           
  int4 multislot;       

  void setupInitOp(PcodeOp *op);    
  Varnode *findMatch(PcodeOp *op);  
  bool sameOpComplement(PcodeOp *bin1op, PcodeOp *bin2op);
  bool andOrComplement(PcodeOp *bin1op, PcodeOp *bin2op);
  bool finalJudgement(Varnode *vn);
public:
  ConditionMarker(void);                
  ~ConditionMarker(void);               
  bool verifyCondition(PcodeOp *op, PcodeOp *initop);   
  int4 getMultiSlot(void) const { return multislot; }   
  bool getFlip(void) const { return matchflip; }    
  static bool varnodeSame(Varnode *a,Varnode *b);
  static bool varnodeComplement(Varnode *a,Varnode *b);
};

class ConditionalExecution {
  Funcdata *fd;         
  PcodeOp *cbranch;     
  BlockBasic *initblock;    
  BlockBasic *iblock;       
  int4 prea_inslot;         
  bool init2a_true;         
  bool iblock2posta_true;   
  int4 camethruposta_slot;  
  int4 posta_outslot;       
  BlockBasic *posta_block;  
  BlockBasic *postb_block;  
  bool directsplit;     
  map<int4,Varnode *> replacement;  
  vector<PcodeOp *> returnop;   
  vector<bool> heritageyes; 

  void buildHeritageArray(void);
  bool testIBlock(void);
  bool findInitPre(void);           
  bool verifySameCondition(void);       
  bool testOpRead(Varnode *vn,PcodeOp *op); 
  bool testMultiRead(Varnode *vn,PcodeOp *op);  
  bool testRemovability(PcodeOp *op);       
  void predefineDirectMulti(PcodeOp *op);
  void adjustDirectMulti(void);         
  Varnode *getNewMulti(PcodeOp *op,BlockBasic *bl);
  Varnode *getReplacementRead(PcodeOp *op,BlockBasic *bl);
  void doReplacement(PcodeOp *op);      
  void fixReturnOp(void);
  bool verify(void);                
public:
  ConditionalExecution(Funcdata *f) { fd = f; } 
  bool trial(BlockBasic *ib);           
  void execute(void);               
};

class ActionConditionalExe : public Action {
public:
  ActionConditionalExe(const string &g) : Action(0,"conditionalexe",g) {}   
  virtual Action *clone(const ActionGroupList &grouplist) const {
    if (!grouplist.contains(getGroup())) return (Action *)0;
    return new ActionConditionalExe(getGroup());
  }
  virtual int4 apply(Funcdata &data);
};

class RuleOrPredicate : public Rule {
  struct MultiPredicate {
    PcodeOp *op;        
    int4 zeroSlot;      
    const FlowBlock *zeroBlock; 
    const FlowBlock *condBlock; 
    PcodeOp *cbranch;       
    Varnode *otherVn;       
    bool zeroPathIsTrue;    
    bool discoverZeroSlot(Varnode *vn);
    bool discoverCbranch(void);
    void discoverPathIsTrue(void);
    bool discoverConditionalZero(Varnode *vn);
  };
  int4 checkSingle(Varnode *vn,MultiPredicate &branch,PcodeOp *op,Funcdata &data);
public:
  RuleOrPredicate(const string &g) : Rule(g, 0, "orpredicate") {}   
  virtual Rule *clone(const ActionGroupList &grouplist) const {
    if (!grouplist.contains(getGroup())) return (Rule *)0;
    return new RuleOrPredicate(getGroup());
  }
  virtual void getOpList(vector<uint4> &oplist) const;
  virtual int4 applyOp(PcodeOp *op,Funcdata &data);
};

#endif