varmap.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_VARMAP__
#define __CPUI_VARMAP__
 
#include "database.hh"
 
class NameRecommend {
  Address addr;         
  Address useaddr;      
  int4 size;            
  string name;          
  uint8 symbolId;       
public:
  NameRecommend(const Address &ad,const Address &use,int4 sz,const string &nm,uint8 id) :
    addr(ad), useaddr(use), size(sz), name(nm), symbolId(id) {} 
  const Address &getAddr(void) const { return addr; }   
  const Address &getUseAddr(void) const { return useaddr; } 
  int4 getSize(void) const { return size; }         
  string getName(void) const { return name; }           
  uint8 getSymbolId(void) const { return symbolId; }        
};
 
class DynamicRecommend {
  Address usePoint;     
  uint8 hash;           
  string name;          
  uint8 symbolId;       
public:
  DynamicRecommend(const Address &addr,uint8 h,const string &nm,uint8 id) :
    usePoint(addr), hash(h), name(nm), symbolId(id) {}  
  const Address &getAddress(void) const { return usePoint; }    
  uint8 getHash(void) const { return hash; }            
  string getName(void) const { return name; }           
  uint8 getSymbolId(void) const { return symbolId; }        
};
 
class TypeRecommend {
  Address addr;     
  Datatype *dataType;   
public:
  TypeRecommend(const Address &ad,Datatype *dt) :
    addr(ad), dataType(dt) {}   
  const Address &getAddress(void) const { return addr; }    
  Datatype *getType(void) const { return dataType; }        
};
 
class RangeHint {
  friend class MapState;
  friend class ScopeLocal;
public:
  enum RangeType {
    fixed = 0,      
    open = 1,       
    endpoint = 2    
  };
private:
  uintb start;      
  int4 size;        
  intb sstart;      
  Datatype *type;   
  uint4 flags;      
  RangeType rangeType;  
  int4 highind;     
public:
  RangeHint(void) {}    
  RangeHint(uintb st,int4 sz,intb sst,Datatype *ct,uint4 fl,RangeType rt,int4 hi) {
    start=st; size=sz; sstart=sst; type=ct; flags=fl; rangeType = rt; highind=hi; } 
  bool reconcile(const RangeHint *b) const;
  bool contain(const RangeHint *b) const;
  bool preferred(const RangeHint *b,bool reconcile) const;
  bool absorb(RangeHint *b);    
  bool merge(RangeHint *b,AddrSpace *space,TypeFactory *typeFactory);   
  int4 compare(const RangeHint &op2) const;     
  static bool compareRanges(const RangeHint *a,const RangeHint *b) { return (a->compare(*b) < 0); } 
};
 
class ProtoModel;
class LoadGuard;
 
class AliasChecker {
public:
  struct AddBase {
    Varnode *base;      
    Varnode *index;     
    AddBase(Varnode *b,Varnode *i) { base=b; index=i; } 
  };
private:
  const Funcdata *fd;       
  AddrSpace *space;     
  mutable vector<AddBase> addBase; 
  mutable vector<uintb> alias;  
  mutable bool calculated;  
  uintb localExtreme;       
  uintb localBoundary;      
  mutable uintb aliasBoundary;  
  int4 direction;       
  void deriveBoundaries(const FuncProto &proto);    
  void gatherInternal(void) const;  
public:
  AliasChecker() { fd = (const Funcdata *)0; space = (AddrSpace *)0; calculated=false; }    
  void gather(const Funcdata *f,AddrSpace *spc,bool defer);     
  bool hasLocalAlias(Varnode *vn) const;    
  void sortAlias(void) const;           
  const vector<AddBase> &getAddBase(void) const { return addBase; } 
  const vector<uintb> &getAlias(void) const { return alias; }       
  static void gatherAdditiveBase(Varnode *startvn,vector<AddBase> &addbase);
  static uintb gatherOffset(Varnode *vn);
};
 
class MapState {
  AddrSpace *spaceid;           
  RangeList range;          
  vector<RangeHint *> maplist;      
  vector<RangeHint *>::iterator iter;   
  Datatype *defaultType;        
  AliasChecker checker;         
  void addGuard(const LoadGuard &guard,OpCode opc,TypeFactory *typeFactory);    
  void addRange(uintb st,Datatype *ct,uint4 fl,RangeHint::RangeType rt,int4 hi);    
  void reconcileDatatypes(void);    
public:
#ifdef OPACTION_DEBUG
  mutable bool debugon;
  mutable Architecture *glb;
  void turnOnDebug(Architecture *g) const { debugon = true; glb=g; }
  void turnOffDebug(void) const { debugon = false; }
#endif
  MapState(AddrSpace *spc,const RangeList &rn,const RangeList &pm,Datatype *dt);    
  ~MapState(void);      
  bool initialize(void);    
  void sortAlias(void) { checker.sortAlias(); }     
  const vector<uintb> &getAlias(void) { return checker.getAlias(); }    
  void gatherSymbols(const EntryMap *rangemap);     
  void gatherVarnodes(const Funcdata &fd);      
  void gatherHighs(const Funcdata &fd);         
  void gatherOpen(const Funcdata &fd);          
  RangeHint *next(void) { return *iter; }       
  bool getNext(void) { ++iter; if (iter==maplist.end()) return false; return true; }    
};
 
class ScopeLocal : public ScopeInternal {
  AddrSpace *space;     
  RangeList localRange;     
  list<NameRecommend> nameRecommend;    
  list<DynamicRecommend> dynRecommend;      
  list<TypeRecommend> typeRecommend;    
  bool stackGrowsNegative;  
  bool rangeLocked;     
  bool adjustFit(RangeHint &a) const;   
  void createEntry(const RangeHint &a); 
  bool restructure(MapState &state);    
  void markUnaliased(const vector<uintb> &alias);   
  void fakeInputSymbols(void);      
  void addRecommendName(Symbol *sym);   
  void collectNameRecs(void);       
public:
  ScopeLocal(uint8 id,AddrSpace *spc,Funcdata *fd,Architecture *g); 
  virtual ~ScopeLocal(void) {}  
 
  AddrSpace *getSpaceId(void) const { return space; }       
 
  bool isUnaffectedStorage(Varnode *vn) const { return (vn->getSpace() == space); }
 
  void markNotMapped(AddrSpace *spc,uintb first,int4 sz,bool param);    
 
                // Routines that are specific to one address space
  virtual void saveXml(ostream &s) const;
  virtual void restoreXml(const Element *el);
  virtual string buildVariableName(const Address &addr,
                   const Address &pc,
                   Datatype *ct,
                   int4 &index,uint4 flags) const;
  void resetLocalWindow(void);  
  void restructureVarnode(bool aliasyes);   
  void restructureHigh(void);           
  SymbolEntry *remapSymbol(Symbol *sym,const Address &addr,const Address &usepoint);
  SymbolEntry *remapSymbolDynamic(Symbol *sym,uint8 hash,const Address &usepoint);
  void recoverNameRecommendationsForSymbols(void);
  void applyTypeRecommendations(void);      
};
 
#endif