funcdata.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_FUNCDATA__
#define __CPUI_FUNCDATA__


#include "architecture.hh"
#include "override.hh"
#include "heritage.hh"
#include "merge.hh"
#include "dynamic.hh"

class FlowInfo;

class Funcdata {
  enum {
    highlevel_on = 1,       
    blocks_generated = 2,   
    blocks_unreachable = 4, 
    processing_started = 8, 
    processing_complete = 0x10, 
    typerecovery_on = 0x20, 
    no_code = 0x40,     
    jumptablerecovery_on = 0x80,    
    jumptablerecovery_dont = 0x100,     
    restart_pending = 0x200,    
    unimplemented_present = 0x400,  
    baddata_present = 0x800,    
    double_precis_on = 0x1000,  
    big_varnodes_generated = 0x2000 
  };
  uint4 flags;          
  uint4 clean_up_index;     
  uint4 high_level_index;   
  uint4 cast_phase_index;   
  Architecture *glb;        
  string name;          
  int4 size;            
  Address baseaddr;     
  FuncProto funcp;      
  ScopeLocal *localmap;     

  vector<FuncCallSpecs *> qlst; 
  vector<JumpTable *> jumpvec;  

  VarnodeBank vbank;        
  PcodeOpBank obank;        
  BlockGraph bblocks;       
  BlockGraph sblocks;       
  Heritage heritage;        
  Merge covermerge;     
  ParamActive *activeoutput;    
  Override localoverride;   
  map<VarnodeData,const LanedRegister *> lanedMap;  

                // Low level Varnode functions
  void setVarnodeProperties(Varnode *vn) const; 
  HighVariable *assignHigh(Varnode *vn);    
  bool syncVarnodesWithSymbol(VarnodeLocSet::const_iterator &iter,uint4 flags,Datatype *ct);
  bool descend2Undef(Varnode *vn);      

  void splitUses(Varnode *vn);          
  Varnode *cloneVarnode(const Varnode *vn); 
  void destroyVarnode(Varnode *vn);     
                // Low level op functions
  void opZeroMulti(PcodeOp *op);        
                // Low level block functions
  void blockRemoveInternal(BlockBasic *bb,bool unreachable);
  void branchRemoveInternal(BlockBasic *bb,int4 num);
  void pushMultiequals(BlockBasic *bb);     
  void clearBlocks(void);           
  void structureReset(void);            
  int4 stageJumpTable(JumpTable *jt,PcodeOp *op,FlowInfo *flow);
  void switchOverJumpTables(const FlowInfo &flow);  
  void clearJumpTables(void);           

  void sortCallSpecs(void);         
  void deleteCallSpecs(PcodeOp *op);        
  void clearCallSpecs(void);            

  BlockBasic *nodeSplitBlockEdge(BlockBasic *b,int4 inedge);
  PcodeOp *nodeSplitCloneOp(PcodeOp *op);
  void nodeSplitCloneVarnode(PcodeOp *op,PcodeOp *newop);
  void nodeSplitRawDuplicate(BlockBasic *b,BlockBasic *bprime);
  void nodeSplitInputPatch(BlockBasic *b,BlockBasic *bprime,int4 inedge);
  static bool descendantsOutside(Varnode *vn);
  static void saveVarnodeXml(ostream &s,VarnodeLocSet::const_iterator iter,VarnodeLocSet::const_iterator enditer);
  static bool checkIndirectUse(Varnode *vn);
  static PcodeOp *findPrimaryBranch(PcodeOpTree::const_iterator iter,PcodeOpTree::const_iterator enditer,
                    bool findbranch,bool findcall,bool findreturn);
public:
  Funcdata(const string &nm,Scope *conf,const Address &addr,int4 sz=0); 
  ~Funcdata(void);                          
  const string &getName(void) const { return name; }            
  const Address &getAddress(void) const { return baseaddr; }        
  int4 getSize(void) const { return size; }             
  Architecture *getArch(void) const { return glb; }         
  bool isHighOn(void) const { return ((flags&highlevel_on)!=0); }   
  bool isProcStarted(void) const { return ((flags&processing_started)!=0); }    
  bool isProcComplete(void) const { return ((flags&processing_complete)!=0); }  
  bool hasUnreachableBlocks(void) const { return ((flags&blocks_unreachable)!=0); } 
  bool isTypeRecoveryOn(void) const { return ((flags&typerecovery_on)!=0); }    
  bool hasNoCode(void) const { return ((flags & no_code)!=0); }     
  void setNoCode(bool val) { if (val) flags |= no_code; else flags &= ~no_code; }   
  bool isLanedRegComplete(void) const { return ((flags&big_varnodes_generated)!=0); }   
  void setLanedRegGenerated(void) { flags |= big_varnodes_generated; }  

  void setJumptableRecovery(bool val) { if (val) flags &= ~jumptablerecovery_dont; else flags |= jumptablerecovery_dont; }

  bool isJumptableRecoveryOn(void) const { return ((flags & jumptablerecovery_on)!=0); }    

  void setDoublePrecisRecovery(bool val) { if (val) flags |= double_precis_on; else flags &= ~double_precis_on; }

  bool isDoublePrecisOn(void) const { return ((flags & double_precis_on)!=0); } 
  bool hasNoStructBlocks(void) const { return (sblocks.getSize() == 0); }   
  void clear(void);                     
  void warning(const string &txt,const Address &ad) const;  
  void warningHeader(const string &txt) const;          
  void startProcessing(void);                   
  void stopProcessing(void);                    
  bool startTypeRecovery(void);                 
  void startCastPhase(void) { cast_phase_index = vbank.getCreateIndex(); }  
  uint4 getCastPhaseIndex(void) const { return cast_phase_index; }  
  uint4 getHighLevelIndex(void) const { return high_level_index; }  
  void startCleanUp(void) { clean_up_index = vbank.getCreateIndex(); }  
  uint4 getCleanUpIndex(void) const { return clean_up_index; }  

  void followFlow(const Address &baddr,const Address &eadddr,uint4 insn_max);
  void truncatedFlow(const Funcdata *fd,const FlowInfo *flow);
  bool inlineFlow(Funcdata *inlinefd,FlowInfo &flow,PcodeOp *callop);
  void overrideFlow(const Address &addr,uint4 type);
  void doLiveInject(InjectPayload *payload,const Address &addr,BlockBasic *bl,list<PcodeOp *>::iterator pos);
  
  void printRaw(ostream &s) const;          
  void printVarnodeTree(ostream &s) const;      
  void printBlockTree(ostream &s) const;        
  void printLocalRange(ostream &s) const;       
  void saveXml(ostream &s,uint8 id,bool savetree) const;    
  uint8 restoreXml(const Element *el);          
  void saveXmlJumpTable(ostream &s) const;      
  void restoreXmlJumpTable(const Element *el);      
  void saveXmlTree(ostream &s) const;           
  void saveXmlHigh(ostream &s) const;           

  Override &getOverride(void) { return localoverride; } 

  void setRestartPending(bool val) { flags = val ? (flags|restart_pending) : (flags & ~((uint4)restart_pending)); }

  bool hasRestartPending(void) const { return ((flags&restart_pending)!=0); }

  bool hasUnimplemented(void) const { return ((flags&unimplemented_present)!=0); }

  bool hasBadData(void) const { return ((flags&baddata_present)!=0); }  
  void spacebase(void);             
  Varnode *newSpacebasePtr(AddrSpace *id);  
  Varnode *findSpacebaseInput(AddrSpace *id) const;
  void spacebaseConstant(PcodeOp *op,int4 slot,SymbolEntry *entry,const Address &rampoint,uintb origval,int4 origsize);

  int4 numHeritagePasses(AddrSpace *spc) { return heritage.numHeritagePasses(spc); }

  void seenDeadcode(AddrSpace *spc) { heritage.seenDeadCode(spc); }

  void setDeadCodeDelay(AddrSpace *spc,int4 delay) { heritage.setDeadCodeDelay(spc,delay); }

  bool deadRemovalAllowed(AddrSpace *spc) const { return heritage.deadRemovalAllowed(spc); }

  bool deadRemovalAllowedSeen(AddrSpace *spc) { return heritage.deadRemovalAllowedSeen(spc); }

  bool isHeritaged(Varnode *vn) { return (heritage.heritagePass(vn->getAddr())>=0); }

  const list<LoadGuard> &getLoadGuards(void) const { return heritage.getLoadGuards(); }     
  const list<LoadGuard> &getStoreGuards(void) const { return heritage.getStoreGuards(); }   
  const LoadGuard *getStoreGuard(PcodeOp *op) const { return heritage.getStoreGuard(op); }  

  // Function prototype and call specification routines
  int4 numCalls(void) const { return qlst.size(); } 
  FuncCallSpecs *getCallSpecs(int4 i) const { return qlst[i]; } 
  FuncCallSpecs *getCallSpecs(const PcodeOp *op) const; 
  void updateOpFromSpec(FuncCallSpecs *fc);
  int4 fillinExtrapop(void);            

  // Varnode routines
  int4 numVarnodes(void) const { return vbank.numVarnodes(); }  
  Varnode *newVarnodeOut(int4 s,const Address &m,PcodeOp *op);  
  Varnode *newUniqueOut(int4 s,PcodeOp *op);            
  Varnode *newVarnode(int4 s,const Address &m,Datatype *ct=(Datatype *)0);
  Varnode *newConstant(int4 s,uintb constant_val);      
  Varnode *newVarnode(int4 s,AddrSpace *base,uintb off);    
  Varnode *newVarnodeIop(PcodeOp *op);              
  Varnode *newVarnodeSpace(AddrSpace *spc);         
  Varnode *newVarnodeCallSpecs(FuncCallSpecs *fc);      
  Varnode *newUnique(int4 s,Datatype *ct=(Datatype *)0);    
  Varnode *newCodeRef(const Address &m);            
  Varnode *setInputVarnode(Varnode *vn);            
  void adjustInputVarnodes(const Address &addr,int4 size);
  void deleteVarnode(Varnode *vn) { vbank.destroy(vn); }    

  Varnode *findCoveredInput(int4 s,const Address &loc) const { return vbank.findCoveredInput(s,loc); }

  Varnode *findCoveringInput(int4 s,const Address &loc) const { return vbank.findCoveringInput(s,loc); }

  Varnode *findVarnodeInput(int4 s,const Address &loc) const { return vbank.findInput(s,loc); }

  Varnode *findVarnodeWritten(int4 s,const Address &loc,const Address &pc,uintm uniq=~((uintm)0)) const {
    return vbank.find(s,loc,pc,uniq); }

  VarnodeLocSet::const_iterator beginLoc(void) const { return vbank.beginLoc(); }

  VarnodeLocSet::const_iterator endLoc(void) const { return vbank.endLoc(); }

  VarnodeLocSet::const_iterator beginLoc(AddrSpace *spaceid) const { return vbank.beginLoc(spaceid); }

  VarnodeLocSet::const_iterator endLoc(AddrSpace *spaceid) const { return vbank.endLoc(spaceid); }

  VarnodeLocSet::const_iterator beginLoc(const Address &addr) const { return vbank.beginLoc(addr); }

  VarnodeLocSet::const_iterator endLoc(const Address &addr) const { return vbank.endLoc(addr); }

  VarnodeLocSet::const_iterator beginLoc(int4 s,const Address &addr) const { return vbank.beginLoc(s,addr); }

  VarnodeLocSet::const_iterator endLoc(int4 s,const Address &addr) const { return vbank.endLoc(s,addr); }

  VarnodeLocSet::const_iterator beginLoc(int4 s,const Address &addr,uint4 fl) const { return vbank.beginLoc(s,addr,fl); }

  VarnodeLocSet::const_iterator endLoc(int4 s,const Address &addr,uint4 fl) const { return vbank.endLoc(s,addr,fl); }

  VarnodeLocSet::const_iterator beginLoc(int4 s,const Address &addr,const Address &pc,uintm uniq=~((uintm)0)) const {
    return vbank.beginLoc(s,addr,pc,uniq); }

  VarnodeLocSet::const_iterator endLoc(int4 s,const Address &addr,const Address &pc,uintm uniq=~((uintm)0)) const {
    return vbank.endLoc(s,addr,pc,uniq); }

  VarnodeDefSet::const_iterator beginDef(void) const { return vbank.beginDef(); }

  VarnodeDefSet::const_iterator endDef(void) const { return vbank.endDef(); }

  VarnodeDefSet::const_iterator beginDef(uint4 fl) const { return vbank.beginDef(fl); }

  VarnodeDefSet::const_iterator endDef(uint4 fl) const { return vbank.endDef(fl); }

  VarnodeDefSet::const_iterator beginDef(uint4 fl,const Address &addr) const { return vbank.beginDef(fl,addr); }

  VarnodeDefSet::const_iterator endDef(uint4 fl,const Address &addr) const { return vbank.endDef(fl,addr); }

  void markLanedVarnode(Varnode *vn,const LanedRegister *lanedReg); 
  map<VarnodeData,const LanedRegister *>::const_iterator beginLaneAccess(void) const { return lanedMap.begin(); }   
  map<VarnodeData,const LanedRegister *>::const_iterator endLaneAccess(void) const { return lanedMap.end(); }   
  void clearLanedAccessMap(void) { lanedMap.clear(); }  

  HighVariable *findHigh(const string &name) const; 
  void mapGlobals(void);            
  bool checkCallDoubleUse(const PcodeOp *opmatch,const PcodeOp *op,const Varnode *vn,const ParamTrial &trial) const;
  bool onlyOpUse(const Varnode *invn,const PcodeOp *opmatch,const ParamTrial &trial) const;
  bool ancestorOpUse(int4 maxlevel,const Varnode *invn,const PcodeOp *op,ParamTrial &trial) const;
  bool syncVarnodesWithSymbols(const ScopeLocal *lm,bool typesyes);
  void transferVarnodeProperties(Varnode *vn,Varnode *newVn,int4 lsbOffset);
  bool fillinReadOnly(Varnode *vn);     
  bool replaceVolatile(Varnode *vn);        
  void markIndirectOnly(void);          
  void totalReplace(Varnode *vn,Varnode *newvn);
  void totalReplaceConstant(Varnode *vn,uintb val);
  ScopeLocal *getScopeLocal(void) { return localmap; }      
  const ScopeLocal *getScopeLocal(void) const { return localmap; }  
  FuncProto &getFuncProto(void) { return funcp; }       
  const FuncProto &getFuncProto(void) const { return funcp; }   
  void initActiveOutput(void);                  
  void clearActiveOutput(void) {
    if (activeoutput != (ParamActive *)0) delete activeoutput;
    activeoutput = (ParamActive *)0;
  }
  ParamActive *getActiveOutput(void) const { return activeoutput; } 
  void setHighLevel(void);                  
  void clearDeadVarnodes(void);                 
  void calcNZMask(void);                    
  void clearDeadOps(void) { obank.destroyDead(); }      
  void clearSymbolLinks(HighVariable *high);            
  void remapVarnode(Varnode *vn,Symbol *sym,const Address &usepoint);
  void remapDynamicVarnode(Varnode *vn,Symbol *sym,const Address &usepoint,uint8 hash);
  Symbol *linkSymbol(Varnode *vn);              
  Symbol *linkSymbolReference(Varnode *vn);         
  Varnode *findLinkedVarnode(SymbolEntry *entry) const; 
  void findLinkedVarnodes(SymbolEntry *entry,vector<Varnode *> &res) const; 
  void buildDynamicSymbol(Varnode *vn);             
  bool attemptDynamicMapping(SymbolEntry *entry,DynamicHash &dhash);
  bool attemptDynamicMappingLate(SymbolEntry *entry,DynamicHash &dhash);
  Merge &getMerge(void) { return covermerge; }          

  // op routines
  PcodeOp *newOp(int4 inputs,const Address &pc);        
  PcodeOp *newOp(int4 inputs,const SeqNum &sq);         
  PcodeOp *newOpBefore(PcodeOp *follow,OpCode opc,Varnode *in1,Varnode *in2,Varnode *in3=(Varnode *)0);
  PcodeOp *cloneOp(const PcodeOp *op,const SeqNum &seq);    
  PcodeOp *getFirstReturnOp(void) const;            
  PcodeOp *newIndirectOp(PcodeOp *indeffect,const Address &addr,int4 size,uint4 extraFlags);
  PcodeOp *newIndirectCreation(PcodeOp *indeffect,const Address &addr,int4 size,bool possibleout);
  void markIndirectCreation(PcodeOp *indop,bool possibleOutput);    
  PcodeOp *findOp(const SeqNum &sq) { return obank.findOp(sq); }    
  void opInsertBefore(PcodeOp *op,PcodeOp *follow);     
  void opInsertAfter(PcodeOp *op,PcodeOp *prev);        
  void opInsertBegin(PcodeOp *op,BlockBasic *bl);       
  void opInsertEnd(PcodeOp *op,BlockBasic *bl);         

  void opDeadInsertAfter(PcodeOp *op,PcodeOp *prev) { obank.insertAfterDead(op,prev); }

  void opHeritage(void) { heritage.heritage(); }        
  void opSetOpcode(PcodeOp *op,OpCode opc);         
  void opMarkHalt(PcodeOp *op,uint4 flag);          
  void opSetOutput(PcodeOp *op,Varnode *vn);            
  void opUnsetOutput(PcodeOp *op);              
  void opSetInput(PcodeOp *op,Varnode *vn,int4 slot);       
  void opSwapInput(PcodeOp *op,int4 slot1,int4 slot2);      
  void opUnsetInput(PcodeOp *op,int4 slot);         
  void opInsert(PcodeOp *op,BlockBasic *bl,list<PcodeOp *>::iterator iter);
  void opUninsert(PcodeOp *op);                 
  void opUnlink(PcodeOp *op);                   
  void opDestroy(PcodeOp *op);                  
  void opDestroyRaw(PcodeOp *op);               
  void opDeadAndGone(PcodeOp *op) { obank.destroy(op); }    
  void opSetAllInput(PcodeOp *op,const vector<Varnode *> &vvec);    
  void opRemoveInput(PcodeOp *op,int4 slot);            
  void opInsertInput(PcodeOp *op,Varnode *vn,int4 slot);    
  void opMarkStartBasic(PcodeOp *op) { op->setFlag(PcodeOp::startbasic); }  
  void opMarkStartInstruction(PcodeOp *op) { op->setFlag(PcodeOp::startmark); } 
  void opMarkNonPrinting(PcodeOp *op) { op->setFlag(PcodeOp::nonprinting); }    
  void opMarkSpecialPrint(PcodeOp *op) { op->setAdditionalFlag(PcodeOp::special_print); }   
  void opMarkNoCollapse(PcodeOp *op) { op->setFlag(PcodeOp::nocollapse); }  
  void opMarkCpoolTransformed(PcodeOp *op) { op->setFlag(PcodeOp::is_cpool_transformed); }  
  void opMarkCalculatedBool(PcodeOp *op) { op->setFlag(PcodeOp::calculated_bool); } 
  void opMarkSpacebasePtr(PcodeOp *op) { op->setFlag(PcodeOp::spacebase_ptr); } 
  void opClearSpacebasePtr(PcodeOp *op) { op->clearFlag(PcodeOp::spacebase_ptr); }  
  void opFlipCondition(PcodeOp *op) { op->flipFlag(PcodeOp::boolean_flip); }    
  PcodeOp *target(const Address &addr) const { return obank.target(addr); } 
  Varnode *createStackRef(AddrSpace *spc,uintb off,PcodeOp *op,Varnode *stackptr,bool insertafter);
  Varnode *opStackLoad(AddrSpace *spc,uintb off,uint4 sz,PcodeOp *op,Varnode *stackptr,bool insertafter);
  PcodeOp *opStackStore(AddrSpace *spc,uintb off,PcodeOp *op,bool insertafter);
  void opUndoPtradd(PcodeOp *op,bool finalize); 

  list<PcodeOp *>::const_iterator beginOp(OpCode opc) const { return obank.begin(opc); }

  list<PcodeOp *>::const_iterator endOp(OpCode opc) const { return obank.end(opc); }

  list<PcodeOp *>::const_iterator beginOpAlive(void) const { return obank.beginAlive(); }

  list<PcodeOp *>::const_iterator endOpAlive(void) const { return obank.endAlive(); }

  list<PcodeOp *>::const_iterator beginOpDead(void) const { return obank.beginDead(); }

  list<PcodeOp *>::const_iterator endOpDead(void) const { return obank.endDead(); }

  PcodeOpTree::const_iterator beginOpAll(void) const { return obank.beginAll(); }

  PcodeOpTree::const_iterator endOpAll(void) const { return obank.endAll(); }

  PcodeOpTree::const_iterator beginOp(const Address &addr) const { return obank.begin(addr); }

  PcodeOpTree::const_iterator endOp(const Address &addr) const { return obank.end(addr); }

  // Jumptable routines
  JumpTable *linkJumpTable(PcodeOp *op);        
  JumpTable *findJumpTable(const PcodeOp *op) const;    
  JumpTable *installJumpTable(const Address &addr); 
  JumpTable *recoverJumpTable(PcodeOp *op,FlowInfo *flow,int4 &failuremode);
  int4 numJumpTables(void) const { return jumpvec.size(); } 
  JumpTable *getJumpTable(int4 i) { return jumpvec[i]; }    
  void removeJumpTable(JumpTable *jt);          

  // Block routines
  BlockGraph &getStructure(void) { return sblocks; }    
  const BlockGraph &getStructure(void) const { return sblocks; }    
  const BlockGraph &getBasicBlocks(void) const { return bblocks; }  

  void setBasicBlockRange(BlockBasic *bb,const Address &beg,const Address &end) { bb->setInitialRange(beg, end); }

  void removeDoNothingBlock(BlockBasic *bb);    
  bool removeUnreachableBlocks(bool issuewarning,bool checkexistence);
  void pushBranch(BlockBasic *bb,int4 slot,BlockBasic *bbnew);
  void removeBranch(BlockBasic *bb,int4 num);   
  BlockBasic *nodeJoinCreateBlock(BlockBasic *block1,BlockBasic *block2,BlockBasic *exita,BlockBasic *exitb,
                  bool fora_block1ishigh,bool forb_block1ishigh,const Address &addr);
  void nodeSplit(BlockBasic *b,int4 inedge);
  bool forceGoto(const Address &pcop,const Address &pcdest);
  void removeFromFlowSplit(BlockBasic *bl,bool swap);
  void switchEdge(FlowBlock *inblock,BlockBasic *outbefore,FlowBlock *outafter);
  void spliceBlockBasic(BlockBasic *bl);    
  void installSwitchDefaults(void);     
  static bool replaceLessequal(Funcdata &data,PcodeOp *op); 
  static bool compareCallspecs(const FuncCallSpecs *a,const FuncCallSpecs *b);

#ifdef OPACTION_DEBUG
  void (*jtcallback)(Funcdata &orig,Funcdata &fd);  
  vector<PcodeOp *> modify_list;        
  vector<string> modify_before;         
  int4 opactdbg_count;              
  int4 opactdbg_breakcount;         
  bool opactdbg_on;             
  bool opactdbg_active;             
  bool opactdbg_breakon;            
  vector<Address> opactdbg_pclow;       
  vector<Address> opactdbg_pchigh;      
  vector<uintm> opactdbg_uqlow;         
  vector<uintm> opactdbg_uqhigh;        
  void enableJTCallback(void (*jtcb)(Funcdata &orig,Funcdata &fd)) { jtcallback = jtcb; }   
  void disableJTCallback(void) { jtcallback = (void (*)(Funcdata &orig,Funcdata &fd))0; }   
  void debugActivate(void) { if (opactdbg_on) opactdbg_active=true; }   
  void debugDeactivate(void) { opactdbg_active = false; }       
  void debugModCheck(PcodeOp *op);      
  void debugModClear(void);         
  void debugModPrint(const string &actionname); 
  bool debugBreak(void) const { return opactdbg_on&&opactdbg_breakon; } 
  int4 debugSize(void) const { return opactdbg_pclow.size(); }  
  void debugEnable(void) { opactdbg_on = true; opactdbg_count = 0; }    
  void debugDisable(void) { opactdbg_on = false; }  
  void debugClear(void) {
    opactdbg_pclow.clear(); opactdbg_pchigh.clear(); opactdbg_uqlow.clear(); opactdbg_uqhigh.clear(); } 
  bool debugCheckRange(PcodeOp *op);        
  void debugSetRange(const Address &pclow,const Address &pchigh,
             uintm uqlow=~((uintm)0),uintm uqhigh=~((uintm)0)); 
  void debugHandleBreak(void) { opactdbg_breakon = false; }     
  void debugSetBreak(int4 count) { opactdbg_breakcount = count; }   
  void debugPrintRange(int4 i) const;       
#endif
};

class PcodeEmitFd : public PcodeEmit {
  Funcdata *fd;         
  virtual void dump(const Address &addr,OpCode opc,VarnodeData *outvar,VarnodeData *vars,int4 isize);
public:
  void setFuncdata(Funcdata *f) { fd = f; } 
};

class AncestorRealistic {
  class State {
  public:
    enum {
      seen_solid0 = 1,      
      seen_solid1 = 2,      
      seen_kill = 4     
    };
    PcodeOp *op;        
    Varnode *vn;        
    int4 slot;          
    uint4 flags;        

    State(PcodeOp *o,int4 s) {
      op = o;
      slot = s;
      vn = op->getIn(slot);
      flags = 0;
    }
    int4 getSolidSlot(void) const { return ((flags & seen_solid0)!=0) ? 0 : 1; }    
    void markSolid(int4 slot) { flags |= (slot==0) ? seen_solid0 : seen_solid1; }   
    void markKill(void) { flags |= seen_kill; }                     
    bool seenSolid(void) const { return ((flags & (seen_solid0|seen_solid1))!=0); } 
    bool seenKill(void) const { return ((flags & seen_kill)!=0); }          
  };
  enum {
    enter_node,     
    pop_success,    
    pop_solid,      
    pop_fail,       
    pop_failkill    
  };
  ParamTrial *trial;            
  vector<State> stateStack;     
  vector<const Varnode *> markedVn; 
  int4 multiDepth;          
  bool allowFailingPath;        

  void mark(Varnode *vn) {
    markedVn.push_back(vn);
    vn->setMark();
  }

  int4 enterNode(State &state);         
  int4 uponPop(State &state,int4 command);  
  bool checkConditionalExe(State &state);   
public:
  bool execute(PcodeOp *op,int4 slot,ParamTrial *t,bool allowFail);
};

extern int4 opFlipInPlaceTest(PcodeOp *op,vector<PcodeOp *> &fliplist);
extern void opFlipInPlaceExecute(Funcdata &data,vector<PcodeOp *> &fliplist);

extern PcodeOp *earliestUseInBlock(Varnode *vn,BlockBasic *bl);
extern PcodeOp *cseFindInBlock(PcodeOp *op,Varnode *vn,BlockBasic *bl,PcodeOp *earliest);
extern PcodeOp *cseElimination(Funcdata &data,PcodeOp *op1,PcodeOp *op2);
extern void cseEliminateList(Funcdata &data,vector< pair<uintm,PcodeOp *> > &list,
                 vector<Varnode *> &outlist);

#endif