PruneZeroValuedLogic.cpp

Go to the documentation of this file.

//===- PruneZeroValuedLogic.cpp - Prune zero-valued logic -----------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This transform removes zero-valued logic from a `hw.module`.
//
//===----------------------------------------------------------------------===//
 
#include "ExportVerilogInternals.h"
#include "circt/Dialect/Comb/CombOps.h"
#include "circt/Dialect/HW/HWOps.h"
#include "circt/Dialect/HW/HWPasses.h"
#include "circt/Dialect/Seq/SeqOps.h"
#include "circt/Support/LLVM.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Transforms/DialectConversion.h"
 
using namespace circt;
using namespace hw;
 
static bool noI0Type(TypeRange types) {
  return llvm::none_of(
      types, [](Type type) { return ExportVerilog::isZeroBitType(type); });
}
 
static bool noI0TypedValue(ValueRange values) {
  return noI0Type(values.getTypes());
}
 
/// Flatten the given value ranges into a single vector of values.
static SmallVector<Value> flattenValues(ArrayRef<ValueRange> values) {
  SmallVector<Value> result;
  for (const auto &vals : values)
    llvm::append_range(result, vals);
  return result;
}
 
namespace {
 
class PruneTypeConverter : public mlir::TypeConverter {
public:
  PruneTypeConverter() {
    addConversion([&](Type type, SmallVectorImpl<Type> &results) {
      if (!ExportVerilog::isZeroBitType(type))
        results.push_back(type);
      return success();
    });
  }
};
 
template <typename TOp>
struct NoI0OperandsConversionPattern : public OpConversionPattern<TOp> {
public:
  using OpConversionPattern<TOp>::OpConversionPattern;
  using OpAdaptor = typename OpConversionPattern<TOp>::OpAdaptor;
  using OneToNOpAdaptor = typename OpConversionPattern<TOp>::OneToNOpAdaptor;
 
  LogicalResult
  matchAndRewrite(TOp op, OneToNOpAdaptor adaptor,
                  ConversionPatternRewriter &rewriter) const override {
    SmallVector<Value> flattenedOperands = flattenValues(adaptor.getOperands());
 
    // flattenedOperands may be empty (in case all operands are i0 typed and
    // have already been pruned. Then the 1:N adaptor will reflect this as no
    // operands).
    if (!flattenedOperands.empty() && noI0TypedValue(flattenedOperands))
      return failure();
 
    // Part of i0-typed logic - prune it!
    rewriter.eraseOp(op);
    return success();
  }
};
 
template <typename... TOp>
static void addNoI0OperandsLegalizationPattern(ConversionTarget &target) {
  target.addDynamicallyLegalOp<TOp...>(
      [&](auto op) { return noI0TypedValue(op->getOperands()); });
}
 
template <>
struct NoI0OperandsConversionPattern<comb::ICmpOp>
    : public OpConversionPattern<comb::ICmpOp> {
public:
  using OpConversionPattern<comb::ICmpOp>::OpConversionPattern;
  using OpAdaptor = typename OpConversionPattern<comb::ICmpOp>::OpAdaptor;
  using OneToNOpAdaptor =
      typename OpConversionPattern<comb::ICmpOp>::OneToNOpAdaptor;
 
  // Returns the result of applying the predicate when the LHS and RHS are the
  // exact same value.
  static bool
  applyCmpPredicateToEqualOperands(circt::comb::ICmpPredicate predicate) {
    switch (predicate) {
    case circt::comb::ICmpPredicate::eq:
    case circt::comb::ICmpPredicate::sle:
    case circt::comb::ICmpPredicate::sge:
    case circt::comb::ICmpPredicate::ule:
    case circt::comb::ICmpPredicate::uge:
    case circt::comb::ICmpPredicate::ceq:
    case circt::comb::ICmpPredicate::weq:
      return true;
    case circt::comb::ICmpPredicate::ne:
    case circt::comb::ICmpPredicate::slt:
    case circt::comb::ICmpPredicate::sgt:
    case circt::comb::ICmpPredicate::ult:
    case circt::comb::ICmpPredicate::ugt:
    case circt::comb::ICmpPredicate::cne:
    case circt::comb::ICmpPredicate::wne:
      return false;
    }
    llvm_unreachable("unknown comparison predicate");
  }
 
  LogicalResult
  matchAndRewrite(comb::ICmpOp op, OneToNOpAdaptor adaptor,
                  ConversionPatternRewriter &rewriter) const override {
    if (noI0TypedValue(flattenValues(adaptor.getOperands())))
      return failure();
 
    // Caluculate the result of i0 value comparison.
    bool result = applyCmpPredicateToEqualOperands(op.getPredicate());
 
    rewriter.replaceOpWithNewOp<hw::ConstantOp>(
        op, APInt(1, result, /*isSigned=*/false));
    return success();
  }
};
 
template <>
struct NoI0OperandsConversionPattern<comb::ParityOp>
    : public OpConversionPattern<comb::ParityOp> {
public:
  using OpConversionPattern<comb::ParityOp>::OpConversionPattern;
  using OpAdaptor = typename OpConversionPattern<comb::ParityOp>::OpAdaptor;
  using OneToNOpAdaptor =
      typename OpConversionPattern<comb::ParityOp>::OneToNOpAdaptor;
 
  LogicalResult
  matchAndRewrite(comb::ParityOp op, OneToNOpAdaptor adaptor,
                  ConversionPatternRewriter &rewriter) const override {
    SmallVector<Value> flattenedOperands = flattenValues(adaptor.getOperands());
    if (!flattenedOperands.empty() && noI0TypedValue(flattenedOperands))
      return failure();
 
    // The value of "comb.parity i0" is 0.
    rewriter.replaceOpWithNewOp<hw::ConstantOp>(
        op, APInt(1, 0, /*isSigned=*/false));
    return success();
  }
};
 
template <>
struct NoI0OperandsConversionPattern<comb::ConcatOp>
    : public OpConversionPattern<comb::ConcatOp> {
public:
  using OpConversionPattern<comb::ConcatOp>::OpConversionPattern;
  using OpAdaptor = typename OpConversionPattern<comb::ConcatOp>::OpAdaptor;
  using OneToNOpAdaptor =
      typename OpConversionPattern<comb::ConcatOp>::OneToNOpAdaptor;
 
  LogicalResult
  matchAndRewrite(comb::ConcatOp op, OneToNOpAdaptor adaptor,
                  ConversionPatternRewriter &rewriter) const override {
    // Replace an i0 value with i0 constant.
    if (op.getType().isInteger(0)) {
      rewriter.replaceOpWithNewOp<hw::ConstantOp>(
          op, APInt(1, 0, /*isSigned=*/false));
      return success();
    }
 
    SmallVector<Value> materializedOperands =
        flattenValues(adaptor.getOperands());
 
    // If the materializedOperands are the same as the original operands, then
    // there were no i0 operands. If not, then that means that this op used to
    // have an i0 operand but materialization removed that operand, as reflect
    // in the 1:N operand adaptor.
    if (materializedOperands.size() == adaptor.getOperands().size())
      return failure();
 
    // Create a new concat op with the materialized operands.
    rewriter.replaceOpWithNewOp<comb::ConcatOp>(op, materializedOperands);
    return success();
  }
};
 
// A generic pruning pattern which prunes any operation which has an operand
// with an i0 typed value. Similarly, an operation is legal if all of its
// operands are not i0 typed.
template <typename TOp>
struct NoI0OperandPruningPattern {
  using ConversionPattern = NoI0OperandsConversionPattern<TOp>;
  static void addLegalizer(ConversionTarget &target) {
    addNoI0OperandsLegalizationPattern<TOp>(target);
  }
};
 
// The NoI0ResultsConversionPattern will aggressively remove any operation
// which has a zero-width result. Furthermore, it will recursively erase any
// downstream users of the operation.
template <typename TOp>
struct NoI0ResultsConversionPattern : public OpConversionPattern<TOp> {
public:
  using OpConversionPattern<TOp>::OpConversionPattern;
  using OneToNOpAdaptor = typename OpConversionPattern<TOp>::OneToNOpAdaptor;
 
  LogicalResult
  matchAndRewrite(TOp op, OneToNOpAdaptor adaptor,
                  ConversionPatternRewriter &rewriter) const override {
    if (noI0TypedValue(op->getResults()))
      return failure();
 
    // Part of i0-typed logic - prune!
    assert(op->getNumResults() == 1 &&
           "expected single result if using rewriter.replaceOpWith");
    rewriter.replaceOpWithNewOp<hw::ConstantOp>(
        op, APInt(0, 0, /*isSigned=*/false));
    return success();
  }
};
 
template <typename... TOp>
static void addNoI0ResultsLegalizationPattern(ConversionTarget &target) {
  target.addDynamicallyLegalOp<TOp...>(
      [&](auto op) { return noI0TypedValue(op->getResults()); });
}
 
// A generic pruning pattern which prunes any operation that returns an i0
// value.
template <typename TOp>
struct NoI0ResultPruningPattern {
  using ConversionPattern = NoI0ResultsConversionPattern<TOp>;
  static void addLegalizer(ConversionTarget &target) {
    addNoI0ResultsLegalizationPattern<TOp>(target);
  }
};
 
// Adds a pruning pattern to the conversion target. TPattern is expected to
// provides ConversionPattern definition and an addLegalizer function.
template <typename... TPattern>
static void addPruningPattern(ConversionTarget &target,
                              RewritePatternSet &patterns,
                              PruneTypeConverter &typeConverter) {
  (patterns.add<typename TPattern::ConversionPattern>(typeConverter,
                                                      patterns.getContext()),
   ...);
  (TPattern::addLegalizer(target), ...);
}
 
template <typename... TOp>
static void addNoI0ResultPruningPattern(ConversionTarget &target,
                                        RewritePatternSet &patterns,
                                        PruneTypeConverter &typeConverter) {
  (patterns.add<typename NoI0ResultPruningPattern<TOp>::ConversionPattern>(
       typeConverter, patterns.getContext()),
   ...);
  (NoI0ResultPruningPattern<TOp>::addLegalizer(target), ...);
}
 
} // namespace
 
void ExportVerilog::pruneZeroValuedLogic(HWEmittableModuleLike module) {
  ConversionTarget target(*module->getContext());
  RewritePatternSet patterns(module->getContext());
  PruneTypeConverter typeConverter;
 
  target.addLegalDialect<sv::SVDialect, comb::CombDialect, hw::HWDialect>();
  addPruningPattern<NoI0OperandPruningPattern<sv::PAssignOp>,
                    NoI0OperandPruningPattern<sv::BPAssignOp>,
                    NoI0OperandPruningPattern<sv::AssignOp>,
                    NoI0OperandPruningPattern<comb::ICmpOp>,
                    NoI0OperandPruningPattern<comb::ParityOp>,
                    NoI0OperandPruningPattern<comb::ConcatOp>>(target, patterns,
                                                               typeConverter);
 
  addNoI0ResultPruningPattern<
      // SV ops
      sv::WireOp, sv::RegOp, sv::ReadInOutOp,
      // Prune all zero-width combinational logic.
      comb::AddOp, comb::AndOp, comb::DivSOp, comb::DivUOp, comb::ExtractOp,
      comb::ModSOp, comb::ModUOp, comb::MulOp, comb::MuxOp, comb::OrOp,
      comb::ReplicateOp, comb::ShlOp, comb::ShrSOp, comb::ShrUOp, comb::SubOp,
      comb::XorOp>(target, patterns, typeConverter);
 
  (void)applyPartialConversion(module, target, std::move(patterns));
}