symbolic_heap.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 <unordered_map>
 
#include "core/adt/id.h"
 
class CallSite;
class Object;
class SymbolicObject;
class Func;
 
 
 
class SymbolicHeap final {
public:
  class Origin final {
  public:
    enum class Kind {
      DATA,
      FRAME,
      ALLOC,
    };
 
    struct DataOrigin {
      Kind K;
      Object *Obj;
 
      DataOrigin(Object *obj)
        : K(Kind::DATA)
        , Obj(obj)
      {
      }
    };
 
    struct FrameOrigin {
      Kind K;
      unsigned Frame;
      unsigned Index;
 
      FrameOrigin(unsigned frame, unsigned index)
        : K(Kind::FRAME)
        , Frame(frame)
        , Index(index)
      {
      }
    };
 
    struct AllocOrigin {
      Kind K;
      unsigned Frame;
      CallSite *Alloc;
 
      AllocOrigin(unsigned frame, CallSite *alloc)
        : K(Kind::ALLOC)
        , Frame(frame)
        , Alloc(alloc)
      {
      }
    };
 
    Kind GetKind() const { return v_.K; }
 
    DataOrigin &AsData() { return v_.D; }
    FrameOrigin &AsFrame() { return v_.F; }
    AllocOrigin &AsAlloc() { return v_.A; }
 
  public:
    template <typename... Args>
    Origin(Args... args) : v_(std::forward<Args>(args)...) {}
 
  public:
    union U {
      Kind K;
      DataOrigin D;
      FrameOrigin F;
      AllocOrigin A;
 
      U(Object *object) { new (&D) DataOrigin(object); }
      U(unsigned fr, unsigned idx) { new (&F) FrameOrigin(fr, idx); }
      U(unsigned fr, CallSite *alloc) { new (&A) AllocOrigin(fr, alloc); }
    } v_;
  };
 
 
public:
  SymbolicHeap() : next_(0u) {}
 
  ID<SymbolicObject> Data(Object *object);
  ID<SymbolicObject> Frame(unsigned frame, unsigned object);
  ID<SymbolicObject> Alloc(unsigned frame, CallSite *site);
  ID<Func> Function(Func *f);
 
  Origin &Map(ID<SymbolicObject> id) { return origins_[id]; }
  Func &Map(ID<Func> id);
 
private:
  unsigned next_;
  std::unordered_map<Object *, ID<SymbolicObject>> objects_;
  std::unordered_map<std::pair<unsigned, unsigned>, ID<SymbolicObject>> frames_;
  std::unordered_map<std::pair<unsigned, CallSite *>, ID<SymbolicObject>> allocs_;
  std::vector<Origin> origins_;
  std::unordered_map<Func *, ID<Func>> funcToIDs_;
  std::vector<Func *> idToFunc_;
};