flow.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_FLOW__
#define __CPUI_FLOW__

#include "funcdata.hh"

class FlowInfo {
public:
  enum { ignore_outofbounds = 1,    
     ignore_unimplemented = 2,  
     error_outofbounds = 4,     
     error_unimplemented = 8,   
     error_reinterpreted = 0x10,    
     error_toomanyinstructions = 0x20,  
     unimplemented_present = 0x40,  
     baddata_present = 0x80,    
     outofbounds_present = 0x100,   
     reinterpreted_present = 0x200, 
     toomanyinstructions_present = 0x400,   
     possible_unreachable = 0x1000, 
     flow_forinline = 0x2000,   
     record_jumploads = 0x4000  
 };
private:
  struct VisitStat {
    SeqNum seqnum;  
    int4 size;      
  };
  Architecture *glb;            
  Funcdata &data;           
  PcodeOpBank &obank;           
  BlockGraph &bblocks;          
  vector<FuncCallSpecs *> &qlst;    
  PcodeEmitFd emitter;          
  vector<Address> unprocessed;      
  vector<Address> addrlist;     
  vector<PcodeOp *> tablelist;      
  vector<PcodeOp *> injectlist;     
  map<Address,VisitStat> visited;   
  list<PcodeOp *> block_edge1;      
  list<PcodeOp *> block_edge2;      
  uint4 insn_count;         
  uint4 insn_max;           
  Address baddr;            
  Address eaddr;            
  Address minaddr;          
  Address maxaddr;          
  bool flowoverride_present;        
  uint4 flags;              
  Funcdata *inline_head;        
  set<Address> *inline_recursion;   
  set<Address> inline_base;     
  bool hasPossibleUnreachable(void) const { return ((flags & possible_unreachable)!=0); }   
  void setPossibleUnreachable(void) { flags |= possible_unreachable; }  
  void clearProperties(void);       
  bool seenInstruction(const Address &addr) const {
    return (visited.find(addr) != visited.end()); } 
  PcodeOp *fallthruOp(PcodeOp *op) const;       
  void newAddress(PcodeOp *from,const Address &to); 
  void deleteRemainingOps(list<PcodeOp *>::const_iterator oiter);
  PcodeOp *xrefControlFlow(list<PcodeOp *>::const_iterator oiter,bool &startbasic,bool &isfallthru,FuncCallSpecs *fc);
  bool processInstruction(const Address &curaddr,bool &startbasic);
  void fallthru(void);                  
  PcodeOp *findRelTarget(PcodeOp *op,Address &res) const;
  void findUnprocessed(void);               
  void dedupUnprocessed(void);              
  void fillinBranchStubs(void);             
  void collectEdges(void);              
  void splitBasic(void);                
  void connectBasic(void);              
  bool setFallthruBound(Address &bound);        
  void handleOutOfBounds(const Address &fromaddr,const Address &toaddr);
  PcodeOp *artificialHalt(const Address &addr,uint4 flag);  
  void reinterpreted(const Address &addr);      
  bool checkForFlowModification(FuncCallSpecs &fspecs);
  void queryCall(FuncCallSpecs &fspecs);        
  bool setupCallSpecs(PcodeOp *op,FuncCallSpecs *fc);   
  bool setupCallindSpecs(PcodeOp *op,bool tryoverride,FuncCallSpecs *fc);
  void xrefInlinedBranch(PcodeOp *op);          
  void doInjection(InjectPayload *payload,InjectContext &icontext,PcodeOp *op,FuncCallSpecs *fc);
  void injectUserOp(PcodeOp *op);           
  bool inlineSubFunction(FuncCallSpecs *fc);        
  bool injectSubFunction(FuncCallSpecs *fc);        
  void checkContainedCall(void);
  void checkMultistageJumptables(void);
  void deleteCallSpec(FuncCallSpecs *fc);       
  void truncateIndirectJump(PcodeOp *op,int4 failuremode);      
  static bool isInArray(vector<PcodeOp *> &array,PcodeOp *op);
public:
  FlowInfo(Funcdata &d,PcodeOpBank &o,BlockGraph &b,vector<FuncCallSpecs *> &q);    
  FlowInfo(Funcdata &d,PcodeOpBank &o,BlockGraph &b,vector<FuncCallSpecs *> &q,const FlowInfo *op2);    
  void setRange(const Address &b,const Address &e) { baddr = b; eaddr = e; }    
  void setMaximumInstructions(uint4 max) { insn_max = max; }    
  void setFlags(uint4 val) { flags |= val; }    
  void clearFlags(uint4 val) { flags &= ~val; } 
  PcodeOp *target(const Address &addr) const;   
  PcodeOp *branchTarget(PcodeOp *op) const; 
  void generateOps(void);           
  void generateBlocks(void);            
  bool testHardInlineRestrictions(Funcdata *inlinefd,PcodeOp *op,Address &retaddr);
  bool checkEZModel(void) const;        
  void injectPcode(void);           
  void forwardRecursion(const FlowInfo &op2);   
  void inlineClone(const FlowInfo &inlineflow,const Address &retaddr);
  void inlineEZClone(const FlowInfo &inlineflow,const Address &calladdr);
  int4 getSize(void) const { return (int4)(maxaddr.getOffset() - minaddr.getOffset()); }    
  bool hasInject(void) const { return !injectlist.empty(); }        
  bool hasUnimplemented(void) const { return ((flags & unimplemented_present)!=0); }    
  bool hasBadData(void) const { return ((flags & baddata_present)!=0); }        
  bool hasOutOfBounds(void) const { return ((flags & outofbounds_present)!=0); }    
  bool hasReinterpreted(void) const { return ((flags & reinterpreted_present)!=0); }    
  bool hasTooManyInstructions(void) const { return ((flags & toomanyinstructions_present)!=0); }    
  bool isFlowForInline(void) const { return ((flags & flow_forinline)!=0); }    
  bool doesJumpRecord(void) const { return ((flags & record_jumploads)!=0); }   
};

#endif