symbolic_object.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/Support/Alignment.h>
 
#include "core/type.h"
#include "core/func.h"
 
#include "passes/pre_eval/symbolic_value.h"
 
class Atom;
class Prog;
class Object;
class SymbolicFrame;
class SymbolicValue;
class SymbolicHeap;
 
 
 
class SymbolicObject final {
public:
  SymbolicObject(
      ID<SymbolicObject> id,
      std::optional<size_t> size,
      llvm::Align align,
      bool rdonly,
      bool zero
  );
  SymbolicObject(const SymbolicObject &that);
  ~SymbolicObject();
 
  ID<SymbolicObject> GetID() const { return id_; }
  llvm::Align GetAlignment() const { return align_; }
 
  const SymbolicValue *begin() const;
  const SymbolicValue *end() const;
 
  void Merge(const SymbolicObject &that);
 
  SymbolicValue Load(int64_t offset, Type type);
  SymbolicValue LoadImprecise(Type type);
 
  bool Init(int64_t offset, const SymbolicValue &val, Type type);
  bool Store(int64_t offset, const SymbolicValue &val, Type type);
  bool StoreImprecise(int64_t offset, const SymbolicValue &val, Type type);
  bool StoreImprecise(const SymbolicValue &val, Type type);
 
private:
  ID<SymbolicObject> id_;
  std::optional<size_t> size_;
  llvm::Align align_;
  bool rdonly_;
 
  class MergedStorage {
  public:
    MergedStorage(const SymbolicValue &value) : value_(value) {}
 
    SymbolicValue Load() const { return value_; }
 
    bool Store(const SymbolicValue &value);
 
    const SymbolicValue *begin() const { return &value_; }
    const SymbolicValue *end() const { return &value_ + 1; }
 
  private:
    bool Accurate = false;
    SymbolicValue value_;
  };
 
  class BucketStorage {
  public:
    BucketStorage(size_t size, const SymbolicValue &value);
 
    void Merge(const BucketStorage &that);
 
    SymbolicValue Load(int64_t offset, Type type) const;
    SymbolicValue Load() const { return approx_; }
 
    bool StorePrecise(int64_t offset, const SymbolicValue &value, Type type);
    bool StoreImprecise(int64_t offset, const SymbolicValue &value, Type type);
 
    const SymbolicValue *begin() const { return &*buckets_.begin(); }
    const SymbolicValue *end() const { return &*buckets_.end(); }
 
  private:
    SymbolicValue Read(int64_t offset, Type type) const;
    bool Write(
        int64_t offset,
        const SymbolicValue &val,
        Type type,
        bool (BucketStorage::*mutate)(unsigned, const SymbolicValue &)
    );
    bool Set(unsigned bucket, const SymbolicValue &val);
    bool Merge(unsigned bucket, const SymbolicValue &val);
 
  private:
    bool Accurate = true;
    std::vector<SymbolicValue> buckets_;
    SymbolicValue approx_;
  };
 
  union U {
    bool Accurate;
    MergedStorage M;
    BucketStorage B;
 
    U() { }
    ~U() { }
  } v_;
};