StoreValueForwarding.hpp

Go to the documentation of this file.

/*
 * Copyright 2026 Håvard Krogstie <krogstie.havard@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_LLVM_OPT_STOREVALUEFORWARDING_HPP
#define JLM_LLVM_OPT_STOREVALUEFORWARDING_HPP
 
#include <jlm/llvm/ir/operators/GetElementPtr.hpp>
#include <jlm/rvsdg/simple-node.hpp>
#include <jlm/rvsdg/Transformation.hpp>
 
namespace jlm::rvsdg
{
class DeltaNode;
class Region;
}
 
namespace jlm::llvm
{
 
struct ValueOrigin;
class LoadTracingInfo;
 
class StoreValueForwarding final : public rvsdg::Transformation
{
  class Statistics;
  struct Context;
 
public:
  ~StoreValueForwarding() noexcept override;
 
  StoreValueForwarding();
 
  StoreValueForwarding(const StoreValueForwarding &) = delete;
 
  StoreValueForwarding(StoreValueForwarding &&) = delete;
 
  StoreValueForwarding &
  operator=(const StoreValueForwarding &) = delete;
 
  StoreValueForwarding &
  operator=(StoreValueForwarding &&) = delete;
 
  void
  Run(rvsdg::RvsdgModule & module, util::StatisticsCollector & statisticsCollector) override;
 
private:
  void
  traverseInterProceduralRegion(rvsdg::Region & region);
 
  void
  traverseIntraProceduralRegion(rvsdg::Region & region);
 
  void
  processLoad(rvsdg::SimpleNode & loadNode);
 
  void
  processLoadWithoutMemoryStates(rvsdg::SimpleNode & loadNode);
 
  struct TracedDelta
  {
    rvsdg::DeltaNode * deltaNode{};
 
    std::vector<GetElementPtrOperation::Constant> gepConstants;
  };
 
  std::optional<TracedDelta>
  traceLoadWithoutMemoryStates(const rvsdg::SimpleNode & loadNode);
 
  void
  forwardLoadWithoutMemoryStates(rvsdg::SimpleNode & loadNode, const TracedDelta & tracedDelta);
 
  void
  processLoadWithMemoryStates(rvsdg::SimpleNode & loadNode);
 
  void
  forwardValueOrigins(LoadTracingInfo & tracingInfo);
 
  rvsdg::Output &
  getValueOriginOutput(
      ValueOrigin storeValueOrigin,
      rvsdg::Region & targetRegion,
      LoadTracingInfo & tracingInfo);
 
  void
  connectUnroutedLoopPosts(LoadTracingInfo & tracingInfo);
 
  rvsdg::Output &
  routeOutputToRegion(rvsdg::Output & output, rvsdg::Region & region);
 
  std::unique_ptr<Context> context_;
};
 
}
 
#endif