symbolic_frame.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 <map>
#include <set>
#include <unordered_map>
 
#include <llvm/ADT/iterator.h>
#include <llvm/ADT/iterator_range.h>
 
#include "core/dag.h"
#include "core/func.h"
#include "passes/pre_eval/symbolic_value.h"
 
class SymbolicContext;
class SymbolicFrameObject;
class SymbolicFrame;
class MemoryStoreInst;
class SymbolicSummary;
 
 
 
class SymbolicFrame {
public:
  using ObjectMap = std::map<unsigned, ID<SymbolicObject>>;
 
  struct object_iterator : llvm::iterator_adaptor_base
      < object_iterator
      , ObjectMap::const_iterator
      , std::random_access_iterator_tag
      , ID<SymbolicObject>
      >
  {
    explicit object_iterator(ObjectMap::const_iterator it)
      : iterator_adaptor_base(it)
    {
    }
 
    ID<SymbolicObject> operator*() const { return this->I->second; }
    ID<SymbolicObject> operator->() const { return operator*(); }
  };
 
public:
  SymbolicFrame(
      SymbolicSummary &ctx,
      DAGFunc &func,
      unsigned index,
      llvm::ArrayRef<SymbolicValue> args,
      llvm::ArrayRef<ID<SymbolicObject>> objects
  );
 
  SymbolicFrame(
      SymbolicSummary &ctx,
      unsigned index,
      llvm::ArrayRef<ID<SymbolicObject>> objects
  );
 
  Func *GetFunc() { return func_ ? &func_->GetFunc() : nullptr; }
  const Func *GetFunc() const
  {
    return const_cast<SymbolicFrame *>(this)->GetFunc();
  }
 
  ID<SymbolicFrame> GetIndex() const { return index_; }
 
  void Leave();
  bool IsValid() const { return valid_; }
 
  bool Set(Ref<Inst> i, const SymbolicValue &value);
 
  const SymbolicValue &Find(ConstRef<Inst> inst);
  const SymbolicValue *FindOpt(ConstRef<Inst> inst);
 
  unsigned GetNumArgs() const { return args_.size(); }
 
  const SymbolicValue &Arg(unsigned index) { return args_[index]; }
 
  ID<SymbolicObject> GetObject(unsigned object);
 
  void Merge(const SymbolicFrame &that);
 
  bool FindBypassed(
      std::set<DAGBlock *> &nodes,
      std::set<SymbolicContext *> &ctx,
      DAGBlock *start,
      DAGBlock *end
  );
 
  bool FindBypassed(
      std::set<DAGBlock *> &nodes,
      std::set<SymbolicContext *> &ctx,
      Block *start,
      Block *end)
  {
    return FindBypassed(nodes, ctx, GetNode(start), GetNode(end));
  }
 
  SymbolicContext *GetBypass(DAGBlock *node);
 
  Block *GetCurrentBlock() const { return current_; }
 
  DAGBlock *GetNode(Block *block) { return (*func_)[block]; }
 
  bool Limited(Block *block);
  void Continue(Block *node);
 
  void Bypass(DAGBlock *node, const SymbolicContext &ctx);
 
  bool IsBypassed(Block *node) { return IsBypassed(GetNode(node)); }
  bool IsBypassed(DAGBlock *node) { return bypass_.find(node) != bypass_.end(); }
  bool IsExecuted(Block *block) { return executed_.count(block); }
  void Approximate(Block *block) { executed_.insert(block); }
 
  DAGBlock *Find(Block *block) { return (*func_)[block]; }
 
  llvm::iterator_range<DAGFunc::node_iterator> nodes()
  {
    return llvm::make_range(func_->begin(), func_->end());
  }
 
  object_iterator object_begin() { return object_iterator(objects_.begin()); }
  object_iterator object_end() { return object_iterator(objects_.end()); }
  llvm::iterator_range<object_iterator> objects()
  {
    return llvm::make_range(object_begin(), object_end());
  }
 
private:
  SymbolicSummary &state_;
  DAGFunc *func_;
  unsigned index_;
  bool valid_;
  std::vector<SymbolicValue> args_;
  ObjectMap objects_;
  std::unordered_map<ConstRef<Inst>, SymbolicValue> values_;
  Block *current_;
  std::unordered_map<DAGBlock *, std::shared_ptr<SymbolicContext>> bypass_;
  std::set<Block *> executed_;
  std::unordered_map<Block *, unsigned> counts_;
};