SEGReturnNode.h

/*
 * SEGReturnNode.h
 *
 * Qingkai
 *
 * This node is to model a super return that merge all returned value.
 */
 
#ifndef IR_SEG_SEGRETURNNODE_H
#define IR_SEG_SEGRETURNNODE_H
 
#include <llvm/IR/BasicBlock.h>
 
#include <unordered_map>
#include <unordered_set>
 
#include "CBAccessPath.h"
#include "IR/SEG/SymbolicExprGraph.h"
 
using namespace llvm;
 
class SEGReturnSite;
 
class SEGReturnNode : public SEGOperandNode {
  friend class SEGSerializer;
  friend class SEGHash;
 
protected:
  std::unordered_set<SEGReturnSite *> RetInsts;
  std::unordered_map<const SEGNodeBase *, SEGReturnSite *> RetNodeSiteMap;
 
  SEGReturnNode(SEGObjectKind, Type *Ty, SymbolicExprGraph *SEG, BasicBlock *BB,
                bool fromDisk);
  SEGReturnNode(SEGObjectKind, Value *Val, Type *Ty, SymbolicExprGraph *SEG,
                BasicBlock *BB, bool fromDisk);
 
  friend class SymbolicExprGraph;
 
public:
  virtual ~SEGReturnNode();
 
  void addReturnNodeSitePair(const SEGNodeBase *Node, SEGReturnSite *Site);
 
  SEGReturnSite *getReturnSite(const SEGNodeBase *Node) const;
 
  decltype(RetNodeSiteMap)::const_iterator returnNodeSiteBegin() const {
    return RetNodeSiteMap.begin();
  }
 
  decltype(RetNodeSiteMap)::const_iterator returnNodeSiteEnd() const {
    return RetNodeSiteMap.end();
  }
 
  virtual int64_t getIndex() const = 0;
 
public:
  static bool classof(const SEGObject *O) {
    return O->getKind() >= SEGOBJK_ReturnBegin &&
           O->getKind() <= SEGOBJK_ReturnEnd;
  }
};
 
class SEGCommonReturnNode : public SEGReturnNode {
 
private:
  SEGCommonReturnNode(Type *Ty, SymbolicExprGraph *SEG, BasicBlock *BB,
                      bool fromDisk);
 
  friend class SymbolicExprGraph;
 
public:
  virtual int64_t getIndex() const {
    assert(false);
    return 0;
  }
 
public:
  static bool classof(const SEGObject *O) {
    return O->getKind() == SEGOBJK_CommonReturn;
  }
};
 
class SEGPseudoReturnNode : public SEGReturnNode {
private:
  // set by SEG
  int64_t Index = -1;
 
  CBAccessPath AP;
 
  SEGPseudoReturnNode(Value *Val, Type *Ty, SymbolicExprGraph *SEG,
                      BasicBlock *BB, bool fromDisk);
 
  friend class SymbolicExprGraph;
  friend class SEGSerializer;
 
public:
  virtual int64_t getIndex() const { return Index; }
 
  const CBAccessPath &getAccessPath() const { return AP; }
 
  CBAccessPath &getAccessPath() { return AP; }
 
public:
  static bool classof(const SEGObject *O) {
    return O->getKind() == SEGOBJK_PseudoReturn;
  }
};
 
#endif