[MooreToCore] Lowering to math.ipow?

[cowardsa]

Is there a strong reason to go from PowUOp to math.ipow as opposed to lowering to a sequence of multiplications?

Is there any existing lowering from math.ipow to the core dialects?

circt/lib/Conversion/MooreToCore/MooreToCore.cpp

Lines 1379 to 1398 in 83effb2

	LogicalResult
	matchAndRewrite(PowUOp op, OpAdaptor adaptor,
	ConversionPatternRewriter &rewriter) const override {
	Type resultType = typeConverter->convertType(op.getResult().getType());
	Location loc = op->getLoc();
	Value zeroVal = hw::ConstantOp::create(rewriter, loc, APInt(1, 0));
	// zero extend both LHS & RHS to ensure the unsigned integers are
	// interpreted correctly when calculating power
	auto lhs = comb::ConcatOp::create(rewriter, loc, zeroVal, adaptor.getLhs());
	auto rhs = comb::ConcatOp::create(rewriter, loc, zeroVal, adaptor.getRhs());
	// lower the exponentiation via MLIR's math dialect
	auto pow = mlir::math::IPowIOp::create(rewriter, loc, lhs, rhs);
	rewriter.replaceOpWithNewOp<comb::ExtractOp>(op, resultType, pow, 0);
	return success();
	}
	};

[uenoku]

I think rhs could be non-constant in simulation code so using math.ipow in MooreToCore seems ok. I think having a lowering pass from math.ipow to comb.mul for constant-rhs looks reasonable

[fabianschuiki]

We could also cook up a comb.pow op and only go to math.ipow when we lower Comb to LLVM. I guess pow is a bit like division, where you only rarely go with the synthesizer-build-me-a-combinational-divider result. But maybe it's useful to track in Comb especially because SV has syntax for it?

[cowardsa]

Agree with Fabian that it's very division like - but hadn't thought about simulation. Perhaps we need both - constant powers lowered to multiplication and non-constants lowered to comb.

How is division by a power of two handled? (feels quite similar) Is it a canonicalization pattern?

[fabianschuiki]

I don't see any canonicalizations in CombFolds.cpp for comb.divu or comb.divs. We only have folders for trivial division by one. But we also don't seem to handle divisions by constants, and divisions by powers-of-two for that matter. Might make sense to turn those into shifts.

[uenoku]

FYI regarding CombToSynth an unsigned division by a power of two is lowered into a shift, otherwise it's lowered to a truth-table if unknown input bits are less than a constant specified by a pass option.