SEGSimpleSite.h

/*
 * SEGSimpleSite.h
 *
 * Qingkai
 *
 * This node is to model simple sites.
 */
 
#ifndef IR_SEG_SEGSIMPLESITE_H
#define IR_SEG_SEGSIMPLESITE_H
 
#include <llvm/IR/Instructions.h>
 
#include "Analysis/Bitcode/BitcodeUtils.h"
#include "IR/SEG/SymbolicExprGraph.h"
#include "Persistence/PersistenceBasis.h"
 
using namespace llvm;
 
class PersistedSEGSimpleSite;
 
class PersistedSEGDereferenceSite;
 
class PersistedSEGSEGDivSite;
 
class PersistedSEGCmpSite;
 
class PersistedSEGGEPSite;
 
class PersistedSEGAllocSite;
 
class SEGSimpleSite : public SEGSiteBase {
public:
  SEGSimpleSite(PersistedSEGSimpleSite *Site, SymbolicExprGraph *SEG)
      : SEGSiteBase(Site, SEG) {}
 
  virtual void assembleSEGObject(std::map<int, SEGObject *> &FuncSEGObjMap) {
    SEGSiteBase::assembleSEGObject(FuncSEGObjMap);
  }
 
protected:
  SEGSimpleSite(SEGObjectKind K, Instruction *U, SymbolicExprGraph *G)
      : SEGSiteBase(K, U, G) {}
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() >= SEGOBJK_SimpleSiteBegin &&
           N->getKind() <= SEGOBJK_SimpleSiteEnd;
  }
};
 
class SEGDereferenceSite : public SEGSimpleSite {
public:
  SEGDereferenceSite(PersistedSEGDereferenceSite *Site, SymbolicExprGraph *SEG)
      : SEGSimpleSite(Site, SEG) {}
 
  virtual void assembleSEGObject(std::map<int, SEGObject *> &FuncSEGObjMap) {
    SEGSimpleSite::assembleSEGObject(FuncSEGObjMap);
  }
 
private:
  SEGNodeBase *PtrOp = nullptr;
  SEGNodeBase *ValOp = nullptr;
 
  SEGDereferenceSite(Instruction *U, SymbolicExprGraph *G)
      : SEGSimpleSite(SEGOBJK_DereferenceSite, U, G) {}
 
  friend class SymbolicExprGraph;
  friend class SymbolicExprGraphBuilder;
  friend class IntraFalcon;
  friend class MantaIntraFalcon;
 
  void setPtrOperand(SEGNodeBase *Node) { PtrOp = Node; }
 
  void setValOperand(SEGNodeBase *Node) { ValOp = Node; }
 
public:
  virtual PersistedSEGObject *createPersistedObject() const {
    PersistedSEGObject *PersistedObj = new PersistedSEGDereferenceSite;
    return PersistedObj;
  }
 
  bool deref(const SEGOperandNode *Node) const {
    if (Value *Val = Node->getLLVMValue()) {
      kvec<Value *> DerefPtrs;
      getDerefPtrFromInst(*getInstruction(), DerefPtrs);
      if (DerefPtrs.find(Val) != DerefPtrs.end()) {
        return true;
      }
    }
    return false;
  }
 
  bool isLoad() { return isa<LoadInst>(getInstruction()); }
 
  bool isStore() { return isa<StoreInst>(getInstruction()); }
 
  SEGNodeBase *getPtrOperand() { return PtrOp; }
 
  SEGNodeBase *getValOperand() { return ValOp; }
 
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_DereferenceSite;
  }
};
 
class SEGCmpSite : public SEGSimpleSite {
public:
  SEGCmpSite(PersistedSEGCmpSite *Site, SymbolicExprGraph *SEG)
      : SEGSimpleSite(Site, SEG) {}
 
  virtual void assembleSEGObject(std::map<int, SEGObject *> &FuncSEGObjMap) {
    SEGSimpleSite::assembleSEGObject(FuncSEGObjMap);
  }
 
private:
  SEGCmpSite(Instruction *U, SymbolicExprGraph *G)
      : SEGSimpleSite(SEGOBJK_CmpSite, U, G) {}
 
  ~SEGCmpSite() override = default;
 
  friend class SymbolicExprGraph;
 
public:
  virtual PersistedSEGObject *createPersistedObject() const {
    PersistedSEGObject *PersistedObj = new PersistedSEGCmpSite;
    return PersistedObj;
  }
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_CmpSite;
  }
};
 
class SEGDivSite : public SEGSimpleSite {
public:
  SEGDivSite(PersistedSEGDivSite *Site, SymbolicExprGraph *SEG)
      : SEGSimpleSite(Site, SEG) {}
 
  virtual void assembleSEGObject(std::map<int, SEGObject *> &FuncSEGObjMap) {
    SEGSimpleSite::assembleSEGObject(FuncSEGObjMap);
  }
 
private:
  SEGDivSite(Instruction *U, SymbolicExprGraph *G)
      : SEGSimpleSite(SEGOBJK_DivSite, U, G) {}
 
  friend class SymbolicExprGraph;
 
public:
  virtual PersistedSEGObject *createPersistedObject() const {
    PersistedSEGObject *PersistedObj = new PersistedSEGDivSite;
    return PersistedObj;
  }
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_DivSite;
  }
};
 
class SEGGEPSite : public SEGSimpleSite {
public:
  SEGGEPSite(PersistedSEGGEPSite *Site, SymbolicExprGraph *SEG)
      : SEGSimpleSite(Site, SEG) {}
 
  virtual void assembleSEGObject(std::map<int, SEGObject *> &FuncSEGObjMap) {
    SEGSimpleSite::assembleSEGObject(FuncSEGObjMap);
  }
 
private:
  SEGNodeBase *PtrOp = nullptr;
  std::vector<SEGNodeBase *> OffsetOps;
 
  SEGGEPSite(Instruction *U, SymbolicExprGraph *G)
      : SEGSimpleSite(SEGOBJK_GEPSite, U, G) {}
 
  friend class SymbolicExprGraph;
  friend class SymbolicExprGraphBuilder;
 
  void setPtrOperand(SEGNodeBase *N) { PtrOp = N; }
 
  void addOffsetOperand(SEGNodeBase *N) { OffsetOps.emplace_back(N); }
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_GEPSite;
  }
 
  Instruction *GEPUsedInstruction() const {
    auto *SiteNode = getParentGraph()->findNode(getInstruction());
    for (auto It = SiteNode->use_site_begin(); It != SiteNode->use_site_end();
         It++) {
      auto I = (*It)->getInstruction();
      auto OpCode = I->getOpcode();
      if (OpCode == Instruction::Load || OpCode == Instruction::Store) {
        return I;
      }
    }
    return nullptr;
  }
 
  virtual PersistedSEGObject *createPersistedObject() const {
    PersistedSEGObject *PersistedObj = new PersistedSEGGEPSite;
    return PersistedObj;
  }
 
  SEGNodeBase *getPtrOperand() { return PtrOp; }
  std::vector<SEGNodeBase *> &getOffsetOperands() { return OffsetOps; }
};
 
class SEGAllocSite : public SEGSimpleSite {
public:
  SEGAllocSite(PersistedSEGAllocSite *Site, SymbolicExprGraph *SEG)
      : SEGSimpleSite(Site, SEG) {}
 
  virtual void assembleSEGObject(std::map<int, SEGObject *> &FuncSEGObjMap) {
    SEGSimpleSite::assembleSEGObject(FuncSEGObjMap);
  }
 
private:
  SEGAllocSite(Instruction *U, SymbolicExprGraph *G)
      : SEGSimpleSite(SEGOBJK_AllocSite, U, G) {}
 
  friend class SymbolicExprGraph;
 
public:
  virtual PersistedSEGObject *createPersistedObject() const {
    PersistedSEGObject *PersistedObj = new PersistedSEGAllocSite;
    return PersistedObj;
  }
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_AllocSite;
  }
};
 
#endif