symbolic_value.h

// This file if part of the llir-opt project.
// Licensing information can be found in the LICENSE file.
// (C) 2018 Nandor Licker. All rights reserved.
 
#pragma once
 
#include <llvm/ADT/APFloat.h>
#include <llvm/ADT/APInt.h>
#include <llvm/Support/raw_ostream.h>
 
#include "core/ref.h"
#include "passes/pre_eval/symbolic_pointer.h"
 
class SymbolicFrame;
class Inst;
using APInt = llvm::APInt;
using APFloat = llvm::APFloat;
 
 
 
class SymbolicValue final {
public:
  enum class Kind {
    UNDEFINED,
    SCALAR,
    INTEGER,
    LOWER_BOUNDED_INTEGER,
    MASKED_INTEGER,
    FLOAT,
    POINTER,
    NULLABLE,
    VALUE,
  };
 
  using Origin = std::pair<ID<SymbolicFrame>, Ref<Inst>>;
 
public:
  SymbolicValue() : kind_(Kind::UNDEFINED) {}
  SymbolicValue(const SymbolicValue &that);
  ~SymbolicValue();
 
  SymbolicValue &operator=(const SymbolicValue &that);
 
  static SymbolicValue Scalar(
      const std::optional<Origin> &orig = std::nullopt
  );
 
  static SymbolicValue Undefined(
      const std::optional<Origin> &orig = std::nullopt
  );
 
  static SymbolicValue Float(
      const APFloat &val,
      const std::optional<Origin> &orig = std::nullopt
  );
 
  static SymbolicValue Integer(
      const APInt &val,
      const std::optional<Origin> &orig = std::nullopt
  );
 
  static SymbolicValue LowerBoundedInteger(
      const APInt &bound,
      const std::optional<Origin> &orig = std::nullopt
  );
 
  static SymbolicValue Mask(
      const APInt &known,
      const APInt &value,
      const std::optional<Origin> &orig = std::nullopt
  );
 
  static SymbolicValue Pointer(
      const SymbolicPointer::Ref &pointer,
      const std::optional<Origin> &orig = std::nullopt
  );
 
  static SymbolicValue Value(
      const SymbolicPointer::Ref &pointer,
      const std::optional<Origin> &orig = std::nullopt
  );
 
  static SymbolicValue Nullable(
      const SymbolicPointer::Ref &pointer,
      const std::optional<Origin> &orig = std::nullopt
  );
 
  Kind GetKind() const { return kind_; }
 
  bool IsInteger() const { return GetKind() == Kind::INTEGER; }
  bool IsScalar() const { return GetKind() == Kind::SCALAR; }
  bool IsLowerBoundedInteger() const { return GetKind() == Kind::LOWER_BOUNDED_INTEGER; }
  bool IsMaskedInteger() const { return GetKind() == Kind::MASKED_INTEGER; }
  bool IsFloat() const { return GetKind() == Kind::FLOAT; }
  bool IsPointer() const { return GetKind() == Kind::POINTER; }
  bool IsValue() const { return GetKind() == Kind::VALUE; }
  bool IsNullable() const { return GetKind() == Kind::NULLABLE; }
 
  bool IsPointerLike() const { return IsPointer() || IsValue() || IsNullable(); }
  bool IsIntegerLike() const { return IsInteger() || IsLowerBoundedInteger(); }
 
  APInt GetInteger() const { assert(IsIntegerLike()); return intVal_; }
 
  APInt GetMaskKnown() const { assert(IsMaskedInteger()); return maskVal_.Known; }
  APInt GetMaskValue() const { assert(IsMaskedInteger()); return maskVal_.Value; }
 
  APFloat GetFloat() const { assert(IsFloat()); return floatVal_; }
 
  const SymbolicPointer::Ref &GetPointer() const
  {
    assert(IsPointerLike());
    return ptrVal_;
  }
 
  const SymbolicPointer *AsPointer() const
  {
    if (IsPointerLike()) {
      return &*GetPointer();
    } else {
      return nullptr;
    }
  }
 
  std::optional<APInt> AsInt() const
  {
    if (IsInteger()) {
      return std::optional<APInt>(GetInteger());
    } else {
      return std::nullopt;
    }
  }
 
  SymbolicValue Pin(Ref<Inst> ref, ID<SymbolicFrame> frame) const;
 
  bool IsTrue() const;
  bool IsFalse() const;
 
  std::optional<Origin> GetOrigin() const { return origin_; }
 
  SymbolicValue Cast(Type type) const;
 
  void Merge(const SymbolicValue &that);
  [[nodiscard]] SymbolicValue LUB(const SymbolicValue &that) const
  {
    SymbolicValue result(*this);
    result.Merge(that);
    return result;
  }
 
  bool operator==(const SymbolicValue &that) const;
  bool operator!=(const SymbolicValue &that) const { return !(*this == that); }
 
  void dump(llvm::raw_ostream &os) const;
 
private:
  SymbolicValue(Kind kind, std::optional<Origin> origin)
    : kind_(kind)
    , origin_(origin)
  {
  }
 
  void Destroy();
 
private:
  Kind kind_;
  std::optional<Origin> origin_;
  union {
    APInt intVal_;
    APFloat floatVal_;
    struct {
      APInt Known;
      APInt Value;
    } maskVal_;
    std::shared_ptr<SymbolicPointer> ptrVal_;
  };
};
 
inline llvm::raw_ostream &operator<<(
    llvm::raw_ostream &os,
    const SymbolicValue &sym)
{
  sym.dump(os);
  return os;
}