NodeReduction.cpp

Go to the documentation of this file.

/*
 * Copyright 2018 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#include <jlm/llvm/ir/operators/ControlOperations.hpp>
#include <jlm/llvm/ir/operators/ConversionOperations.hpp>
#include <jlm/llvm/ir/operators/Gamma.hpp>
#include <jlm/llvm/ir/operators/GetElementPtr.hpp>
#include <jlm/llvm/ir/operators/IntegerOperations.hpp>
#include <jlm/llvm/ir/operators/IOBarrier.hpp>
#include <jlm/llvm/ir/operators/Load.hpp>
#include <jlm/llvm/ir/operators/MemoryStateOperations.hpp>
#include <jlm/llvm/ir/operators/operators.hpp>
#include <jlm/llvm/ir/operators/Store.hpp>
#include <jlm/llvm/opt/NodeReduction.hpp>
#include <jlm/rvsdg/binary.hpp>
#include <jlm/rvsdg/gamma.hpp>
#include <jlm/rvsdg/MatchType.hpp>
#include <jlm/rvsdg/NodeNormalization.hpp>
#include <jlm/rvsdg/RvsdgModule.hpp>
#include <jlm/rvsdg/theta.hpp>
#include <jlm/rvsdg/traverser.hpp>
#include <jlm/util/Statistics.hpp>
 
namespace jlm::llvm
{
 
void
NodeReduction::Statistics::Start(const rvsdg::Graph & graph) noexcept
{
  AddMeasurement(Label::NumRvsdgNodesBefore, rvsdg::nnodes(&graph.GetRootRegion()));
  AddMeasurement(Label::NumRvsdgInputsBefore, rvsdg::ninputs(&graph.GetRootRegion()));
  AddTimer(Label::Timer).start();
}
 
void
NodeReduction::Statistics::End(const rvsdg::Graph & graph) noexcept
{
  AddMeasurement(Label::NumRvsdgNodesAfter, rvsdg::nnodes(&graph.GetRootRegion()));
  AddMeasurement(Label::NumRvsdgInputsAfter, rvsdg::ninputs(&graph.GetRootRegion()));
 
  AddMeasurement(NumRegionsLabel_, getNumRegions());
  AddMeasurement(NumTotalRegionIterationsLabel_, getTotalIterations());
  AddMeasurement(MaxIterationsPerRegionLabel_, getMaxIterationsPerRegion());
 
  auto & counters = getReductionCounters();
  AddMeasurement("#LoadNonVolatileReductions", counters.numLoadNonVolatileReductions);
  AddMeasurement("#StoreNonVolatileReductions", counters.numStoreNonVolatileReductions);
  AddMeasurement("#MemoryStateMergeReductions", counters.numMemoryStateMergeReductions);
  AddMeasurement("#MemoryStateJoinReductions", counters.numMemoryStateJoinReductions);
  AddMeasurement("#MemoryStateSplitReductions", counters.numMemoryStateSplitReductions);
  AddMeasurement(
      "#LambdaExitMemoryStateMergeReductions",
      counters.numLambdaExitMemoryStateMergeReductions);
  AddMeasurement("#MatchReductions", counters.numMatchReductions);
  AddMeasurement("#SExtReductions", counters.numSExtReductions);
  AddMeasurement("#ZExtReductions", counters.numZExtReductions);
  AddMeasurement("#TruncReductions", counters.numTruncReductions);
  AddMeasurement("#FPExtReductions", counters.numFPExtReductions);
  AddMeasurement("#FPTruncReductions", counters.numFPTruncReductions);
  AddMeasurement("#IntegerEqReductions", counters.numIntegerEqReductions);
  AddMeasurement("#IntegerNeReductions", counters.numIntegerNeReductions);
  AddMeasurement("#IntegerSgeReductions", counters.numIntegerSgeReductions);
  AddMeasurement("#IntegerSgtReductions", counters.numIntegerSgtReductions);
  AddMeasurement("#IntegerSleReductions", counters.numIntegerSleReductions);
  AddMeasurement("#IntegerSltReductions", counters.numIntegerSltReductions);
  AddMeasurement("#IntegerUgeReductions", counters.numIntegerUgeReductions);
  AddMeasurement("#IntegerUgtReductions", counters.numIntegerUgtReductions);
  AddMeasurement("#IntegerUleReductions", counters.numIntegerUleReductions);
  AddMeasurement("#IntegerUltReductions", counters.numIntegerUltReductions);
 
  AddMeasurement("#IntegerAddReductions", counters.numIntegerAddReductions);
  AddMeasurement("#IntegerSubReductions", counters.numIntegerSubReductions);
  AddMeasurement("#IntegerMulReductions", counters.numIntegerMulReductions);
  AddMeasurement("#IntegerSDivReductions", counters.numIntegerSDivReductions);
  AddMeasurement("#IntegerUDivReductions", counters.numIntegerUDivReductions);
  AddMeasurement("#IntegerSRemReductions", counters.numIntegerSRemReductions);
  AddMeasurement("#IntegerURemReductions", counters.numIntegerURemReductions);
  AddMeasurement("#IntegerAShrReductions", counters.numIntegerAShrReductions);
  AddMeasurement("#IntegerShlReductions", counters.numIntegerShlReductions);
  AddMeasurement("#IntegerLShrReductions", counters.numIntegerLShrReductions);
  AddMeasurement("#IntegerAndReductions", counters.numIntegerAndReductions);
  AddMeasurement("#IntegerOrReductions", counters.numIntegerOrReductions);
  AddMeasurement("#IntegerXorReductions", counters.numIntegerXorReductions);
 
  AddMeasurement("#FPBinaryOpReductions", counters.numFPBinaryOpReductions);
 
  AddMeasurement("#PtrCmpReductions", counters.numPtrCmpReductions);
  AddMeasurement("#GetElementPtrReductions", counters.numGetElementPtrReductions);
  AddMeasurement("#FCmpReductions", counters.numFCmpReductions);
  AddMeasurement("#MemoryHoistBarrierReductions", counters.numMemoryHoistBarrierReductions);
  AddMeasurement("#BinaryReductions", counters.numBinaryReductions);
 
  AddMeasurement("#GammaReductions", counters.numGammaReductions);
  AddMeasurement("#ThetaReductions", counters.numThetaReductions);
 
  GetTimer(Label::Timer).stop();
}
 
bool
NodeReduction::Statistics::AddIteration(const rvsdg::Region & region, size_t numIterations)
{
  const auto it = NumIterations_.find(&region);
  NumIterations_[&region] = numIterations;
  return it != NumIterations_.end();
}
 
std::optional<size_t>
NodeReduction::Statistics::GetNumIterations(const rvsdg::Region & region) const noexcept
{
  if (const auto it = NumIterations_.find(&region); it != NumIterations_.end())
  {
    return it->second;
  }
 
  return std::nullopt;
}
 
size_t
NodeReduction::Statistics::getNumRegions() const noexcept
{
  return NumIterations_.size();
}
 
size_t
NodeReduction::Statistics::getTotalIterations() const noexcept
{
  size_t sum = 0;
  for (auto [_, numIterations] : NumIterations_)
  {
    sum += numIterations;
  }
 
  return sum;
}
 
size_t
NodeReduction::Statistics::getMaxIterationsPerRegion() const noexcept
{
  return std::max_element(
             NumIterations_.begin(),
             NumIterations_.end(),
             [](const auto & p1, const auto & p2)
             {
               return p1.second < p2.second;
             })
      ->second;
}
 
static std::vector<rvsdg::NodeNormalization<rvsdg::MatchOperation>>
    matchOperationNormalizations({ foldMatchOperationWithConstant });
 
static std::vector<rvsdg::NodeNormalization<SExtOperation>>
    sextOperationNormalizations({ SExtOperation::foldConstant });
 
static std::vector<rvsdg::NodeNormalization<ZExtOperation>>
    zextOperationNormalizations({ ZExtOperation::foldConstant });
 
static std::vector<rvsdg::NodeNormalization<TruncOperation>>
    truncOperationNormalizations({ TruncOperation::foldConstant });
 
static std::vector<rvsdg::NodeNormalization<FPExtOperation>>
    fpExtOperationNormalizations({ FPExtOperation::foldConstant });
 
static std::vector<rvsdg::NodeNormalization<FPTruncOperation>>
    fpTruncOperationNormalizations({ FPTruncOperation::foldConstant });
 
static std::vector<rvsdg::NodeNormalization<IntegerEqOperation>> integerEqNormalizations(
    { IntegerEqOperation::foldConstants, IntegerEqOperation::normalizeIdenticalOperands });
 
static std::vector<rvsdg::NodeNormalization<IntegerNeOperation>> integerNeNormalizations(
    { IntegerNeOperation::foldConstants, IntegerNeOperation::normalizeIdenticalOperands });
 
static std::vector<rvsdg::NodeNormalization<IntegerSgeOperation>> integerSgeNormalizations(
    { IntegerSgeOperation::foldConstants, IntegerSgeOperation::normalizeIdenticalOperands });
 
static std::vector<rvsdg::NodeNormalization<IntegerSgtOperation>> integerSgtNormalizations(
    { IntegerSgtOperation::foldConstants, IntegerSgtOperation::normalizeIdenticalOperands });
 
static std::vector<rvsdg::NodeNormalization<IntegerSleOperation>> integerSleNormalizations(
    { IntegerSleOperation::foldConstants, IntegerSleOperation::normalizeIdenticalOperands });
 
static std::vector<rvsdg::NodeNormalization<IntegerSltOperation>> integerSltNormalizations(
    { IntegerSltOperation::foldConstants, IntegerSltOperation::normalizeIdenticalOperands });
 
static std::vector<rvsdg::NodeNormalization<IntegerUgeOperation>> integerUgeNormalizations(
    { IntegerUgeOperation::foldConstants, IntegerUgeOperation::normalizeIdenticalOperands });
 
static std::vector<rvsdg::NodeNormalization<IntegerUgtOperation>> integerUgtNormalizations(
    { IntegerUgtOperation::foldConstants, IntegerUgtOperation::normalizeIdenticalOperands });
 
static std::vector<rvsdg::NodeNormalization<IntegerUleOperation>> integerUleNormalizations(
    { IntegerUleOperation::foldConstants, IntegerUleOperation::normalizeIdenticalOperands });
 
static std::vector<rvsdg::NodeNormalization<IntegerUltOperation>> integerUltNormalizations(
    { IntegerUltOperation::foldConstants, IntegerUltOperation::normalizeIdenticalOperands });
 
static std::vector<rvsdg::NodeNormalization<IntegerAddOperation>>
    integerAddNormalizations({ IntegerAddOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<IntegerSubOperation>> integerSubNormalizations(
    { IntegerSubOperation::normalizeAdditiveInverse, IntegerSubOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<IntegerMulOperation>>
    integerMulNormalizations({ IntegerMulOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<IntegerSDivOperation>>
    integerSDivNormalizations({ IntegerSDivOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<IntegerUDivOperation>>
    integerUDivNormalizations({ IntegerUDivOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<IntegerSRemOperation>>
    integerSRemNormalizations({ IntegerSRemOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<IntegerURemOperation>>
    integerURemNormalizations({ IntegerURemOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<IntegerAShrOperation>>
    integerAShrNormalizations({ IntegerAShrOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<IntegerShlOperation>>
    integerShlNormalizations({ IntegerShlOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<IntegerLShrOperation>>
    integerLShrNormalizations({ IntegerLShrOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<IntegerAndOperation>>
    integerAndNormalizations({ IntegerAndOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<IntegerOrOperation>> integerOrNormalizations(
    { IntegerOrOperation::foldConstants, IntegerOrOperation::normalizeIdempotent });
 
static std::vector<rvsdg::NodeNormalization<IntegerXorOperation>>
    integerXorNormalizations({ IntegerXorOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<FBinaryOperation>>
    fpBinaryOpNormalizations({ FBinaryOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<LoadNonVolatileOperation>>
    loadNonVolatileNormalizations({ LoadNonVolatileOperation::NormalizeLoadStore,
                                    LoadNonVolatileOperation::NormalizeLoadAlloca,
                                    LoadNonVolatileOperation::NormalizeDuplicateStates,
                                    LoadNonVolatileOperation::NormalizeLoadStoreState,
                                    LoadNonVolatileOperation::normalizeMemoryHoistBarrierAddress });
 
static std::vector<rvsdg::NodeNormalization<StoreNonVolatileOperation>>
    storeNonVolatileNormalizations({ StoreNonVolatileOperation::NormalizeStoreMux,
                                     StoreNonVolatileOperation::normalizeStoreStore,
                                     StoreNonVolatileOperation::NormalizeStoreAlloca,
                                     StoreNonVolatileOperation::NormalizeDuplicateStates,
                                     StoreNonVolatileOperation::normalizeMemoryHoistBarrierAddress,
                                     StoreNonVolatileOperation::normalizeStoreAllocaSingleUser });
 
static std::vector<rvsdg::NodeNormalization<MemoryStateMergeOperation>>
    memoryStateMergeNormalizations({ MemoryStateMergeOperation::NormalizeSingleOperand,
                                     MemoryStateMergeOperation::NormalizeDuplicateOperands,
                                     MemoryStateMergeOperation::NormalizeNestedMerges,
                                     MemoryStateMergeOperation::NormalizeMergeSplit });
 
static std::vector<rvsdg::NodeNormalization<MemoryStateJoinOperation>>
    memoryStateJoinNormalizations({ MemoryStateJoinOperation::NormalizeSingleOperand,
                                    MemoryStateJoinOperation::NormalizeDuplicateOperands });
 
static std::vector<rvsdg::NodeNormalization<MemoryStateSplitOperation>>
    memoryStateSplitNormalizations({ MemoryStateSplitOperation::NormalizeSingleResult,
                                     MemoryStateSplitOperation::NormalizeNestedSplits,
                                     MemoryStateSplitOperation::NormalizeSplitMerge });
 
static std::vector<rvsdg::NodeNormalization<LambdaExitMemoryStateMergeOperation>>
    lambdaExitMemoryStateMergeNormalizations(
        { LambdaExitMemoryStateMergeOperation::NormalizeLoadFromAlloca,
          LambdaExitMemoryStateMergeOperation::NormalizeStoreToAlloca,
          LambdaExitMemoryStateMergeOperation::NormalizeAlloca });
 
static std::vector<rvsdg::NodeNormalization<PtrCmpOperation>>
    ptrCmpNormalizations({ PtrCmpOperation::normalizeNullPointerComparison,
                           PtrCmpOperation::normalizeIdenticalOperands });
 
static std::vector<rvsdg::NodeNormalization<GetElementPtrOperation>>
    getElementPtrNormalizations({ GetElementPtrOperation::normalizeIdempotent });
 
static std::vector<rvsdg::NodeNormalization<FCmpOperation>>
    fCmpNormalizations({ FCmpOperation::foldConstants });
 
static std::vector<rvsdg::NodeNormalization<MemoryHoistBarrierOperation>>
    memoryHoistBarrierNormalizations(
        { MemoryHoistBarrierOperation::normalizeNestedMemoryHoistBarriers });
 
static std::vector<rvsdg::NodeNormalization<rvsdg::BinaryOperation>>
    binaryOperationNormalizations({ rvsdg::NormalizeBinaryOperation });
 
template<typename TOperation>
static rvsdg::NodeNormalization<TOperation>
createNormalizer(const std::vector<rvsdg::NodeNormalization<TOperation>> & nodeNormalizations)
{
  return [&](const TOperation & operation, const std::vector<rvsdg::Output *> & operands)
  {
    return rvsdg::NormalizeSequence<TOperation>(nodeNormalizations, operation, operands);
  };
}
 
template<class TOperation>
static bool
reduceSimpleNode(
    rvsdg::SimpleNode & simpleNode,
    const std::vector<rvsdg::NodeNormalization<TOperation>> & normalizations,
    size_t & counter)
{
  auto normalizer = createNormalizer(normalizations);
  const bool reductionPerformed = rvsdg::ReduceNode<TOperation>(normalizer, simpleNode);
  if (reductionPerformed)
    counter += 1;
  return reductionPerformed;
}
 
NodeReduction::~NodeReduction() noexcept = default;
 
NodeReduction::NodeReduction()
    : Transformation("NodeReduction")
{}
 
void
NodeReduction::Run(
    rvsdg::RvsdgModule & rvsdgModule,
    util::StatisticsCollector & statisticsCollector)
{
  const auto & graph = rvsdgModule.Rvsdg();
 
  Statistics_ = Statistics::Create(rvsdgModule.SourceFilePath().value());
  Statistics_->Start(graph);
 
  ReduceNodesInRegion(graph.GetRootRegion());
 
  Statistics_->End(graph);
  statisticsCollector.CollectDemandedStatistics(std::move(Statistics_));
}
 
void
NodeReduction::ReduceNodesInRegion(rvsdg::Region & region)
{
  bool reductionPerformed = false;
  size_t numIterations = 0;
  do
  {
    numIterations++;
    reductionPerformed = false;
 
    for (const auto node : rvsdg::TopDownTraverser(&region))
    {
      MatchTypeOrFail(
          *node,
          [this, &reductionPerformed](rvsdg::StructuralNode & structuralNode)
          {
            reductionPerformed |= ReduceStructuralNode(structuralNode);
          },
          [this, &reductionPerformed](rvsdg::SimpleNode & simpleNode)
          {
            reductionPerformed |= ReduceSimpleNode(simpleNode);
          });
    }
 
    if (reductionPerformed)
    {
      // Let's remove all dead nodes in this region to avoid reductions on
      // dead nodes in the next iteration.
      region.prune(false);
    }
  } while (reductionPerformed);
 
  Statistics_->AddIteration(region, numIterations);
}
 
bool
NodeReduction::ReduceStructuralNode(rvsdg::StructuralNode & structuralNode)
{
  const bool reductionPerformed = rvsdg::MatchTypeWithDefault(
      structuralNode,
      [this](rvsdg::GammaNode & gammaNode)
      {
        return ReduceGammaNode(gammaNode);
      },
      [this](rvsdg::ThetaNode & thetaNode)
      {
        return reduceThetaNode(thetaNode);
      },
      []()
      {
        return false;
      });
 
  if (reductionPerformed)
  {
    // We cannot go through the subregions as the structural node might already have been removed.
    return true;
  }
 
  // Reduce all nodes in the subregions
  for (size_t n = 0; n < structuralNode.nsubregions(); n++)
  {
    const auto subregion = structuralNode.subregion(n);
    ReduceNodesInRegion(*subregion);
  }
 
  return false;
}
 
bool
NodeReduction::ReduceGammaNode(rvsdg::GammaNode & gammaNode)
{
  // FIXME: We can not apply the reduction below due to a bug. See github issue #303
  // rvsdg::ReduceGammaControlConstant
 
  const bool reductionPerformed = reduceStaticallyKnownPredicate(gammaNode);
  if (reductionPerformed)
    Statistics_->getReductionCounters().numGammaReductions++;
 
  return reductionPerformed;
}
 
bool
NodeReduction::reduceThetaNode(rvsdg::ThetaNode & thetaNode)
{
  const bool reductionPerformed = rvsdg::ThetaNode::reduceStaticallyKnownPredicate(thetaNode);
  if (reductionPerformed)
    Statistics_->getReductionCounters().numThetaReductions++;
 
  return reductionPerformed;
}
 
bool
NodeReduction::ReduceSimpleNode(rvsdg::SimpleNode & simpleNode)
{
  if (is<LoadNonVolatileOperation>(&simpleNode))
  {
    return reduceSimpleNode<LoadNonVolatileOperation>(
        simpleNode,
        loadNonVolatileNormalizations,
        Statistics_->getReductionCounters().numLoadNonVolatileReductions);
  }
  if (is<StoreNonVolatileOperation>(&simpleNode))
  {
    return reduceSimpleNode<StoreNonVolatileOperation>(
        simpleNode,
        storeNonVolatileNormalizations,
        Statistics_->getReductionCounters().numStoreNonVolatileReductions);
  }
  if (is<MemoryStateMergeOperation>(&simpleNode))
  {
    return reduceSimpleNode<MemoryStateMergeOperation>(
        simpleNode,
        memoryStateMergeNormalizations,
        Statistics_->getReductionCounters().numMemoryStateMergeReductions);
  }
  if (is<MemoryStateJoinOperation>(&simpleNode))
  {
    return reduceSimpleNode<MemoryStateJoinOperation>(
        simpleNode,
        memoryStateJoinNormalizations,
        Statistics_->getReductionCounters().numMemoryStateJoinReductions);
  }
  if (is<MemoryStateSplitOperation>(&simpleNode))
  {
    return reduceSimpleNode<MemoryStateSplitOperation>(
        simpleNode,
        memoryStateSplitNormalizations,
        Statistics_->getReductionCounters().numMemoryStateSplitReductions);
  }
  if (is<LambdaExitMemoryStateMergeOperation>(&simpleNode))
  {
    return reduceSimpleNode<LambdaExitMemoryStateMergeOperation>(
        simpleNode,
        lambdaExitMemoryStateMergeNormalizations,
        Statistics_->getReductionCounters().numLambdaExitMemoryStateMergeReductions);
  }
  if (is<rvsdg::MatchOperation>(&simpleNode))
  {
    return reduceSimpleNode<rvsdg::MatchOperation>(
        simpleNode,
        matchOperationNormalizations,
        Statistics_->getReductionCounters().numMatchReductions);
  }
  if (is<SExtOperation>(&simpleNode))
  {
    return reduceSimpleNode<SExtOperation>(
        simpleNode,
        sextOperationNormalizations,
        Statistics_->getReductionCounters().numSExtReductions);
  }
  if (is<ZExtOperation>(&simpleNode))
  {
    return reduceSimpleNode<ZExtOperation>(
        simpleNode,
        zextOperationNormalizations,
        Statistics_->getReductionCounters().numZExtReductions);
  }
  if (is<TruncOperation>(&simpleNode))
  {
    return reduceSimpleNode<TruncOperation>(
        simpleNode,
        truncOperationNormalizations,
        Statistics_->getReductionCounters().numTruncReductions);
  }
  if (is<FPExtOperation>(&simpleNode))
  {
    return reduceSimpleNode<FPExtOperation>(
        simpleNode,
        fpExtOperationNormalizations,
        Statistics_->getReductionCounters().numFPExtReductions);
  }
  if (is<FPTruncOperation>(&simpleNode))
  {
    return reduceSimpleNode<FPTruncOperation>(
        simpleNode,
        fpTruncOperationNormalizations,
        Statistics_->getReductionCounters().numFPTruncReductions);
  }
  if (is<IntegerEqOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerEqOperation>(
        simpleNode,
        integerEqNormalizations,
        Statistics_->getReductionCounters().numIntegerEqReductions);
  }
  if (is<IntegerNeOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerNeOperation>(
        simpleNode,
        integerNeNormalizations,
        Statistics_->getReductionCounters().numIntegerNeReductions);
  }
  if (is<IntegerSgeOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerSgeOperation>(
        simpleNode,
        integerSgeNormalizations,
        Statistics_->getReductionCounters().numIntegerSgeReductions);
  }
  if (is<IntegerSgtOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerSgtOperation>(
        simpleNode,
        integerSgtNormalizations,
        Statistics_->getReductionCounters().numIntegerSgtReductions);
  }
  if (is<IntegerSleOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerSleOperation>(
        simpleNode,
        integerSleNormalizations,
        Statistics_->getReductionCounters().numIntegerSleReductions);
  }
  if (is<IntegerSltOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerSltOperation>(
        simpleNode,
        integerSltNormalizations,
        Statistics_->getReductionCounters().numIntegerSltReductions);
  }
  if (is<IntegerUgeOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerUgeOperation>(
        simpleNode,
        integerUgeNormalizations,
        Statistics_->getReductionCounters().numIntegerUgeReductions);
  }
  if (is<IntegerUgtOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerUgtOperation>(
        simpleNode,
        integerUgtNormalizations,
        Statistics_->getReductionCounters().numIntegerUgtReductions);
  }
  if (is<IntegerUleOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerUleOperation>(
        simpleNode,
        integerUleNormalizations,
        Statistics_->getReductionCounters().numIntegerUleReductions);
  }
  if (is<IntegerUltOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerUltOperation>(
        simpleNode,
        integerUltNormalizations,
        Statistics_->getReductionCounters().numIntegerUltReductions);
  }
  if (is<IntegerAddOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerAddOperation>(
        simpleNode,
        integerAddNormalizations,
        Statistics_->getReductionCounters().numIntegerAddReductions);
  }
  if (is<IntegerSubOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerSubOperation>(
        simpleNode,
        integerSubNormalizations,
        Statistics_->getReductionCounters().numIntegerSubReductions);
  }
  if (is<IntegerMulOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerMulOperation>(
        simpleNode,
        integerMulNormalizations,
        Statistics_->getReductionCounters().numIntegerMulReductions);
  }
  if (is<IntegerSDivOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerSDivOperation>(
        simpleNode,
        integerSDivNormalizations,
        Statistics_->getReductionCounters().numIntegerSDivReductions);
  }
  if (is<IntegerUDivOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerUDivOperation>(
        simpleNode,
        integerUDivNormalizations,
        Statistics_->getReductionCounters().numIntegerUDivReductions);
  }
  if (is<IntegerSRemOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerSRemOperation>(
        simpleNode,
        integerSRemNormalizations,
        Statistics_->getReductionCounters().numIntegerSRemReductions);
  }
  if (is<IntegerURemOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerURemOperation>(
        simpleNode,
        integerURemNormalizations,
        Statistics_->getReductionCounters().numIntegerURemReductions);
  }
  if (is<IntegerAShrOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerAShrOperation>(
        simpleNode,
        integerAShrNormalizations,
        Statistics_->getReductionCounters().numIntegerAShrReductions);
  }
  if (is<IntegerShlOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerShlOperation>(
        simpleNode,
        integerShlNormalizations,
        Statistics_->getReductionCounters().numIntegerShlReductions);
  }
  if (is<IntegerLShrOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerLShrOperation>(
        simpleNode,
        integerLShrNormalizations,
        Statistics_->getReductionCounters().numIntegerLShrReductions);
  }
  if (is<IntegerAndOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerAndOperation>(
        simpleNode,
        integerAndNormalizations,
        Statistics_->getReductionCounters().numIntegerAndReductions);
  }
  if (is<IntegerOrOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerOrOperation>(
        simpleNode,
        integerOrNormalizations,
        Statistics_->getReductionCounters().numIntegerOrReductions);
  }
  if (is<IntegerXorOperation>(&simpleNode))
  {
    return reduceSimpleNode<IntegerXorOperation>(
        simpleNode,
        integerXorNormalizations,
        Statistics_->getReductionCounters().numIntegerXorReductions);
  }
  if (is<FBinaryOperation>(&simpleNode))
  {
    return reduceSimpleNode<FBinaryOperation>(
        simpleNode,
        fpBinaryOpNormalizations,
        Statistics_->getReductionCounters().numFPBinaryOpReductions);
  }
  if (is<PtrCmpOperation>(&simpleNode))
  {
    return reduceSimpleNode<PtrCmpOperation>(
        simpleNode,
        ptrCmpNormalizations,
        Statistics_->getReductionCounters().numPtrCmpReductions);
  }
  if (is<GetElementPtrOperation>(&simpleNode))
  {
    return reduceSimpleNode<GetElementPtrOperation>(
        simpleNode,
        getElementPtrNormalizations,
        Statistics_->getReductionCounters().numGetElementPtrReductions);
  }
  if (is<FCmpOperation>(&simpleNode))
  {
    return reduceSimpleNode<FCmpOperation>(
        simpleNode,
        fCmpNormalizations,
        Statistics_->getReductionCounters().numFCmpReductions);
  }
  if (is<MemoryHoistBarrierOperation>(&simpleNode))
  {
    return reduceSimpleNode<MemoryHoistBarrierOperation>(
        simpleNode,
        memoryHoistBarrierNormalizations,
        Statistics_->getReductionCounters().numMemoryHoistBarrierReductions);
  }
  if (is<rvsdg::BinaryOperation>(&simpleNode))
  {
    return reduceSimpleNode<rvsdg::BinaryOperation>(
        simpleNode,
        binaryOperationNormalizations,
        Statistics_->getReductionCounters().numBinaryReductions);
  }
 
  return false;
}
 
}