Ghidra-Decompiler-Analysis-Engine-Document/funcdata_8hh_source.html

/* ###

 * 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

  };

  uint4 flags;

  uint4 clean_up_index;

  uint4 high_level_index;

  uint4 cast_phase_index;

  uint4 minLanedSize;

  int4 size;

  Architecture *glb;

  FunctionSymbol *functionSymbol;

  string name;

  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);

  Symbol *handleSymbolConflict(SymbolEntry *entry,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);

  void coverVarnodes(SymbolEntry *entry,vector<Varnode *> &list);

                // 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,FunctionSymbol *sym,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; }

  FunctionSymbol *getSymbol(void) const { return functionSymbol; }

  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; }

  void setLanedRegGenerated(void) { minLanedSize = 1000000; }


  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);

  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 getHeritagePass(void) const { return heritage.getPass(); }


  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;

  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); }


  Address findDisjointCover(Varnode *vn,int4 &sz);


  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 checkForLanedRegister(int4 size,const Address &addr);

  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->setAdditionalFlag(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); }


  bool moveRespectingCover(PcodeOp *op,PcodeOp *lastOp);


  // 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);

  bool replaceLessequal(PcodeOp *op);

  bool distributeIntMultAdd(PcodeOp *op);

  bool collapseIntMultMult(Varnode *vn);

  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