op.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_OP__
#define __CPUI_OP__

#include "typeop.hh"

class IopSpace : public AddrSpace {
public:
  IopSpace(AddrSpaceManager *m,const Translate *t,const string &nm,int4 ind);
  virtual void saveXmlAttributes(ostream &s,uintb offset) const { s << " space=\"iop\""; }
  virtual void saveXmlAttributes(ostream &s,uintb offset,int4 size) const { s << " space=\"iop\""; }
  virtual void printRaw(ostream &s,uintb offset) const;
  virtual void saveXml(ostream &s) const;
  virtual void restoreXml(const Element *el);
};


class PcodeOp {
  friend class BlockBasic; // Just insert_before, insert_after, setOrder
  friend class Funcdata;
  friend class PcodeOpBank;
  friend class VarnodeBank;    // Only uses setInput
public:
  enum {
    startbasic = 1,     
    branch = 2,         
    call = 4,           
    returns = 0x8,      
    nocollapse = 0x10,      
    dead = 0x20,        
    marker = 0x40,          
    booloutput = 0x80,      
    boolean_flip = 0x100,   
    fallthru_true = 0x200,  
    indirect_source = 0x400,    
    coderef = 0x800,        
    startmark = 0x1000,     
    mark = 0x2000,      
    commutative = 0x4000,   
    unary = 0x8000,     
    binary = 0x10000,       
    special = 0x20000,      
    floatingpoint = 0x40000,    
    splittingbranch = 0x80000,  
    nonprinting = 0x100000, 
    halt = 0x200000,        
    badinstruction = 0x400000,  
    unimplemented = 0x800000,   
    noreturn = 0x1000000,   
    missing = 0x2000000,    
    spacebase_ptr = 0x4000000,  
    indirect_creation = 0x8000000,  
    calculated_bool = 0x10000000, 
    is_cpool_transformed = 0x20000000, 
    ptrflow = 0x40000000,   
    indirect_store = 0x80000000 
  };
  enum {
    has_thisptr = 0x1,      
    is_constructor = 0x2,   
    is_destructor = 0x4,    
    special_prop = 0x8,     
    special_print = 0x10,   
    modified = 0x20,        
    warning = 0x40,     
    incidental_copy = 0x80  
  };
private:
  TypeOp *opcode;       
  mutable uint4 flags;      
  mutable uint4 addlflags;  
  SeqNum start;                 
  BlockBasic *parent;           
  list<PcodeOp *>::iterator basiciter;  
  list<PcodeOp *>::iterator insertiter; 
  list<PcodeOp *>::iterator codeiter;   
  Varnode *output;      
  vector<Varnode *> inrefs; 

  // Only used by Funcdata
  void setOpcode(TypeOp *t_op); 
  void setOutput(Varnode *vn) { output = vn; } 
  void clearInput(int4 slot) { inrefs[slot] = (Varnode *)0; } 
  void setInput(Varnode *vn,int4 slot) { inrefs[slot] = vn; } 
  void setFlag(uint4 fl) { flags |= fl; } 
  void clearFlag(uint4 fl) { flags &= ~fl; } 
  void setAdditionalFlag(uint4 fl) { addlflags |= fl; } 
  void clearAdditionalFlag(uint4 fl) { addlflags &= ~fl; } 
  void flipFlag(uint4 fl) { flags ^= fl; } 
  void setNumInputs(int4 num);  
  void removeInput(int4 slot);  
  void insertInput(int4 slot);  
  void setOrder(uintm ord) { start.setOrder(ord); } 
  void setParent(BlockBasic *p) { parent = p; } 
  void setBasicIter(list<PcodeOp *>::iterator iter) { basiciter = iter; } 

public:
  PcodeOp(int4 s,const SeqNum &sq); 
  ~PcodeOp(void) {}     
  int4 numInput(void) const { return inrefs.size(); } 
  Varnode *getOut(void) { return output; } 
  const Varnode *getOut(void) const { return (const Varnode *) output; } 
  Varnode *getIn(int4 slot) { return inrefs[slot]; } 
  const Varnode *getIn(int4 slot) const { return (const Varnode *) inrefs[slot]; } 
  const BlockBasic *getParent(void) const { return (const BlockBasic *) parent; } 
  BlockBasic *getParent(void) { return parent; } 
  const Address &getAddr(void) const { return start.getAddr(); } 
  uintm getTime(void) const { return start.getTime(); } 
  const SeqNum &getSeqNum(void) const { return start; } 
  list<PcodeOp *>::iterator getInsertIter(void) const { return insertiter; } 
  list<PcodeOp *>::iterator getBasicIter(void) const { return basiciter; } 
  int4 getSlot(const Varnode *vn) const { int4 i,n; n=inrefs.size(); for(i=0;i<n;++i) if (inrefs[i]==vn) break; return i; }
  int4 getRepeatSlot(const Varnode *vn,int4 firstSlot,list<PcodeOp *>::const_iterator iter) const;
  uint4 getEvalType(void) const { return (flags&(PcodeOp::unary|PcodeOp::binary|PcodeOp::special)); }
  uint4 getHaltType(void) const { return (flags&(PcodeOp::halt|PcodeOp::badinstruction|PcodeOp::unimplemented|
                          PcodeOp::noreturn|PcodeOp::missing)); }
  bool isDead(void) const { return ((flags&PcodeOp::dead)!=0); } 
  bool isAssignment(void) const { return (output!=(Varnode *)0); } 
  bool isCall(void) const { return ((flags&PcodeOp::call)!=0); } 
  bool isMarker(void) const { return ((flags&PcodeOp::marker)!=0); } 
  bool isIndirectCreation(void) const { return ((flags&PcodeOp::indirect_creation)!=0); } 
  bool isIndirectStore(void) const { return ((flags&PcodeOp::indirect_store)!=0); } 
  bool notPrinted(void) const { return ((flags&(PcodeOp::marker|PcodeOp::nonprinting|PcodeOp::noreturn))!=0); }
  bool isBoolOutput(void) const { return ((flags&PcodeOp::booloutput)!=0); }
  bool isBranch(void) const { return ((flags&PcodeOp::branch)!=0); } 
  bool isCallOrBranch(void) const { return ((flags&(PcodeOp::branch|PcodeOp::call))!=0); }
  bool isFlowBreak(void) const { return ((flags&(PcodeOp::branch|PcodeOp::returns))!=0); }
  bool isBooleanFlip(void) const { return ((flags&PcodeOp::boolean_flip)!=0); }
  bool isFallthruTrue(void) const { return ((flags&PcodeOp::fallthru_true)!=0); }
  bool isCodeRef(void) const { return ((flags&PcodeOp::coderef)!=0); } 
  bool isInstructionStart(void) const { return ((flags&PcodeOp::startmark)!=0); } 
  bool isBlockStart(void) const { return ((flags&PcodeOp::startbasic)!=0); } 
  bool isModified(void) const { return ((addlflags&PcodeOp::modified)!=0); } 
  bool isMark(void) const { return ((flags&PcodeOp::mark)!=0); } 
  void setMark(void) const { flags |= PcodeOp::mark; } 
  bool isWarning(void) const { return ((addlflags&PcodeOp::warning)!=0); } 
  void clearMark(void) const { flags &= ~PcodeOp::mark; } 
  bool isIndirectSource(void) const { return ((flags&PcodeOp::indirect_source)!=0); } 
  void setIndirectSource(void) { flags |= PcodeOp::indirect_source; } 
  void clearIndirectSource(void) { flags &= ~PcodeOp::indirect_source; } 
  bool isPtrFlow(void) const { return ((flags&PcodeOp::ptrflow)!=0); } 
  void setPtrFlow(void) { flags |= PcodeOp::ptrflow; } 
  bool isSplitting(void) const { return ((flags&PcodeOp::splittingbranch)!=0); } 
  bool doesSpecialPropagation(void) const { return ((addlflags&PcodeOp::special_prop)!=0); } 
  bool doesSpecialPrinting(void) const { return ((addlflags&PcodeOp::special_print)!=0); } 
  bool hasThisPointer(void) const { return ((addlflags&PcodeOp::has_thisptr)!=0); } 
  bool isConstructor(void) const { return ((addlflags&PcodeOp::is_constructor)!=0); } 
  bool isDestructor(void) const { return ((addlflags&PcodeOp::is_destructor)!=0); } 
  bool isIncidentalCopy(void) const { return ((addlflags&PcodeOp::incidental_copy)!=0); } 
  bool isCalculatedBool(void) const { return ((flags&(PcodeOp::calculated_bool|PcodeOp::booloutput))!=0); }
  bool isCpoolTransformed(void) const { return ((flags&PcodeOp::is_cpool_transformed)!=0); }
  bool isCollapsible(void) const; 
  bool usesSpacebasePtr(void) const { return ((flags&PcodeOp::spacebase_ptr)!=0); }
  uintm getCseHash(void) const; 
  bool isCseMatch(const PcodeOp *op) const; 
  TypeOp *getOpcode(void) const { return opcode; } 
  OpCode code(void) const { return opcode->getOpcode(); } 
  bool isCommutative(void) const { return ((flags & PcodeOp::commutative)!=0); } 
  uintb collapse(bool &markedInput) const;  
  void collapseConstantSymbol(Varnode *newConst) const; 
  PcodeOp *nextOp(void) const;  
  PcodeOp *previousOp(void) const; 
  PcodeOp *target(void) const;  
  uintb getNZMaskLocal(bool cliploop) const; 
  int4 compareOrder(const PcodeOp *bop) const; 
  void printRaw(ostream &s) const { opcode->printRaw(s,this); } 
  const string &getOpName(void) const { return opcode->getName(); } 
  void printDebug(ostream &s) const; 
  void saveXml(ostream &s) const; 
  static PcodeOp *getOpFromConst(const Address &addr) { return (PcodeOp *)(uintp)addr.getOffset(); }

  Datatype *outputTypeLocal(void) const { return opcode->getOutputLocal(this); } 
  Datatype *inputTypeLocal(int4 slot) const { return opcode->getInputLocal(this,slot); }    
  bool markExplicitUnsigned(int4 slot) { return opcode->markExplicitUnsigned(this,slot); } 
  bool inheritsSign(void) const { return opcode->inheritsSign(); } 
};

typedef map<SeqNum,PcodeOp *> PcodeOpTree;

class PcodeOpBank {
  PcodeOpTree optree;           
  list<PcodeOp *> deadlist;     
  list<PcodeOp *> alivelist;        
  list<PcodeOp *> storelist;        
  list<PcodeOp *> returnlist;       
  list<PcodeOp *> useroplist;       
  list<PcodeOp *> deadandgone;      
  uintm uniqid;             
  void addToCodeList(PcodeOp *op);  
  void removeFromCodeList(PcodeOp *op); 
  void clearCodeLists(void);        
public:
  void clear(void);                 
  PcodeOpBank(void) { uniqid = 0; }         
  ~PcodeOpBank(void) { clear(); }           
  void setUniqId(uintm val) { uniqid = val; }       
  uintm getUniqId(void) const { return uniqid; }    
  PcodeOp *create(int4 inputs,const Address &pc);   
  PcodeOp *create(int4 inputs,const SeqNum &sq);    
  void destroy(PcodeOp *op);                
  void destroyDead(void);               
  void changeOpcode(PcodeOp *op,TypeOp *newopc);    
  void markAlive(PcodeOp *op);              
  void markDead(PcodeOp *op);               
  void insertAfterDead(PcodeOp *op,PcodeOp *prev);  
  void moveSequenceDead(PcodeOp *firstop,PcodeOp *lastop,PcodeOp *prev);
  void markIncidentalCopy(PcodeOp *firstop,PcodeOp *lastop);    
  bool empty(void) const { return optree.empty(); } 
  PcodeOp *target(const Address &addr) const;       
  PcodeOp *findOp(const SeqNum &num) const;     
  PcodeOp *fallthru(const PcodeOp *op) const;       

  PcodeOpTree::const_iterator beginAll(void) const { return optree.begin(); }

  PcodeOpTree::const_iterator endAll(void) const { return optree.end(); }

  PcodeOpTree::const_iterator begin(const Address &addr) const;

  PcodeOpTree::const_iterator end(const Address &addr) const;

  list<PcodeOp *>::const_iterator beginAlive(void) const { return alivelist.begin(); }

  list<PcodeOp *>::const_iterator endAlive(void) const { return alivelist.end(); }

  list<PcodeOp *>::const_iterator beginDead(void) const { return deadlist.begin(); }

  list<PcodeOp *>::const_iterator endDead(void) const { return deadlist.end(); }

  list<PcodeOp *>::const_iterator begin(OpCode opc) const;

  list<PcodeOp *>::const_iterator end(OpCode opc) const;
};

extern int4 functionalEqualityLevel(Varnode *vn1,Varnode *vn2,Varnode **res1,Varnode **res2);
extern bool functionalEquality(Varnode *vn1,Varnode *vn2);
extern bool functionalDifference(Varnode *vn1,Varnode *vn2,int4 depth);

#endif