globalcontext.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 __GLOBALCONTEXT__
#define __GLOBALCONTEXT__


#include "pcoderaw.hh"
#include "partmap.hh"

class ContextBitRange {
  int4 word;        
  int4 startbit;    
  int4 endbit;      
  int4 shift;       
  uintm mask;       
public:
  ContextBitRange(void) { } 
  ContextBitRange(int4 sbit,int4 ebit);     
  int4 getShift(void) const { return shift; }   
  uintm getMask(void) const { return mask; }    
  int4 getWord(void) const { return word; } 

  void setValue(uintm *vec,uintm val) const {
    uintm newval = vec[word];
    newval &= ~(mask<<shift);
    newval |= ((val & mask)<<shift);
    vec[word] = newval;
  }

  uintm getValue(const uintm *vec) const {
    return ((vec[word]>>shift)&mask);
  }
};

struct TrackedContext {
  VarnodeData loc;  
  uintb val;        
  void restoreXml(const Element *el,const AddrSpaceManager *manage);    
  void saveXml(ostream &s) const;                   
};
typedef vector<TrackedContext> TrackedSet;      

class ContextDatabase {
protected:
  static void saveTracked(ostream &s,const Address &addr,const TrackedSet &vec);
  static void restoreTracked(const Element *el,const AddrSpaceManager *manage,TrackedSet &vec);

  virtual ContextBitRange &getVariable(const string &nm)=0;

  virtual const ContextBitRange &getVariable(const string &nm) const=0;

  virtual void getRegionForSet(vector<uintm *> &res,const Address &addr1,
                   const Address &addr2,int4 num,uintm mask)=0;

  virtual void getRegionToChangePoint(vector<uintm *> &res,const Address &addr,int4 num,uintm mask)=0;

  virtual uintm *getDefaultValue(void)=0;

  virtual const uintm *getDefaultValue(void) const=0;
public:
  virtual ~ContextDatabase() {}         

  virtual int4 getContextSize(void) const=0;

  virtual void registerVariable(const string &nm,int4 sbit,int4 ebit)=0;

  virtual const uintm *getContext(const Address &addr) const=0;

  virtual const uintm *getContext(const Address &addr,uintb &first,uintb &last) const=0;

  virtual TrackedSet &getTrackedDefault(void)=0;

  virtual const TrackedSet &getTrackedSet(const Address &addr) const=0;

  virtual TrackedSet &createSet(const Address &addr1,const Address &addr2)=0;

  virtual void saveXml(ostream &s) const=0;

  virtual void restoreXml(const Element *el,const AddrSpaceManager *manage)=0;

  virtual void restoreFromSpec(const Element *el,const AddrSpaceManager *manage)=0;

  void setVariableDefault(const string &nm,uintm val);  
  uintm getDefaultValue(const string &nm) const;    
  void setVariable(const string &nm,const Address &addr,uintm value);   
  uintm getVariable(const string &nm,const Address &addr) const;    
  void setContextChangePoint(const Address &addr,int4 num,uintm mask,uintm value);
  void setContextRegion(const Address &addr1,const Address &addr2,int4 num,uintm mask,uintm value);
  void setVariableRegion(const string &nm,const Address &begad,
             const Address &endad,uintm value);
  uintb getTrackedValue(const VarnodeData &mem,const Address &point) const;
};

class ContextInternal : public ContextDatabase {

  struct FreeArray {
    uintm *array;       
    uintm *mask;        
    int4 size;          
    FreeArray(void) { size=0; array = (uintm *)0; mask = (uintm *)0; }  
    ~FreeArray(void) { if (size!=0) { delete [] array; delete [] mask; } }  
    void reset(int4 sz);    
    FreeArray &operator=(const FreeArray &op2); 
  };

  int4 size;            
  map<string,ContextBitRange> variables;        
  partmap<Address,FreeArray> database;          
  partmap<Address,TrackedSet> trackbase;        
  void saveContext(ostream &s,const Address &addr,const uintm *vec) const;
  void restoreContext(const Element *el,const Address &addr1,const Address &addr2);
  virtual ContextBitRange &getVariable(const string &nm);
  virtual const ContextBitRange &getVariable(const string &nm) const;
  virtual void getRegionForSet(vector<uintm *> &res,const Address &addr1,
                   const Address &addr2,int4 num,uintm mask);
  virtual void getRegionToChangePoint(vector<uintm *> &res,const Address &addr,int4 num,uintm mask);
  virtual uintm *getDefaultValue(void) { return database.defaultValue().array; }
  virtual const uintm *getDefaultValue(void) const { return database.defaultValue().array; }
public:
  ContextInternal(void) { size = 0; }
  virtual ~ContextInternal(void) {}
  virtual int4 getContextSize(void) const { return size; }
  virtual void registerVariable(const string &nm,int4 sbit,int4 ebit);

  virtual const uintm *getContext(const Address &addr) const { return database.getValue(addr).array; }
  virtual const uintm *getContext(const Address &addr,uintb &first,uintb &last) const;

  virtual TrackedSet &getTrackedDefault(void) { return trackbase.defaultValue(); }
  virtual const TrackedSet &getTrackedSet(const Address &addr) const { return trackbase.getValue(addr); }
  virtual TrackedSet &createSet(const Address &addr1,const Address &addr2);

  virtual void saveXml(ostream &s) const;
  virtual void restoreXml(const Element *el,const AddrSpaceManager *manage);
  virtual void restoreFromSpec(const Element *el,const AddrSpaceManager *manage);
};

class ContextCache {
  ContextDatabase *database;        
  bool allowset;            
  mutable AddrSpace *curspace;      
  mutable uintb first;          
  mutable uintb last;           
  mutable const uintm *context;     
public:
  ContextCache(ContextDatabase *db);    
  ContextDatabase *getDatabase(void) const { return database; }     
  void allowSet(bool val) { allowset = val; }       
  void getContext(const Address &addr,uintm *buf) const;    
  void setContext(const Address &addr,int4 num,uintm mask,uintm value);
  void setContext(const Address &addr1,const Address &addr2,int4 num,uintm mask,uintm value);
};

#endif