Trace.hpp

Go to the documentation of this file.

/*
 * Copyright 2025 Håvard Krogstie <krogstie.havard@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_RVSDG_TRACE_HPP
#define JLM_RVSDG_TRACE_HPP
 
#include <jlm/rvsdg/node.hpp>
 
#include <optional>
 
namespace jlm::rvsdg
{
class GammaNode;
class ThetaNode;
 
class OutputTracer
{
public:
  virtual ~OutputTracer();
 
  explicit OutputTracer(bool enableCaching) noexcept;
 
  [[nodiscard]] bool
  isTracingThroughStructuralNodes() const noexcept
  {
    return traceThroughStrucutalNodes_;
  }
 
  void
  setTraceThroughStructuralNodes(bool value) noexcept
  {
    traceThroughStrucutalNodes_ = value;
  }
 
  [[nodiscard]] bool
  isEnteringPhiNodes() const noexcept
  {
    return enterPhiNodes_;
  }
 
  void
  setEnterPhiNodes(bool value) noexcept
  {
    enterPhiNodes_ = value;
  }
 
  [[nodiscard]] bool
  isInterprocedural() const noexcept
  {
    return isInterprocedural_;
  }
 
  void
  setInterprocedural(bool value) noexcept
  {
    isInterprocedural_ = value;
  }
 
  [[nodiscard]] Output &
  trace(Output & output);
 
  [[nodiscard]] Output &
  trace(Output & output, const rvsdg::Region * withinRegion);
 
  [[nodiscard]] Output *
  tryTraceThroughGamma(GammaNode & gammaNode, Output & output);
 
  [[nodiscard]] Output *
  tryTraceThroughTheta(ThetaNode & thetaNode, Output & output);
 
  void
  clearCache()
  {
    traceCache_.clear();
  }
 
protected:
  [[nodiscard]] virtual Output &
  traceStep(Output & output, const rvsdg::Region * withinRegion);
 
  Output *
  insertInCache(const Output & output, Input * traceResult);
 
  std::optional<Output *>
  lookupInCache(const Output & output);
 
  // When true, tracing enters subregions of structural nodes to check if the value is invariant.
  // When false, values are only considered invariant if they are directly connected to arguments.
  bool traceThroughStrucutalNodes_ = true;
 
  // When true, tracing can go from the output of a Phi node into its subregion.
  // When false, tracing will stop at the Phi output.
  bool enterPhiNodes_ = true;
 
  // When true, tracing is allowed to continue outside of lambda nodes.
  // When false, tracing will stop at the lambda's context arguments.
  bool isInterprocedural_ = true;
 
  // When true, tracing is allowed to cache traced values.
  bool enableCaching_;
  std::unordered_map<const Output *, Input *> traceCache_{};
};
 
Output &
traceOutputIntraProcedurally(Output & output);
 
inline const Output &
traceOutputIntraProcedurally(const Output & output)
{
  return traceOutputIntraProcedurally(const_cast<Output &>(output));
}
 
Output &
traceOutput(Output & output, const rvsdg::Region * withinRegion = nullptr);
 
inline const Output &
traceOutput(const Output & output, const rvsdg::Region * withinRegion = nullptr)
{
  return traceOutput(const_cast<Output &>(output), withinRegion);
}
 
}
 
#endif // JLM_RVSDG_TRACE_HPP