sleigh.hh

/* ###
 * 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; // Record containing relative offset
  uintb calling_index;      // Index of instruction containing relative offset
};

struct PcodeData { // Data for building one pcode instruction
  OpCode opc;
  VarnodeData *outvar;       // Points to outvar is there is an output
  VarnodeData *invar;       // Inputs
  int4 isize;           // Number of inputs
};

class PcodeCacher { // Cached chunk of pcode, prior to emitting
  VarnodeData *poolstart;
  VarnodeData *curpool;
  VarnodeData *endpool;
  vector<PcodeData> issued;
  list<RelativeRecord> label_refs; // References to labels
  vector<uintb> labels;     // Locations of 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.push_back(PcodeData());
    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;        // Can call getParserContext this many times, before a ParserContext is reused
  uint4 mask;           // Size of the hashtable in form 2^n-1
  ParserContext **list;     // (circular) array of currently cached ParserContext objects
  int4 nextfree;        // Current end/beginning of circular list
  ParserContext **hashtable;    // Hashtable for looking up ParserContext via Address
  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