| 1 | //===- RaiseWasmMLIR.cpp - Convert Wasm to less abstract dialects ---*- C++ |
| 2 | //-*-===// |
| 3 | // |
| 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 5 | // See https://llvm.org/LICENSE.txt for license information. |
| 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file implements lowering of wasm operations to standard dialects ops. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #include "mlir/Conversion/RaiseWasm/RaiseWasmMLIR.h" |
| 15 | |
| 16 | #include "mlir/Dialect/Arith/IR/Arith.h" |
| 17 | #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h" |
| 18 | #include "mlir/Dialect/Func/IR/FuncOps.h" |
| 19 | #include "mlir/Dialect/Math/IR/Math.h" |
| 20 | #include "mlir/Dialect/MemRef/IR/MemRef.h" |
| 21 | #include "mlir/Dialect/Vector/IR/VectorOps.h" |
| 22 | #include "mlir/Dialect/WasmSSA/IR/WasmSSA.h" |
| 23 | #include "mlir/Dialect/WasmSSA/IR/WasmSSAInterfaces.h" |
| 24 | #include "mlir/IR/BuiltinAttributes.h" |
| 25 | #include "mlir/IR/BuiltinDialect.h" |
| 26 | #include "mlir/IR/ValueRange.h" |
| 27 | #include "mlir/Transforms/DialectConversion.h" |
| 28 | #include "mlir/Transforms/Passes.h" |
| 29 | #include "llvm/Support/LogicalResult.h" |
| 30 | #include <optional> |
| 31 | |
| 32 | #define DEBUG_TYPE "wasm-convert" |
| 33 | |
| 34 | namespace mlir { |
| 35 | #define GEN_PASS_DEF_RAISEWASMMLIR |
| 36 | #include "mlir/Conversion/Passes.h.inc" |
| 37 | } // namespace mlir |
| 38 | |
| 39 | using namespace mlir; |
| 40 | using namespace mlir::wasmssa; |
| 41 | namespace { |
| 42 | |
| 43 | template <typename OpTy> |
| 44 | static typename OpTy::Properties getDefaultProperties(MLIRContext *context) { |
| 45 | typename OpTy::Properties properties{}; |
| 46 | if constexpr (!std::is_same_v<typename OpTy::Properties, EmptyProperties>) |
| 47 | OpTy::populateDefaultProperties( |
| 48 | OperationName(OpTy::getOperationName(), context), properties); |
| 49 | return properties; |
| 50 | } |
| 51 | |
| 52 | template <typename SourceOp, typename TargetIntOp, typename TargetFPOp> |
| 53 | struct IntFPDispatchMappingConversion : OpConversionPattern<SourceOp> { |
| 54 | using OpConversionPattern<SourceOp>::OpConversionPattern; |
| 55 | |
| 56 | LogicalResult |
| 57 | matchAndRewrite(SourceOp srcOp, typename SourceOp::Adaptor adaptor, |
| 58 | ConversionPatternRewriter &rewriter) const override { |
| 59 | Type type = srcOp.getRhs().getType(); |
| 60 | if (type.isInteger()) { |
| 61 | rewriter.replaceOpWithNewOp<TargetIntOp>( |
| 62 | srcOp, srcOp->getResultTypes(), adaptor.getOperands(), |
| 63 | getDefaultProperties<TargetIntOp>(rewriter.getContext()), |
| 64 | ArrayRef<NamedAttribute>{}); |
| 65 | return success(); |
| 66 | } |
| 67 | if (!type.isFloat()) |
| 68 | return failure(); |
| 69 | rewriter.replaceOpWithNewOp<TargetFPOp>( |
| 70 | srcOp, srcOp->getResultTypes(), adaptor.getOperands(), |
| 71 | getDefaultProperties<TargetFPOp>(rewriter.getContext()), |
| 72 | ArrayRef<NamedAttribute>{}); |
| 73 | return success(); |
| 74 | } |
| 75 | }; |
| 76 | |
| 77 | using WasmAddOpConversion = |
| 78 | IntFPDispatchMappingConversion<AddOp, arith::AddIOp, arith::AddFOp>; |
| 79 | using WasmMulOpConversion = |
| 80 | IntFPDispatchMappingConversion<MulOp, arith::MulIOp, arith::MulFOp>; |
| 81 | using WasmSubOpConversion = |
| 82 | IntFPDispatchMappingConversion<SubOp, arith::SubIOp, arith::SubFOp>; |
| 83 | |
| 84 | /// Convert a k-ary source operation \p SourceOp into an operation \p TargetOp. |
| 85 | /// Both \p SourceOp and \p TargetOp must have the same number of operands. |
| 86 | template <typename SourceOp, typename TargetOp> |
| 87 | struct OpMappingConversion : OpConversionPattern<SourceOp> { |
| 88 | using OpConversionPattern<SourceOp>::OpConversionPattern; |
| 89 | |
| 90 | LogicalResult |
| 91 | matchAndRewrite(SourceOp srcOp, typename SourceOp::Adaptor adaptor, |
| 92 | ConversionPatternRewriter &rewriter) const override { |
| 93 | rewriter.replaceOpWithNewOp<TargetOp>( |
| 94 | srcOp, srcOp->getResultTypes(), adaptor.getOperands(), |
| 95 | getDefaultProperties<TargetOp>(rewriter.getContext()), |
| 96 | ArrayRef<NamedAttribute>{}); |
| 97 | return success(); |
| 98 | } |
| 99 | }; |
| 100 | |
| 101 | using WasmAndOpConversion = OpMappingConversion<AndOp, arith::AndIOp>; |
| 102 | using WasmCeilOpConversion = OpMappingConversion<CeilOp, math::CeilOp>; |
| 103 | /// TODO: SIToFP and UIToFP don't allow specification of the floating point |
| 104 | /// rounding mode |
| 105 | using WasmConvertSOpConversion = |
| 106 | OpMappingConversion<ConvertSOp, arith::SIToFPOp>; |
| 107 | using WasmConvertUOpConversion = |
| 108 | OpMappingConversion<ConvertUOp, arith::UIToFPOp>; |
| 109 | using WasmDemoteOpConversion = OpMappingConversion<DemoteOp, arith::TruncFOp>; |
| 110 | using WasmDivFPOpConversion = OpMappingConversion<DivOp, arith::DivFOp>; |
| 111 | using WasmDivSIOpConversion = OpMappingConversion<DivSIOp, arith::DivSIOp>; |
| 112 | using WasmDivUIOpConversion = OpMappingConversion<DivUIOp, arith::DivUIOp>; |
| 113 | using WasmExtendSOpConversion = |
| 114 | OpMappingConversion<ExtendSI32Op, arith::ExtSIOp>; |
| 115 | using WasmExtendUOpConversion = |
| 116 | OpMappingConversion<ExtendUI32Op, arith::ExtUIOp>; |
| 117 | using WasmFloorOpConversion = OpMappingConversion<FloorOp, math::FloorOp>; |
| 118 | using WasmMaxOpConversion = OpMappingConversion<MaxOp, arith::MaximumFOp>; |
| 119 | using WasmMinOpConversion = OpMappingConversion<MinOp, arith::MinimumFOp>; |
| 120 | using WasmOrOpConversion = OpMappingConversion<OrOp, arith::OrIOp>; |
| 121 | using WasmPromoteOpConversion = OpMappingConversion<PromoteOp, arith::ExtFOp>; |
| 122 | using WasmRemSIOpConversion = OpMappingConversion<RemSIOp, arith::RemSIOp>; |
| 123 | using WasmRemUIOpConversion = OpMappingConversion<RemUIOp, arith::RemUIOp>; |
| 124 | using WasmReinterpretOpConversion = |
| 125 | OpMappingConversion<ReinterpretOp, arith::BitcastOp>; |
| 126 | using WasmShLOpConversion = OpMappingConversion<ShLOp, arith::ShLIOp>; |
| 127 | using WasmShRSOpConversion = OpMappingConversion<ShRSOp, arith::ShRSIOp>; |
| 128 | using WasmShRUOpConversion = OpMappingConversion<ShRUOp, arith::ShRUIOp>; |
| 129 | using WasmXOrOpConversion = OpMappingConversion<XOrOp, arith::XOrIOp>; |
| 130 | using WasmNegOpConversion = OpMappingConversion<NegOp, arith::NegFOp>; |
| 131 | using WasmCopySignOpConversion = |
| 132 | OpMappingConversion<CopySignOp, math::CopySignOp>; |
| 133 | using WasmClzOpConversion = |
| 134 | OpMappingConversion<ClzOp, math::CountLeadingZerosOp>; |
| 135 | using WasmCtzOpConversion = |
| 136 | OpMappingConversion<CtzOp, math::CountTrailingZerosOp>; |
| 137 | using WasmPopCntOpConversion = OpMappingConversion<PopCntOp, math::CtPopOp>; |
| 138 | using WasmAbsOpConversion = OpMappingConversion<AbsOp, math::AbsFOp>; |
| 139 | using WasmTruncOpConversion = OpMappingConversion<TruncOp, math::TruncOp>; |
| 140 | using WasmSqrtOpConversion = OpMappingConversion<SqrtOp, math::SqrtOp>; |
| 141 | using WasmWrapOpConversion = OpMappingConversion<WrapOp, arith::TruncIOp>; |
| 142 | |
| 143 | /// Lower a rotate to a series of bitwise operations. Intended for us |
| 144 | /// in dialects that do not natively support rotate operations. |
| 145 | /// |
| 146 | /// Result stays in the wasm dialect. It will then subsequently be lowered to |
| 147 | /// the target dialect. |
| 148 | /// |
| 149 | /// The rotate will be lowered to a pattern like so: |
| 150 | /// |
| 151 | /// (val LHSShiftOp (bits & (width-1))) | (val RHSShiftOp (-bits & (width-1))) |
| 152 | /// |
| 153 | /// Where LHSShiftOp and RHSShiftOp are shift operations. Concretely, |
| 154 | /// |
| 155 | /// rotr = (val >> (bits & (width - 1))) | (val << (-bits & (width - 1))) |
| 156 | /// rotl = (val << (bits & (width - 1))) | (val >> (-bits & (width - 1))) |
| 157 | /// |
| 158 | /// Using this variant ensures that our rotate is defined in the target dialect. |
| 159 | /// |
| 160 | /// \p SourceOp - Rotate operation to replace. |
| 161 | /// \p LHSShiftOp - Shift operation to use on the left-hand side of the OR. |
| 162 | /// \p RHSShiftOp - Shift operation to use on the right-hand side of the OR. |
| 163 | template <typename SourceOp, typename LHSShiftOp, typename RHSShiftOp> |
| 164 | struct RotateOpConversion : OpConversionPattern<SourceOp> { |
| 165 | using OpConversionPattern<SourceOp>::OpConversionPattern; |
| 166 | |
| 167 | LogicalResult |
| 168 | matchAndRewrite(SourceOp srcOp, typename SourceOp::Adaptor adaptor, |
| 169 | ConversionPatternRewriter &rewriter) const override { |
| 170 | const Type ty = srcOp->getResultTypes()[0]; |
| 171 | const Location loc = srcOp->getLoc(); |
| 172 | const Value val = adaptor.getVal(); |
| 173 | const Value bits = adaptor.getBits(); |
| 174 | const unsigned width = ty.getIntOrFloatBitWidth(); |
| 175 | |
| 176 | // Materialize (width - 1) for use in both sides of the expression. |
| 177 | auto cstWidthMinusOne = |
| 178 | ConstOp::create(builder&: rewriter, location: loc, value: IntegerAttr::get(type: ty, value: width - 1)); |
| 179 | |
| 180 | // Form the left-hand side of the OR: |
| 181 | // (val (lhs shift op) (bits & (width - 1))) |
| 182 | auto orLHS = LHSShiftOp::create( |
| 183 | rewriter, loc, val, |
| 184 | AndOp::create(builder&: rewriter, location: loc, lhs: bits, rhs: cstWidthMinusOne)); |
| 185 | |
| 186 | // Form the right-hand side of the OR: |
| 187 | // (val (rhs shift op) (-bits & (width - 1))) |
| 188 | auto orRHS = RHSShiftOp::create( |
| 189 | rewriter, loc, val, |
| 190 | // (-bits & (width - 1)) |
| 191 | AndOp::create(builder&: rewriter, location: loc, |
| 192 | // 0 - bits == -bits |
| 193 | lhs: SubOp::create(builder&: rewriter, location: loc, |
| 194 | lhs: ConstOp::create(builder&: rewriter, location: loc, |
| 195 | value: IntegerAttr::get(type: ty, value: 0)), |
| 196 | rhs: bits), |
| 197 | rhs: cstWidthMinusOne)); |
| 198 | |
| 199 | // OR together the two shifts and replace the rotate with the new |
| 200 | // expression. |
| 201 | rewriter.replaceOpWithNewOp<OrOp>(srcOp, orLHS, orRHS); |
| 202 | return success(); |
| 203 | } |
| 204 | }; |
| 205 | |
| 206 | using WasmRotrOpConversion = RotateOpConversion<RotrOp, ShRUOp, ShLOp>; |
| 207 | using WasmRotlOpConversion = RotateOpConversion<RotlOp, ShLOp, ShRUOp>; |
| 208 | |
| 209 | template <typename SourceOp, typename TargetOp, typename AttrType, |
| 210 | typename ValType, ValType flag> |
| 211 | struct ComparisonOpConversion : OpConversionPattern<SourceOp> { |
| 212 | using OpConversionPattern<SourceOp>::OpConversionPattern; |
| 213 | |
| 214 | LogicalResult |
| 215 | matchAndRewrite(SourceOp srcOp, typename SourceOp::Adaptor adaptor, |
| 216 | ConversionPatternRewriter &rewriter) const override { |
| 217 | auto cmpRes = |
| 218 | TargetOp::create(rewriter, srcOp.getLoc(), rewriter.getI1Type(), |
| 219 | AttrType::get(rewriter.getContext(), flag), |
| 220 | adaptor.getLhs(), adaptor.getRhs()) |
| 221 | .getResult(); |
| 222 | rewriter.replaceOpWithNewOp<arith::ExtUIOp>(srcOp, rewriter.getI32Type(), |
| 223 | cmpRes); |
| 224 | |
| 225 | return success(); |
| 226 | } |
| 227 | }; |
| 228 | |
| 229 | template <typename SourceOp, arith::CmpFPredicate compFlag> |
| 230 | using FPComparisonConversion = |
| 231 | ComparisonOpConversion<SourceOp, arith::CmpFOp, arith::CmpFPredicateAttr, |
| 232 | arith::CmpFPredicate, compFlag>; |
| 233 | |
| 234 | template <typename SourceOp, arith::CmpIPredicate compFlag> |
| 235 | using IntComparisonConversion = |
| 236 | ComparisonOpConversion<SourceOp, arith::CmpIOp, arith::CmpIPredicateAttr, |
| 237 | arith::CmpIPredicate, compFlag>; |
| 238 | |
| 239 | using WasmLtSIOpConversion = |
| 240 | IntComparisonConversion<LtSIOp, arith::CmpIPredicate::slt>; |
| 241 | using WasmLeSIOpConversion = |
| 242 | IntComparisonConversion<LeSIOp, arith::CmpIPredicate::sle>; |
| 243 | using WasmGtSIOpConversion = |
| 244 | IntComparisonConversion<GtSIOp, arith::CmpIPredicate::sgt>; |
| 245 | using WasmGeSIOpConversion = |
| 246 | IntComparisonConversion<GeSIOp, arith::CmpIPredicate::sge>; |
| 247 | using WasmLtUIOpConversion = |
| 248 | IntComparisonConversion<LtUIOp, arith::CmpIPredicate::ult>; |
| 249 | using WasmLeUIOpConversion = |
| 250 | IntComparisonConversion<LeUIOp, arith::CmpIPredicate::ule>; |
| 251 | using WasmGtUIOpConversion = |
| 252 | IntComparisonConversion<GtUIOp, arith::CmpIPredicate::ugt>; |
| 253 | using WasmGeUIOpConversion = |
| 254 | IntComparisonConversion<GeUIOp, arith::CmpIPredicate::uge>; |
| 255 | using WasmLtOpConversion = |
| 256 | FPComparisonConversion<LtOp, arith::CmpFPredicate::OLT>; |
| 257 | using WasmLeOpConversion = |
| 258 | FPComparisonConversion<LeOp, arith::CmpFPredicate::OLE>; |
| 259 | using WasmGtOpConversion = |
| 260 | FPComparisonConversion<GtOp, arith::CmpFPredicate::OGT>; |
| 261 | using WasmGeOpConversion = |
| 262 | FPComparisonConversion<GeOp, arith::CmpFPredicate::OGE>; |
| 263 | |
| 264 | template <typename SourceOp, arith::CmpIPredicate IntFlag, |
| 265 | arith::CmpFPredicate FloatFlag> |
| 266 | struct IntFpComparisonOpConversion : OpConversionPattern<SourceOp> { |
| 267 | using OpConversionPattern<SourceOp>::OpConversionPattern; |
| 268 | |
| 269 | LogicalResult |
| 270 | matchAndRewrite(SourceOp srcOp, typename SourceOp::Adaptor adaptor, |
| 271 | ConversionPatternRewriter &rewriter) const override { |
| 272 | Value comparisonResult; |
| 273 | if (srcOp.getLhs().getType().isInteger()) |
| 274 | comparisonResult = |
| 275 | arith::CmpIOp::create( |
| 276 | rewriter, srcOp.getLoc(), rewriter.getI1Type(), |
| 277 | arith::CmpIPredicateAttr::get(context: rewriter.getContext(), val: IntFlag), |
| 278 | adaptor.getLhs(), adaptor.getRhs()) |
| 279 | .getResult(); |
| 280 | else if (srcOp.getLhs().getType().isFloat()) |
| 281 | comparisonResult = |
| 282 | arith::CmpFOp::create( |
| 283 | rewriter, srcOp.getLoc(), rewriter.getI1Type(), |
| 284 | arith::CmpFPredicateAttr::get(context: rewriter.getContext(), val: FloatFlag), |
| 285 | adaptor.getLhs(), adaptor.getRhs()) |
| 286 | .getResult(); |
| 287 | else |
| 288 | return rewriter.notifyMatchFailure( |
| 289 | srcOp.getLoc(), "Unsupported datatype for comparison OP." ); |
| 290 | |
| 291 | rewriter.replaceOpWithNewOp<arith::ExtUIOp>(srcOp, rewriter.getI32Type(), |
| 292 | comparisonResult); |
| 293 | return success(); |
| 294 | } |
| 295 | }; |
| 296 | |
| 297 | using WasmEqOpConversion = |
| 298 | IntFpComparisonOpConversion<EqOp, arith::CmpIPredicate::eq, |
| 299 | arith::CmpFPredicate::OEQ>; |
| 300 | using WasmNeOpConversion = |
| 301 | IntFpComparisonOpConversion<NeOp, arith::CmpIPredicate::ne, |
| 302 | arith::CmpFPredicate::ONE>; |
| 303 | |
| 304 | struct WasmCallOpConversion : OpConversionPattern<FuncCallOp> { |
| 305 | using Base::Base; |
| 306 | |
| 307 | LogicalResult |
| 308 | matchAndRewrite(FuncCallOp funcCallOp, FuncCallOp::Adaptor adaptor, |
| 309 | ConversionPatternRewriter &rewriter) const override { |
| 310 | rewriter.replaceOpWithNewOp<func::CallOp>( |
| 311 | op: funcCallOp, args: funcCallOp.getCallee(), args: funcCallOp.getResults().getTypes(), |
| 312 | args: funcCallOp.getOperands()); |
| 313 | return success(); |
| 314 | } |
| 315 | }; |
| 316 | |
| 317 | struct WasmConstOpConversion : OpConversionPattern<ConstOp> { |
| 318 | using Base::Base; |
| 319 | |
| 320 | LogicalResult |
| 321 | matchAndRewrite(ConstOp constOp, ConstOp::Adaptor adaptor, |
| 322 | ConversionPatternRewriter &rewriter) const override { |
| 323 | rewriter.replaceOpWithNewOp<arith::ConstantOp>(op: constOp, args: constOp.getValue()); |
| 324 | return success(); |
| 325 | } |
| 326 | }; |
| 327 | |
| 328 | struct WasmEqzOpConversion : OpConversionPattern<EqzOp> { |
| 329 | using Base::Base; |
| 330 | |
| 331 | LogicalResult |
| 332 | matchAndRewrite(EqzOp eqzOp, EqzOp::Adaptor adaptor, |
| 333 | ConversionPatternRewriter &rewriter) const override { |
| 334 | auto loc = eqzOp->getLoc(); |
| 335 | auto zero = arith::ConstantOp::create( |
| 336 | builder&: rewriter, location: loc, |
| 337 | value: rewriter.getIntegerAttr(type: adaptor.getInput().getType(), value: 0)) |
| 338 | .getResult(); |
| 339 | auto cmpRes = arith::CmpIOp::create( |
| 340 | builder&: rewriter, location: loc, result: rewriter.getI1Type(), |
| 341 | predicate: arith::CmpIPredicateAttr::get(context: rewriter.getContext(), |
| 342 | val: arith::CmpIPredicate::eq), |
| 343 | lhs: adaptor.getInput(), rhs: zero) |
| 344 | .getResult(); |
| 345 | rewriter.replaceOpWithNewOp<arith::ExtUIOp>(op: eqzOp, args: rewriter.getI32Type(), |
| 346 | args&: cmpRes); |
| 347 | |
| 348 | return success(); |
| 349 | } |
| 350 | }; |
| 351 | |
| 352 | struct WasmExtendLowBitsOpConversion : OpConversionPattern<ExtendLowBitsSOp> { |
| 353 | using Base::Base; |
| 354 | |
| 355 | LogicalResult |
| 356 | matchAndRewrite(ExtendLowBitsSOp extendLowBytesSOp, |
| 357 | ExtendLowBitsSOp::Adaptor adaptor, |
| 358 | ConversionPatternRewriter &rewriter) const override { |
| 359 | auto truncWidth = extendLowBytesSOp.getBitsToTake().getInt(); |
| 360 | auto truncation = arith::TruncIOp::create( |
| 361 | builder&: rewriter, location: extendLowBytesSOp->getLoc(), |
| 362 | out: rewriter.getIntegerType(width: truncWidth), in: adaptor.getInput()); |
| 363 | rewriter.replaceOpWithNewOp<arith::ExtSIOp>( |
| 364 | op: extendLowBytesSOp, args: extendLowBytesSOp.getResult().getType(), |
| 365 | args: truncation.getResult()); |
| 366 | return success(); |
| 367 | } |
| 368 | }; |
| 369 | |
| 370 | struct WasmFuncImportOpConversion : OpConversionPattern<FuncImportOp> { |
| 371 | using Base::Base; |
| 372 | |
| 373 | LogicalResult |
| 374 | matchAndRewrite(FuncImportOp funcImportOp, FuncImportOp::Adaptor, |
| 375 | ConversionPatternRewriter &rewriter) const override { |
| 376 | auto nFunc = rewriter.replaceOpWithNewOp<func::FuncOp>( |
| 377 | op: funcImportOp, args: funcImportOp.getSymName(), args: funcImportOp.getType()); |
| 378 | nFunc.setVisibility(SymbolTable::Visibility::Private); |
| 379 | return success(); |
| 380 | } |
| 381 | }; |
| 382 | |
| 383 | struct WasmFuncOpConversion : OpConversionPattern<FuncOp> { |
| 384 | using Base::Base; |
| 385 | /// |
| 386 | /// Control flow conversion needs shared state for tracking which block |
| 387 | /// corresponds to which operation at which level. |
| 388 | /// |
| 389 | /// This class handles such tracking and performs the conversion of control |
| 390 | /// flow related ops contained in a function. |
| 391 | class CFRewriterVisitor { |
| 392 | private: |
| 393 | using branch_to_dest_t = llvm::DenseMap<LabelBranchingOpInterface, Block *>; |
| 394 | Value getCompResultAsI1(Value compResult, |
| 395 | ConversionPatternRewriter &rewriter) { |
| 396 | auto testValue = arith::ConstantOp::create(builder&: rewriter, location: compResult.getLoc(), |
| 397 | value: rewriter.getI32IntegerAttr(value: 0)); |
| 398 | auto flag = arith::CmpIOp::create( |
| 399 | builder&: rewriter, location: compResult.getLoc(), result: rewriter.getIntegerType(width: 1), |
| 400 | predicate: arith::CmpIPredicate::ne, lhs: compResult, rhs: testValue) |
| 401 | .getResult(); |
| 402 | return flag; |
| 403 | } |
| 404 | |
| 405 | void replaceNestLevelWithBranch(BlockOp blockOp, |
| 406 | llvm::ArrayRef<Block *> regionsToEntry, |
| 407 | ConversionPatternRewriter &rewriter) { |
| 408 | rewriter.replaceOpWithNewOp<cf::BranchOp>(op: blockOp, args: regionsToEntry[0], |
| 409 | args: blockOp->getOperands()); |
| 410 | } |
| 411 | |
| 412 | void replaceNestLevelWithBranch(LoopOp loopOp, |
| 413 | llvm::ArrayRef<Block *> regionsToEntry, |
| 414 | ConversionPatternRewriter &rewriter) { |
| 415 | rewriter.replaceOpWithNewOp<cf::BranchOp>(op: loopOp, args: regionsToEntry[0], |
| 416 | args: loopOp->getOperands()); |
| 417 | } |
| 418 | |
| 419 | void replaceNestLevelWithBranch(IfOp ifOp, |
| 420 | llvm::ArrayRef<Block *> regionsToEntry, |
| 421 | ConversionPatternRewriter &rewriter) { |
| 422 | Block *falseDest = |
| 423 | regionsToEntry.size() == 2 ? regionsToEntry[1] : ifOp.getTarget(); |
| 424 | auto flag = getCompResultAsI1(compResult: ifOp.getCondition(), rewriter); |
| 425 | rewriter.replaceOpWithNewOp<cf::CondBranchOp>( |
| 426 | op: ifOp, args&: flag, args: regionsToEntry[0], args: ifOp.getInputs(), args&: falseDest, |
| 427 | args: ifOp.getInputs()); |
| 428 | } |
| 429 | |
| 430 | template <typename LevelType> |
| 431 | LogicalResult |
| 432 | replaceNestLevelWithBranchWrapper(LabelLevelOpInterface nestingOp, |
| 433 | llvm::ArrayRef<Block *> regionsToEntry, |
| 434 | ConversionPatternRewriter &rewriter) { |
| 435 | auto cast = dyn_cast<LevelType>(nestingOp.getOperation()); |
| 436 | if (!cast) |
| 437 | return failure(); |
| 438 | replaceNestLevelWithBranch(cast, regionsToEntry, rewriter); |
| 439 | return success(); |
| 440 | } |
| 441 | |
| 442 | template <typename... LevelTypes> |
| 443 | LogicalResult inlineNestDispatcher(LabelLevelOpInterface nestingOp, |
| 444 | ConversionPatternRewriter &rewriter) { |
| 445 | auto sip = rewriter.saveInsertionPoint(); |
| 446 | Block *blockSuccessor = nestingOp->getSuccessor(index: 0); |
| 447 | llvm::SmallVector<Block *, 2> regionEntries; |
| 448 | LLVM_DEBUG(llvm::dbgs() |
| 449 | << "Starting inlining blocks for " << nestingOp << "\n" ;); |
| 450 | for (auto ®ion : nestingOp->getRegions()) { |
| 451 | if (region.empty()) |
| 452 | continue; |
| 453 | regionEntries.push_back(Elt: ®ion.front()); |
| 454 | /// Inline blocks of nested ops |
| 455 | llvm::SmallVector<LabelLevelOpInterface> nestedOps{ |
| 456 | region.getOps<LabelLevelOpInterface>()}; |
| 457 | for (auto nestedOp : nestedOps) { |
| 458 | LLVM_DEBUG(llvm::dbgs() << " Found nested op: " << nestedOp); |
| 459 | if (failed(Result: inlineBlocks(nestingOp: nestedOp, rewriter))) |
| 460 | return failure(); |
| 461 | } |
| 462 | rewriter.inlineRegionBefore(region, before: blockSuccessor); |
| 463 | } |
| 464 | LLVM_DEBUG(llvm::dbgs() << "End of region inlining\n" ); |
| 465 | LLVM_DEBUG(llvm::dbgs() << "Replacing initial op with branching\n" ); |
| 466 | rewriter.setInsertionPoint(nestingOp); |
| 467 | auto res = success( |
| 468 | (... || succeeded(replaceNestLevelWithBranchWrapper<LevelTypes>( |
| 469 | nestingOp, regionEntries, rewriter)))); |
| 470 | rewriter.restoreInsertionPoint(ip: sip); |
| 471 | if (failed(res)) |
| 472 | return emitError(loc: nestingOp->getLoc(), |
| 473 | message: "Unable to inline the operation regions." ); |
| 474 | return success(); |
| 475 | } |
| 476 | |
| 477 | /// Take a nesting level defining op and inline it in the parent region. |
| 478 | LogicalResult inlineBlocks(LabelLevelOpInterface nestingOp, |
| 479 | ConversionPatternRewriter &rewriter) { |
| 480 | return inlineNestDispatcher<BlockOp, IfOp, LoopOp>(nestingOp, rewriter); |
| 481 | } |
| 482 | |
| 483 | llvm::FailureOr<Block *> getBlockFor(LabelBranchingOpInterface branchOp) { |
| 484 | auto destIter = branchToDest.find(Val: branchOp); |
| 485 | if (destIter == branchToDest.end()) |
| 486 | return branchOp->emitError(message: "No indexed label op for this operation: " ) |
| 487 | << branchOp; |
| 488 | return destIter->second; |
| 489 | } |
| 490 | |
| 491 | inline void convertBranch(BranchIfOp brOp, Block *dest, |
| 492 | ConversionPatternRewriter &rewriter) { |
| 493 | auto flag = getCompResultAsI1(compResult: brOp.getCondition(), rewriter); |
| 494 | rewriter.replaceOpWithNewOp<cf::CondBranchOp>( |
| 495 | op: brOp, args&: flag, args&: dest, args: brOp.getInputs(), args: brOp.getElseSuccessor(), |
| 496 | args: ValueRange{}); |
| 497 | } |
| 498 | |
| 499 | inline void convertBranch(BlockReturnOp brOp, Block *dest, |
| 500 | ConversionPatternRewriter &rewriter) { |
| 501 | rewriter.replaceOpWithNewOp<cf::BranchOp>(op: brOp, args&: dest, args: brOp.getInputs()); |
| 502 | } |
| 503 | |
| 504 | template <typename LevelInterfaceT> |
| 505 | inline LogicalResult |
| 506 | convertBranchWrapper(LabelBranchingOpInterface branchOp, Block *dest, |
| 507 | ConversionPatternRewriter &rewriter) { |
| 508 | auto cast = dyn_cast<LevelInterfaceT>(branchOp.getOperation()); |
| 509 | if (!cast) |
| 510 | return failure(); |
| 511 | auto sip = rewriter.saveInsertionPoint(); |
| 512 | rewriter.setInsertionPoint(branchOp); |
| 513 | convertBranch(cast, dest, rewriter); |
| 514 | rewriter.restoreInsertionPoint(ip: sip); |
| 515 | return success(); |
| 516 | } |
| 517 | |
| 518 | template <typename... BranchInterfaceT> |
| 519 | LogicalResult convertBranchDispatch(LabelBranchingOpInterface branchOp, |
| 520 | ConversionPatternRewriter &rewriter) { |
| 521 | auto dest = getBlockFor(branchOp); |
| 522 | if (failed(Result: dest)) |
| 523 | return failure(); |
| 524 | auto res = |
| 525 | success((... || succeeded(convertBranchWrapper<BranchInterfaceT>( |
| 526 | branchOp, *dest, rewriter)))); |
| 527 | if (failed(res)) |
| 528 | return emitError(loc: branchOp->getLoc(), message: "No known converter for op " ) |
| 529 | << branchOp; |
| 530 | return res; |
| 531 | } |
| 532 | |
| 533 | LogicalResult convertBranch(LabelBranchingOpInterface branchOp, |
| 534 | ConversionPatternRewriter &rewriter) { |
| 535 | return convertBranchDispatch<BlockReturnOp, BranchIfOp>(branchOp, |
| 536 | rewriter); |
| 537 | } |
| 538 | |
| 539 | func::FuncOp func; |
| 540 | branch_to_dest_t branchToDest; |
| 541 | |
| 542 | public: |
| 543 | CFRewriterVisitor(func::FuncOp func) : func{func} { |
| 544 | func.walk(callback: [this](LabelBranchingOpInterface branchOp) { |
| 545 | branchToDest.insert(KV: {branchOp, branchOp.getTarget()}); |
| 546 | }); |
| 547 | } |
| 548 | LogicalResult rewrite(ConversionPatternRewriter &rewriter) { |
| 549 | llvm::SmallVector<LabelLevelOpInterface> nestingOps{ |
| 550 | func.getOps<LabelLevelOpInterface>()}; |
| 551 | for (auto nestingOp : nestingOps) |
| 552 | if (failed(Result: inlineBlocks(nestingOp, rewriter))) |
| 553 | return failure(); |
| 554 | |
| 555 | auto res = |
| 556 | func->walk(callback: [this, &rewriter](LabelBranchingOpInterface branchOp) { |
| 557 | if (failed(Result: convertBranch(branchOp, rewriter))) |
| 558 | return WalkResult::interrupt(); |
| 559 | return WalkResult::advance(); |
| 560 | }); |
| 561 | return failure(IsFailure: res.wasInterrupted()); |
| 562 | } |
| 563 | }; |
| 564 | |
| 565 | LogicalResult |
| 566 | matchAndRewrite(FuncOp funcOp, FuncOp::Adaptor adaptor, |
| 567 | ConversionPatternRewriter &rewriter) const override { |
| 568 | auto newFunc = |
| 569 | func::FuncOp::create(builder&: rewriter, location: funcOp->getLoc(), name: funcOp.getSymName(), |
| 570 | type: funcOp.getFunctionType()); |
| 571 | rewriter.cloneRegionBefore(region&: funcOp.getBody(), parent&: newFunc.getBody(), |
| 572 | before: newFunc.getBody().end()); |
| 573 | Block *oldEntryBlock = &newFunc.getBody().front(); |
| 574 | auto blockArgTypes = oldEntryBlock->getArgumentTypes(); |
| 575 | TypeConverter::SignatureConversion sC{oldEntryBlock->getNumArguments()}; |
| 576 | auto numArgs = blockArgTypes.size(); |
| 577 | for (size_t i = 0; i < numArgs; ++i) { |
| 578 | auto argType = dyn_cast<LocalRefType>(Val: blockArgTypes[i]); |
| 579 | if (!argType) |
| 580 | return failure(); |
| 581 | sC.addInputs(origInputNo: i, types: argType.getElementType()); |
| 582 | } |
| 583 | |
| 584 | rewriter.applySignatureConversion(block: oldEntryBlock, conversion&: sC, converter: getTypeConverter()); |
| 585 | rewriter.replaceOp(op: funcOp, newOp: newFunc); |
| 586 | CFRewriterVisitor cfRewriter{newFunc}; |
| 587 | return cfRewriter.rewrite(rewriter); |
| 588 | } |
| 589 | }; |
| 590 | |
| 591 | struct WasmGlobalImportOpConverter : OpConversionPattern<GlobalImportOp> { |
| 592 | using Base::Base; |
| 593 | LogicalResult |
| 594 | matchAndRewrite(GlobalImportOp gIOp, GlobalImportOp::Adaptor adaptor, |
| 595 | ConversionPatternRewriter &rewriter) const override { |
| 596 | auto memrefGOp = rewriter.replaceOpWithNewOp<memref::GlobalOp>( |
| 597 | op: gIOp, args: gIOp.getSymNameAttr(), args: rewriter.getStringAttr(bytes: "nested" ), |
| 598 | args: TypeAttr::get(type: MemRefType::get(shape: {1}, elementType: gIOp.getType())), args: Attribute{}, |
| 599 | /*constant*/ args: UnitAttr{}, |
| 600 | /*alignment*/ args: IntegerAttr{}); |
| 601 | memrefGOp.setConstant(!gIOp.getIsMutable()); |
| 602 | return success(); |
| 603 | } |
| 604 | }; |
| 605 | |
| 606 | template <typename CRTP, typename OriginOpType> |
| 607 | struct GlobalOpConverter : OpConversionPattern<GlobalOp> { |
| 608 | using Base::Base; |
| 609 | LogicalResult |
| 610 | matchAndRewrite(GlobalOp globalOp, GlobalOp::Adaptor adaptor, |
| 611 | ConversionPatternRewriter &rewriter) const override { |
| 612 | ReturnOp rop = globalOp.getInitTerminator(); |
| 613 | |
| 614 | if (rop->getNumOperands() != 1) |
| 615 | return rewriter.notifyMatchFailure( |
| 616 | arg&: globalOp, msg: "globalOp initializer should return one value exactly" ); |
| 617 | |
| 618 | auto initializerOp = |
| 619 | dyn_cast<OriginOpType>(rop->getOperand(idx: 0).getDefiningOp()); |
| 620 | |
| 621 | if (!initializerOp) |
| 622 | return rewriter.notifyMatchFailure( |
| 623 | arg&: globalOp, msg: "invalid initializer op type for this pattern" ); |
| 624 | |
| 625 | return static_cast<CRTP const *>(this)->handleInitializer( |
| 626 | globalOp, rewriter, initializerOp); |
| 627 | } |
| 628 | }; |
| 629 | |
| 630 | struct WasmGlobalWithConstInitConversion |
| 631 | : GlobalOpConverter<WasmGlobalWithConstInitConversion, ConstOp> { |
| 632 | using GlobalOpConverter::GlobalOpConverter; |
| 633 | LogicalResult handleInitializer(GlobalOp globalOp, |
| 634 | ConversionPatternRewriter &rewriter, |
| 635 | ConstOp constInit) const { |
| 636 | auto initializer = |
| 637 | DenseElementsAttr::get(type: RankedTensorType::get(shape: {1}, elementType: globalOp.getType()), |
| 638 | values: ArrayRef<Attribute>{constInit.getValueAttr()}); |
| 639 | auto globalReplacement = rewriter.replaceOpWithNewOp<memref::GlobalOp>( |
| 640 | op: globalOp, args: globalOp.getSymNameAttr(), args: rewriter.getStringAttr(bytes: "private" ), |
| 641 | args: TypeAttr::get(type: MemRefType::get(shape: {1}, elementType: globalOp.getType())), args&: initializer, |
| 642 | /*constant*/ args: UnitAttr{}, |
| 643 | /*alignment*/ args: IntegerAttr{}); |
| 644 | globalReplacement.setConstant(!globalOp.getIsMutable()); |
| 645 | return success(); |
| 646 | } |
| 647 | }; |
| 648 | |
| 649 | struct WasmGlobalWithGetGlobalInitConversion |
| 650 | : GlobalOpConverter<WasmGlobalWithGetGlobalInitConversion, GlobalGetOp> { |
| 651 | using GlobalOpConverter::GlobalOpConverter; |
| 652 | LogicalResult handleInitializer(GlobalOp globalOp, |
| 653 | ConversionPatternRewriter &rewriter, |
| 654 | GlobalGetOp constInit) const { |
| 655 | auto globalReplacement = rewriter.replaceOpWithNewOp<memref::GlobalOp>( |
| 656 | op: globalOp, args: globalOp.getSymNameAttr(), args: rewriter.getStringAttr(bytes: "private" ), |
| 657 | args: TypeAttr::get(type: MemRefType::get(shape: {1}, elementType: globalOp.getType())), |
| 658 | args: rewriter.getUnitAttr(), |
| 659 | /*constant*/ args: UnitAttr{}, |
| 660 | /*alignment*/ args: IntegerAttr{}); |
| 661 | globalReplacement.setConstant(!globalOp.getIsMutable()); |
| 662 | auto loc = globalOp.getLoc(); |
| 663 | auto initializerName = (globalOp.getSymName() + "::initializer" ).str(); |
| 664 | auto globalInitializer = |
| 665 | func::FuncOp::create(builder&: rewriter, location: loc, name: initializerName, |
| 666 | type: FunctionType::get(context: getContext(), inputs: {}, results: {})); |
| 667 | globalInitializer->setAttr(name: rewriter.getStringAttr(bytes: "initializer" ), |
| 668 | value: rewriter.getUnitAttr()); |
| 669 | auto *initializerBody = globalInitializer.addEntryBlock(); |
| 670 | auto sip = rewriter.saveInsertionPoint(); |
| 671 | rewriter.setInsertionPointToStart(initializerBody); |
| 672 | auto srcGlobalPtr = memref::GetGlobalOp::create( |
| 673 | builder&: rewriter, location: loc, result: MemRefType::get(shape: {1}, elementType: constInit.getType()), |
| 674 | name: constInit.getGlobal()); |
| 675 | auto destGlobalPtr = |
| 676 | memref::GetGlobalOp::create(builder&: rewriter, location: loc, result: globalReplacement.getType(), |
| 677 | name: globalReplacement.getSymName()); |
| 678 | auto idx = arith::ConstantIndexOp::create(builder&: rewriter, location: loc, value: 0).getResult(); |
| 679 | auto loadSrc = |
| 680 | memref::LoadOp::create(builder&: rewriter, location: loc, memref: srcGlobalPtr, indices: ValueRange{idx}); |
| 681 | memref::StoreOp::create(builder&: rewriter, location: loc, valueToStore: loadSrc.getResult(), |
| 682 | memref: destGlobalPtr.getResult(), indices: ValueRange{idx}); |
| 683 | func::ReturnOp::create(builder&: rewriter, location: loc); |
| 684 | rewriter.restoreInsertionPoint(ip: sip); |
| 685 | return success(); |
| 686 | } |
| 687 | }; |
| 688 | |
| 689 | struct WasmGlobalSetOpConversion : OpConversionPattern<GlobalSetOp> { |
| 690 | using Base::Base; |
| 691 | LogicalResult |
| 692 | matchAndRewrite(GlobalSetOp globalSetOp, GlobalSetOp::Adaptor adaptor, |
| 693 | ConversionPatternRewriter &rewriter) const override { |
| 694 | auto loc = globalSetOp.getLoc(); |
| 695 | auto globalPtr = memref::GetGlobalOp::create( |
| 696 | builder&: rewriter, location: loc, result: MemRefType::get(shape: {1}, elementType: adaptor.getValue().getType()), |
| 697 | name: globalSetOp.getGlobal()); |
| 698 | auto idx = arith::ConstantIndexOp::create(builder&: rewriter, location: loc, value: 0); |
| 699 | rewriter.replaceOpWithNewOp<memref::StoreOp>( |
| 700 | op: globalSetOp, args: adaptor.getValue(), args: globalPtr.getResult(), |
| 701 | args: ValueRange{idx.getResult()}); |
| 702 | return success(); |
| 703 | } |
| 704 | }; |
| 705 | |
| 706 | struct WasmMemoryOpConversion : OpConversionPattern<MemOp> { |
| 707 | using Base::Base; |
| 708 | |
| 709 | LogicalResult |
| 710 | matchAndRewrite(MemOp memOp, MemOp::Adaptor adaptor, |
| 711 | ConversionPatternRewriter &rewriter) const override { |
| 712 | auto loc = memOp.getLoc(); |
| 713 | auto bufferType = |
| 714 | MemRefType::get(shape: {ShapedType::kDynamic}, elementType: rewriter.getI8Type()); |
| 715 | auto bufferPtrType = MemRefType::get(shape: {1}, elementType: bufferType); |
| 716 | auto memVisibility = memOp.getVisibility(); |
| 717 | // Convert to StringAttr since memref::GlobalOp expects visibility as a |
| 718 | // string attribute. |
| 719 | mlir::StringAttr visAttr; |
| 720 | if (memVisibility == mlir::SymbolTable::Visibility::Public) |
| 721 | visAttr = mlir::StringAttr::get(context: memOp->getContext(), bytes: "public" ); |
| 722 | else if (memVisibility == mlir::SymbolTable::Visibility::Private) |
| 723 | visAttr = mlir::StringAttr::get(context: memOp->getContext(), bytes: "private" ); |
| 724 | else |
| 725 | visAttr = mlir::StringAttr::get(context: memOp->getContext(), bytes: "nested" ); |
| 726 | |
| 727 | auto memPtr = rewriter.replaceOpWithNewOp<memref::GlobalOp>( |
| 728 | op: memOp, args: memOp.getSymNameAttr(), args&: visAttr, args: TypeAttr::get(type: bufferPtrType), |
| 729 | /*initialValue*/ args: rewriter.getUnitAttr(), |
| 730 | /*constant*/ args: UnitAttr{}, /*alignment*/ args: IntegerAttr{}); |
| 731 | auto initializerName = (memPtr.getSymName() + "::initializer" ).str(); |
| 732 | auto memInitializer = |
| 733 | func::FuncOp::create(builder&: rewriter, location: loc, name: initializerName, |
| 734 | type: FunctionType::get(context: getContext(), inputs: {}, results: {})); |
| 735 | memInitializer->setAttr(name: rewriter.getStringAttr(bytes: "initializer" ), |
| 736 | value: rewriter.getUnitAttr()); |
| 737 | auto *initializerBody = memInitializer.addEntryBlock(); |
| 738 | auto sip = rewriter.saveInsertionPoint(); |
| 739 | rewriter.setInsertionPointToStart(initializerBody); |
| 740 | auto memRefPtr = memref::GetGlobalOp::create( |
| 741 | builder&: rewriter, location: loc, result: MemRefType::get(shape: {1}, elementType: bufferType), name: memPtr.getSymName()); |
| 742 | auto alloc = memref::AllocOp::create( |
| 743 | builder&: rewriter, location: loc, |
| 744 | memrefType: MemRefType::get(shape: {memOp.getLimits().getMin()}, elementType: rewriter.getI8Type())); |
| 745 | auto castOp = |
| 746 | memref::CastOp::create(builder&: rewriter, location: loc, dest: bufferType, source: alloc.getResult()); |
| 747 | auto idx = arith::ConstantIndexOp::create(builder&: rewriter, location: loc, value: 0); |
| 748 | memref::StoreOp::create(builder&: rewriter, location: loc, valueToStore: castOp.getResult(), |
| 749 | memref: memRefPtr.getResult(), indices: ValueRange{idx.getResult()}); |
| 750 | func::ReturnOp::create(builder&: rewriter, location: loc); |
| 751 | rewriter.restoreInsertionPoint(ip: sip); |
| 752 | func::CallOp::create(builder&: rewriter, location: loc, callee: memInitializer); |
| 753 | return success(); |
| 754 | } |
| 755 | }; |
| 756 | |
| 757 | inline TypedAttr getInitializerAttr(Type t) { |
| 758 | assert(t.isIntOrFloat() && |
| 759 | "This helper is intended to use with int and float types" ); |
| 760 | if (t.isInteger()) |
| 761 | return IntegerAttr::get(type: t, value: 0); |
| 762 | if (t.isFloat()) |
| 763 | return FloatAttr::get(type: t, value: 0.); |
| 764 | return TypedAttr{}; |
| 765 | } |
| 766 | |
| 767 | struct WasmLocalConversion : OpConversionPattern<LocalOp> { |
| 768 | using Base::Base; |
| 769 | LogicalResult |
| 770 | matchAndRewrite(LocalOp localOp, LocalOp::Adaptor adaptor, |
| 771 | ConversionPatternRewriter &rewriter) const override { |
| 772 | auto alloca = rewriter.replaceOpWithNewOp<memref::AllocaOp>( |
| 773 | op: localOp, |
| 774 | args: MemRefType::get(shape: {}, elementType: localOp.getResult().getType().getElementType())); |
| 775 | auto initializer = arith::ConstantOp::create( |
| 776 | builder&: rewriter, location: localOp->getLoc(), |
| 777 | value: getInitializerAttr(t: localOp.getResult().getType().getElementType())); |
| 778 | memref::StoreOp::create(builder&: rewriter, location: localOp->getLoc(), |
| 779 | valueToStore: initializer.getResult(), memref: alloca.getResult()); |
| 780 | return success(); |
| 781 | } |
| 782 | }; |
| 783 | |
| 784 | struct WasmLocalGetConversion : OpConversionPattern<LocalGetOp> { |
| 785 | using Base::Base; |
| 786 | LogicalResult |
| 787 | matchAndRewrite(LocalGetOp localGetOp, LocalGetOp::Adaptor adaptor, |
| 788 | ConversionPatternRewriter &rewriter) const override { |
| 789 | rewriter.replaceOpWithNewOp<memref::LoadOp>( |
| 790 | op: localGetOp, args: localGetOp.getResult().getType(), args: adaptor.getLocalVar(), |
| 791 | args: ValueRange{}); |
| 792 | return success(); |
| 793 | } |
| 794 | }; |
| 795 | |
| 796 | struct WasmLocalSetConversion : OpConversionPattern<LocalSetOp> { |
| 797 | using Base::Base; |
| 798 | LogicalResult |
| 799 | matchAndRewrite(LocalSetOp localSetOp, LocalSetOp::Adaptor adaptor, |
| 800 | ConversionPatternRewriter &rewriter) const override { |
| 801 | rewriter.replaceOpWithNewOp<memref::StoreOp>( |
| 802 | op: localSetOp, args: adaptor.getValue(), args: adaptor.getLocalVar(), args: ValueRange{}); |
| 803 | return success(); |
| 804 | } |
| 805 | }; |
| 806 | |
| 807 | struct WasmLocalTeeConversion : OpConversionPattern<LocalTeeOp> { |
| 808 | using Base::Base; |
| 809 | LogicalResult |
| 810 | matchAndRewrite(LocalTeeOp localTeeOp, LocalTeeOp::Adaptor adaptor, |
| 811 | ConversionPatternRewriter &rewriter) const override { |
| 812 | memref::StoreOp::create(builder&: rewriter, location: localTeeOp->getLoc(), valueToStore: adaptor.getValue(), |
| 813 | memref: adaptor.getLocalVar()); |
| 814 | rewriter.replaceOp(op: localTeeOp, newValues: adaptor.getValue()); |
| 815 | return success(); |
| 816 | } |
| 817 | }; |
| 818 | |
| 819 | struct WasmReturnOpConversion : OpConversionPattern<ReturnOp> { |
| 820 | using Base::Base; |
| 821 | |
| 822 | LogicalResult |
| 823 | matchAndRewrite(ReturnOp returnOp, ReturnOp::Adaptor adaptor, |
| 824 | ConversionPatternRewriter &rewriter) const override { |
| 825 | rewriter.replaceOpWithNewOp<func::ReturnOp>(op: returnOp, |
| 826 | args: adaptor.getOperands()); |
| 827 | return success(); |
| 828 | } |
| 829 | }; |
| 830 | |
| 831 | struct WasmSelectOpConversion : OpConversionPattern<SelectOp> { |
| 832 | using Base::Base; |
| 833 | |
| 834 | LogicalResult |
| 835 | matchAndRewrite(SelectOp selectOp, SelectOp::Adaptor adaptor, |
| 836 | ConversionPatternRewriter &rewriter) const override { |
| 837 | auto loc = selectOp.getLoc(); |
| 838 | auto zero = |
| 839 | arith::ConstantOp::create(builder&: rewriter, location: loc, value: rewriter.getI32IntegerAttr(value: 0)); |
| 840 | auto flag = arith::CmpIOp::create(builder&: rewriter, location: loc, predicate: arith::CmpIPredicate::ne, |
| 841 | lhs: adaptor.getCondition(), rhs: zero.getResult()); |
| 842 | rewriter.replaceOpWithNewOp<arith::SelectOp>(op: selectOp, args: flag.getResult(), |
| 843 | args: adaptor.getTrueValue(), |
| 844 | args: adaptor.getFalseValue()); |
| 845 | return success(); |
| 846 | } |
| 847 | }; |
| 848 | |
| 849 | struct RaiseWasmMLIRPass : public impl::RaiseWasmMLIRBase<RaiseWasmMLIRPass> { |
| 850 | void runOnOperation() override { |
| 851 | ConversionTarget target{getContext()}; |
| 852 | target.addIllegalDialect<WasmSSADialect>(); |
| 853 | target.addLegalDialect<arith::ArithDialect, BuiltinDialect, |
| 854 | cf::ControlFlowDialect, func::FuncDialect, |
| 855 | memref::MemRefDialect, math::MathDialect>(); |
| 856 | RewritePatternSet patterns(&getContext()); |
| 857 | TypeConverter tc{}; |
| 858 | tc.addConversion(callback: [](Type type) -> std::optional<Type> { return type; }); |
| 859 | tc.addConversion(callback: [](LocalRefType type) -> std::optional<Type> { |
| 860 | return MemRefType::get(shape: {}, elementType: type.getElementType()); |
| 861 | }); |
| 862 | tc.addTargetMaterialization(callback: [](OpBuilder &builder, MemRefType destType, |
| 863 | ValueRange values, Location loc) -> Value { |
| 864 | if (values.size() != 1 || |
| 865 | values.front().getType() != destType.getElementType()) |
| 866 | return {}; |
| 867 | auto localVar = memref::AllocaOp::create(builder, location: loc, memrefType: destType); |
| 868 | memref::StoreOp::create(builder, location: loc, valueToStore: values.front(), |
| 869 | memref: localVar.getResult()); |
| 870 | return localVar.getResult(); |
| 871 | }); |
| 872 | populateRaiseWasmMLIRConversionPatterns(tc, patterns); |
| 873 | |
| 874 | llvm::DenseMap<StringAttr, StringAttr> idxSymToImportSym{}; |
| 875 | auto *topOp = getOperation(); |
| 876 | topOp->walk(callback: [&idxSymToImportSym, this](ImportOpInterface importOp) { |
| 877 | auto const qualifiedImportName = importOp.getQualifiedImportName(); |
| 878 | auto qualNameAttr = StringAttr::get(context: &getContext(), bytes: qualifiedImportName); |
| 879 | idxSymToImportSym.insert( |
| 880 | KV: std::make_pair(x: importOp.getSymbolName(), y&: qualNameAttr)); |
| 881 | }); |
| 882 | |
| 883 | if (failed(Result: applyFullConversion(op: topOp, target, patterns: std::move(patterns)))) |
| 884 | return signalPassFailure(); |
| 885 | |
| 886 | auto symTable = SymbolTable{topOp}; |
| 887 | for (auto &[oldName, newName] : idxSymToImportSym) { |
| 888 | if (failed(Result: symTable.rename(from: oldName, to: newName))) |
| 889 | return signalPassFailure(); |
| 890 | } |
| 891 | } |
| 892 | }; |
| 893 | } // namespace |
| 894 | |
| 895 | void mlir::populateRaiseWasmMLIRConversionPatterns( |
| 896 | TypeConverter &tc, RewritePatternSet &patternSet) { |
| 897 | auto *ctx = patternSet.getContext(); |
| 898 | // Disable clang-format in patternSet for readability + small diffs. |
| 899 | // clang-format off |
| 900 | patternSet |
| 901 | .add< |
| 902 | WasmAbsOpConversion, |
| 903 | WasmAddOpConversion, |
| 904 | WasmAndOpConversion, |
| 905 | WasmCallOpConversion, |
| 906 | WasmCeilOpConversion, |
| 907 | WasmClzOpConversion, |
| 908 | WasmConstOpConversion, |
| 909 | WasmConvertSOpConversion, |
| 910 | WasmConvertUOpConversion, |
| 911 | WasmCopySignOpConversion, |
| 912 | WasmCtzOpConversion, |
| 913 | WasmDemoteOpConversion, |
| 914 | WasmDivFPOpConversion, |
| 915 | WasmDivSIOpConversion, |
| 916 | WasmDivUIOpConversion, |
| 917 | WasmEqOpConversion, |
| 918 | WasmEqzOpConversion, |
| 919 | WasmExtendLowBitsOpConversion, |
| 920 | WasmExtendSOpConversion, |
| 921 | WasmExtendUOpConversion, |
| 922 | WasmFloorOpConversion, |
| 923 | WasmFuncImportOpConversion, |
| 924 | WasmFuncOpConversion, |
| 925 | WasmGeOpConversion, |
| 926 | WasmGeSIOpConversion, |
| 927 | WasmGeUIOpConversion, |
| 928 | WasmGlobalImportOpConverter, |
| 929 | WasmGlobalSetOpConversion, |
| 930 | WasmGlobalWithConstInitConversion, |
| 931 | WasmGlobalWithGetGlobalInitConversion, |
| 932 | WasmGtOpConversion, |
| 933 | WasmGtSIOpConversion, |
| 934 | WasmGtUIOpConversion, |
| 935 | WasmLeOpConversion, |
| 936 | WasmLeSIOpConversion, |
| 937 | WasmLeUIOpConversion, |
| 938 | WasmLocalConversion, |
| 939 | WasmLocalGetConversion, |
| 940 | WasmLocalSetConversion, |
| 941 | WasmLocalTeeConversion, |
| 942 | WasmLtOpConversion, |
| 943 | WasmLtSIOpConversion, |
| 944 | WasmLtUIOpConversion, |
| 945 | WasmMaxOpConversion, |
| 946 | WasmMemoryOpConversion, |
| 947 | WasmMinOpConversion, |
| 948 | WasmMulOpConversion, |
| 949 | WasmNeOpConversion, |
| 950 | WasmNegOpConversion, |
| 951 | WasmOrOpConversion, |
| 952 | WasmPopCntOpConversion, |
| 953 | WasmPromoteOpConversion, |
| 954 | WasmReinterpretOpConversion, |
| 955 | WasmRemSIOpConversion, |
| 956 | WasmRemUIOpConversion, |
| 957 | WasmReturnOpConversion, |
| 958 | WasmRotlOpConversion, |
| 959 | WasmRotrOpConversion, |
| 960 | WasmSelectOpConversion, |
| 961 | WasmShLOpConversion, |
| 962 | WasmShRSOpConversion, |
| 963 | WasmShRUOpConversion, |
| 964 | WasmSqrtOpConversion, |
| 965 | WasmSubOpConversion, |
| 966 | WasmTruncOpConversion, |
| 967 | WasmWrapOpConversion, |
| 968 | WasmXOrOpConversion |
| 969 | >(arg&: tc, args&: ctx); |
| 970 | // clang-format on |
| 971 | } |
| 972 | |
| 973 | std::unique_ptr<Pass> createRaiseWasmMLIRPass() { |
| 974 | return std::make_unique<RaiseWasmMLIRPass>(); |
| 975 | } |
| 976 | |