SEGCallSitePseudoInputNode.h

/*
 * SEGCallSitePseudoInputNode.h
 *
 * Zhou Jinguo
 *
 * 2016.5.19
 *
 * This node is to model the pseudo input of a call site.
 */
 
#ifndef IR_SEG_SEGCALLSITEPSEUDOINPUTNODE_H
#define IR_SEG_SEGCALLSITEPSEUDOINPUTNODE_H
 
#include <llvm/IR/BasicBlock.h>
#include <llvm/IR/CallSite.h>
#include <llvm/IR/Constants.h>
#include <llvm/IR/Function.h>
#include <llvm/IR/Instructions.h>
#include <llvm/IR/Value.h>
#include <llvm/Support/FileSystem.h>
#include <llvm/Support/Format.h>
#include <llvm/Support/raw_ostream.h>
 
#include "CBAccessPath.h"
#include "IR/SEG/SymbolicExprGraph.h"
#include "Persistence/PersistenceBasis.h"
 
using namespace llvm;
 
class SEGCallSitePseudoInputNode : public SEGOperandNode {
public:
  SEGCallSitePseudoInputNode(PersistedSEGCallSitePseudoInputNode *Node,
                             SymbolicExprGraph *SEG)
      : SEGOperandNode(Node, SEG) {
    this->index = Node->getIndex();
    auto *WrappedMod = SEG->getWrappedMod();
    this->WrappedCallee = dyn_cast<WrappedFunction>(
        WrappedMod->findWrappedValue(Node->getCalleeFunctionID()));
    this->WrappedCallSiteInst = dyn_cast<WrappedInstruction>(
        WrappedMod->findWrappedValue(Node->getCallSiteInstructionID()));
    if (this->WrappedCallee) {
      if (Function *callee = this->WrappedCallee->getRealFunc())
        this->Callee = callee;
    }
    if (this->WrappedCallSiteInst) {
      if (Instruction *CSI = this->WrappedCallSiteInst->getRealInstruction())
        this->LLVMCS = CallSite(CSI);
    }
  }
 
  virtual void assembleSEGObject(std::map<int, SEGObject *> &FuncSEGObjMap) {
    SEGOperandNode::assembleSEGObject(FuncSEGObjMap);
  }
 
protected:
  CallSite LLVMCS;
  WrappedInstruction *WrappedCallSiteInst = nullptr;
 
  Function *Callee = nullptr;
  WrappedFunction *WrappedCallee = nullptr;
 
  SEGCallSitePseudoInputNode(CallSite CS, Function *Callee, Value *Val,
                             Type *Ty, SymbolicExprGraph *SEG, BasicBlock *BB)
      : SEGOperandNode(SEGOBJK_CallSitePseudoInput, Val, Ty, SEG, BB),
        LLVMCS(CS), Callee(Callee), index(-1) {
    access_path.reset(Val);
    WrappedCallee = WrappedValue::findWrappedFunction(Callee);
    WrappedCallSiteInst =
        WrappedValue::findWrappedInstruction(CS.getInstruction());
  }
 
  friend class SymbolicExprGraph;
  friend class SEGCallSite;
 
  CBAccessPath access_path;
 
  int index;
 
public:
  ~SEGCallSitePseudoInputNode() {}
 
  virtual PersistedSEGObject *createPersistedObject() const {
    PersistedSEGObject *PersistedObj = new PersistedSEGCallSitePseudoInputNode;
    return PersistedObj;
  }
 
  CallSite getCallSite() const { return LLVMCS; }
 
  WrappedCallSite getWrappedCallSite() const {
    return WrappedCallSite(WrappedCallSiteInst);
  }
 
  WrappedInstruction *getWrappedCallSiteInst() const {
    return WrappedCallSiteInst;
  }
 
  Function *getCallee() const { return Callee; }
 
  WrappedFunction *getWrappedCallee() const { return WrappedCallee; }
 
  virtual size_t getIndex() const { return index; }
 
  const CBAccessPath &getAccessPath() const { return access_path; }
 
  CBAccessPath &getAccessPath() { return access_path; }
 
  virtual std::string getSrcFile() const {
    if (WrappedCallSiteInst) {
      return WrappedCallSiteInst->getSrcFileName();
    }
    return SEGNodeBase::getSrcFile();
  }
 
  virtual std::int32_t getSrcLine() const {
    if (WrappedCallSiteInst) {
      return WrappedCallSiteInst->getSrcLine();
    }
    return SEGNodeBase::getSrcLine();
  }
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_CallSitePseudoInput;
  }
};
 
#endif