SEGArgumentNode.h

/*
 * SEGArgumentNode.h
 *
 * Qingkai
 *
 * This node is to model arguments of a function.
 */
 
#ifndef IR_SEG_SEGARGUMENTNODE_H
#define IR_SEG_SEGARGUMENTNODE_H
 
#include <llvm/IR/BasicBlock.h>
 
#include "CBAccessPath.h"
#include "IR/SEG/SymbolicExprGraph.h"
#include "Persistence/PersistenceBasis.h"
using namespace llvm;
 
class SEGArgumentNode : public SEGOperandNode {
public:
  SEGArgumentNode(PersistedSEGArgumentNode *Node, SymbolicExprGraph *SEG)
      : SEGOperandNode(Node, SEG) {}
 
  virtual void assembleSEGObject(std::map<int, SEGObject *> &FuncSEGObjMap) {
    SEGOperandNode::assembleSEGObject(FuncSEGObjMap);
  }
 
protected:
  SEGArgumentNode(SEGObjectKind NTy, Type *Ty, SymbolicExprGraph *SEG,
                  BasicBlock *BB)
      : SEGOperandNode(NTy, Ty, SEG, BB) {}
 
  SEGArgumentNode(SEGObjectKind NTy, Value *Val, Type *Ty,
                  SymbolicExprGraph *SEG, BasicBlock *BB)
      : SEGOperandNode(NTy, Val, Ty, SEG, BB) {}
 
  ~SEGArgumentNode() {}
 
  friend class SymbolicExprGraph;
 
public:
  virtual size_t getIndex() const = 0;
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() >= SEGOBJK_ArgumentBegin &&
           N->getKind() <= SEGOBJK_ArgumentEnd;
  }
};
 
class SEGCommonArgumentNode : public SEGArgumentNode {
public:
  SEGCommonArgumentNode(PersistedSEGCommonArgumentNode *Node,
                        SymbolicExprGraph *SEG)
      : SEGArgumentNode(Node, SEG) {
    this->Index = Node->getIndex();
  }
 
  virtual void assembleSEGObject(std::map<int, SEGObject *> &FuncSEGObjMap) {
    SEGArgumentNode::assembleSEGObject(FuncSEGObjMap);
  }
 
private:
  // The index is set by SEG
  size_t Index = -1;
 
  SEGCommonArgumentNode(Type *Ty, SymbolicExprGraph *SEG, BasicBlock *BB)
      : SEGArgumentNode(SEGOBJK_CommonArgument, Ty, SEG, BB) {
    std::string Desc(std::string("carg_") + this->getDescription());
    this->setDescription(Desc);
  }
 
  SEGCommonArgumentNode(Value *Val, Type *Ty, SymbolicExprGraph *SEG,
                        BasicBlock *BB)
      : SEGArgumentNode(SEGOBJK_CommonArgument, Val, Ty, SEG, BB) {
    std::string Desc(std::string("carg_") + this->getDescription());
    this->setDescription(Desc);
  }
 
  friend class SymbolicExprGraph;
 
public:
  virtual ~SEGCommonArgumentNode() {}
 
  virtual PersistedSEGObject *createPersistedObject() const {
    PersistedSEGObject *PersistedObj = new PersistedSEGCommonArgumentNode;
    return PersistedObj;
  }
 
  virtual size_t getIndex() const {
    assert(Index != (size_t)-1 && "Index of a common argument is not set!");
    return Index;
  }
 
  virtual std::string getAuxiliaryDebugStr() const {
    return "the index of this common argument is " + std::to_string(Index);
  }
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_CommonArgument;
  }
};
 
class SEGVarArgumentNode : public SEGArgumentNode {
public:
  SEGVarArgumentNode(PersistedSEGVarArgumentNode *Node, SymbolicExprGraph *SEG)
      : SEGArgumentNode(Node, SEG) {}
 
  virtual void assembleSEGObject(std::map<int, SEGObject *> &FuncSEGObjMap) {
    SEGArgumentNode::assembleSEGObject(FuncSEGObjMap);
  }
 
private:
  SEGVarArgumentNode(Type *Ty, SymbolicExprGraph *SEG, BasicBlock *BB)
      : SEGArgumentNode(SEGOBJK_VarArgument, Ty, SEG, BB) {
    std::string Desc(std::string("varg_") + this->getDescription());
    this->setDescription(Desc);
  }
 
  SEGVarArgumentNode(Value *Val, Type *Ty, SymbolicExprGraph *SEG,
                     BasicBlock *BB)
      : SEGArgumentNode(SEGOBJK_VarArgument, Val, Ty, SEG, BB) {
    std::string Desc(std::string("varg_") + this->getDescription());
    this->setDescription(Desc);
  }
 
  friend class SymbolicExprGraph;
 
public:
  ~SEGVarArgumentNode() {}
 
  virtual PersistedSEGObject *createPersistedObject() const {
    PersistedSEGObject *PersistedObj = new PersistedSEGVarArgumentNode;
    return PersistedObj;
  }
 
  virtual size_t getIndex() const {
    assert(false);
    return -1;
  }
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_VarArgument;
  }
};
 
class SEGPseudoArgumentNode : public SEGArgumentNode {
public:
  SEGPseudoArgumentNode(PersistedSEGPseudoArgumentNode *Node,
                        SymbolicExprGraph *SEG)
      : SEGArgumentNode(Node, SEG) {
    this->Index = Node->getIndex();
  }
 
  virtual void assembleSEGObject(std::map<int, SEGObject *> &FuncSEGObjMap) {
    SEGArgumentNode::assembleSEGObject(FuncSEGObjMap);
  }
 
private:
  // The index is set by SEG
  size_t Index = -1;
 
  CBAccessPath AP;
 
  SEGPseudoArgumentNode(Type *Ty, SymbolicExprGraph *SEG, BasicBlock *BB)
      : SEGArgumentNode(SEGOBJK_PseudoArgument, Ty, SEG, BB) {
    std::string Desc(std::string("parg_") + this->getDescription());
    this->setDescription(Desc);
  }
 
  SEGPseudoArgumentNode(Value *Val, Type *Ty, SymbolicExprGraph *SEG,
                        BasicBlock *BB)
      : SEGArgumentNode(SEGOBJK_PseudoArgument, Val, Ty, SEG, BB) {
    std::string Desc(std::string("parg_") + this->getDescription());
    this->setDescription(Desc);
  }
 
  friend class SymbolicExprGraph;
 
public:
  ~SEGPseudoArgumentNode() {}
 
  virtual PersistedSEGObject *createPersistedObject() const {
    PersistedSEGObject *PersistedObj = new PersistedSEGPseudoArgumentNode;
    return PersistedObj;
  }
 
  virtual size_t getIndex() const {
    assert(Index != (size_t)-1 && "Index of a pseudo argument is not set!");
    return Index;
  }
 
public:
  static bool classof(const SEGObject *N) {
    return N->getKind() == SEGOBJK_PseudoArgument;
  }
 
  CBAccessPath &getAccessPath() { return AP; }
 
  const CBAccessPath &getAccessPath() const { return AP; }
};
 
#endif