[MooreToCore] Support pow op

[fabianschuiki]

Add support for the moore.pow* ops in MooreToCore: https://chipsalliance.github.io/sv-tests-results/?v=circt_verilog+11.4.3+binary_op_pow

[maerhart]

We already have canonicalizers and folders that cover the simple cases here:

circt/lib/Dialect/Moore/MooreOps.cpp

Lines 1131 to 1197 in 337dad5

	//===----------------------------------------------------------------------===//
	// PowSOp
	//===----------------------------------------------------------------------===//
	static OpFoldResult powCommonFolding(MLIRContext *ctxt, Attribute lhs,
	Attribute rhs) {
	auto lhsValue = dyn_cast_or_null<FVIntegerAttr>(lhs);
	if (lhsValue && lhsValue.getValue() == 1)
	return lhs;
	auto rhsValue = dyn_cast_or_null<FVIntegerAttr>(rhs);
	if (rhsValue && rhsValue.getValue().isZero())
	return FVIntegerAttr::get(ctxt,
	FVInt(rhsValue.getValue().getBitWidth(), 1));
	return {};
	}
	OpFoldResult PowSOp::fold(FoldAdaptor adaptor) {
	return powCommonFolding(getContext(), adaptor.getLhs(), adaptor.getRhs());
	}
	LogicalResult PowSOp::canonicalize(PowSOp op, PatternRewriter &rewriter) {
	Location loc = op.getLoc();
	auto intType = cast<IntType>(op.getRhs().getType());
	if (auto baseOp = op.getLhs().getDefiningOp<ConstantOp>()) {
	if (baseOp.getValue() == 2) {
	Value constOne = rewriter.create<ConstantOp>(loc, intType, 1);
	Value constZero = rewriter.create<ConstantOp>(loc, intType, 0);
	Value shift = rewriter.create<ShlOp>(loc, constOne, op.getRhs());
	Value isNegative = rewriter.create<SltOp>(loc, op.getRhs(), constZero);
	auto condOp = rewriter.replaceOpWithNewOp<ConditionalOp>(
	op, op.getLhs().getType(), isNegative);
	Block *thenBlock = rewriter.createBlock(&condOp.getTrueRegion());
	rewriter.setInsertionPointToStart(thenBlock);
	rewriter.create<YieldOp>(loc, constZero);
	Block *elseBlock = rewriter.createBlock(&condOp.getFalseRegion());
	rewriter.setInsertionPointToStart(elseBlock);
	rewriter.create<YieldOp>(loc, shift);
	return success();
	}
	}
	return failure();
	}
	//===----------------------------------------------------------------------===//
	// PowUOp
	//===----------------------------------------------------------------------===//
	OpFoldResult PowUOp::fold(FoldAdaptor adaptor) {
	return powCommonFolding(getContext(), adaptor.getLhs(), adaptor.getRhs());
	}
	LogicalResult PowUOp::canonicalize(PowUOp op, PatternRewriter &rewriter) {
	Location loc = op.getLoc();
	auto intType = cast<IntType>(op.getRhs().getType());
	if (auto baseOp = op.getLhs().getDefiningOp<ConstantOp>()) {
	if (baseOp.getValue() == 2) {
	Value constOne = rewriter.create<ConstantOp>(loc, intType, 1);
	rewriter.replaceOpWithNewOp<ShlOp>(op, constOne, op.getRhs());
	return success();
	}
	}
	return failure();
	}

The folders are automatically called during Dialect Conversion, the canonicalization aren't.

@fabianschuiki How should the a ** b case in the table be handled here? Since there's no pow op in Comb.

[fabianschuiki]

👍 We could start out with a pretty dumb iterative approach? Maybe an scf.for that just goes from 0 to b and keeps multiplying a result by a? Pretty sure this almost never comes up in practice, and that would make it more of a performance issue than a correctness issue.