MemoryStateEncoder.hpp

Go to the documentation of this file.

/*
 * Copyright 2021 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_LLVM_OPT_ALIAS_ANALYSES_MEMORYSTATEENCODER_HPP
#define JLM_LLVM_OPT_ALIAS_ANALYSES_MEMORYSTATEENCODER_HPP
 
#include <memory>
#include <vector>
 
namespace jlm::rvsdg
{
class GammaNode;
class LambdaNode;
class Output;
class Region;
class RvsdgModule;
class SimpleNode;
class ThetaNode;
}
 
namespace jlm::util
{
class StatisticsCollector;
}
 
namespace jlm::llvm::aa
{
 
class ModRefSummary;
 
class MemoryStateEncoder final
{
public:
  struct MemoryStateTypeCounters;
  class Statistics;
  class StateMap;
 
  struct EncodingCounter
  {
    size_t numReplacedLoads = 0;
    size_t numRedirectedLoads = 0;
 
    size_t numReplacedStores = 0;
    size_t numRedirectedStores = 0;
  };
 
  ~MemoryStateEncoder() noexcept;
 
  MemoryStateEncoder();
 
  MemoryStateEncoder(const MemoryStateEncoder &) = delete;
 
  MemoryStateEncoder(MemoryStateEncoder &&) = delete;
 
  MemoryStateEncoder &
  operator=(const MemoryStateEncoder &) = delete;
 
  MemoryStateEncoder &
  operator=(MemoryStateEncoder &&) = delete;
 
  void
  Encode(
      rvsdg::RvsdgModule & rvsdgModule,
      const ModRefSummary & modRefSummary,
      util::StatisticsCollector & statisticsCollector);
 
private:
  void
  encodeInterProcedural(rvsdg::Region & region);
 
  void
  encodeIntraProcedural(rvsdg::Region & region, StateMap & stateMap);
 
  void
  encodeAlloca(const rvsdg::SimpleNode & allocaNode, StateMap & stateMap) const;
 
  void
  encodeMalloc(const rvsdg::SimpleNode & mallocNode, StateMap & stateMap) const;
 
  void
  encodeLoad(const rvsdg::SimpleNode & node, StateMap & stateMap);
 
  void
  encodeStore(const rvsdg::SimpleNode & node, StateMap & stateMap);
 
  void
  encodeFree(const rvsdg::SimpleNode & freeNode, StateMap & stateMap) const;
 
  void
  encodeCall(const rvsdg::SimpleNode & callNode, StateMap & stateMap) const;
 
  void
  encodeMemcpy(const rvsdg::SimpleNode & memcpyNode, StateMap & stateMap) const;
 
  void
  encodeMemset(const rvsdg::SimpleNode & memsetNode, StateMap & stateMap) const;
 
  void
  encodeMemmove(const rvsdg::SimpleNode & memmoveNode, StateMap & stateMap) const;
 
  void
  encodeLambda(const rvsdg::LambdaNode & lambda);
 
  void
  encodeGamma(rvsdg::GammaNode & gammaNode, StateMap & stateMap);
 
  void
  encodeTheta(rvsdg::ThetaNode & thetaNode, StateMap & stateMap);
 
  std::unique_ptr<MemoryStateTypeCounters>
  gatherStatistics(const rvsdg::Region & region) const;
 
  [[nodiscard]] static rvsdg::SimpleNode &
  replaceLoadNode(
      const rvsdg::SimpleNode & node,
      const std::vector<rvsdg::Output *> & memoryStates);
 
  [[nodiscard]] static rvsdg::SimpleNode &
  replaceStoreNode(
      const rvsdg::SimpleNode & node,
      const std::vector<rvsdg::Output *> & memoryStates);
 
  [[nodiscard]] static rvsdg::SimpleNode &
  replaceMemcpyNode(
      const rvsdg::SimpleNode & memCpyNode,
      const std::vector<rvsdg::Output *> & memoryStates);
 
  [[nodiscard]] static rvsdg::SimpleNode &
  replaceMemsetNode(
      const rvsdg::SimpleNode & memsetNode,
      const std::vector<rvsdg::Output *> & memoryStates);
 
  [[nodiscard]] static rvsdg::SimpleNode &
  replaceMemmoveNode(
      const rvsdg::SimpleNode & memmoveNode,
      const std::vector<rvsdg::Output *> & memoryStates);
 
  EncodingCounter encodingCounter_;
  std::unique_ptr<Statistics> statistics_;
  const ModRefSummary * modRefSummary_ = nullptr;
};
 
}
 
#endif // JLM_LLVM_OPT_ALIAS_ANALYSES_MEMORYSTATEENCODER_HPP