MLIR  16.0.0git
Go to the documentation of this file.
1 //===- VectorPattern.h - Conversion pattern to the LLVM dialect -*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
15 namespace mlir {
17 namespace LLVM {
18 namespace detail {
19 // Helper struct to "unroll" operations on n-D vectors in terms of operations on
20 // 1-D LLVM vectors.
22  // LLVM array struct which encodes n-D vectors.
24  // LLVM vector type which encodes the inner 1-D vector type.
26  // Multiplicity of llvmNDVectorTy to llvm1DVectorTy.
28 };
30 // For >1-D vector types, extracts the necessary information to iterate over all
31 // 1-D subvectors in the underlying llrepresentation of the n-D vector
32 // Iterates on the llvm array type until we hit a non-array type (which is
33 // asserted to be an llvm vector type).
35  LLVMTypeConverter &converter);
37 // Express `linearIndex` in terms of coordinates of `basis`.
38 // Returns the empty vector when linearIndex is out of the range [0, P] where
39 // P is the product of all the basis coordinates.
40 //
41 // Prerequisites:
42 // Basis is an array of nonnegative integers (signed type inherited from
43 // vector shape type).
45  unsigned linearIndex);
47 // Iterate of linear index, convert to coords space and insert splatted 1-D
48 // vector in each position.
49 void nDVectorIterate(const NDVectorTypeInfo &info, OpBuilder &builder,
50  function_ref<void(ArrayRef<int64_t>)> fun);
53  Operation *op, ValueRange operands, LLVMTypeConverter &typeConverter,
54  std::function<Value(Type, ValueRange)> createOperand,
55  ConversionPatternRewriter &rewriter);
57 LogicalResult vectorOneToOneRewrite(Operation *op, StringRef targetOp,
58  ValueRange operands,
59  LLVMTypeConverter &typeConverter,
60  ConversionPatternRewriter &rewriter);
61 } // namespace detail
62 } // namespace LLVM
64 /// Basic lowering implementation to rewrite Ops with just one result to the
65 /// LLVM Dialect. This supports higher-dimensional vector types.
66 template <typename SourceOp, typename TargetOp>
68 public:
73  matchAndRewrite(SourceOp op, typename SourceOp::Adaptor adaptor,
74  ConversionPatternRewriter &rewriter) const override {
75  static_assert(
76  std::is_base_of<OpTrait::OneResult<SourceOp>, SourceOp>::value,
77  "expected single result op");
79  op, TargetOp::getOperationName(), adaptor.getOperands(),
80  *this->getTypeConverter(), rewriter);
81  }
82 };
83 } // namespace mlir
Include the generated interface declarations.
Utility class for operation conversions targeting the LLVM dialect that match exactly one source oper...
Definition: Pattern.h:133
NDVectorTypeInfo extractNDVectorTypeInfo(VectorType vectorType, LLVMTypeConverter &converter)
Operation is a basic unit of execution within MLIR.
Definition: Operation.h:28
Basic lowering implementation to rewrite Ops with just one result to the LLVM Dialect.
Definition: VectorPattern.h:67
This class provides return value APIs for ops that are known to have a single result.
Definition: OpDefinition.h:608
LogicalResult handleMultidimensionalVectors(Operation *op, ValueRange operands, LLVMTypeConverter &typeConverter, std::function< Value(Type, ValueRange)> createOperand, ConversionPatternRewriter &rewriter)
SmallVector< int64_t, 4 > arraySizes
Definition: VectorPattern.h:27
static constexpr const bool value
This class represents an efficient way to signal success or failure.
Definition: LogicalResult.h:26
SmallVector< int64_t, 4 > getCoordinates(ArrayRef< int64_t > basis, unsigned linearIndex)
LogicalResult vectorOneToOneRewrite(Operation *op, StringRef targetOp, ValueRange operands, LLVMTypeConverter &typeConverter, ConversionPatternRewriter &rewriter)
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
Definition: Types.h:74
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Definition: Value.h:85
LogicalResult matchAndRewrite(SourceOp op, typename SourceOp::Adaptor adaptor, ConversionPatternRewriter &rewriter) const override
Definition: VectorPattern.h:73
Conversion from types to the LLVM IR dialect.
Definition: TypeConverter.h:30
static VectorType vectorType(CodeGen &codegen, Type etp)
Constructs vector type.
This class implements a pattern rewriter for use with ConversionPatterns.
This class helps build Operations.
Definition: Builders.h:196
This class provides an abstraction over the different types of ranges over Values.
Definition: ValueRange.h:345
void nDVectorIterate(const NDVectorTypeInfo &info, OpBuilder &builder, function_ref< void(ArrayRef< int64_t >)> fun)