varnode.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_VARNODE__
#define __CPUI_VARNODE__

#include "pcoderaw.hh"
#include "cover.hh"

class HighVariable;

class Varnode;      // Forward declaration
class VarnodeBank;
class Merge;
class Funcdata;
class SymbolEntry;
class ValueSet;

struct VarnodeCompareLocDef {
  bool operator()(const Varnode *a,const Varnode *b) const; 
};

struct VarnodeCompareDefLoc {
  bool operator()(const Varnode *a,const Varnode *b) const; 
};

typedef set<Varnode *,VarnodeCompareLocDef> VarnodeLocSet;

typedef set<Varnode *,VarnodeCompareDefLoc> VarnodeDefSet;

class Varnode {
public:
  enum varnode_flags {
    mark = 0x01,    
    constant = 0x02,    
    annotation = 0x04,  
    input = 0x08,       
    written = 0x10, 
    insert = 0x20,  
    implied = 0x40, 
    explict = 0x80, 
    
    typelock = 0x100,   
    namelock = 0x200,   
    nolocalalias = 0x400,   
    volatil = 0x800,    
    spacebase_placeholder = 0x1000, 
    
    externref = 0x2000, 
    readonly = 0x4000,  
    persist = 0x8000,   
    addrtied = 0x10000, 
    unaffected = 0x20000,   
    spacebase = 0x40000,    
    indirectonly = 0x80000, 
    directwrite = 0x100000, 
    addrforce = 0x200000, 
    
    mapped = 0x400000, 
    indirect_creation = 0x800000, 
    return_address = 0x1000000, 
    coverdirty = 0x2000000, 
    precislo = 0x4000000,   
    precishi = 0x8000000,   
    indirectstorage = 0x10000000, 
    hiddenretparm = 0x20000000,  
    incidental_copy = 0x40000000, 
    auto_live = 0x80000000  
  };
  enum addl_flags {
    activeheritage = 0x01,  
    writemask = 0x02,           
    vacconsume = 0x04,      
    lisconsume = 0x08,      
    ptrcheck = 0x10,            
    ptrflow = 0x20,             
    unsignedprint = 0x40,   
    stack_store = 0x80,     
    locked_input = 0x100    
  };
private:
  mutable uint4 flags;      
  int4 size;            
  uint4 create_index;       
  int2 mergegroup;      
  uint2 addlflags;      
  Address loc;          

                // Heritage fields
  PcodeOp *def;         
  HighVariable *high;       
  SymbolEntry *mapentry;    
  Datatype *type;       
  VarnodeLocSet::iterator lociter;  
  VarnodeDefSet::iterator defiter;  
  list<PcodeOp *> descend;      
  mutable Cover *cover;     
  mutable union {
    Datatype *dataType;     
    ValueSet *valueSet;     
  } temp;           
  uintb consumed;       
  uintb nzm;            
  friend class VarnodeBank;
  friend class Merge;
  friend class Funcdata;
  void updateCover(void) const; 
  void calcCover(void) const;   
  void clearCover(void) const; 
  void setFlags(uint4 fl) const; 
  void clearFlags(uint4 fl) const; 
  void setUnaffected(void) { setFlags(Varnode::unaffected); } 
  // These functions should be only private things used by VarnodeBank
  void setInput(void) { setFlags(Varnode::input|Varnode::coverdirty); } 
  void setDef(PcodeOp *op); 
  bool setSymbolProperties(SymbolEntry *entry); 
  void setSymbolEntry(SymbolEntry *entry);  
  void setSymbolReference(SymbolEntry *entry,int4 off); 
  void addDescend(PcodeOp *op); 
  void eraseDescend(PcodeOp *op); 
  void destroyDescend(void);    
public:
  // only to be used by HighVariable
  void setHigh(HighVariable *tv,int2 mg) { high = tv; mergegroup = mg; } 

  const Address &getAddr(void) const { return (const Address &) loc; } 
  AddrSpace *getSpace(void) const { return loc.getSpace(); } 
  uintb getOffset(void) const { return loc.getOffset(); } 
  int4 getSize(void) const { return size; } 
  int2 getMergeGroup(void) const { return mergegroup; } 
  PcodeOp *getDef(void) { return def; } 
  const PcodeOp *getDef(void) const { return (const PcodeOp *) def; } 
  HighVariable *getHigh(void) const; 
  SymbolEntry *getSymbolEntry(void) const { return mapentry; } 
  uint4 getFlags(void) const { return flags; } 
  Datatype *getType(void) const { return type; } 
  void setTempType(Datatype *t) const { temp.dataType = t; }    
  Datatype *getTempType(void) const { return temp.dataType; } 
  void setValueSet(ValueSet *v) const { temp.valueSet = v; }    
  ValueSet *getValueSet(void) const { return temp.valueSet; }   
  uint4 getCreateIndex(void) const { return create_index; } 
  Cover *getCover(void) const { updateCover(); return cover; } 
  list<PcodeOp *>::const_iterator beginDescend(void) const { return descend.begin(); } 
  list<PcodeOp *>::const_iterator endDescend(void) const { return descend.end(); } 
  uintb getConsume(void) const { return consumed; } 
  void setConsume(uintb val) { consumed = val; } 
  bool isConsumeList(void) const { return ((addlflags&Varnode::lisconsume)!=0); } 
  bool isConsumeVacuous(void) const { return ((addlflags&Varnode::vacconsume)!=0); } 
  void setConsumeList(void) { addlflags |= Varnode::lisconsume; } 
  void setConsumeVacuous(void) { addlflags |= Varnode::vacconsume; } 
  void clearConsumeList(void) { addlflags &= ~Varnode::lisconsume; } 
  void clearConsumeVacuous(void) { addlflags &= ~Varnode::vacconsume; } 
  PcodeOp *loneDescend(void) const; 
  Address getUsePoint(const Funcdata &fd) const; 
  int4 printRawNoMarkup(ostream &s) const; 
  void printRaw(ostream &s) const; 
  void printCover(ostream &s) const; 
  void printInfo(ostream &s) const; 
  Varnode(int4 s,const Address &m,Datatype *dt);    
  bool operator<(const Varnode &op2) const; 
  bool operator==(const Varnode &op2) const; 
  bool operator!=(const Varnode &op2) const { return !operator==(op2); } 
  ~Varnode(void);       
  bool intersects(const Varnode &op) const; 
  bool intersects(const Address &op2loc,int4 op2size) const; 
  int4 contains(const Varnode &op) const; 
  int4 characterizeOverlap(const Varnode &op) const; 
  int4 overlap(const Varnode &op) const;    
  int4 overlap(const Address &op2loc,int4 op2size) const;   
  uintb getNZMask(void) const { return nzm; } 
  int4 termOrder(const Varnode *op) const; 
  void printRawHeritage(ostream &s,int4 depth) const; 
  bool isAnnotation(void) const { return ((flags&Varnode::annotation)!=0); } 
  bool isImplied(void) const { return ((flags&Varnode::implied)!=0); } 
  bool isExplicit(void) const { return ((flags&Varnode::explict)!=0); } 
  bool isConstant(void) const { return ((flags&Varnode::constant)!=0); } 
  bool isFree(void) const { return ((flags&(Varnode::written|Varnode::input))==0); } 
  bool isInput(void) const { return ((flags&Varnode::input)!=0); } 
  bool isIllegalInput(void) const { return ((flags&(Varnode::input|Varnode::directwrite))==Varnode::input); } 
  bool isIndirectOnly(void) const { return ((flags&Varnode::indirectonly)!=0); } 
  bool isExternalRef(void) const { return ((flags&Varnode::externref)!=0); } 
  bool hasActionProperty(void) const { return ((flags&(Varnode::readonly|Varnode::volatil))!=0); } 
  bool isReadOnly(void) const { return ((flags&Varnode::readonly)!=0); } 
  bool isVolatile(void) const { return ((flags&Varnode::volatil)!=0); } 
  bool isPersist(void) const { return ((flags&Varnode::persist)!=0); } 
  bool isDirectWrite(void) const { return ((flags&Varnode::directwrite)!=0); } 

  bool isAddrTied(void) const { return ((flags&(Varnode::addrtied|Varnode::insert))==(Varnode::addrtied|Varnode::insert)); }
  bool isAddrForce(void) const { return ((flags&Varnode::addrforce)!=0); } 
  bool isAutoLive(void) const { return ((flags&Varnode::auto_live)!=0); } 
  bool isMapped(void) const { return ((flags&Varnode::mapped)!=0); } 
  bool isUnaffected(void) const { return ((flags&Varnode::unaffected)!=0); } 
  bool isSpacebase(void) const { return ((flags&Varnode::spacebase)!=0); } 
  bool isReturnAddress(void) const { return ((flags&Varnode::return_address)!=0); } 
  bool isPtrCheck(void) const { return ((addlflags&Varnode::ptrcheck)!=0); } 
  bool isPtrFlow(void) const { return ((addlflags&Varnode::ptrflow)!=0); } 
  bool isSpacebasePlaceholder(void) const { return ((flags&Varnode::spacebase_placeholder)!=0); } 
  bool hasNoLocalAlias(void) const { return ((flags&Varnode::nolocalalias)!=0); } 
  bool isMark(void) const { return ((flags&Varnode::mark)!=0); } 
  bool isActiveHeritage(void) const { return ((addlflags&Varnode::activeheritage)!=0); } 
  bool isStackStore(void) const { return ((addlflags&Varnode::stack_store)!=0); } 
  bool isLockedInput(void) const { return ((addlflags&Varnode::locked_input)!=0); } 

  bool isIndirectZero(void) const { return ((flags&(Varnode::indirect_creation|Varnode::constant))==(Varnode::indirect_creation|Varnode::constant)); }

  bool isExtraOut(void) const { return ((flags&(Varnode::indirect_creation|Varnode::addrtied))==Varnode::indirect_creation); }
  bool isPrecisLo(void) const { return ((flags&Varnode::precislo)!=0); } 
  bool isPrecisHi(void) const { return ((flags&Varnode::precishi)!=0); } 
  bool isIncidentalCopy(void) const { return ((flags&Varnode::incidental_copy)!=0); } 
  bool isWriteMask(void) const { return ((addlflags&Varnode::writemask)!=0); } 
  bool isUnsignedPrint(void) const { return ((addlflags&Varnode::unsignedprint)!=0); } 
  bool isWritten(void) const { return ((flags&Varnode::written)!=0); }   

  bool hasCover(void) const {
    return ((flags&(Varnode::constant|Varnode::annotation|Varnode::insert))==Varnode::insert); }
  bool hasNoDescend(void) const { return descend.empty(); } 

  bool constantMatch(uintb val) const {
    if (!isConstant()) return false;
    return (loc.getOffset() == val);
  }

  int4 isConstantExtended(uintb &val) const; 
  bool isHeritageKnown(void) const { return ((flags&(Varnode::insert|Varnode::constant|Varnode::annotation))!=0); }
  bool isTypeLock(void) const { return ((flags&Varnode::typelock)!=0); } 
  bool isNameLock(void) const { return ((flags&Varnode::namelock)!=0); } 
  void setActiveHeritage(void) { addlflags |= Varnode::activeheritage; } 
  void clearActiveHeritage(void) { addlflags &= ~Varnode::activeheritage; } 
  void setMark(void) const { flags |= Varnode::mark; } 
  void clearMark(void) const { flags &= ~Varnode::mark; } 
  void setDirectWrite(void) { flags |= Varnode::directwrite; } 
  void clearDirectWrite(void) { flags &= ~Varnode::directwrite; } 
  void setAddrForce(void) { setFlags(Varnode::addrforce | Varnode::auto_live); } 
  void clearAddrForce(void) { clearFlags(Varnode::addrforce | Varnode::auto_live); }    
  void setAutoLive(void) { flags |= Varnode::auto_live; } 
  void clearAutoLive(void) { flags &= ~Varnode::auto_live; } 
  void setImplied(void) { setFlags(Varnode::implied); } 
  void clearImplied(void) { clearFlags(Varnode::implied); } 
  void setExplicit(void) { setFlags(Varnode::explict); } 
  void clearExplicit(void) { clearFlags(Varnode::explict); } 
  void setReturnAddress(void) { flags |= Varnode::return_address; } 
  void clearReturnAddress(void) { flags &= ~Varnode::return_address; } 
  void setPtrCheck(void) { addlflags |= Varnode::ptrcheck; } 
  void clearPtrCheck(void) { addlflags &= ~Varnode::ptrcheck; } 
  void setPtrFlow(void) { addlflags |= Varnode::ptrflow; } 
  void clearPtrFlow(void) { addlflags &= ~Varnode::ptrflow; } 
  void setSpacebasePlaceholder(void) { setFlags(Varnode::spacebase_placeholder); } 
  void clearSpacebasePlaceholder(void) { clearFlags(Varnode::spacebase_placeholder); } 
  void setPrecisLo(void) { setFlags(Varnode::precislo); } 
  void clearPrecisLo(void) { clearFlags(Varnode::precislo); } 
  void setPrecisHi(void) { setFlags(Varnode::precishi); } 
  void clearPrecisHi(void) { clearFlags(Varnode::precishi); } 
  void setWriteMask(void) { addlflags |= Varnode::writemask; } 
  void clearWriteMask(void) { addlflags &= ~Varnode::writemask; } 
  void setUnsignedPrint(void) { addlflags |= Varnode::unsignedprint; } 
  bool updateType(Datatype *ct,bool lock,bool override); 
  void setStackStore(void) { addlflags |= Varnode::stack_store; } 
  void setLockedInput(void) { addlflags |= Varnode::locked_input; } 
  void copySymbol(const Varnode *vn); 
  void copySymbolIfValid(const Varnode *vn);    
  Datatype *getLocalType(void) const; 
  bool copyShadow(const Varnode *op2) const; 
  void saveXml(ostream &s) const; 
  static bool comparePointers(const Varnode *a,const Varnode *b) { return (*a < *b); }  
  //  static Varnode *restoreXml(const Element *el,Funcdata &fd,bool coderef);
};

class VarnodeBank {
  AddrSpaceManager *manage; 
  AddrSpace *uniq_space;    
  uintm uniqbase;       
  uintm uniqid;         
  uint4 create_index;       
  VarnodeLocSet loc_tree;   
  VarnodeDefSet def_tree;   
  mutable Varnode searchvn; 
  Varnode *xref(Varnode *vn);   
public:
  VarnodeBank(AddrSpaceManager *m,AddrSpace *uspace,uintm ubase);   
  void clear(void);                     
  ~VarnodeBank(void) { clear(); }               
  int4 numVarnodes(void) const { return loc_tree.size(); }  
  Varnode *create(int4 s,const Address &m,Datatype *ct);    
  Varnode *createDef(int4 s,const Address &m,Datatype *ct,PcodeOp *op); 
  Varnode *createUnique(int4 s,Datatype *ct);           
  Varnode *createDefUnique(int4 s,Datatype *ct,PcodeOp *op);    
  void destroy(Varnode *vn);                    
  Varnode *setInput(Varnode *vn);               
  Varnode *setDef(Varnode *vn,PcodeOp *op);         
  void makeFree(Varnode *vn);                   
  void replace(Varnode *oldvn,Varnode *newvn);          
  Varnode *find(int4 s,const Address &loc,const Address &pc,uintm uniq=~((uintm)0)) const;  
  Varnode *findInput(int4 s,const Address &loc) const;      
  Varnode *findCoveredInput(int4 s,const Address &loc) const;   
  Varnode *findCoveringInput(int4 s,const Address &loc) const;  
  uint4 getCreateIndex(void) const { return create_index; } 
  VarnodeLocSet::const_iterator beginLoc(void) const { return loc_tree.begin(); }   
  VarnodeLocSet::const_iterator endLoc(void) const { return loc_tree.end(); }       
  VarnodeLocSet::const_iterator beginLoc(AddrSpace *spaceid) const;
  VarnodeLocSet::const_iterator endLoc(AddrSpace *spaceid) const;
  VarnodeLocSet::const_iterator beginLoc(const Address &addr) const;
  VarnodeLocSet::const_iterator endLoc(const Address &addr) const;
  VarnodeLocSet::const_iterator beginLoc(int4 s,const Address &addr) const;
  VarnodeLocSet::const_iterator endLoc(int4 s,const Address &addr) const;
  VarnodeLocSet::const_iterator beginLoc(int4 s,const Address &addr,uint4 fl) const;
  VarnodeLocSet::const_iterator endLoc(int4 s,const Address &addr,uint4 fl) const;
  VarnodeLocSet::const_iterator beginLoc(int4 s,const Address &addr,const Address &pc,uintm uniq) const;
  VarnodeLocSet::const_iterator endLoc(int4 s,const Address &addr,const Address &pc,uintm uniq) const;
  VarnodeDefSet::const_iterator beginDef(void) const { return def_tree.begin(); }   
  VarnodeDefSet::const_iterator endDef(void) const { return def_tree.end(); }   
  VarnodeDefSet::const_iterator beginDef(uint4 fl) const;
  VarnodeDefSet::const_iterator endDef(uint4 fl) const;
  VarnodeDefSet::const_iterator beginDef(uint4 fl,const Address &addr) const;
  VarnodeDefSet::const_iterator endDef(uint4 fl,const Address &addr) const;
#ifdef VARBANK_DEBUG
  void verifyIntegrity(void) const;     
#endif
};

bool contiguous_test(Varnode *vn1,Varnode *vn2);    
Varnode *findContiguousWhole(Funcdata &data,Varnode *vn1,
                  Varnode *vn2);    
#endif