variable.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_TYPEVAR__
#define __CPUI_TYPEVAR__
 
#include "varnode.hh"
 
class Symbol;
 
class HighVariable {
public:
  enum {
    flagsdirty = 1,     
    namerepdirty = 2,       
    typedirty = 4,      
    coverdirty = 8,     
    symboldirty = 0x10,     
    copy_in1 = 0x20,        
    copy_in2 = 0x40,        
    type_finalized = 0x80,  
    unmerged = 0x100        
  };
private:
  friend class Varnode;
  friend class Merge;
  vector<Varnode *> inst;       
  int4 numMergeClasses;         
  mutable uint4 highflags;      
  mutable uint4 flags;          
  mutable Datatype *type;       
  mutable Varnode *nameRepresentative;  
  mutable Cover wholecover;     
  mutable Symbol *symbol;       
  mutable int4 symboloffset;        
  int4 instanceIndex(const Varnode *vn) const;  
  void updateFlags(void) const;     
  void updateCover(void) const;     
  void updateType(void) const;      
  void updateSymbol(void) const;    
  void setCopyIn1(void) const { highflags |= copy_in1; }    
  void setCopyIn2(void) const { highflags |= copy_in2; }    
  void clearCopyIns(void) const { highflags &= ~(copy_in1 | copy_in2); }    
  bool hasCopyIn1(void) const { return ((highflags&copy_in1)!=0); } 
  bool hasCopyIn2(void) const { return ((highflags&copy_in2)!=0); } 
  void remove(Varnode *vn);             
  void merge(HighVariable *tv2,bool isspeculative); 
  void setSymbol(Varnode *vn) const;        
  void setSymbolReference(Symbol *sym,int4 off);    
  void flagsDirty(void) const { highflags |= flagsdirty | namerepdirty; }   
  void coverDirty(void) const { highflags |= coverdirty; }  
  void typeDirty(void) const { highflags |= typedirty; }    
  void setUnmerged(void) const { highflags |= unmerged; }   
public:
  HighVariable(Varnode *vn);        
  Datatype *getType(void) const { updateType(); return type; }  
  Symbol *getSymbol(void) const { updateSymbol(); return symbol; }  
  SymbolEntry *getSymbolEntry(void) const;          
  int4 getSymbolOffset(void) const { return symboloffset; } 
  int4 numInstances(void) const { return inst.size(); }     
  Varnode *getInstance(int4 i) const { return inst[i]; }    
  void finalizeDatatype(Datatype *tp);      
 
  void printCover(ostream &s) const { if ((highflags&HighVariable::coverdirty)==0) wholecover.print(s); else s << "Cover dirty"; }
 
  void printInfo(ostream &s) const;     
  bool hasName(void) const;         
  Varnode *getTiedVarnode(void) const;      
  Varnode *getInputVarnode(void) const;     
  Varnode *getTypeRepresentative(void) const;   
  Varnode *getNameRepresentative(void) const;   
  int4 getNumMergeClasses(void) const { return numMergeClasses; }   
  bool isMapped(void) const { updateFlags(); return ((flags&Varnode::mapped)!=0); } 
  bool isPersist(void) const { updateFlags(); return ((flags&Varnode::persist)!=0); }   
  bool isAddrTied(void) const { updateFlags(); return ((flags&Varnode::addrtied)!=0); } 
  bool isInput(void) const { updateFlags(); return ((flags&Varnode::input)!=0); }   
  bool isImplied(void) const { updateFlags(); return ((flags&Varnode::implied)!=0); }   
  bool isSpacebase(void) const { updateFlags(); return ((flags&Varnode::spacebase)!=0); }   
  bool isConstant(void) const { updateFlags(); return ((flags&Varnode::constant)!=0); } 
  bool isUnaffected(void) const { updateFlags(); return ((flags&Varnode::unaffected)!=0); } 
  bool isExtraOut(void) const { updateFlags(); return ((flags&(Varnode::indirect_creation|Varnode::addrtied))==Varnode::indirect_creation); }   
  void setMark(void) const { flags |= Varnode::mark; }      
  void clearMark(void) const { flags &= ~Varnode::mark; }   
  bool isMark(void) const { return ((flags&Varnode::mark)!=0); }    
  bool isUnmerged(void) const { return ((highflags&unmerged)!=0); } 
 
  bool hasCover(void) const {
    updateFlags();
    return ((flags&(Varnode::constant|Varnode::annotation|Varnode::insert))==Varnode::insert); }
 
  bool isUnattached(void) const { return inst.empty(); }    
  bool isTypeLock(void) const { updateType(); return ((flags & Varnode::typelock)!=0); }    
  bool isNameLock(void) const { updateFlags(); return ((flags & Varnode::namelock)!=0); }   
  void saveXml(ostream &s) const;       
#ifdef MERGEMULTI_DEBUG
  void verifyCover(void) const;
#endif
  //  Varnode *findGlobalRep(void) const;
  static bool compareName(Varnode *vn1,Varnode *vn2);   
  static bool compareJustLoc(const Varnode *a,const Varnode *b);    
  static int4 markExpression(Varnode *vn,vector<HighVariable *> &highList); 
};
 
#endif