1//===- InferIntDivisibilityOpInterfaceImpl.cpp ----------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Direct implementations of `InferIntDivisibilityOpInterface` for arith ops.
10//
11//===----------------------------------------------------------------------===//
12
13#include "mlir/Dialect/Arith/IR/Arith.h"
14#include "mlir/IR/Matchers.h"
15#include "mlir/Interfaces/InferIntDivisibilityOpInterface.h"
16
17#include <cstdlib>
18
19using namespace mlir;
20using namespace mlir::arith;
21
22static ConstantIntDivisibility
23getDivisibilityOfOperand(Value v, IntegerDivisibility divisibility) {
24 if (!divisibility.isUninitialized())
25 return divisibility.getValue();
26 APInt intVal;
27 if (matchPattern(value: v, pattern: m_ConstantInt(bind_value: &intVal))) {
28 uint64_t udiv = intVal.getZExtValue();
29 uint64_t sdiv = std::abs(i: intVal.getSExtValue());
30 return ConstantIntDivisibility(udiv, sdiv);
31 }
32 return ConstantIntDivisibility(1, 1);
33}
34
35// Result divisibility is the GCD (union) of the operand divisibilities.
36template <typename OpTy>
37static void
38inferBinaryGCDResultDivisibility(OpTy op, ArrayRef<IntegerDivisibility> argDivs,
39 SetIntDivisibilityFn setResultDivs) {
40 auto lhsDiv = getDivisibilityOfOperand(op.getLhs(), argDivs[0]);
41 auto rhsDiv = getDivisibilityOfOperand(op.getRhs(), argDivs[1]);
42 setResultDivs(op.getResult(), lhsDiv.getUnion(rhsDiv));
43}
44
45void ConstantOp::inferResultDivisibility(ArrayRef<IntegerDivisibility> argDivs,
46 SetIntDivisibilityFn setResultDivs) {
47 auto constAttr = dyn_cast_if_present<IntegerAttr>(Val: getValue());
48 if (!constAttr)
49 return;
50 const APInt &value = constAttr.getValue();
51 uint64_t udiv = value.getZExtValue();
52 uint64_t sdiv = std::abs(i: value.getSExtValue());
53 setResultDivs(getResult(), ConstantIntDivisibility(udiv, sdiv));
54}
55
56void AddIOp::inferResultDivisibility(ArrayRef<IntegerDivisibility> argDivs,
57 SetIntDivisibilityFn setResultDivs) {
58 inferBinaryGCDResultDivisibility(op: *this, argDivs, setResultDivs);
59}
60
61void SubIOp::inferResultDivisibility(ArrayRef<IntegerDivisibility> argDivs,
62 SetIntDivisibilityFn setResultDivs) {
63 inferBinaryGCDResultDivisibility(op: *this, argDivs, setResultDivs);
64}
65
66void MinUIOp::inferResultDivisibility(ArrayRef<IntegerDivisibility> argDivs,
67 SetIntDivisibilityFn setResultDivs) {
68 inferBinaryGCDResultDivisibility(op: *this, argDivs, setResultDivs);
69}
70
71void MaxUIOp::inferResultDivisibility(ArrayRef<IntegerDivisibility> argDivs,
72 SetIntDivisibilityFn setResultDivs) {
73 inferBinaryGCDResultDivisibility(op: *this, argDivs, setResultDivs);
74}
75
76void MinSIOp::inferResultDivisibility(ArrayRef<IntegerDivisibility> argDivs,
77 SetIntDivisibilityFn setResultDivs) {
78 inferBinaryGCDResultDivisibility(op: *this, argDivs, setResultDivs);
79}
80
81void MaxSIOp::inferResultDivisibility(ArrayRef<IntegerDivisibility> argDivs,
82 SetIntDivisibilityFn setResultDivs) {
83 inferBinaryGCDResultDivisibility(op: *this, argDivs, setResultDivs);
84}
85
86void MulIOp::inferResultDivisibility(ArrayRef<IntegerDivisibility> argDivs,
87 SetIntDivisibilityFn setResultDivs) {
88 auto lhsDivisibility = getDivisibilityOfOperand(v: getLhs(), divisibility: argDivs[0]);
89 auto rhsDivisibility = getDivisibilityOfOperand(v: getRhs(), divisibility: argDivs[1]);
90
91 uint64_t mulUDiv = lhsDivisibility.udiv() * rhsDivisibility.udiv();
92 uint64_t mulSDiv = lhsDivisibility.sdiv() * rhsDivisibility.sdiv();
93
94 setResultDivs(getResult(), ConstantIntDivisibility(mulUDiv, mulSDiv));
95}
96
97void DivUIOp::inferResultDivisibility(ArrayRef<IntegerDivisibility> argDivs,
98 SetIntDivisibilityFn setResultDivs) {
99 APInt intVal;
100 if (!matchPattern(value: getRhs(), pattern: m_ConstantInt(bind_value: &intVal)))
101 return;
102
103 // Division by zero is undefined, so there is nothing to infer.
104 if (intVal.isZero())
105 return;
106
107 auto lhsDivisibility = getDivisibilityOfOperand(v: getLhs(), divisibility: argDivs[0]);
108
109 uint64_t divUDiv = lhsDivisibility.udiv() % intVal.getZExtValue() == 0
110 ? lhsDivisibility.udiv() / intVal.getZExtValue()
111 : 1;
112 uint64_t divSDiv =
113 lhsDivisibility.sdiv() % std::abs(i: intVal.getSExtValue()) == 0
114 ? lhsDivisibility.sdiv() / std::abs(i: intVal.getSExtValue())
115 : 1;
116
117 setResultDivs(getResult(), ConstantIntDivisibility(divUDiv, divSDiv));
118}
119
120void SelectOp::inferResultDivisibility(ArrayRef<IntegerDivisibility> argDivs,
121 SetIntDivisibilityFn setResultDivs) {
122 // argDivs[0] is the condition (i1), argDivs[1] is true, argDivs[2] is false.
123 auto trueDiv = getDivisibilityOfOperand(v: getTrueValue(), divisibility: argDivs[1]);
124 auto falseDiv = getDivisibilityOfOperand(v: getFalseValue(), divisibility: argDivs[2]);
125 setResultDivs(getResult(), trueDiv.getUnion(other: falseDiv));
126}
127