sleigh.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 __SLEIGH__
#define __SLEIGH__
 
#include "sleighbase.hh"
 
class LoadImage;
 
struct RelativeRecord {
  VarnodeData *dataptr;     
  uintb calling_index;      
};
 
struct PcodeData {
  OpCode opc;           
  VarnodeData *outvar;          
  VarnodeData *invar;       
  int4 isize;           
};
 
class PcodeCacher {
  VarnodeData *poolstart;       
  VarnodeData *curpool;         
  VarnodeData *endpool;         
  vector<PcodeData> issued;     
  list<RelativeRecord> label_refs;  
  vector<uintb> labels;         
  VarnodeData *expandPool(uint4 size);  
public:
  PcodeCacher(void);        
  ~PcodeCacher(void);       
 
  VarnodeData *allocateVarnodes(uint4 size) {
    VarnodeData *newptr = curpool + size;
    if (newptr <= endpool) {
      VarnodeData *res = curpool;
      curpool = newptr;
      return res;
    }
    return expandPool(size);
  }
 
  PcodeData *allocateInstruction(void) {
    issued.emplace_back();
    PcodeData *res = &issued.back();
    res->outvar = (VarnodeData *)0;
    res->invar = (VarnodeData *)0;
    return res;
  }
  void addLabelRef(VarnodeData *ptr);   
  void addLabel(uint4 id);      
  void clear(void);         
  void resolveRelatives(void);      
  void emit(const Address &addr,PcodeEmit *emt) const;  
};
 
class DisassemblyCache {
  ContextCache *contextcache;   
  AddrSpace *constspace;    
  int4 minimumreuse;        
  uint4 mask;           
  ParserContext **list;     
  int4 nextfree;        
  ParserContext **hashtable;    
  void initialize(int4 min,int4 hashsize);  
  void free(void);      
public:
  DisassemblyCache(ContextCache *ccache,AddrSpace *cspace,int4 cachesize,int4 windowsize);  
  ~DisassemblyCache(void) { free(); }   
  ParserContext *getParserContext(const Address &addr);     
};
 
class SleighBuilder : public PcodeBuilder {
  virtual void dump( OpTpl *op );
  AddrSpace *const_space;       
  AddrSpace *uniq_space;        
  uintb uniquemask;         
  uintb uniqueoffset;           
  DisassemblyCache *discache;       
  PcodeCacher *cache;           
  void buildEmpty(Constructor *ct,int4 secnum);
  void generateLocation(const VarnodeTpl *vntpl,VarnodeData &vn);
  AddrSpace *generatePointer(const VarnodeTpl *vntpl,VarnodeData &vn);
  void setUniqueOffset(const Address &addr);    
public:
  SleighBuilder(ParserWalker *w,DisassemblyCache *dcache,PcodeCacher *pc,AddrSpace *cspc,AddrSpace *uspc,uint4 umask);
  virtual void appendBuild(OpTpl *bld,int4 secnum);
  virtual void delaySlot(OpTpl *op);
  virtual void setLabel(OpTpl *op);
  virtual void appendCrossBuild(OpTpl *bld,int4 secnum);
};
 
class Sleigh : public SleighBase {
  LoadImage *loader;            
  ContextDatabase *context_db;      
  ContextCache *cache;          
  mutable DisassemblyCache *discache;   
  mutable PcodeCacher pcode_cache;  
  void clearForDelete(void);        
protected:
  ParserContext *obtainContext(const Address &addr,int4 state) const;
  void resolve(ParserContext &pos) const;   
  void resolveHandles(ParserContext &pos) const;    
public:
  Sleigh(LoadImage *ld,ContextDatabase *c_db);      
  virtual ~Sleigh(void);                
  void reset(LoadImage *ld,ContextDatabase *c_db);  
  virtual void initialize(DocumentStorage &store);
  virtual void registerContext(const string &name,int4 sbit,int4 ebit);
  virtual void setContextDefault(const string &nm,uintm val);
  virtual void allowContextSet(bool val) const;
  virtual int4 instructionLength(const Address &baseaddr) const;
  virtual int4 oneInstruction(PcodeEmit &emit,const Address &baseaddr) const;
  virtual int4 printAssembly(AssemblyEmit &emit,const Address &baseaddr) const;
};
 
#endif