transform.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 __TRANSFORM__
#define __TRANSFORM__

#include "varnode.hh"
class Funcdata;         // Forward declaration
class TransformOp;

class TransformVar {
  friend class TransformManager;
  friend class TransformOp;
public:
  enum {
    piece = 1,          
    preexisting = 2,        
    normal_temp = 3,        
    piece_temp = 4,     
    constant = 5,       
    constant_iop = 6,       
  };
  enum {
    split_terminator = 1,   
    input_duplicate = 2     
  };
private:
  Varnode *vn;          
  Varnode *replacement;     
  uint4 type;           
  uint4 flags;          
  int4 byteSize;        
  int4 bitSize;         
  uintb val;            
  TransformOp *def;     
  void createReplacement(Funcdata *fd); 
  void initialize(uint4 tp,Varnode *v,int4 bits,int4 bytes,uintb value);
public:
  Varnode *getOriginal(void) const { return vn; }   
  TransformOp *getDef(void) const { return def; }   
};

class TransformOp {
  friend class TransformManager;
  friend class TransformVar;
public:
  enum {
    op_replacement = 1,     
    op_preexisting = 2,     
    indirect_creation = 4,  
    indirect_creation_possible_out = 8  
  };
private:
  PcodeOp *op;          
  PcodeOp *replacement;     
  OpCode opc;           
  uint4 special;        
  TransformVar *output; 
  vector<TransformVar *> input; 
  TransformOp *follow;      
  void createReplacement(Funcdata *fd); 
  bool attemptInsertion(Funcdata *fd);  
public:
  TransformVar *getOut(void) const { return output; }   
  TransformVar *getIn(int4 i) const { return input[i]; }    
};

class LanedRegister {
  friend class LanedIterator;
public:
  class LanedIterator {
    int4 size;      
    uint4 mask;     
    void normalize(void);   
  public:
    LanedIterator(const LanedRegister *lanedR) { size = 0; mask = lanedR->sizeBitMask; normalize(); }   
    LanedIterator(void) { size = -1; mask = 0; }    
    LanedIterator &operator++(void) { size += 1; normalize(); return *this; }   
    int4 operator*(void) const { return size; }     
    LanedIterator &operator=(const LanedIterator &op2) { size = op2.size; mask = op2.mask; return *this; }  
    bool operator==(const LanedIterator &op2) const { return (size == op2.size); }  
    bool operator!=(const LanedIterator &op2) const { return (size != op2.size); }  
  };
  typedef LanedIterator const_iterator;     
private:
  int4 wholeSize;       
  uint4 sizeBitMask;        
public:
  LanedRegister(void) { wholeSize = 0; sizeBitMask = 0; }   
  LanedRegister(int4 sz,uint4 mask) { wholeSize = sz; sizeBitMask = mask; } 
  bool restoreXml(const Element *el,const AddrSpaceManager *manage);    
  int4 getWholeSize(void) const { return wholeSize; }   
  uint4 getSizeBitMask(void) const { return sizeBitMask; }  
  void addLaneSize(int4 size) { sizeBitMask |= ((uint4)1 << size); }    
  bool allowedLane(int4 size) const { return (((sizeBitMask >> size) & 1) != 0); }  
  const_iterator begin(void) const { return LanedIterator(this); }  
  const_iterator end(void) const { return LanedIterator(); }    
};

class LaneDescription {
  int4 wholeSize;       
  vector<int4> laneSize;    
  vector<int4> lanePosition;    
public:
  LaneDescription(const LaneDescription &op2);  
  LaneDescription(int4 origSize,int4 sz);   
  LaneDescription(int4 origSize,int4 lo,int4 hi);   
  bool subset(int4 lsbOffset,int4 size);    
  int4 getNumLanes(void) const { return laneSize.size(); }  
  int4 getWholeSize(void) const { return wholeSize; }       
  int4 getSize(int4 i) const { return laneSize[i]; }        
  int4 getPosition(int4 i) const { return lanePosition[i]; }    
  int4 getBoundary(int4 bytePos) const;     
  bool restriction(int4 numLanes,int4 skipLanes,int4 bytePos,int4 size,int4 &resNumLanes,int4 &resSkipLanes) const;
  bool extension(int4 numLanes,int4 skipLanes,int4 bytePos,int4 size,int4 &resNumLanes,int4 &resSkipLanes) const;
};

class TransformManager {
  Funcdata *fd;                 
  map<int4,TransformVar *> pieceMap;        
  list<TransformVar> newVarnodes;       
  list<TransformOp> newOps;         

  void specialHandling(TransformOp &rop);
  void createOps(void);     
  void createVarnodes(vector<TransformVar *> &inputList);   
  void removeOld(void);     
  void transformInputVarnodes(vector<TransformVar *> &inputList);   
  void placeInputs(void);   
public:
  TransformManager(Funcdata *f) { fd = f; } 
  virtual ~TransformManager(void);      
  virtual bool preserveAddress(Varnode *vn,int4 bitSize,int4 lsbOffset) const;
  Funcdata *getFunction(void) const { return fd; }  
  void clearVarnodeMarks(void);         
  TransformVar *newPreexistingVarnode(Varnode *vn); 
  TransformVar *newUnique(int4 size);       
  TransformVar *newConstant(int4 size,int4 lsbOffset,uintb val);    
  TransformVar *newIop(Varnode *vn);    
  TransformVar *newPiece(Varnode *vn,int4 bitSize,int4 lsbOffset);  
  TransformVar *newSplit(Varnode *vn,const LaneDescription &description);
  TransformVar *newSplit(Varnode *vn,const LaneDescription &description,int4 numLanes,int4 startLane);
  TransformOp *newOpReplace(int4 numParams,OpCode opc,PcodeOp *replace);
  TransformOp *newOp(int4 numParams,OpCode opc,TransformOp *follow);
  TransformOp *newPreexistingOp(int4 numParams,OpCode opc,PcodeOp *originalOp);

  TransformVar *getPreexistingVarnode(Varnode *vn); 
  TransformVar *getPiece(Varnode *vn,int4 bitSize,int4 lsbOffset);  
  TransformVar *getSplit(Varnode *vn,const LaneDescription &description);
  TransformVar *getSplit(Varnode *vn,const LaneDescription &description,int4 numLanes,int4 startLane);
  void opSetInput(TransformOp *rop,TransformVar *rvn,int4 slot);    
  void opSetOutput(TransformOp *rop,TransformVar *rvn);     
  static bool preexistingGuard(int4 slot,TransformVar *rvn);    

  void apply(void);     
};

inline void TransformVar::initialize(uint4 tp,Varnode *v,int4 bits,int4 bytes,uintb value)

{
  type = tp;
  vn = v;
  val = value;
  bitSize = bits;
  byteSize = bytes;
  flags = 0;
  def = (TransformOp *)0;
  replacement = (Varnode *)0;
}

inline void TransformManager::opSetInput(TransformOp *rop,TransformVar *rvn,int4 slot)

{
  rop->input[slot] = rvn;
}

inline void TransformManager::opSetOutput(TransformOp *rop,TransformVar *rvn)

{
  rop->output = rvn;
  rvn->def = rop;
}

inline bool TransformManager::preexistingGuard(int4 slot,TransformVar *rvn)

{
  if (slot == 0) return true;   // If we came in on the first slot, build the TransformOp
  if (rvn->type == TransformVar::piece || rvn->type == TransformVar::piece_temp)
    return false;       // The op was/will be visited on slot 0, don't create TransformOp now
  return true;          // The op was not (will not be) visited on slot 0, build now
}

#endif