Skip to content

Commit 4ae9fdc

Browse files
maksleventalmakslevental
authored
[mlir][NFC] update Conversion create APIs (6/n) (#149888)
See #147168 for more info.
1 parent f904cdd commit 4ae9fdc

File tree

22 files changed

+1046
-992
lines changed

22 files changed

+1046
-992
lines changed

‎mlir/lib/Conversion/IndexToLLVM/IndexToLLVM.cpp

Lines changed: 36 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -36,34 +36,34 @@ struct ConvertIndexCeilDivS : mlir::ConvertOpToLLVMPattern<CeilDivSOp> {
3636
Location loc = op.getLoc();
3737
Value n = adaptor.getLhs();
3838
Value m = adaptor.getRhs();
39-
Value zero = rewriter.create<LLVM::ConstantOp>(loc, n.getType(), 0);
40-
Value posOne = rewriter.create<LLVM::ConstantOp>(loc, n.getType(), 1);
41-
Value negOne = rewriter.create<LLVM::ConstantOp>(loc, n.getType(), -1);
39+
Value zero = LLVM::ConstantOp::create(rewriter, loc, n.getType(), 0);
40+
Value posOne = LLVM::ConstantOp::create(rewriter, loc, n.getType(), 1);
41+
Value negOne = LLVM::ConstantOp::create(rewriter, loc, n.getType(), -1);
4242

4343
// Compute `x`.
4444
Value mPos =
45-
rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sgt, m, zero);
46-
Value x = rewriter.create<LLVM::SelectOp>(loc, mPos, negOne, posOne);
45+
LLVM::ICmpOp::create(rewriter, loc, LLVM::ICmpPredicate::sgt, m, zero);
46+
Value x = LLVM::SelectOp::create(rewriter, loc, mPos, negOne, posOne);
4747

4848
// Compute the positive result.
49-
Value nPlusX = rewriter.create<LLVM::AddOp>(loc, n, x);
50-
Value nPlusXDivM = rewriter.create<LLVM::SDivOp>(loc, nPlusX, m);
51-
Value posRes = rewriter.create<LLVM::AddOp>(loc, nPlusXDivM, posOne);
49+
Value nPlusX = LLVM::AddOp::create(rewriter, loc, n, x);
50+
Value nPlusXDivM = LLVM::SDivOp::create(rewriter, loc, nPlusX, m);
51+
Value posRes = LLVM::AddOp::create(rewriter, loc, nPlusXDivM, posOne);
5252

5353
// Compute the negative result.
54-
Value negN = rewriter.create<LLVM::SubOp>(loc, zero, n);
55-
Value negNDivM = rewriter.create<LLVM::SDivOp>(loc, negN, m);
56-
Value negRes = rewriter.create<LLVM::SubOp>(loc, zero, negNDivM);
54+
Value negN = LLVM::SubOp::create(rewriter, loc, zero, n);
55+
Value negNDivM = LLVM::SDivOp::create(rewriter, loc, negN, m);
56+
Value negRes = LLVM::SubOp::create(rewriter, loc, zero, negNDivM);
5757

5858
// Pick the positive result if `n` and `m` have the same sign and `n` is
5959
// non-zero, i.e. `(n > 0) == (m > 0) && n != 0`.
6060
Value nPos =
61-
rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::sgt, n, zero);
62-
Value sameSign =
63-
rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, nPos, mPos);
61+
LLVM::ICmpOp::create(rewriter, loc, LLVM::ICmpPredicate::sgt, n, zero);
62+
Value sameSign = LLVM::ICmpOp::create(rewriter, loc,
63+
LLVM::ICmpPredicate::eq, nPos, mPos);
6464
Value nNonZero =
65-
rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, n, zero);
66-
Value cmp = rewriter.create<LLVM::AndOp>(loc, sameSign, nNonZero);
65+
LLVM::ICmpOp::create(rewriter, loc, LLVM::ICmpPredicate::ne, n, zero);
66+
Value cmp = LLVM::AndOp::create(rewriter, loc, sameSign, nNonZero);
6767
rewriter.replaceOpWithNewOp<LLVM::SelectOp>(op, cmp, posRes, negRes);
6868
return success();
6969
}
@@ -83,17 +83,17 @@ struct ConvertIndexCeilDivU : mlir::ConvertOpToLLVMPattern<CeilDivUOp> {
8383
Location loc = op.getLoc();
8484
Value n = adaptor.getLhs();
8585
Value m = adaptor.getRhs();
86-
Value zero = rewriter.create<LLVM::ConstantOp>(loc, n.getType(), 0);
87-
Value one = rewriter.create<LLVM::ConstantOp>(loc, n.getType(), 1);
86+
Value zero = LLVM::ConstantOp::create(rewriter, loc, n.getType(), 0);
87+
Value one = LLVM::ConstantOp::create(rewriter, loc, n.getType(), 1);
8888

8989
// Compute the non-zero result.
90-
Value minusOne = rewriter.create<LLVM::SubOp>(loc, n, one);
91-
Value quotient = rewriter.create<LLVM::UDivOp>(loc, minusOne, m);
92-
Value plusOne = rewriter.create<LLVM::AddOp>(loc, quotient, one);
90+
Value minusOne = LLVM::SubOp::create(rewriter, loc, n, one);
91+
Value quotient = LLVM::UDivOp::create(rewriter, loc, minusOne, m);
92+
Value plusOne = LLVM::AddOp::create(rewriter, loc, quotient, one);
9393

9494
// Pick the result.
9595
Value cmp =
96-
rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, n, zero);
96+
LLVM::ICmpOp::create(rewriter, loc, LLVM::ICmpPredicate::eq, n, zero);
9797
rewriter.replaceOpWithNewOp<LLVM::SelectOp>(op, cmp, zero, plusOne);
9898
return success();
9999
}
@@ -114,32 +114,32 @@ struct ConvertIndexFloorDivS : mlir::ConvertOpToLLVMPattern<FloorDivSOp> {
114114
Location loc = op.getLoc();
115115
Value n = adaptor.getLhs();
116116
Value m = adaptor.getRhs();
117-
Value zero = rewriter.create<LLVM::ConstantOp>(loc, n.getType(), 0);
118-
Value posOne = rewriter.create<LLVM::ConstantOp>(loc, n.getType(), 1);
119-
Value negOne = rewriter.create<LLVM::ConstantOp>(loc, n.getType(), -1);
117+
Value zero = LLVM::ConstantOp::create(rewriter, loc, n.getType(), 0);
118+
Value posOne = LLVM::ConstantOp::create(rewriter, loc, n.getType(), 1);
119+
Value negOne = LLVM::ConstantOp::create(rewriter, loc, n.getType(), -1);
120120

121121
// Compute `x`.
122122
Value mNeg =
123-
rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::slt, m, zero);
124-
Value x = rewriter.create<LLVM::SelectOp>(loc, mNeg, posOne, negOne);
123+
LLVM::ICmpOp::create(rewriter, loc, LLVM::ICmpPredicate::slt, m, zero);
124+
Value x = LLVM::SelectOp::create(rewriter, loc, mNeg, posOne, negOne);
125125

126126
// Compute the negative result.
127-
Value xMinusN = rewriter.create<LLVM::SubOp>(loc, x, n);
128-
Value xMinusNDivM = rewriter.create<LLVM::SDivOp>(loc, xMinusN, m);
129-
Value negRes = rewriter.create<LLVM::SubOp>(loc, negOne, xMinusNDivM);
127+
Value xMinusN = LLVM::SubOp::create(rewriter, loc, x, n);
128+
Value xMinusNDivM = LLVM::SDivOp::create(rewriter, loc, xMinusN, m);
129+
Value negRes = LLVM::SubOp::create(rewriter, loc, negOne, xMinusNDivM);
130130

131131
// Compute the positive result.
132-
Value posRes = rewriter.create<LLVM::SDivOp>(loc, n, m);
132+
Value posRes = LLVM::SDivOp::create(rewriter, loc, n, m);
133133

134134
// Pick the negative result if `n` and `m` have different signs and `n` is
135135
// non-zero, i.e. `(n < 0) != (m < 0) && n != 0`.
136136
Value nNeg =
137-
rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::slt, n, zero);
138-
Value diffSign =
139-
rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, nNeg, mNeg);
137+
LLVM::ICmpOp::create(rewriter, loc, LLVM::ICmpPredicate::slt, n, zero);
138+
Value diffSign = LLVM::ICmpOp::create(rewriter, loc,
139+
LLVM::ICmpPredicate::ne, nNeg, mNeg);
140140
Value nNonZero =
141-
rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::ne, n, zero);
142-
Value cmp = rewriter.create<LLVM::AndOp>(loc, diffSign, nNonZero);
141+
LLVM::ICmpOp::create(rewriter, loc, LLVM::ICmpPredicate::ne, n, zero);
142+
Value cmp = LLVM::AndOp::create(rewriter, loc, diffSign, nNonZero);
143143
rewriter.replaceOpWithNewOp<LLVM::SelectOp>(op, cmp, negRes, posRes);
144144
return success();
145145
}

‎mlir/lib/Conversion/IndexToSPIRV/IndexToSPIRV.cpp

Lines changed: 43 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -111,33 +111,33 @@ struct ConvertIndexCeilDivSPattern final : OpConversionPattern<CeilDivSOp> {
111111
Value m = adaptor.getRhs();
112112

113113
// Define the constants
114-
Value zero = rewriter.create<spirv::ConstantOp>(
115-
loc, n_type, IntegerAttr::get(n_type, 0));
116-
Value posOne = rewriter.create<spirv::ConstantOp>(
117-
loc, n_type, IntegerAttr::get(n_type, 1));
118-
Value negOne = rewriter.create<spirv::ConstantOp>(
119-
loc, n_type, IntegerAttr::get(n_type, -1));
114+
Value zero = spirv::ConstantOp::create(rewriter, loc, n_type,
115+
IntegerAttr::get(n_type, 0));
116+
Value posOne = spirv::ConstantOp::create(rewriter, loc, n_type,
117+
IntegerAttr::get(n_type, 1));
118+
Value negOne = spirv::ConstantOp::create(rewriter, loc, n_type,
119+
IntegerAttr::get(n_type, -1));
120120

121121
// Compute `x`.
122-
Value mPos = rewriter.create<spirv::SGreaterThanOp>(loc, m, zero);
123-
Value x = rewriter.create<spirv::SelectOp>(loc, mPos, negOne, posOne);
122+
Value mPos = spirv::SGreaterThanOp::create(rewriter, loc, m, zero);
123+
Value x = spirv::SelectOp::create(rewriter, loc, mPos, negOne, posOne);
124124

125125
// Compute the positive result.
126-
Value nPlusX = rewriter.create<spirv::IAddOp>(loc, n, x);
127-
Value nPlusXDivM = rewriter.create<spirv::SDivOp>(loc, nPlusX, m);
128-
Value posRes = rewriter.create<spirv::IAddOp>(loc, nPlusXDivM, posOne);
126+
Value nPlusX = spirv::IAddOp::create(rewriter, loc, n, x);
127+
Value nPlusXDivM = spirv::SDivOp::create(rewriter, loc, nPlusX, m);
128+
Value posRes = spirv::IAddOp::create(rewriter, loc, nPlusXDivM, posOne);
129129

130130
// Compute the negative result.
131-
Value negN = rewriter.create<spirv::ISubOp>(loc, zero, n);
132-
Value negNDivM = rewriter.create<spirv::SDivOp>(loc, negN, m);
133-
Value negRes = rewriter.create<spirv::ISubOp>(loc, zero, negNDivM);
131+
Value negN = spirv::ISubOp::create(rewriter, loc, zero, n);
132+
Value negNDivM = spirv::SDivOp::create(rewriter, loc, negN, m);
133+
Value negRes = spirv::ISubOp::create(rewriter, loc, zero, negNDivM);
134134

135135
// Pick the positive result if `n` and `m` have the same sign and `n` is
136136
// non-zero, i.e. `(n > 0) == (m > 0) && n != 0`.
137-
Value nPos = rewriter.create<spirv::SGreaterThanOp>(loc, n, zero);
138-
Value sameSign = rewriter.create<spirv::LogicalEqualOp>(loc, nPos, mPos);
139-
Value nNonZero = rewriter.create<spirv::INotEqualOp>(loc, n, zero);
140-
Value cmp = rewriter.create<spirv::LogicalAndOp>(loc, sameSign, nNonZero);
137+
Value nPos = spirv::SGreaterThanOp::create(rewriter, loc, n, zero);
138+
Value sameSign = spirv::LogicalEqualOp::create(rewriter, loc, nPos, mPos);
139+
Value nNonZero = spirv::INotEqualOp::create(rewriter, loc, n, zero);
140+
Value cmp = spirv::LogicalAndOp::create(rewriter, loc, sameSign, nNonZero);
141141
rewriter.replaceOpWithNewOp<spirv::SelectOp>(op, cmp, posRes, negRes);
142142
return success();
143143
}
@@ -161,18 +161,18 @@ struct ConvertIndexCeilDivUPattern final : OpConversionPattern<CeilDivUOp> {
161161
Value m = adaptor.getRhs();
162162

163163
// Define the constants
164-
Value zero = rewriter.create<spirv::ConstantOp>(
165-
loc, n_type, IntegerAttr::get(n_type, 0));
166-
Value one = rewriter.create<spirv::ConstantOp>(loc, n_type,
167-
IntegerAttr::get(n_type, 1));
164+
Value zero = spirv::ConstantOp::create(rewriter, loc, n_type,
165+
IntegerAttr::get(n_type, 0));
166+
Value one = spirv::ConstantOp::create(rewriter, loc, n_type,
167+
IntegerAttr::get(n_type, 1));
168168

169169
// Compute the non-zero result.
170-
Value minusOne = rewriter.create<spirv::ISubOp>(loc, n, one);
171-
Value quotient = rewriter.create<spirv::UDivOp>(loc, minusOne, m);
172-
Value plusOne = rewriter.create<spirv::IAddOp>(loc, quotient, one);
170+
Value minusOne = spirv::ISubOp::create(rewriter, loc, n, one);
171+
Value quotient = spirv::UDivOp::create(rewriter, loc, minusOne, m);
172+
Value plusOne = spirv::IAddOp::create(rewriter, loc, quotient, one);
173173

174174
// Pick the result
175-
Value cmp = rewriter.create<spirv::IEqualOp>(loc, n, zero);
175+
Value cmp = spirv::IEqualOp::create(rewriter, loc, n, zero);
176176
rewriter.replaceOpWithNewOp<spirv::SelectOp>(op, cmp, zero, plusOne);
177177
return success();
178178
}
@@ -197,32 +197,33 @@ struct ConvertIndexFloorDivSPattern final : OpConversionPattern<FloorDivSOp> {
197197
Value m = adaptor.getRhs();
198198

199199
// Define the constants
200-
Value zero = rewriter.create<spirv::ConstantOp>(
201-
loc, n_type, IntegerAttr::get(n_type, 0));
202-
Value posOne = rewriter.create<spirv::ConstantOp>(
203-
loc, n_type, IntegerAttr::get(n_type, 1));
204-
Value negOne = rewriter.create<spirv::ConstantOp>(
205-
loc, n_type, IntegerAttr::get(n_type, -1));
200+
Value zero = spirv::ConstantOp::create(rewriter, loc, n_type,
201+
IntegerAttr::get(n_type, 0));
202+
Value posOne = spirv::ConstantOp::create(rewriter, loc, n_type,
203+
IntegerAttr::get(n_type, 1));
204+
Value negOne = spirv::ConstantOp::create(rewriter, loc, n_type,
205+
IntegerAttr::get(n_type, -1));
206206

207207
// Compute `x`.
208-
Value mNeg = rewriter.create<spirv::SLessThanOp>(loc, m, zero);
209-
Value x = rewriter.create<spirv::SelectOp>(loc, mNeg, posOne, negOne);
208+
Value mNeg = spirv::SLessThanOp::create(rewriter, loc, m, zero);
209+
Value x = spirv::SelectOp::create(rewriter, loc, mNeg, posOne, negOne);
210210

211211
// Compute the negative result
212-
Value xMinusN = rewriter.create<spirv::ISubOp>(loc, x, n);
213-
Value xMinusNDivM = rewriter.create<spirv::SDivOp>(loc, xMinusN, m);
214-
Value negRes = rewriter.create<spirv::ISubOp>(loc, negOne, xMinusNDivM);
212+
Value xMinusN = spirv::ISubOp::create(rewriter, loc, x, n);
213+
Value xMinusNDivM = spirv::SDivOp::create(rewriter, loc, xMinusN, m);
214+
Value negRes = spirv::ISubOp::create(rewriter, loc, negOne, xMinusNDivM);
215215

216216
// Compute the positive result.
217-
Value posRes = rewriter.create<spirv::SDivOp>(loc, n, m);
217+
Value posRes = spirv::SDivOp::create(rewriter, loc, n, m);
218218

219219
// Pick the negative result if `n` and `m` have different signs and `n` is
220220
// non-zero, i.e. `(n < 0) != (m < 0) && n != 0`.
221-
Value nNeg = rewriter.create<spirv::SLessThanOp>(loc, n, zero);
222-
Value diffSign = rewriter.create<spirv::LogicalNotEqualOp>(loc, nNeg, mNeg);
223-
Value nNonZero = rewriter.create<spirv::INotEqualOp>(loc, n, zero);
221+
Value nNeg = spirv::SLessThanOp::create(rewriter, loc, n, zero);
222+
Value diffSign =
223+
spirv::LogicalNotEqualOp::create(rewriter, loc, nNeg, mNeg);
224+
Value nNonZero = spirv::INotEqualOp::create(rewriter, loc, n, zero);
224225

225-
Value cmp = rewriter.create<spirv::LogicalAndOp>(loc, diffSign, nNonZero);
226+
Value cmp = spirv::LogicalAndOp::create(rewriter, loc, diffSign, nNonZero);
226227
rewriter.replaceOpWithNewOp<spirv::SelectOp>(op, cmp, posRes, negRes);
227228
return success();
228229
}

0 commit comments

Comments
 (0)