1 /* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
2
3 Licensed under the Apache License, Version 2.0 (the "License");
4 you may not use this file except in compliance with the License.
5 You may obtain a copy of the License at
6
7 http://www.apache.org/licenses/LICENSE-2.0
8
9 Unless required by applicable law or agreed to in writing, software
10 distributed under the License is distributed on an "AS IS" BASIS,
11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 See the License for the specific language governing permissions and
13 limitations under the License.
14 ==============================================================================*/
15
16 // This file implements logic for translating mixed IR to buffer form.
17 // Currently it supports MHLO and some operations from the Standard dialect.
18
19 #include <memory>
20 #include <utility>
21
22 #include "llvm/ADT/STLExtras.h"
23 #include "mlir/IR/Attributes.h" // from @llvm-project
24 #include "mlir/IR/BuiltinOps.h" // from @llvm-project
25 #include "mlir/IR/BuiltinTypes.h" // from @llvm-project
26 #include "mlir/IR/MLIRContext.h" // from @llvm-project
27 #include "mlir/IR/Operation.h" // from @llvm-project
28 #include "mlir/IR/PatternMatch.h" // from @llvm-project
29 #include "mlir/Support/LogicalResult.h" // from @llvm-project
30 #include "mlir/Transforms/DialectConversion.h" // from @llvm-project
31 #include "tensorflow/compiler/mlir/hlo/include/mlir-hlo/Dialect/mhlo/transforms/type_conversion.h"
32 #include "tensorflow/compiler/mlir/tools/kernel_gen/transforms/passes.h"
33
34 namespace mlir {
35 namespace kernel_gen {
36 namespace transforms {
37 namespace {
38
39 // Generic pattern that rewrites any op by rewriting its operands and result
40 // types. Regions are also rewritten.
41 class ConvertToSignless : public ConversionPattern {
42 public:
ConvertToSignless(TypeConverter & type_converter,MLIRContext * context)43 ConvertToSignless(TypeConverter& type_converter, MLIRContext* context)
44 : ConversionPattern(type_converter, MatchAnyOpTypeTag{}, 0, context) {}
45
matchAndRewrite(Operation * op,ArrayRef<Value> operands,ConversionPatternRewriter & rewriter) const46 LogicalResult matchAndRewrite(
47 Operation* op, ArrayRef<Value> operands,
48 ConversionPatternRewriter& rewriter) const final {
49 SmallVector<Type> result_types;
50 if (failed(typeConverter->convertTypes(op->getResultTypes(), result_types)))
51 return failure();
52
53 auto* new_op = Operation::create(op->getLoc(), op->getName(), result_types,
54 operands, op->getAttrs(),
55 op->getSuccessors(), op->getNumRegions());
56 for (auto regions : llvm::zip(op->getRegions(), new_op->getRegions())) {
57 Region& before = std::get<0>(regions);
58 Region& parent = std::get<1>(regions);
59 rewriter.inlineRegionBefore(before, parent, parent.end());
60 if (failed(rewriter.convertRegionTypes(&parent, *typeConverter)))
61 return failure();
62 }
63 rewriter.insert(new_op);
64 rewriter.replaceOp(op, new_op->getResults());
65 return success();
66 }
67 };
68
69 #define GEN_PASS_CLASSES
70 #include "tensorflow/compiler/mlir/tools/kernel_gen/transforms/kernel_gen_passes.h.inc"
71
72 struct ConvertToSignlessPass
73 : public ConvertToSignlessPassBase<ConvertToSignlessPass> {
74 public:
runOnOperationmlir::kernel_gen::transforms::__anond3a632690111::ConvertToSignlessPass75 void runOnOperation() override {
76 auto& context = getContext();
77 ConversionTarget target(context);
78
79 mhlo::RemoveSignTypeConverter converter;
80 target.markUnknownOpDynamicallyLegal([&](auto op) {
81 return converter.isLegal(op->getOperandTypes()) &&
82 converter.isLegal(op->getResultTypes());
83 });
84 target.addDynamicallyLegalOp<FuncOp>(
85 [&](FuncOp op) { return converter.isSignatureLegal(op.getType()); });
86
87 RewritePatternSet patterns(&getContext());
88 patterns.insert<ConvertToSignless>(converter, &context);
89 // FuncOp is special as it has type encoding via attributes.
90 populateFunctionLikeTypeConversionPattern<FuncOp>(patterns, converter);
91
92 auto module = getOperation();
93 if (failed(applyFullConversion(module, target, std::move(patterns)))) {
94 signalPassFailure();
95 }
96 }
97 };
98
99 } // namespace
100
CreateConvertToSignlessPass()101 std::unique_ptr<OperationPass<ModuleOp>> CreateConvertToSignlessPass() {
102 return std::make_unique<ConvertToSignlessPass>();
103 }
104
105 } // namespace transforms
106 } // namespace kernel_gen
107 } // namespace mlir
108