lattice.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 <optional>
#include <llvm/ADT/APFloat.h>
#include <llvm/ADT/APInt.h>
#include <llvm/Support/raw_ostream.h>
 
using APInt = llvm::APInt;
using APFloat = llvm::APFloat;
 
class Global;
 
 
 
class Lattice {
public:
  enum class Kind {
    UNKNOWN,
    OVERDEFINED,
    INT,
    MASK,
    FLOAT,
    FLOAT_ZERO,
    FRAME,
    GLOBAL,
    POINTER,
    RANGE,
    UNDEFINED,
  };
 
public:
  Lattice(const Lattice &that);
  ~Lattice();
 
  Kind GetKind() const { return kind_; }
  bool IsUnknown() const { return GetKind() == Kind::UNKNOWN; }
  bool IsOverdefined() const { return GetKind() == Kind::OVERDEFINED; }
  bool IsUndefined() const { return GetKind() == Kind::UNDEFINED; }
  bool IsInt() const { return GetKind() == Kind::INT; }
  bool IsMask() const { return GetKind() == Kind::MASK; }
  bool IsFloat() const { return GetKind() == Kind::FLOAT; }
  bool IsFloatZero() const { return GetKind() == Kind::FLOAT_ZERO; }
  bool IsGlobal() const { return GetKind() == Kind::GLOBAL; }
  bool IsFrame() const { return GetKind() == Kind::FRAME; }
  bool IsPointer() const { return GetKind() == Kind::POINTER; }
  bool IsRange() const { return GetKind() == Kind::RANGE; }
 
  bool IsPointerLike() const { return IsPointer() || IsFrame() || IsGlobal(); }
 
  APInt GetInt() const { assert(IsInt()); return intVal_; }
  APInt GetKnown() const { assert(IsMask()); return maskVal_.Known; }
  APInt GetValue() const { assert(IsMask()); return maskVal_.Value; }
  APFloat GetFloat() const { assert(IsFloat()); return floatVal_; }
  unsigned GetFrameObject() const { assert(IsFrame()); return frameVal_.Obj; }
  int64_t GetFrameOffset() const { assert(IsFrame()); return frameVal_.Off; }
  Global *GetGlobalSymbol() const { assert(IsGlobal()); return globalVal_.Sym; }
  int64_t GetGlobalOffset() const { assert(IsGlobal()); return globalVal_.Off; }
  Global *GetRange() const { assert(IsRange()); return globalVal_.Sym; }
 
  bool IsTrue() const;
  bool IsFalse() const;
 
  std::optional<APInt> AsInt() const
  {
    return IsInt() ? std::optional<APInt>(intVal_) : std::nullopt;
  }
 
  std::optional<APFloat> AsFloat() const
  {
    return IsFloat() ? std::optional<APFloat>(floatVal_) : std::nullopt;
  }
 
  bool operator != (const Lattice &that) const { return !(*this == that); }
 
  bool operator == (const Lattice &that) const;
 
  Lattice &operator = (const Lattice &that);
 
  Lattice LUB(const Lattice &that) const;
 
public:
  static Lattice Unknown();
  static Lattice Overdefined();
  static Lattice Undefined();
  static Lattice Pointer();
  static Lattice CreateFrame(unsigned obj, int64_t off);
  static Lattice CreateGlobal(Global *g, int64_t Off = 0);
  static Lattice CreateRange(Global *g);
  static Lattice CreateInteger(int64_t i);
  static Lattice CreateInteger(const APInt &i);
  static Lattice CreateMask(const APInt &known, const APInt &values);
  static Lattice CreateFloat(double f);
  static Lattice CreateFloat(const APFloat &f);
  static Lattice CreateFloatZero();
 
private:
  Lattice(Kind kind) : kind_(kind) {}
  Kind kind_;
 
  union {
    APInt intVal_;
    APFloat floatVal_;
    struct {
      APInt Known;
      APInt Value;
    } maskVal_;
    struct {
      unsigned Obj;
      int64_t Off;
    } frameVal_;
    struct {
      Global *Sym;
      int64_t Off;
    } globalVal_;
  };
};
 
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Lattice &l);