SEGPhiNode.h

/*
 * SEGPhiNode.h
 *
 * Qingkai
 *
 * This node is to model a phi value.
 */
 
#ifndef IR_SEG_SEGPHINODE_H
#define IR_SEG_SEGPHINODE_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 "IR/LLVMWrapper/ValueWrapper.h"
#include "IR/SEG/SymbolicExprGraph.h"
 
using namespace llvm;
 
class PersistedSEGPhiNode;
 
class SEGPhiNode : public SEGOperandNode {
public:
  SEGPhiNode(PersistedSEGPhiNode *Node, SymbolicExprGraph *SEG);
 
  virtual void assembleSEGObject(std::map<int, SEGObject *> &FuncSEGObjMap);
 
public:
  struct IncomeNode {
    SEGNodeBase *ValNode;            // The incoming value
    WrappedBasicBlock *BB = nullptr; // The incoming basic block.
    SEGNodeBase *InCondNode; // The condition node on immediate predecessor
    bool Cond;
  };
 
private:
  std::vector<IncomeNode> InComingNodes;
 
  friend class SymbolicExprGraph;
 
  SEGPhiNode(Value *Val, Type *Ty, SymbolicExprGraph *SEG, BasicBlock *BB);
 
public:
  typedef std::vector<IncomeNode>::const_iterator const_iterator;
 
  ~SEGPhiNode() = default;
 
  virtual PersistedSEGObject *createPersistedObject() const;
 
  void addIncomeValue(SEGNodeBase *InValue, BasicBlock *BB,
                      SEGNodeBase *condValue, bool Cond) {
    auto *WrappedBB = WrappedValue::findWrappedBasicBlock(BB);
    struct IncomeNode Node;
    Node.ValNode = InValue;
    Node.BB = WrappedBB;
    Node.InCondNode = condValue;
    Node.Cond = Cond;
    InComingNodes.emplace_back(Node);
    // Also add it to children set.
    addChild(InValue);
  }
 
  // Get the "IN" condition for a phi "IN".
  std::pair<SEGNodeBase *, bool> getInCond(size_t I) {
    assert(I < size() && "getInCond i should less than the size.");
 
    auto &InComingNode = InComingNodes[I];
    return std::make_pair(InComingNode.InCondNode, InComingNode.Cond);
  }
 
  void dot(raw_fd_ostream &O) const;
 
  // Override
  bool isTerminalNode() const { return InComingNodes.empty(); }
 
  const_iterator begin() const { return InComingNodes.begin(); }
 
  const_iterator end() const { return InComingNodes.end(); }
 
  size_t size() const { return InComingNodes.size(); }
 
  bool empty() const { return InComingNodes.empty(); }
 
public:
  static bool classof(const SEGObject *O) {
    return O->getKind() == SEGOBJK_Phi;
  }
};
 
#endif