Lines Matching defs:rewriter
72 static LogicalResult convertSinhOp(math::SinhOp op, PatternRewriter &rewriter) {
73 ImplicitLocOpBuilder b(op->getLoc(), rewriter);
81 Value half = createFloatConst(op->getLoc(), opType, 0.5, rewriter);
83 rewriter.replaceOp(op, res);
88 static LogicalResult convertCoshOp(math::CoshOp op, PatternRewriter &rewriter) {
89 ImplicitLocOpBuilder b(op->getLoc(), rewriter);
97 Value half = createFloatConst(op->getLoc(), opType, 0.5, rewriter);
99 rewriter.replaceOp(op, res);
111 static LogicalResult convertTanhOp(math::TanhOp op, PatternRewriter &rewriter) {
114 Value zero = createFloatConst(loc, floatType, 0.0, rewriter);
115 Value one = createFloatConst(loc, floatType, 1.0, rewriter);
116 Value negTwo = createFloatConst(loc, floatType, -2.0, rewriter);
119 Value isNegative = rewriter.create<arith::CmpFOp>(
122 rewriter.create<arith::UIToFPOp>(loc, floatType, isNegative);
124 rewriter.create<arith::MulFOp>(loc, isNegativeFloat, negTwo);
125 Value sign = rewriter.create<arith::AddFOp>(loc, isNegativeTimesNegTwo, one);
128 Value positiveX = rewriter.create<arith::MulFOp>(loc, sign, op.getOperand());
131 Value negDoubledX = rewriter.create<arith::MulFOp>(loc, negTwo, positiveX);
132 Value exp2x = rewriter.create<math::ExpOp>(loc, negDoubledX);
133 Value dividend = rewriter.create<arith::SubFOp>(loc, one, exp2x);
134 Value divisor = rewriter.create<arith::AddFOp>(loc, one, exp2x);
135 Value positiveRes = rewriter.create<arith::DivFOp>(loc, dividend, divisor);
138 rewriter.replaceOpWithNewOp<arith::MulFOp>(op, sign, positiveRes);
144 static LogicalResult convertTanOp(math::TanOp op, PatternRewriter &rewriter) {
145 ImplicitLocOpBuilder b(op->getLoc(), rewriter);
151 rewriter.replaceOp(op, div);
157 PatternRewriter &rewriter) {
158 ImplicitLocOpBuilder b(op->getLoc(), rewriter);
162 Value one = createFloatConst(op->getLoc(), opType, 1.0, rewriter);
167 rewriter.replaceOp(op, res);
173 PatternRewriter &rewriter) {
174 ImplicitLocOpBuilder b(op->getLoc(), rewriter);
178 Value negOne = createFloatConst(op->getLoc(), opType, -1.0, rewriter);
183 rewriter.replaceOp(op, res);
189 PatternRewriter &rewriter) {
190 ImplicitLocOpBuilder b(op->getLoc(), rewriter);
194 Value one = createFloatConst(op->getLoc(), opType, 1.0, rewriter);
200 Value half = createFloatConst(op->getLoc(), opType, 0.5, rewriter);
202 rewriter.replaceOp(op, res);
206 static LogicalResult convertFmaFOp(math::FmaOp op, PatternRewriter &rewriter) {
207 ImplicitLocOpBuilder b(op->getLoc(), rewriter);
214 rewriter.replaceOp(op, add);
223 static LogicalResult convertCeilOp(math::CeilOp op, PatternRewriter &rewriter) {
224 ImplicitLocOpBuilder b(op->getLoc(), rewriter);
230 Value zero = createFloatConst(op->getLoc(), opType, 0.00, rewriter);
231 Value one = createFloatConst(op->getLoc(), opType, 1.00, rewriter);
238 rewriter.replaceOp(op, ret);
247 PatternRewriter &rewriter) {
248 ImplicitLocOpBuilder b(op->getLoc(), rewriter);
255 rewriter.create<arith::SIToFPOp>(op.getLoc(), baseType, power);
256 Value res = rewriter.create<math::PowFOp>(op.getLoc(), baseType, base,
258 rewriter.replaceOp(op, res);
273 Value one = createFloatConst(op->getLoc(), baseType, 1.00, rewriter);
274 Value res = createFloatConst(op->getLoc(), baseType, 1.00, rewriter);
289 APFloat::getZero(sem, /*Negative=*/false), rewriter);
292 APFloat::getZero(sem, /*Negative=*/true), rewriter);
295 APFloat::getInf(sem, /*Negative=*/false), rewriter);
298 APFloat::getInf(sem, /*Negative=*/true), rewriter);
310 rewriter.replaceOp(op, res);
316 static LogicalResult convertPowfOp(math::PowFOp op, PatternRewriter &rewriter) {
317 ImplicitLocOpBuilder b(op->getLoc(), rewriter);
321 Value zero = createFloatConst(op->getLoc(), opType, 0.00, rewriter);
322 Value one = createFloatConst(op->getLoc(), opType, 1.00, rewriter);
336 rewriter.replaceOp(op, finalResult);
345 PatternRewriter &rewriter) {
346 ImplicitLocOpBuilder b(op->getLoc(), rewriter);
352 rewriter.replaceOp(op, exp);
357 PatternRewriter &rewriter) {
359 ImplicitLocOpBuilder b(loc, rewriter);
365 return rewriter.notifyMatchFailure(op, "not a round of f32.");
410 rewriter.replaceOp(op, result);
417 PatternRewriter &rewriter) {
433 Value count = createIntConst(loc, operandTy, 0, rewriter);
436 auto bits = createIntConst(loc, operandTy, half, rewriter);
437 auto mask = createIntConst(loc, operandTy, allbits >> half, rewriter);
440 rewriter.create<arith::CmpIOp>(loc, arith::CmpIPredicate::ule, x, mask);
441 Value add = rewriter.create<arith::AddIOp>(loc, count, bits);
442 Value shift = rewriter.create<arith::ShLIOp>(loc, x, bits);
444 x = rewriter.create<arith::SelectOp>(loc, pred, shift, x);
445 count = rewriter.create<arith::SelectOp>(loc, pred, add, count);
448 Value zero = createIntConst(loc, operandTy, 0, rewriter);
449 Value pred = rewriter.create<arith::CmpIOp>(loc, arith::CmpIPredicate::eq,
452 Value bwval = createIntConst(loc, operandTy, bitwidth, rewriter);
453 Value sel = rewriter.create<arith::SelectOp>(loc, pred, bwval, count);
454 rewriter.replaceOp(op, sel);
460 PatternRewriter &rewriter) {
462 ImplicitLocOpBuilder b(loc, rewriter);
470 return rewriter.notifyMatchFailure(op, "not a roundeven of f16 or f32.");
474 Type iTy = rewriter.getIntegerType(operandETy.getIntOrFloatBitWidth());
586 rewriter.replaceOp(op, result);
592 PatternRewriter &rewriter) {
601 auto constOneFloat = createFloatConst(loc, operandTy, 1.0, rewriter);
602 auto sqrtOp = rewriter.create<math::SqrtOp>(loc, operand);
603 rewriter.replaceOpWithNewOp<arith::DivFOp>(op, constOneFloat, sqrtOp);