subflow.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 __SUBVARIABLE_FLOW__
#define __SUBVARIABLE_FLOW__

#include "funcdata.hh"

class SubvariableFlow {
  class ReplaceOp;
  class ReplaceVarnode {
    friend class SubvariableFlow;
    Varnode *vn;        
    Varnode *replacement;   
    uintb mask;         
    uintb val;          
    ReplaceOp *def;     
  };

  class ReplaceOp {
    friend class SubvariableFlow;
    PcodeOp *op;        
    PcodeOp *replacement;   
    OpCode opc;         
    int4 numparams;     
    ReplaceVarnode *output; 
    vector<ReplaceVarnode *> input; 
  };

  class PatchRecord {
    friend class SubvariableFlow;
    enum patchtype {
      copy_patch,       
      compare_patch,        
      parameter_patch,      
      extension_patch,      
      push_patch        
    };
    patchtype type;     
    PcodeOp *patchOp;       
    ReplaceVarnode *in1;    
    ReplaceVarnode *in2;    
    int4 slot;          
  };

  int4 flowsize;        
  int4 bitsize;         
  bool returnsTraversed;    
  bool aggressive;      
  bool sextrestrictions;    
  Funcdata *fd;         
  map<Varnode *,ReplaceVarnode> varmap; 
  list<ReplaceVarnode> newvarlist;  
  list<ReplaceOp> oplist;       
  list<PatchRecord> patchlist;  
  vector<ReplaceVarnode *> worklist;    
  int4 pullcount;       
  static int4 doesOrSet(PcodeOp *orop,uintb mask);
  static int4 doesAndClear(PcodeOp *andop,uintb mask);
  Address getReplacementAddress(ReplaceVarnode *rvn) const;
  ReplaceVarnode *setReplacement(Varnode *vn,uintb mask,bool &inworklist);
  ReplaceOp *createOp(OpCode opc,int4 numparam,ReplaceVarnode *outrvn);
  ReplaceOp *createOpDown(OpCode opc,int4 numparam,PcodeOp *op,ReplaceVarnode *inrvn,int4 slot);
  bool tryCallPull(PcodeOp *op,ReplaceVarnode *rvn,int4 slot);
  bool tryReturnPull(PcodeOp *op,ReplaceVarnode *rvn,int4 slot);
  bool tryCallReturnPush(PcodeOp *op,ReplaceVarnode *rvn);
  bool trySwitchPull(PcodeOp *op,ReplaceVarnode *rvn);
  bool traceForward(ReplaceVarnode *rvn);   
  bool traceBackward(ReplaceVarnode *rvn);  
  bool traceForwardSext(ReplaceVarnode *rvn);   
  bool traceBackwardSext(ReplaceVarnode *rvn);  
  bool createLink(ReplaceOp *rop,uintb mask,int4 slot,Varnode *vn);
  bool createCompareBridge(PcodeOp *op,ReplaceVarnode *inrvn,int4 slot,Varnode *othervn);
  void addPush(PcodeOp *pushOp,ReplaceVarnode *rvn);
  void addTerminalPatch(PcodeOp *pullop,ReplaceVarnode *rvn);
  void addTerminalPatchSameOp(PcodeOp *pullop,ReplaceVarnode *rvn,int4 slot);
  void addBooleanPatch(PcodeOp *pullop,ReplaceVarnode *rvn,int4 slot);
  void addSuggestedPatch(ReplaceVarnode *rvn,PcodeOp *pushop,int4 sa);
  void addComparePatch(ReplaceVarnode *in1,ReplaceVarnode *in2,PcodeOp *op);
  ReplaceVarnode *addConstant(ReplaceOp *rop,uintb mask,uint4 slot,uintb val);
  void createNewOut(ReplaceOp *rop,uintb mask);
  void replaceInput(ReplaceVarnode *rvn);
  bool useSameAddress(ReplaceVarnode *rvn);
  Varnode *getReplaceVarnode(ReplaceVarnode *rvn);
  bool processNextWork(void);       
public:
  SubvariableFlow(Funcdata *f,Varnode *root,uintb mask,bool aggr,bool sext,bool big);   
  bool doTrace(void);           
  void doReplacement(void);     
};

class SplitFlow : public TransformManager {
  LaneDescription laneDescription;  
  vector<TransformVar *> worklist;  
  TransformVar *setReplacement(Varnode *vn);
  bool addOp(PcodeOp *op,TransformVar *rvn,int4 slot);
  bool traceForward(TransformVar *rvn);
  bool traceBackward(TransformVar *rvn);
  bool processNextWork(void);       
public:
  SplitFlow(Funcdata *f,Varnode *root,int4 lowSize);    
  bool doTrace(void);           
};

class SubfloatFlow : public TransformManager {
  int4 precision;       
  int4 terminatorCount;     
  const FloatFormat *format;    
  vector<TransformVar *> worklist;  
  TransformVar *setReplacement(Varnode *vn);
  bool traceForward(TransformVar *rvn);
  bool traceBackward(TransformVar *rvn);
  bool processNextWork(void);
public:
  SubfloatFlow(Funcdata *f,Varnode *root,int4 prec);
  virtual bool preserveAddress(Varnode *vn,int4 bitSize,int4 lsbOffset) const;
  bool doTrace(void);       
};

class LaneDivide : public TransformManager {
  class WorkNode {
    friend class LaneDivide;
    Varnode *vn;    
    TransformVar *lanes;    
    int4 numLanes;  
    int4 skipLanes; 
  };

  LaneDescription description;  
  vector<WorkNode> workList;    
  bool allowSubpieceTerminator; 

  TransformVar *setReplacement(Varnode *vn,int4 numLanes,int4 skipLanes);
  void buildUnaryOp(OpCode opc,PcodeOp *op,TransformVar *inVars,TransformVar *outVars,int4 numLanes);
  void buildBinaryOp(OpCode opc,PcodeOp *op,TransformVar *in0Vars,TransformVar *in1Vars,TransformVar *outVars,int4 numLanes);
  bool buildPiece(PcodeOp *op,TransformVar *outVars,int4 numLanes,int4 skipLanes);
  bool buildMultiequal(PcodeOp *op,TransformVar *outVars,int4 numLanes,int4 skipLanes);
  bool buildStore(PcodeOp *op,int4 numLanes,int4 skipLanes);
  bool buildLoad(PcodeOp *op,TransformVar *outVars,int4 numLanes,int4 skipLanes);
  bool buildRightShift(PcodeOp *op,TransformVar *outVars,int4 numLanes,int4 skipLanes);
  bool traceForward(TransformVar *rvn,int4 numLanes,int4 skipLanes);
  bool traceBackward(TransformVar *rvn,int4 numLanes,int4 skipLanes);
  bool processNextWork(void);       
public:
  LaneDivide(Funcdata *f,Varnode *root,const LaneDescription &desc,bool allowDowncast); 
  bool doTrace(void);       
};

#endif