SEGValue.h

/*
 * Developed by Yibo, Jin
 * Copy Right by Prism Research Group and HKUST.
 */
 
#ifndef SEGVALUE_H
#define SEGVALUE_H
 
#include <llvm/IR/BasicBlock.h>
#include <llvm/IR/CallSite.h>
#include <llvm/IR/Constants.h>
#include <llvm/IR/Function.h>
#include <llvm/IR/InstIterator.h>
#include <llvm/IR/Instruction.h>
#include <llvm/IR/Instructions.h>
#include <llvm/IR/Value.h>
 
#include <llvm/Support/Casting.h>
#include <llvm/Support/FileSystem.h>
#include <llvm/Support/Format.h>
#include <llvm/Support/raw_ostream.h>
 
#include <llvm/Analysis/MemoryBuiltins.h>
#include <llvm/Target/TargetLibraryInfo.h>
 
#include "Analysis/Bitcode/BitcodeUtils.h"
 
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
using namespace llvm;
 
class SEGValue;
 
class SEGValue {
 
public:
  enum SEGValueKind {
    value,
    basicblock,
    instruction,
    function,
  };
 
private:
  Value *Val;
 
  friend class SEGObject;
  friend class SEGNodeBase;
  friend class SEGSiteBase;
 
public:
  SEGValue(Value *val) : Val(val) {}
  ~SEGValue() {}
 
  /* --------- Value --------- */
 
  Value *getValue() { return Val; }
 
  bool hasName() const { return Val->hasName(); }
 
  StringRef getValueName() const { return Val->getName(); }
 
  bool isEqualValue(SEGValue *sValue) const {
    return Val == sValue->getValue();
  }
 
  bool isConstantInt() const {
    if (!Val) {
      return false;
    }
    if (isa<ConstantInt>(Val)) {
      return true;
    }
    return false;
  }
 
  bool isConstantInt(int constantInt) const {
    if (!Val) {
      return false;
    }
    if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) {
      if (CI->getSExtValue() == constantInt) {
        return true;
      }
    }
    return false;
  }
 
  /* --------- Type --------- */
 
  bool isUndefined() const { return isa<UndefValue>(Val); }
 
  bool isPointerType() const { return Val->getType()->isPointerTy(); }
 
  bool isConstantPointerNull() const { return isa<ConstantPointerNull>(Val); }
 
  /* --------- Instruction --------- */
 
  bool isInstruction() const { return isa<Instruction>(Val); }
 
  bool isSame(SEGValue *sValue) const { return Val == sValue->getValue(); }
 
  bool isPhiInst() const { return isa<PHINode>(Val); }
 
  bool isFreeInst(TargetLibraryInfo *TLI) const {
    if (isInstruction())
      return isFreeCall(dyn_cast<Instruction>(Val), TLI);
    return false;
  }
 
  bool isLoadInst() const {
    assert(isInstruction() && "Not an instruction");
    return isa<LoadInst>(Val);
  }
 
  bool isDivInst() const {
    assert(isInstruction() && "Not an instruction");
    auto *Inst = dyn_cast<Instruction>(Val);
    return Inst->getOpcode() == Instruction::UDiv ||
           Inst->getOpcode() == Instruction::SDiv ||
           Inst->getOpcode() == Instruction::FDiv ||
           Inst->getOpcode() == Instruction::URem ||
           Inst->getOpcode() == Instruction::SRem ||
           Inst->getOpcode() == Instruction::FRem;
  }
 
  bool isConstantString() {
    if (auto *GV = dyn_cast<GlobalVariable>(Val)) {
      if (!GV->hasInitializer()) {
        return false;
      }
      Constant *CI = GV->getInitializer();
      if (isa<ConstantDataArray>(CI) || isa<ConstantDataSequential>(CI) ||
          isa<ConstantDataVector>(CI)) {
        return true;
      }
    }
    return false;
  }
 
  StringRef getConstantString() {
    assert(isConstantString() && "Current SEGValue is not a constant string!");
    if (auto *GV = dyn_cast<GlobalVariable>(Val)) {
      Constant *CI = GV->getInitializer();
      if (auto *CA = dyn_cast<ConstantDataArray>(CI)) {
        CA->getAsString();
      } else if (auto *CS = dyn_cast<ConstantDataSequential>(CI)) {
        CS->getAsString();
      } else if (auto *CV = dyn_cast<ConstantDataVector>(CI)) {
        CV->getAsString();
      } else {
        return nullptr;
      }
    }
  }
 
  SEGValue *getInstOperand(size_t offset) {
    if (isInstruction()) {
      auto *Inst = dyn_cast<Instruction>(Val);
      return new SEGValue(Inst->getOperand(offset));
    }
    return nullptr;
  }
 
  bool isDerefPtr(SEGValue *sValue) const {
    if (isInstruction()) {
      kvec<Value *> DerefPtrs;
      getDerefPtrFromInst(*(dyn_cast<Instruction>(Val)), DerefPtrs);
      if (DerefPtrs.find(sValue->getValue()) != DerefPtrs.end()) {
        return true;
      }
    }
    return false;
  }
 
  /* --------- CallSite --------- */
 
  bool isCallOrInvoke() const {
    return isa<CallInst>(Val) || isa<InvokeInst>(Val);
  }
 
  size_t getCallSiteArgSize() const {
    return CallSite(dyn_cast<Instruction>(Val)).arg_size();
  }
 
  /* --------- Function --------- */
 
  bool hasCalledFunction() const {
    assert((isa<CallInst>(Val) || isa<InvokeInst>(Val)) &&
           "Val is nullptr or neither a CallInst nor InvokeInst");
    return CallSite(Val).getCalledFunction() != nullptr;
  }
 
  Function *getCalledFunction() const {
    assert(Val && (isa<CallInst>(Val) || isa<InvokeInst>(Val)) &&
           "Val is nullptr or neither a CallInst nor InvokeInst");
    CallSite CS(Val);
    return CS.getCalledFunction();
  }
 
  size_t getFuncArgSize() const {
    assert(Val && (isa<CallInst>(Val) || isa<InvokeInst>(Val)) &&
           "Val is nullptr or neither a CallInst nor InvokeInst");
    Function *callee = CallSite(Val).getCalledFunction();
    return callee->arg_size();
  }
 
  bool isFuncNthArgument(SEGValue *sValue, size_t offset) const {
    Value *Inst = sValue->getValue();
    assert((isa<CallInst>(Inst) || isa<InvokeInst>(Inst)) &&
           "Val is nullptr or neither a CallInst nor InvokeInst");
    CallSite CS(Inst);
    return Val == CS.getArgument(offset);
  }
 
  StringRef getFuncName() const {
    assert(Val && (isa<CallInst>(Val) || isa<InvokeInst>(Val)) &&
           "Val is nullptr or neither a CallInst nor InvokeInst");
    CallSite CS(Val);
    Function *Func = CS.getCalledFunction();
    if (Func != nullptr) {
      return Func->getName();
    }
    return {""};
  }
 
  bool hasFuncName() const {
    assert(Val && (isa<CallInst>(Val) || isa<InvokeInst>(Val)) &&
           "Val is nullptr or neither a CallInst nor InvokeInst");
    CallSite CS(Val);
    Function *Func = CS.getCalledFunction();
    return Func && Func->hasName();
  }
};
 
#endif