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"
 
using namespace llvm;
 
class SEGSimpleSite : public SEGSiteBase {
protected:
  SEGSimpleSite(SEGObjectKind K, Instruction *U, SymbolicExprGraph *G,
                bool fromDisk)
      : SEGSiteBase(K, U, G, fromDisk) {}
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() >= SEGOBJK_SimpleSiteBegin &&
           N->getKind() <= SEGOBJK_SimpleSiteEnd;
  }
};
 
class SEGDereferenceSite : public SEGSimpleSite {
private:
  SEGNodeBase *PtrOp = nullptr;
  SEGNodeBase *ValOp = nullptr;
 
  SEGDereferenceSite(Instruction *U, SymbolicExprGraph *G, bool fromDisk)
      : SEGSimpleSite(SEGOBJK_DereferenceSite, U, G, fromDisk) {}
 
  friend class SymbolicExprGraph;
  friend class SymbolicExprGraphBuilder;
  friend class OCValueFlowBuilder;
  friend class IntraFalcon;
  friend class MantaIntraFalcon;
  friend class SEGSerializer;
 
  void setPtrOperand(SEGNodeBase *Node) { PtrOp = Node; }
 
  void setValOperand(SEGNodeBase *Node) { ValOp = Node; }
 
public:
  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() const { return PtrOp; }
 
  SEGNodeBase *getValOperand() const { return ValOp; }
 
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_DereferenceSite;
  }
};
 
class SEGCmpSite : public SEGSimpleSite {
private:
  SEGCmpSite(Instruction *U, SymbolicExprGraph *G, bool fromDisk)
      : SEGSimpleSite(SEGOBJK_CmpSite, U, G, fromDisk) {}
 
  ~SEGCmpSite() override = default;
 
  friend class SymbolicExprGraph;
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_CmpSite;
  }
};
 
class SEGDivSite : public SEGSimpleSite {
private:
  SEGDivSite(Instruction *U, SymbolicExprGraph *G, bool fromDisk)
      : SEGSimpleSite(SEGOBJK_DivSite, U, G, fromDisk) {}
 
  friend class SymbolicExprGraph;
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_DivSite;
  }
};
 
class SEGGEPSite : public SEGSimpleSite {
private:
  SEGNodeBase *PtrOp = nullptr;
  std::vector<SEGNodeBase *> OffsetOps;
 
  SEGGEPSite(Instruction *U, SymbolicExprGraph *G, bool fromDisk)
      : SEGSimpleSite(SEGOBJK_GEPSite, U, G, fromDisk) {}
 
  friend class SymbolicExprGraph;
  friend class SymbolicExprGraphBuilder;
  friend class OCValueFlowBuilder;
  friend class SEGSerializer;
 
  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;
  }
 
  SEGNodeBase *getPtrOperand() const { return PtrOp; }
  std::vector<SEGNodeBase *> &getOffsetOperands() { return OffsetOps; }
};
 
class SEGAllocSite : public SEGSimpleSite {
private:
  SEGAllocSite(Instruction *U, SymbolicExprGraph *G, bool fromDisk)
      : SEGSimpleSite(SEGOBJK_AllocSite, U, G, fromDisk) {}
 
  friend class SymbolicExprGraph;
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_AllocSite;
  }
};
 
#endif