7945 lines
402 KiB
C++
7945 lines
402 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
||
|* *|
|
||
|* Op Declarations *|
|
||
|* *|
|
||
|* Automatically generated file, do not edit! *|
|
||
|* From: ArmSVE.td *|
|
||
|* *|
|
||
\*===----------------------------------------------------------------------===*/
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
/// BFloat16 matrix multiply-accumulate
|
||
/// BFMMLA: BFloat16 matrix multiply-accumulate into 2×2 matrices";
|
||
///
|
||
/// This operation multiplies the 2x4 BFloat16 matrix held in each 128-bit
|
||
/// segment of the first source vector by the 4x2 BFloat16 matrix in the
|
||
/// corresponding segment of the second source vector, then accumulates
|
||
/// this intermediate result with the 2x2 Float32 matrix in the corresponding
|
||
/// segment of the accumulator vector, yielding the final 2x2 Float32
|
||
/// segment of the result.
|
||
///
|
||
/// Source:
|
||
/// https://developer.arm.com/documentation/100987/0000
|
||
class BfmmlaOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ConvertFromSvboolIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// Convert a svbool type to a SVE predicate type
|
||
/// Converts svbool types (`vector<[16]xi1>` or vectors of that type, e.g.
|
||
/// `vector<2x3x[16]xi1>`) to SVE predicate types. Note: Only the trailing
|
||
/// dimension can be scalable.
|
||
///
|
||
/// Example 1: Convert a 1-D svbool mask to a SVE predicate.
|
||
/// ```mlir
|
||
/// %source = vector.load %memref[%c0] : memref<?xi1>, vector<[16]xi1>
|
||
/// %result = arm_sve.convert_from_svbool %source : vector<[4]xi1>
|
||
/// ```
|
||
///
|
||
/// Example 2: Convert a 2-D svbool mask to a mask of SVE predicates.
|
||
/// ```mlir
|
||
/// %source = vector.load %memref[%c0, %c0] : memref<2x?xi1>, vector<2x[16]xi1>
|
||
/// %result = arm_sve.convert_from_svbool %source : vector<2x[8]xi1>
|
||
/// ```
|
||
///
|
||
/// ---
|
||
///
|
||
/// A `svbool` is the smallest SVE predicate type that has a in-memory
|
||
/// representation (and maps to a full predicate register). In MLIR `svbool` is
|
||
/// represented as `vector<[16]xi1>`. Smaller SVE predicate types
|
||
/// (`vector<[1|2|4|8]xi1>`) must be stored as a `svbool` then converted back to
|
||
/// the original predicate type after loading.
|
||
class ConvertFromSvboolOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ConvertToSvboolIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// Convert a SVE predicate type to a svbool type
|
||
/// Converts SVE predicate types (or vectors of predicate types, e.g.
|
||
/// `vector<4x[4]xi1>`) to svbool types. Note: Only the trailing dimension can
|
||
/// be scalable.
|
||
///
|
||
/// Example 1: Convert a 1-D SVE predicate to a svbool mask.
|
||
/// ```mlir
|
||
/// %source = vector.create_mask %dim_size : vector<[4]xi1>
|
||
/// %result = arm_sve.convert_to_svbool %source : vector<[4]xi1>
|
||
/// // => Results in vector<[16]xi1>
|
||
/// ```
|
||
///
|
||
/// Example 2: Convert a 2-D mask of SVE predicates to a svbool mask.
|
||
/// ```mlir
|
||
/// %source = vector.create_mask %c2, %dim_size : vector<2x[2]xi1>
|
||
/// %result = arm_sve.convert_to_svbool %source : vector<2x[2]xi1>
|
||
/// // => Results in vector<2x[16]xi1>
|
||
/// ```
|
||
///
|
||
/// ---
|
||
///
|
||
/// A `svbool` is the smallest SVE predicate type that has a in-memory
|
||
/// representation (and maps to a full predicate register). In MLIR `svbool` is
|
||
/// represented as `vector<[16]xi1>`. Smaller SVE predicate types
|
||
/// (`vector<[1|2|4|8]xi1>`) must be converted to a `svbool` before they can be
|
||
/// stored.
|
||
class ConvertToSvboolOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class DupQLaneIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// Broadcast indexed 128-bit segment to vector
|
||
/// This operation fills each 128-bit segment of a vector with the elements
|
||
/// from the indexed 128-bit segment of the source vector. If the VL is
|
||
/// 128 bits the operation is a NOP. If the index exceeds the number of
|
||
/// 128-bit segments in a vector the result is an all-zeroes vector.
|
||
///
|
||
/// Example:
|
||
/// ```mlir
|
||
/// // VL == 256
|
||
/// // %X = [A B C D x x x x]
|
||
/// %Y = arm_sve.dupq_lane %X[0] : vector<[4]xi32>
|
||
/// // Y = [A B C D A B C D]
|
||
///
|
||
/// // %U = [x x x x x x x x A B C D E F G H]
|
||
/// %V = arm_sve.dupq_lane %U[1] : vector<[8]xf16>
|
||
/// // %V = [A B C D E F H A B C D E F H]
|
||
/// ```
|
||
///
|
||
/// Note: The semantics of the operation match those of the `svdupq_lane` intrinsics.
|
||
/// [Source](https://developer.arm.com/architectures/instruction-sets/intrinsics/#q=svdupq_lane)
|
||
class DupQLaneOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class PselIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// Predicate select
|
||
/// This operation returns the input predicate `p1` or an all-false predicate
|
||
/// based on the bit at `p2[index]`. Informally, the semantics are:
|
||
/// ```
|
||
/// if p2[index % num_elements(p2)] == 1:
|
||
/// return p1 : type(p1)
|
||
/// return all-false : type(p1)
|
||
/// ```
|
||
///
|
||
/// Example:
|
||
/// ```mlir
|
||
/// // Note: p1 and p2 can have different sizes.
|
||
/// %pd = arm_sve.psel %p1, %p2[%index] : vector<[4]xi1>, vector<[8]xi1>
|
||
/// ```
|
||
///
|
||
/// Note: This requires SME or SVE2.1 (`+sme` or `+sve2p1` in LLVM target features).
|
||
class PselOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ScalableMaskedAddFIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// masked addition for scalable vectors of floats
|
||
/// The `arm_sve.masked.addf` operation takes one scalable vector mask
|
||
/// and two scalable vector operands, and perform floating point addition on active lanes. Inactive lanes will keep the value of
|
||
/// the first operand.
|
||
class ScalableMaskedAddFOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ScalableMaskedAddIIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// masked addition for scalable vectors of integers
|
||
/// The `arm_sve.masked.addi` operation takes one scalable vector mask
|
||
/// and two scalable vector operands, and perform integer addition on active lanes. Inactive lanes will keep the value of
|
||
/// the first operand.
|
||
class ScalableMaskedAddIOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ScalableMaskedDivFIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// masked division for scalable vectors of floats
|
||
/// The `arm_sve.masked.divf` operation takes one scalable vector mask
|
||
/// and two scalable vector operands, and perform floating point division on active lanes. Inactive lanes will keep the value of
|
||
/// the first operand.
|
||
class ScalableMaskedDivFOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ScalableMaskedMulFIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// masked multiplication for scalable vectors of floats
|
||
/// The `arm_sve.masked.mulf` operation takes one scalable vector mask
|
||
/// and two scalable vector operands, and perform floating point multiplication on active lanes. Inactive lanes will keep the value of
|
||
/// the first operand.
|
||
class ScalableMaskedMulFOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ScalableMaskedMulIIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// masked multiplication for scalable vectors of integers
|
||
/// The `arm_sve.masked.muli` operation takes one scalable vector mask
|
||
/// and two scalable vector operands, and perform integer multiplication on active lanes. Inactive lanes will keep the value of
|
||
/// the first operand.
|
||
class ScalableMaskedMulIOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ScalableMaskedSDivIIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// masked signed division for scalable vectors of integers
|
||
/// The `arm_sve.masked.divi_signed` operation takes one scalable vector mask
|
||
/// and two scalable vector operands, and perform integer signed division on active lanes. Inactive lanes will keep the value of
|
||
/// the first operand.
|
||
class ScalableMaskedSDivIOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ScalableMaskedSubFIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// masked subtraction for scalable vectors of floats
|
||
/// The `arm_sve.masked.subf` operation takes one scalable vector mask
|
||
/// and two scalable vector operands, and perform floating point subtraction on active lanes. Inactive lanes will keep the value of
|
||
/// the first operand.
|
||
class ScalableMaskedSubFOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ScalableMaskedSubIIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// masked subtraction for scalable vectors of integers
|
||
/// The `arm_sve.masked.subi` operation takes one scalable vector mask
|
||
/// and two scalable vector operands, and perform integer subtraction on active lanes. Inactive lanes will keep the value of
|
||
/// the first operand.
|
||
class ScalableMaskedSubIOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ScalableMaskedUDivIIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// masked unsigned division for scalable vectors of integers
|
||
/// The `arm_sve.masked.divi_unsigned` operation takes one scalable vector mask
|
||
/// and two scalable vector operands, and perform integer unsigned division on active lanes. Inactive lanes will keep the value of
|
||
/// the first operand.
|
||
class ScalableMaskedUDivIOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class SdotIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// Vector-vector dot product and accumulate op
|
||
/// SDOT: Signed integer addition of dot product.
|
||
///
|
||
/// This function maps to the SDOT instruction, and it takes signless integer
|
||
/// operands that the operation interprets as signed. It partitions the second
|
||
/// and third vector inputs into groups of four elements. They calculate the dot
|
||
/// product of each group (without loss of precision) and then add each result
|
||
/// to the overlapping element of the first vector input.
|
||
///
|
||
/// Source:
|
||
/// https://developer.arm.com/documentation/100987/0000
|
||
class SdotOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class SmmlaIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// Matrix-matrix multiply and accumulate op
|
||
/// SMMLA: Signed integer matrix multiply-accumulate.
|
||
///
|
||
/// This function maps to the SMMLA instruction, and it takes signless integer
|
||
/// operands that the operation interprets as signed. It partitions the inputs
|
||
/// into 128-bit quadwords, with the first input containing a row-by-row 2×2
|
||
/// matrix of 32-bit integers, the second input containing a row-by-row 2×8
|
||
/// matrix of 8-bit integers, and the third input containing a column-by-column
|
||
/// 8×2 matrix of 8-bit integers. For each quadword, they multiply the second
|
||
/// input matrix by the third input matrix using natural arithmetic and then add
|
||
/// the result to the first input using modular arithmetic.
|
||
///
|
||
/// Source:
|
||
/// https://developer.arm.com/documentation/100987/0000
|
||
class SmmlaOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class UdotIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// Vector-vector dot product and accumulate op
|
||
/// UDOT: Unsigned integer addition of dot product.
|
||
///
|
||
/// This function maps to the UDOT instruction, and it takes signless integer
|
||
/// operands that the operation interprets as unsigned. It partitions the second
|
||
/// and third vector inputs into groups of four elements. They calculate the dot
|
||
/// product of each group (without loss of precision) and then add each result
|
||
/// to the overlapping element of the first vector input.
|
||
///
|
||
/// Source:
|
||
/// https://developer.arm.com/documentation/100987/0000
|
||
class UdotOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class UmmlaIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// Matrix-matrix multiply and accumulate op
|
||
/// UMMLA: Unsigned integer matrix multiply-accumulate.
|
||
///
|
||
/// This function maps to the UMMLA instruction, and it takes signless integer
|
||
/// operands that the operation interprets as unsigned. It partitions the inputs
|
||
/// into 128-bit quadwords, with the first input containing a row-by-row 2×2
|
||
/// matrix of 32-bit integers, the second input containing a row-by-row 2×8
|
||
/// matrix of 8-bit integers, and the third input containing a column-by-column
|
||
/// 8×2 matrix of 8-bit integers. For each quadword, they multiply the second
|
||
/// input matrix by the third input matrix using natural arithmetic and then add
|
||
/// the result to the first input using modular arithmetic.
|
||
///
|
||
/// Source:
|
||
/// https://developer.arm.com/documentation/100987/0000
|
||
class UmmlaOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class UsmmlaIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// Matrix-matrix multiply and accumulate op
|
||
/// USMMLA: Unsigned by signed integer matrix multiply-accumulate.
|
||
///
|
||
/// The unsigned by signed integer matrix multiply-accumulate operation
|
||
/// multiplies the 2×8 matrix of unsigned 8-bit integer values held
|
||
/// the first source vector by the 8×2 matrix of signed 8-bit integer
|
||
/// values in the second source vector. The resulting 2×2 widened 32-bit
|
||
/// integer matrix product is then added to the 32-bit integer matrix
|
||
/// accumulator.
|
||
///
|
||
/// Source:
|
||
/// https://developer.arm.com/documentation/100987/0000
|
||
class UsmmlaOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class WhileLTIntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ZipX2IntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// Multi-vector two-way zip op
|
||
/// This operation interleaves elements from two input SVE vectors, returning
|
||
/// two new SVE vectors (`resultV1` and `resultV2`), which contain the low and
|
||
/// high halves of the result respectively.
|
||
///
|
||
/// Example:
|
||
/// ```mlir
|
||
/// // sourceV1 = [ A1, A2, A3, ... An ]
|
||
/// // sourceV2 = [ B1, B2, B3, ... Bn ]
|
||
/// // (resultV1, resultV2) = [ A1, B1, A2, B2, A3, B3, ... An, Bn ]
|
||
/// %resultV1, %resultV2 = arm_sve.zip.x2 %sourceV1, %sourceV2 : vector<[16]xi8>
|
||
/// ```
|
||
///
|
||
/// Note: This requires SME 2 (`+sme2` in LLVM target features)
|
||
///
|
||
/// [Source](https://developer.arm.com/documentation/ddi0602/2023-12/SME-Instructions/ZIP--two-registers---Interleave-elements-from-two-vectors-?lang=en)
|
||
class ZipX2Op;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
class ZipX4IntrOp;
|
||
|
||
} // namespace mlir::arm_sve
|
||
namespace mlir::arm_sve {
|
||
|
||
/// Multi-vector four-way zip op
|
||
/// This operation interleaves elements from four input SVE vectors, returning
|
||
/// four new SVE vectors, each of which contain a quarter of the result. The
|
||
/// first quarter will be in `resultV1`, second in `resultV2`, third in
|
||
/// `resultV3`, and fourth in `resultV4`.
|
||
///
|
||
/// ```mlir
|
||
/// // sourceV1 = [ A1, A2, ... An ]
|
||
/// // sourceV2 = [ B1, B2, ... Bn ]
|
||
/// // sourceV3 = [ C1, C2, ... Cn ]
|
||
/// // sourceV4 = [ D1, D2, ... Dn ]
|
||
/// // (resultV1, resultV2, resultV3, resultV4)
|
||
/// // = [ A1, B1, C1, D1, A2, B2, C2, D2, ... An, Bn, Cn, Dn ]
|
||
/// %resultV1, %resultV2, %resultV3, %resultV4 = arm_sve.zip.x4
|
||
/// %sourceV1, %sourceV2, %sourceV3, %sourceV4 : vector<[16]xi8>
|
||
/// ```
|
||
///
|
||
/// **Warning:** The result of this op is undefined for 64-bit elements on
|
||
/// hardware with less than 256-bit vectors!
|
||
///
|
||
/// Note: This requires SME 2 (`+sme2` in LLVM target features)
|
||
///
|
||
/// [Source](https://developer.arm.com/documentation/ddi0602/2023-12/SME-Instructions/ZIP--four-registers---Interleave-elements-from-four-vectors-?lang=en)
|
||
class ZipX4Op;
|
||
|
||
} // namespace mlir::arm_sve
|
||
#ifdef GET_OP_CLASSES
|
||
#undef GET_OP_CLASSES
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::BfmmlaOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class BfmmlaOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
BfmmlaOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.bfmmla", odsAttrs.getContext());
|
||
}
|
||
|
||
BfmmlaOpGenericAdaptorBase(BfmmlaOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class BfmmlaOpGenericAdaptor : public detail::BfmmlaOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::BfmmlaOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_acc = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
BfmmlaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
BfmmlaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : BfmmlaOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
BfmmlaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : BfmmlaOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
BfmmlaOpGenericAdaptor(RangeT values, const BfmmlaOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = BfmmlaOp, typename = std::enable_if_t<std::is_same_v<LateInst, BfmmlaOp>>>
|
||
BfmmlaOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getAcc() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class BfmmlaOpAdaptor : public BfmmlaOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using BfmmlaOpGenericAdaptor::BfmmlaOpGenericAdaptor;
|
||
BfmmlaOpAdaptor(BfmmlaOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class BfmmlaOp : public ::mlir::Op<BfmmlaOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = BfmmlaOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = BfmmlaOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_acc = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.bfmmla");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getAcc() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getAccMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static BfmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static BfmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static BfmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static BfmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static BfmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static BfmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static BfmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static BfmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::BfmmlaOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ConvertFromSvboolIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ConvertFromSvboolIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ConvertFromSvboolIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.convert.from.svbool", odsAttrs.getContext());
|
||
}
|
||
|
||
ConvertFromSvboolIntrOpGenericAdaptorBase(ConvertFromSvboolIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ConvertFromSvboolIntrOpGenericAdaptor : public detail::ConvertFromSvboolIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ConvertFromSvboolIntrOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_svbool = 0;
|
||
public:
|
||
ConvertFromSvboolIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ConvertFromSvboolIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ConvertFromSvboolIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ConvertFromSvboolIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ConvertFromSvboolIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ConvertFromSvboolIntrOpGenericAdaptor(RangeT values, const ConvertFromSvboolIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ConvertFromSvboolIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ConvertFromSvboolIntrOp>>>
|
||
ConvertFromSvboolIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getSvbool() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ConvertFromSvboolIntrOpAdaptor : public ConvertFromSvboolIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ConvertFromSvboolIntrOpGenericAdaptor::ConvertFromSvboolIntrOpGenericAdaptor;
|
||
ConvertFromSvboolIntrOpAdaptor(ConvertFromSvboolIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ConvertFromSvboolIntrOp : public ::mlir::Op<ConvertFromSvboolIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ConvertFromSvboolIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ConvertFromSvboolIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_svbool = 0;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.convert.from.svbool");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSvbool() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getSvboolMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value svbool);
|
||
static ConvertFromSvboolIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value svbool);
|
||
static ConvertFromSvboolIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value svbool);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value svbool);
|
||
static ConvertFromSvboolIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value svbool);
|
||
static ConvertFromSvboolIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value svbool);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ConvertFromSvboolIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ConvertFromSvboolIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ConvertFromSvboolIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ConvertFromSvboolIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ConvertFromSvboolIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ConvertFromSvboolOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ConvertFromSvboolOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ConvertFromSvboolOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.convert_from_svbool", odsAttrs.getContext());
|
||
}
|
||
|
||
ConvertFromSvboolOpGenericAdaptorBase(ConvertFromSvboolOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ConvertFromSvboolOpGenericAdaptor : public detail::ConvertFromSvboolOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ConvertFromSvboolOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_source = 0;
|
||
public:
|
||
ConvertFromSvboolOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ConvertFromSvboolOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ConvertFromSvboolOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ConvertFromSvboolOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ConvertFromSvboolOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ConvertFromSvboolOpGenericAdaptor(RangeT values, const ConvertFromSvboolOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ConvertFromSvboolOp, typename = std::enable_if_t<std::is_same_v<LateInst, ConvertFromSvboolOp>>>
|
||
ConvertFromSvboolOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getSource() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ConvertFromSvboolOpAdaptor : public ConvertFromSvboolOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ConvertFromSvboolOpGenericAdaptor::ConvertFromSvboolOpGenericAdaptor;
|
||
ConvertFromSvboolOpAdaptor(ConvertFromSvboolOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ConvertFromSvboolOp : public ::mlir::Op<ConvertFromSvboolOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ConvertFromSvboolOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ConvertFromSvboolOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_source = 0;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.convert_from_svbool");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSource() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getSourceMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getResult() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value source);
|
||
static ConvertFromSvboolOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type result, ::mlir::Value source);
|
||
static ConvertFromSvboolOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type result, ::mlir::Value source);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value source);
|
||
static ConvertFromSvboolOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value source);
|
||
static ConvertFromSvboolOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value source);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ConvertFromSvboolOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ConvertFromSvboolOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ConvertFromSvboolOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ConvertFromSvboolOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ConvertFromSvboolOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ConvertToSvboolIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ConvertToSvboolIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ConvertToSvboolIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.convert.to.svbool", odsAttrs.getContext());
|
||
}
|
||
|
||
ConvertToSvboolIntrOpGenericAdaptorBase(ConvertToSvboolIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ConvertToSvboolIntrOpGenericAdaptor : public detail::ConvertToSvboolIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ConvertToSvboolIntrOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_mask = 0;
|
||
public:
|
||
ConvertToSvboolIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ConvertToSvboolIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ConvertToSvboolIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ConvertToSvboolIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ConvertToSvboolIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ConvertToSvboolIntrOpGenericAdaptor(RangeT values, const ConvertToSvboolIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ConvertToSvboolIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ConvertToSvboolIntrOp>>>
|
||
ConvertToSvboolIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getMask() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ConvertToSvboolIntrOpAdaptor : public ConvertToSvboolIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ConvertToSvboolIntrOpGenericAdaptor::ConvertToSvboolIntrOpGenericAdaptor;
|
||
ConvertToSvboolIntrOpAdaptor(ConvertToSvboolIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ConvertToSvboolIntrOp : public ::mlir::Op<ConvertToSvboolIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ConvertToSvboolIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ConvertToSvboolIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_mask = 0;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.convert.to.svbool");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getMask() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getMaskMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value mask);
|
||
static ConvertToSvboolIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value mask);
|
||
static ConvertToSvboolIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value mask);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value mask);
|
||
static ConvertToSvboolIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value mask);
|
||
static ConvertToSvboolIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value mask);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ConvertToSvboolIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ConvertToSvboolIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ConvertToSvboolIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ConvertToSvboolIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ConvertToSvboolIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ConvertToSvboolOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ConvertToSvboolOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ConvertToSvboolOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.convert_to_svbool", odsAttrs.getContext());
|
||
}
|
||
|
||
ConvertToSvboolOpGenericAdaptorBase(ConvertToSvboolOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ConvertToSvboolOpGenericAdaptor : public detail::ConvertToSvboolOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ConvertToSvboolOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_source = 0;
|
||
public:
|
||
ConvertToSvboolOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ConvertToSvboolOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ConvertToSvboolOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ConvertToSvboolOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ConvertToSvboolOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ConvertToSvboolOpGenericAdaptor(RangeT values, const ConvertToSvboolOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ConvertToSvboolOp, typename = std::enable_if_t<std::is_same_v<LateInst, ConvertToSvboolOp>>>
|
||
ConvertToSvboolOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getSource() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ConvertToSvboolOpAdaptor : public ConvertToSvboolOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ConvertToSvboolOpGenericAdaptor::ConvertToSvboolOpGenericAdaptor;
|
||
ConvertToSvboolOpAdaptor(ConvertToSvboolOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ConvertToSvboolOp : public ::mlir::Op<ConvertToSvboolOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ConvertToSvboolOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ConvertToSvboolOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_source = 0;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.convert_to_svbool");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSource() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getSourceMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getResult() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value source);
|
||
static ConvertToSvboolOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type result, ::mlir::Value source);
|
||
static ConvertToSvboolOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type result, ::mlir::Value source);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value source);
|
||
static ConvertToSvboolOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value source);
|
||
static ConvertToSvboolOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value source);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ConvertToSvboolOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ConvertToSvboolOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ConvertToSvboolOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ConvertToSvboolOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ConvertToSvboolOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::DupQLaneIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class DupQLaneIntrOpGenericAdaptorBase {
|
||
public:
|
||
struct Properties {
|
||
using laneTy = ::mlir::IntegerAttr;
|
||
laneTy lane;
|
||
|
||
auto getLane() const {
|
||
auto &propStorage = this->lane;
|
||
return ::llvm::cast<::mlir::IntegerAttr>(propStorage);
|
||
}
|
||
void setLane(const ::mlir::IntegerAttr &propValue) {
|
||
this->lane = propValue;
|
||
}
|
||
bool operator==(const Properties &rhs) const {
|
||
return
|
||
rhs.lane == this->lane &&
|
||
true;
|
||
}
|
||
bool operator!=(const Properties &rhs) const {
|
||
return !(*this == rhs);
|
||
}
|
||
};
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
DupQLaneIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.dupq_lane", odsAttrs.getContext());
|
||
}
|
||
|
||
DupQLaneIntrOpGenericAdaptorBase(DupQLaneIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
::mlir::IntegerAttr getLaneAttr() {
|
||
auto attr = ::llvm::cast<::mlir::IntegerAttr>(getProperties().lane);
|
||
return attr;
|
||
}
|
||
|
||
uint64_t getLane();
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class DupQLaneIntrOpGenericAdaptor : public detail::DupQLaneIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::DupQLaneIntrOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_v = 0;
|
||
public:
|
||
DupQLaneIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
DupQLaneIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : DupQLaneIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
DupQLaneIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : DupQLaneIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
DupQLaneIntrOpGenericAdaptor(RangeT values, const DupQLaneIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = DupQLaneIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, DupQLaneIntrOp>>>
|
||
DupQLaneIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getV() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class DupQLaneIntrOpAdaptor : public DupQLaneIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using DupQLaneIntrOpGenericAdaptor::DupQLaneIntrOpGenericAdaptor;
|
||
DupQLaneIntrOpAdaptor(DupQLaneIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class DupQLaneIntrOp : public ::mlir::Op<DupQLaneIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = DupQLaneIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = DupQLaneIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_v = 0;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
static ::llvm::StringRef attrNames[] = {::llvm::StringRef("lane")};
|
||
return ::llvm::ArrayRef(attrNames);
|
||
}
|
||
|
||
::mlir::StringAttr getLaneAttrName() {
|
||
return getAttributeNameForIndex(0);
|
||
}
|
||
|
||
static ::mlir::StringAttr getLaneAttrName(::mlir::OperationName name) {
|
||
return getAttributeNameForIndex(name, 0);
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.dupq_lane");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getV() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getVMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state);
|
||
void writeProperties(::mlir::DialectBytecodeWriter &writer);
|
||
::mlir::IntegerAttr getLaneAttr() {
|
||
return ::llvm::cast<::mlir::IntegerAttr>(getProperties().lane);
|
||
}
|
||
|
||
uint64_t getLane();
|
||
void setLaneAttr(::mlir::IntegerAttr attr) {
|
||
getProperties().lane = attr;
|
||
}
|
||
|
||
void setLane(uint64_t attrValue);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value v, ::mlir::IntegerAttr lane);
|
||
static DupQLaneIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value v, ::mlir::IntegerAttr lane);
|
||
static DupQLaneIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value v, ::mlir::IntegerAttr lane);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value v, ::mlir::IntegerAttr lane);
|
||
static DupQLaneIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value v, ::mlir::IntegerAttr lane);
|
||
static DupQLaneIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value v, ::mlir::IntegerAttr lane);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value v, uint64_t lane);
|
||
static DupQLaneIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value v, uint64_t lane);
|
||
static DupQLaneIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value v, uint64_t lane);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value v, uint64_t lane);
|
||
static DupQLaneIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value v, uint64_t lane);
|
||
static DupQLaneIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value v, uint64_t lane);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static DupQLaneIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static DupQLaneIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static DupQLaneIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static DupQLaneIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
private:
|
||
::mlir::StringAttr getAttributeNameForIndex(unsigned index) {
|
||
return getAttributeNameForIndex((*this)->getName(), index);
|
||
}
|
||
|
||
static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) {
|
||
assert(index < 1 && "invalid attribute index");
|
||
assert(name.getStringRef() == getOperationName() && "invalid operation name");
|
||
assert(name.isRegistered() && "Operation isn't registered, missing a "
|
||
"dependent dialect loading?");
|
||
return name.getAttributeNames()[index];
|
||
}
|
||
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::DupQLaneIntrOp)
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::detail::DupQLaneIntrOpGenericAdaptorBase::Properties)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::DupQLaneOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class DupQLaneOpGenericAdaptorBase {
|
||
public:
|
||
struct Properties {
|
||
using laneTy = ::mlir::IntegerAttr;
|
||
laneTy lane;
|
||
|
||
auto getLane() const {
|
||
auto &propStorage = this->lane;
|
||
return ::llvm::cast<::mlir::IntegerAttr>(propStorage);
|
||
}
|
||
void setLane(const ::mlir::IntegerAttr &propValue) {
|
||
this->lane = propValue;
|
||
}
|
||
bool operator==(const Properties &rhs) const {
|
||
return
|
||
rhs.lane == this->lane &&
|
||
true;
|
||
}
|
||
bool operator!=(const Properties &rhs) const {
|
||
return !(*this == rhs);
|
||
}
|
||
};
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
DupQLaneOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.dupq_lane", odsAttrs.getContext());
|
||
}
|
||
|
||
DupQLaneOpGenericAdaptorBase(DupQLaneOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
::mlir::IntegerAttr getLaneAttr() {
|
||
auto attr = ::llvm::cast<::mlir::IntegerAttr>(getProperties().lane);
|
||
return attr;
|
||
}
|
||
|
||
uint64_t getLane();
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class DupQLaneOpGenericAdaptor : public detail::DupQLaneOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::DupQLaneOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_src = 0;
|
||
public:
|
||
DupQLaneOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
DupQLaneOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : DupQLaneOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
DupQLaneOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : DupQLaneOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
DupQLaneOpGenericAdaptor(RangeT values, const DupQLaneOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = DupQLaneOp, typename = std::enable_if_t<std::is_same_v<LateInst, DupQLaneOp>>>
|
||
DupQLaneOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getSrc() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class DupQLaneOpAdaptor : public DupQLaneOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using DupQLaneOpGenericAdaptor::DupQLaneOpGenericAdaptor;
|
||
DupQLaneOpAdaptor(DupQLaneOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class DupQLaneOp : public ::mlir::Op<DupQLaneOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = DupQLaneOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = DupQLaneOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_src = 0;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
static ::llvm::StringRef attrNames[] = {::llvm::StringRef("lane")};
|
||
return ::llvm::ArrayRef(attrNames);
|
||
}
|
||
|
||
::mlir::StringAttr getLaneAttrName() {
|
||
return getAttributeNameForIndex(0);
|
||
}
|
||
|
||
static ::mlir::StringAttr getLaneAttrName(::mlir::OperationName name) {
|
||
return getAttributeNameForIndex(name, 0);
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.dupq_lane");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getSrc() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getSrcMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getDst() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state);
|
||
void writeProperties(::mlir::DialectBytecodeWriter &writer);
|
||
::mlir::IntegerAttr getLaneAttr() {
|
||
return ::llvm::cast<::mlir::IntegerAttr>(getProperties().lane);
|
||
}
|
||
|
||
uint64_t getLane();
|
||
void setLaneAttr(::mlir::IntegerAttr attr) {
|
||
getProperties().lane = attr;
|
||
}
|
||
|
||
void setLane(uint64_t attrValue);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value src, int64_t lane);
|
||
static DupQLaneOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value src, int64_t lane);
|
||
static DupQLaneOp create(::mlir::ImplicitLocOpBuilder &builder, Value src, int64_t lane);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type dst, ::mlir::Value src, ::mlir::IntegerAttr lane);
|
||
static DupQLaneOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type dst, ::mlir::Value src, ::mlir::IntegerAttr lane);
|
||
static DupQLaneOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type dst, ::mlir::Value src, ::mlir::IntegerAttr lane);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value src, ::mlir::IntegerAttr lane);
|
||
static DupQLaneOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value src, ::mlir::IntegerAttr lane);
|
||
static DupQLaneOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value src, ::mlir::IntegerAttr lane);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type dst, ::mlir::Value src, uint64_t lane);
|
||
static DupQLaneOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type dst, ::mlir::Value src, uint64_t lane);
|
||
static DupQLaneOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type dst, ::mlir::Value src, uint64_t lane);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value src, uint64_t lane);
|
||
static DupQLaneOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value src, uint64_t lane);
|
||
static DupQLaneOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value src, uint64_t lane);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static DupQLaneOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static DupQLaneOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static DupQLaneOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static DupQLaneOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
private:
|
||
::mlir::StringAttr getAttributeNameForIndex(unsigned index) {
|
||
return getAttributeNameForIndex((*this)->getName(), index);
|
||
}
|
||
|
||
static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) {
|
||
assert(index < 1 && "invalid attribute index");
|
||
assert(name.getStringRef() == getOperationName() && "invalid operation name");
|
||
assert(name.isRegistered() && "Operation isn't registered, missing a "
|
||
"dependent dialect loading?");
|
||
return name.getAttributeNames()[index];
|
||
}
|
||
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::DupQLaneOp)
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::detail::DupQLaneOpGenericAdaptorBase::Properties)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::PselIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class PselIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
PselIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.psel", odsAttrs.getContext());
|
||
}
|
||
|
||
PselIntrOpGenericAdaptorBase(PselIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class PselIntrOpGenericAdaptor : public detail::PselIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::PselIntrOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_p1 = 0;
|
||
static constexpr int odsIndex_p2 = 1;
|
||
static constexpr int odsIndex_index = 2;
|
||
public:
|
||
PselIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
PselIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : PselIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
PselIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : PselIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
PselIntrOpGenericAdaptor(RangeT values, const PselIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = PselIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, PselIntrOp>>>
|
||
PselIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getP1() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getP2() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getIndex() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class PselIntrOpAdaptor : public PselIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using PselIntrOpGenericAdaptor::PselIntrOpGenericAdaptor;
|
||
PselIntrOpAdaptor(PselIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class PselIntrOp : public ::mlir::Op<PselIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = PselIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = PselIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_p1 = 0;
|
||
static constexpr int odsIndex_p2 = 1;
|
||
static constexpr int odsIndex_index = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.psel");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getP1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getP2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::IntegerType> getIndex() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getP1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getP2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getIndexMutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value p1, ::mlir::Value p2, ::mlir::Value index);
|
||
static PselIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value p1, ::mlir::Value p2, ::mlir::Value index);
|
||
static PselIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value p1, ::mlir::Value p2, ::mlir::Value index);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value p1, ::mlir::Value p2, ::mlir::Value index);
|
||
static PselIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value p1, ::mlir::Value p2, ::mlir::Value index);
|
||
static PselIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value p1, ::mlir::Value p2, ::mlir::Value index);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static PselIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static PselIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static PselIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static PselIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::PselIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::PselOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class PselOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
PselOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.psel", odsAttrs.getContext());
|
||
}
|
||
|
||
PselOpGenericAdaptorBase(PselOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class PselOpGenericAdaptor : public detail::PselOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::PselOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_p1 = 0;
|
||
static constexpr int odsIndex_p2 = 1;
|
||
static constexpr int odsIndex_index = 2;
|
||
public:
|
||
PselOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
PselOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : PselOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
PselOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : PselOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
PselOpGenericAdaptor(RangeT values, const PselOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = PselOp, typename = std::enable_if_t<std::is_same_v<LateInst, PselOp>>>
|
||
PselOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getP1() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getP2() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getIndex() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class PselOpAdaptor : public PselOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using PselOpGenericAdaptor::PselOpGenericAdaptor;
|
||
PselOpAdaptor(PselOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class PselOp : public ::mlir::Op<PselOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = PselOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = PselOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_p1 = 0;
|
||
static constexpr int odsIndex_p2 = 1;
|
||
static constexpr int odsIndex_index = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.psel");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getP1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getP2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::IndexType> getIndex() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::IndexType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getP1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getP2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getIndexMutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getResult() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value p1, Value p2, Value index);
|
||
static PselOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value p1, Value p2, Value index);
|
||
static PselOp create(::mlir::ImplicitLocOpBuilder &builder, Value p1, Value p2, Value index);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value p1, ::mlir::Value p2, ::mlir::Value index);
|
||
static PselOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type result, ::mlir::Value p1, ::mlir::Value p2, ::mlir::Value index);
|
||
static PselOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type result, ::mlir::Value p1, ::mlir::Value p2, ::mlir::Value index);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value p1, ::mlir::Value p2, ::mlir::Value index);
|
||
static PselOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value p1, ::mlir::Value p2, ::mlir::Value index);
|
||
static PselOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value p1, ::mlir::Value p2, ::mlir::Value index);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static PselOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static PselOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static PselOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static PselOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::PselOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedAddFIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedAddFIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedAddFIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.fadd", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedAddFIntrOpGenericAdaptorBase(ScalableMaskedAddFIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedAddFIntrOpGenericAdaptor : public detail::ScalableMaskedAddFIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedAddFIntrOpGenericAdaptorBase;
|
||
public:
|
||
ScalableMaskedAddFIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedAddFIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedAddFIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedAddFIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedAddFIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedAddFIntrOpGenericAdaptor(RangeT values, const ScalableMaskedAddFIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedAddFIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedAddFIntrOp>>>
|
||
ScalableMaskedAddFIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedAddFIntrOpAdaptor : public ScalableMaskedAddFIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedAddFIntrOpGenericAdaptor::ScalableMaskedAddFIntrOpGenericAdaptor;
|
||
ScalableMaskedAddFIntrOpAdaptor(ScalableMaskedAddFIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedAddFIntrOp : public ::mlir::Op<ScalableMaskedAddFIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedAddFIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedAddFIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.fadd");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedAddFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedAddFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedAddFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedAddFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedAddFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedAddFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedAddFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedAddFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedAddFIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedAddFOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedAddFOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedAddFOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.masked.addf", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedAddFOpGenericAdaptorBase(ScalableMaskedAddFOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedAddFOpGenericAdaptor : public detail::ScalableMaskedAddFOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedAddFOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
ScalableMaskedAddFOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedAddFOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedAddFOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedAddFOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedAddFOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedAddFOpGenericAdaptor(RangeT values, const ScalableMaskedAddFOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedAddFOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedAddFOp>>>
|
||
ScalableMaskedAddFOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getMask() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedAddFOpAdaptor : public ScalableMaskedAddFOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedAddFOpGenericAdaptor::ScalableMaskedAddFOpGenericAdaptor;
|
||
ScalableMaskedAddFOpAdaptor(ScalableMaskedAddFOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedAddFOp : public ::mlir::Op<ScalableMaskedAddFOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsCommutative> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedAddFOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedAddFOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.masked.addf");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getMask() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getMaskMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedAddFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedAddFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedAddFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedAddFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedAddFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedAddFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedAddFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedAddFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedAddFOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedAddIIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedAddIIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedAddIIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.add", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedAddIIntrOpGenericAdaptorBase(ScalableMaskedAddIIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedAddIIntrOpGenericAdaptor : public detail::ScalableMaskedAddIIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedAddIIntrOpGenericAdaptorBase;
|
||
public:
|
||
ScalableMaskedAddIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedAddIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedAddIIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedAddIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedAddIIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedAddIIntrOpGenericAdaptor(RangeT values, const ScalableMaskedAddIIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedAddIIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedAddIIntrOp>>>
|
||
ScalableMaskedAddIIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedAddIIntrOpAdaptor : public ScalableMaskedAddIIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedAddIIntrOpGenericAdaptor::ScalableMaskedAddIIntrOpGenericAdaptor;
|
||
ScalableMaskedAddIIntrOpAdaptor(ScalableMaskedAddIIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedAddIIntrOp : public ::mlir::Op<ScalableMaskedAddIIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedAddIIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedAddIIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.add");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedAddIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedAddIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedAddIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedAddIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedAddIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedAddIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedAddIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedAddIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedAddIIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedAddIOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedAddIOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedAddIOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.masked.addi", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedAddIOpGenericAdaptorBase(ScalableMaskedAddIOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedAddIOpGenericAdaptor : public detail::ScalableMaskedAddIOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedAddIOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
ScalableMaskedAddIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedAddIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedAddIOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedAddIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedAddIOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedAddIOpGenericAdaptor(RangeT values, const ScalableMaskedAddIOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedAddIOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedAddIOp>>>
|
||
ScalableMaskedAddIOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getMask() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedAddIOpAdaptor : public ScalableMaskedAddIOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedAddIOpGenericAdaptor::ScalableMaskedAddIOpGenericAdaptor;
|
||
ScalableMaskedAddIOpAdaptor(ScalableMaskedAddIOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedAddIOp : public ::mlir::Op<ScalableMaskedAddIOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsCommutative> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedAddIOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedAddIOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.masked.addi");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getMask() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getMaskMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedAddIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedAddIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedAddIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedAddIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedAddIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedAddIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedAddIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedAddIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedAddIOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedDivFIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedDivFIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedDivFIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.fdiv", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedDivFIntrOpGenericAdaptorBase(ScalableMaskedDivFIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedDivFIntrOpGenericAdaptor : public detail::ScalableMaskedDivFIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedDivFIntrOpGenericAdaptorBase;
|
||
public:
|
||
ScalableMaskedDivFIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedDivFIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedDivFIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedDivFIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedDivFIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedDivFIntrOpGenericAdaptor(RangeT values, const ScalableMaskedDivFIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedDivFIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedDivFIntrOp>>>
|
||
ScalableMaskedDivFIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedDivFIntrOpAdaptor : public ScalableMaskedDivFIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedDivFIntrOpGenericAdaptor::ScalableMaskedDivFIntrOpGenericAdaptor;
|
||
ScalableMaskedDivFIntrOpAdaptor(ScalableMaskedDivFIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedDivFIntrOp : public ::mlir::Op<ScalableMaskedDivFIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedDivFIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedDivFIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.fdiv");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedDivFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedDivFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedDivFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedDivFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedDivFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedDivFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedDivFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedDivFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedDivFIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedDivFOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedDivFOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedDivFOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.masked.divf", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedDivFOpGenericAdaptorBase(ScalableMaskedDivFOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedDivFOpGenericAdaptor : public detail::ScalableMaskedDivFOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedDivFOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
ScalableMaskedDivFOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedDivFOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedDivFOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedDivFOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedDivFOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedDivFOpGenericAdaptor(RangeT values, const ScalableMaskedDivFOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedDivFOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedDivFOp>>>
|
||
ScalableMaskedDivFOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getMask() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedDivFOpAdaptor : public ScalableMaskedDivFOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedDivFOpGenericAdaptor::ScalableMaskedDivFOpGenericAdaptor;
|
||
ScalableMaskedDivFOpAdaptor(ScalableMaskedDivFOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedDivFOp : public ::mlir::Op<ScalableMaskedDivFOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedDivFOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedDivFOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.masked.divf");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getMask() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getMaskMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedDivFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedDivFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedDivFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedDivFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedDivFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedDivFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedDivFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedDivFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedDivFOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedMulFIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedMulFIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedMulFIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.fmul", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedMulFIntrOpGenericAdaptorBase(ScalableMaskedMulFIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedMulFIntrOpGenericAdaptor : public detail::ScalableMaskedMulFIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedMulFIntrOpGenericAdaptorBase;
|
||
public:
|
||
ScalableMaskedMulFIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedMulFIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedMulFIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedMulFIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedMulFIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedMulFIntrOpGenericAdaptor(RangeT values, const ScalableMaskedMulFIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedMulFIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedMulFIntrOp>>>
|
||
ScalableMaskedMulFIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedMulFIntrOpAdaptor : public ScalableMaskedMulFIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedMulFIntrOpGenericAdaptor::ScalableMaskedMulFIntrOpGenericAdaptor;
|
||
ScalableMaskedMulFIntrOpAdaptor(ScalableMaskedMulFIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedMulFIntrOp : public ::mlir::Op<ScalableMaskedMulFIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedMulFIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedMulFIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.fmul");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedMulFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedMulFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedMulFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedMulFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedMulFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedMulFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedMulFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedMulFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedMulFIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedMulFOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedMulFOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedMulFOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.masked.mulf", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedMulFOpGenericAdaptorBase(ScalableMaskedMulFOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedMulFOpGenericAdaptor : public detail::ScalableMaskedMulFOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedMulFOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
ScalableMaskedMulFOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedMulFOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedMulFOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedMulFOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedMulFOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedMulFOpGenericAdaptor(RangeT values, const ScalableMaskedMulFOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedMulFOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedMulFOp>>>
|
||
ScalableMaskedMulFOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getMask() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedMulFOpAdaptor : public ScalableMaskedMulFOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedMulFOpGenericAdaptor::ScalableMaskedMulFOpGenericAdaptor;
|
||
ScalableMaskedMulFOpAdaptor(ScalableMaskedMulFOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedMulFOp : public ::mlir::Op<ScalableMaskedMulFOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsCommutative> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedMulFOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedMulFOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.masked.mulf");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getMask() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getMaskMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedMulFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedMulFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedMulFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedMulFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedMulFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedMulFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedMulFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedMulFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedMulFOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedMulIIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedMulIIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedMulIIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.mul", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedMulIIntrOpGenericAdaptorBase(ScalableMaskedMulIIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedMulIIntrOpGenericAdaptor : public detail::ScalableMaskedMulIIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedMulIIntrOpGenericAdaptorBase;
|
||
public:
|
||
ScalableMaskedMulIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedMulIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedMulIIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedMulIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedMulIIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedMulIIntrOpGenericAdaptor(RangeT values, const ScalableMaskedMulIIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedMulIIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedMulIIntrOp>>>
|
||
ScalableMaskedMulIIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedMulIIntrOpAdaptor : public ScalableMaskedMulIIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedMulIIntrOpGenericAdaptor::ScalableMaskedMulIIntrOpGenericAdaptor;
|
||
ScalableMaskedMulIIntrOpAdaptor(ScalableMaskedMulIIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedMulIIntrOp : public ::mlir::Op<ScalableMaskedMulIIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedMulIIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedMulIIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.mul");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedMulIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedMulIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedMulIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedMulIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedMulIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedMulIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedMulIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedMulIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedMulIIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedMulIOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedMulIOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedMulIOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.masked.muli", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedMulIOpGenericAdaptorBase(ScalableMaskedMulIOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedMulIOpGenericAdaptor : public detail::ScalableMaskedMulIOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedMulIOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
ScalableMaskedMulIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedMulIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedMulIOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedMulIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedMulIOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedMulIOpGenericAdaptor(RangeT values, const ScalableMaskedMulIOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedMulIOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedMulIOp>>>
|
||
ScalableMaskedMulIOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getMask() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedMulIOpAdaptor : public ScalableMaskedMulIOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedMulIOpGenericAdaptor::ScalableMaskedMulIOpGenericAdaptor;
|
||
ScalableMaskedMulIOpAdaptor(ScalableMaskedMulIOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedMulIOp : public ::mlir::Op<ScalableMaskedMulIOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsCommutative> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedMulIOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedMulIOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.masked.muli");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getMask() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getMaskMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedMulIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedMulIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedMulIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedMulIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedMulIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedMulIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedMulIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedMulIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedMulIOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedSDivIIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedSDivIIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedSDivIIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.sdiv", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedSDivIIntrOpGenericAdaptorBase(ScalableMaskedSDivIIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedSDivIIntrOpGenericAdaptor : public detail::ScalableMaskedSDivIIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedSDivIIntrOpGenericAdaptorBase;
|
||
public:
|
||
ScalableMaskedSDivIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedSDivIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedSDivIIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedSDivIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedSDivIIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedSDivIIntrOpGenericAdaptor(RangeT values, const ScalableMaskedSDivIIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedSDivIIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedSDivIIntrOp>>>
|
||
ScalableMaskedSDivIIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedSDivIIntrOpAdaptor : public ScalableMaskedSDivIIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedSDivIIntrOpGenericAdaptor::ScalableMaskedSDivIIntrOpGenericAdaptor;
|
||
ScalableMaskedSDivIIntrOpAdaptor(ScalableMaskedSDivIIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedSDivIIntrOp : public ::mlir::Op<ScalableMaskedSDivIIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedSDivIIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedSDivIIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.sdiv");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedSDivIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedSDivIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedSDivIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedSDivIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedSDivIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedSDivIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedSDivIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedSDivIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedSDivIIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedSDivIOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedSDivIOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedSDivIOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.masked.divi_signed", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedSDivIOpGenericAdaptorBase(ScalableMaskedSDivIOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedSDivIOpGenericAdaptor : public detail::ScalableMaskedSDivIOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedSDivIOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
ScalableMaskedSDivIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedSDivIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedSDivIOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedSDivIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedSDivIOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedSDivIOpGenericAdaptor(RangeT values, const ScalableMaskedSDivIOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedSDivIOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedSDivIOp>>>
|
||
ScalableMaskedSDivIOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getMask() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedSDivIOpAdaptor : public ScalableMaskedSDivIOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedSDivIOpGenericAdaptor::ScalableMaskedSDivIOpGenericAdaptor;
|
||
ScalableMaskedSDivIOpAdaptor(ScalableMaskedSDivIOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedSDivIOp : public ::mlir::Op<ScalableMaskedSDivIOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedSDivIOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedSDivIOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.masked.divi_signed");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getMask() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getMaskMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedSDivIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedSDivIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedSDivIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedSDivIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedSDivIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedSDivIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedSDivIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedSDivIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedSDivIOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedSubFIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedSubFIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedSubFIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.fsub", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedSubFIntrOpGenericAdaptorBase(ScalableMaskedSubFIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedSubFIntrOpGenericAdaptor : public detail::ScalableMaskedSubFIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedSubFIntrOpGenericAdaptorBase;
|
||
public:
|
||
ScalableMaskedSubFIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedSubFIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedSubFIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedSubFIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedSubFIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedSubFIntrOpGenericAdaptor(RangeT values, const ScalableMaskedSubFIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedSubFIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedSubFIntrOp>>>
|
||
ScalableMaskedSubFIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedSubFIntrOpAdaptor : public ScalableMaskedSubFIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedSubFIntrOpGenericAdaptor::ScalableMaskedSubFIntrOpGenericAdaptor;
|
||
ScalableMaskedSubFIntrOpAdaptor(ScalableMaskedSubFIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedSubFIntrOp : public ::mlir::Op<ScalableMaskedSubFIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedSubFIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedSubFIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.fsub");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedSubFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedSubFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedSubFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedSubFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedSubFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedSubFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedSubFIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedSubFIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedSubFIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedSubFOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedSubFOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedSubFOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.masked.subf", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedSubFOpGenericAdaptorBase(ScalableMaskedSubFOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedSubFOpGenericAdaptor : public detail::ScalableMaskedSubFOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedSubFOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
ScalableMaskedSubFOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedSubFOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedSubFOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedSubFOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedSubFOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedSubFOpGenericAdaptor(RangeT values, const ScalableMaskedSubFOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedSubFOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedSubFOp>>>
|
||
ScalableMaskedSubFOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getMask() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedSubFOpAdaptor : public ScalableMaskedSubFOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedSubFOpGenericAdaptor::ScalableMaskedSubFOpGenericAdaptor;
|
||
ScalableMaskedSubFOpAdaptor(ScalableMaskedSubFOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedSubFOp : public ::mlir::Op<ScalableMaskedSubFOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedSubFOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedSubFOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.masked.subf");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getMask() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getMaskMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedSubFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedSubFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedSubFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedSubFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedSubFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedSubFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedSubFOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedSubFOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedSubFOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedSubIIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedSubIIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedSubIIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.sub", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedSubIIntrOpGenericAdaptorBase(ScalableMaskedSubIIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedSubIIntrOpGenericAdaptor : public detail::ScalableMaskedSubIIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedSubIIntrOpGenericAdaptorBase;
|
||
public:
|
||
ScalableMaskedSubIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedSubIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedSubIIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedSubIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedSubIIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedSubIIntrOpGenericAdaptor(RangeT values, const ScalableMaskedSubIIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedSubIIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedSubIIntrOp>>>
|
||
ScalableMaskedSubIIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedSubIIntrOpAdaptor : public ScalableMaskedSubIIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedSubIIntrOpGenericAdaptor::ScalableMaskedSubIIntrOpGenericAdaptor;
|
||
ScalableMaskedSubIIntrOpAdaptor(ScalableMaskedSubIIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedSubIIntrOp : public ::mlir::Op<ScalableMaskedSubIIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedSubIIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedSubIIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.sub");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedSubIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedSubIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedSubIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedSubIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedSubIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedSubIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedSubIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedSubIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedSubIIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedSubIOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedSubIOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedSubIOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.masked.subi", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedSubIOpGenericAdaptorBase(ScalableMaskedSubIOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedSubIOpGenericAdaptor : public detail::ScalableMaskedSubIOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedSubIOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
ScalableMaskedSubIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedSubIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedSubIOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedSubIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedSubIOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedSubIOpGenericAdaptor(RangeT values, const ScalableMaskedSubIOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedSubIOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedSubIOp>>>
|
||
ScalableMaskedSubIOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getMask() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedSubIOpAdaptor : public ScalableMaskedSubIOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedSubIOpGenericAdaptor::ScalableMaskedSubIOpGenericAdaptor;
|
||
ScalableMaskedSubIOpAdaptor(ScalableMaskedSubIOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedSubIOp : public ::mlir::Op<ScalableMaskedSubIOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedSubIOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedSubIOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.masked.subi");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getMask() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getMaskMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedSubIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedSubIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedSubIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedSubIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedSubIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedSubIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedSubIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedSubIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedSubIOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedUDivIIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedUDivIIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedUDivIIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.udiv", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedUDivIIntrOpGenericAdaptorBase(ScalableMaskedUDivIIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedUDivIIntrOpGenericAdaptor : public detail::ScalableMaskedUDivIIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedUDivIIntrOpGenericAdaptorBase;
|
||
public:
|
||
ScalableMaskedUDivIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedUDivIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedUDivIIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedUDivIIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedUDivIIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedUDivIIntrOpGenericAdaptor(RangeT values, const ScalableMaskedUDivIIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedUDivIIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedUDivIIntrOp>>>
|
||
ScalableMaskedUDivIIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedUDivIIntrOpAdaptor : public ScalableMaskedUDivIIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedUDivIIntrOpGenericAdaptor::ScalableMaskedUDivIIntrOpGenericAdaptor;
|
||
ScalableMaskedUDivIIntrOpAdaptor(ScalableMaskedUDivIIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedUDivIIntrOp : public ::mlir::Op<ScalableMaskedUDivIIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedUDivIIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedUDivIIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.udiv");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedUDivIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedUDivIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedUDivIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static ScalableMaskedUDivIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedUDivIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedUDivIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedUDivIIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedUDivIIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedUDivIIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ScalableMaskedUDivIOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ScalableMaskedUDivIOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ScalableMaskedUDivIOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.masked.divi_unsigned", odsAttrs.getContext());
|
||
}
|
||
|
||
ScalableMaskedUDivIOpGenericAdaptorBase(ScalableMaskedUDivIOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ScalableMaskedUDivIOpGenericAdaptor : public detail::ScalableMaskedUDivIOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ScalableMaskedUDivIOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
ScalableMaskedUDivIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ScalableMaskedUDivIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ScalableMaskedUDivIOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ScalableMaskedUDivIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ScalableMaskedUDivIOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ScalableMaskedUDivIOpGenericAdaptor(RangeT values, const ScalableMaskedUDivIOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ScalableMaskedUDivIOp, typename = std::enable_if_t<std::is_same_v<LateInst, ScalableMaskedUDivIOp>>>
|
||
ScalableMaskedUDivIOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getMask() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ScalableMaskedUDivIOpAdaptor : public ScalableMaskedUDivIOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ScalableMaskedUDivIOpGenericAdaptor::ScalableMaskedUDivIOpGenericAdaptor;
|
||
ScalableMaskedUDivIOpAdaptor(ScalableMaskedUDivIOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ScalableMaskedUDivIOp : public ::mlir::Op<ScalableMaskedUDivIOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ScalableMaskedUDivIOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ScalableMaskedUDivIOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_mask = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.masked.divi_unsigned");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getMask() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getMaskMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedUDivIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedUDivIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedUDivIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static ScalableMaskedUDivIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value mask, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedUDivIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ScalableMaskedUDivIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedUDivIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ScalableMaskedUDivIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ScalableMaskedUDivIOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::SdotIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class SdotIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
SdotIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.sdot", odsAttrs.getContext());
|
||
}
|
||
|
||
SdotIntrOpGenericAdaptorBase(SdotIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class SdotIntrOpGenericAdaptor : public detail::SdotIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::SdotIntrOpGenericAdaptorBase;
|
||
public:
|
||
SdotIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
SdotIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : SdotIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
SdotIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : SdotIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
SdotIntrOpGenericAdaptor(RangeT values, const SdotIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = SdotIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, SdotIntrOp>>>
|
||
SdotIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class SdotIntrOpAdaptor : public SdotIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using SdotIntrOpGenericAdaptor::SdotIntrOpGenericAdaptor;
|
||
SdotIntrOpAdaptor(SdotIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class SdotIntrOp : public ::mlir::Op<SdotIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = SdotIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = SdotIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.sdot");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static SdotIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static SdotIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static SdotIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static SdotIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static SdotIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static SdotIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static SdotIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static SdotIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::SdotIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::SdotOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class SdotOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
SdotOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.sdot", odsAttrs.getContext());
|
||
}
|
||
|
||
SdotOpGenericAdaptorBase(SdotOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class SdotOpGenericAdaptor : public detail::SdotOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::SdotOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_acc = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
SdotOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
SdotOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : SdotOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
SdotOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : SdotOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
SdotOpGenericAdaptor(RangeT values, const SdotOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = SdotOp, typename = std::enable_if_t<std::is_same_v<LateInst, SdotOp>>>
|
||
SdotOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getAcc() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class SdotOpAdaptor : public SdotOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using SdotOpGenericAdaptor::SdotOpGenericAdaptor;
|
||
SdotOpAdaptor(SdotOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class SdotOp : public ::mlir::Op<SdotOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = SdotOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = SdotOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_acc = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.sdot");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getAcc() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getAccMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getDst() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static SdotOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static SdotOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static SdotOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static SdotOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static SdotOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static SdotOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static SdotOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static SdotOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::SdotOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::SmmlaIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class SmmlaIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
SmmlaIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.smmla", odsAttrs.getContext());
|
||
}
|
||
|
||
SmmlaIntrOpGenericAdaptorBase(SmmlaIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class SmmlaIntrOpGenericAdaptor : public detail::SmmlaIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::SmmlaIntrOpGenericAdaptorBase;
|
||
public:
|
||
SmmlaIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
SmmlaIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : SmmlaIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
SmmlaIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : SmmlaIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
SmmlaIntrOpGenericAdaptor(RangeT values, const SmmlaIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = SmmlaIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, SmmlaIntrOp>>>
|
||
SmmlaIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class SmmlaIntrOpAdaptor : public SmmlaIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using SmmlaIntrOpGenericAdaptor::SmmlaIntrOpGenericAdaptor;
|
||
SmmlaIntrOpAdaptor(SmmlaIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class SmmlaIntrOp : public ::mlir::Op<SmmlaIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = SmmlaIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = SmmlaIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.smmla");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static SmmlaIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static SmmlaIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static SmmlaIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static SmmlaIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static SmmlaIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static SmmlaIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static SmmlaIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static SmmlaIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::SmmlaIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::SmmlaOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class SmmlaOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
SmmlaOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.smmla", odsAttrs.getContext());
|
||
}
|
||
|
||
SmmlaOpGenericAdaptorBase(SmmlaOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class SmmlaOpGenericAdaptor : public detail::SmmlaOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::SmmlaOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_acc = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
SmmlaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
SmmlaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : SmmlaOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
SmmlaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : SmmlaOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
SmmlaOpGenericAdaptor(RangeT values, const SmmlaOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = SmmlaOp, typename = std::enable_if_t<std::is_same_v<LateInst, SmmlaOp>>>
|
||
SmmlaOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getAcc() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class SmmlaOpAdaptor : public SmmlaOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using SmmlaOpGenericAdaptor::SmmlaOpGenericAdaptor;
|
||
SmmlaOpAdaptor(SmmlaOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class SmmlaOp : public ::mlir::Op<SmmlaOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = SmmlaOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = SmmlaOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_acc = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.smmla");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getAcc() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getAccMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getDst() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static SmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static SmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static SmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static SmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static SmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static SmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static SmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static SmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::SmmlaOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::UdotIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class UdotIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
UdotIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.udot", odsAttrs.getContext());
|
||
}
|
||
|
||
UdotIntrOpGenericAdaptorBase(UdotIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class UdotIntrOpGenericAdaptor : public detail::UdotIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::UdotIntrOpGenericAdaptorBase;
|
||
public:
|
||
UdotIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
UdotIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : UdotIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
UdotIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : UdotIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
UdotIntrOpGenericAdaptor(RangeT values, const UdotIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = UdotIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, UdotIntrOp>>>
|
||
UdotIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class UdotIntrOpAdaptor : public UdotIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using UdotIntrOpGenericAdaptor::UdotIntrOpGenericAdaptor;
|
||
UdotIntrOpAdaptor(UdotIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class UdotIntrOp : public ::mlir::Op<UdotIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = UdotIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = UdotIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.udot");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static UdotIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static UdotIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static UdotIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static UdotIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static UdotIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static UdotIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static UdotIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static UdotIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::UdotIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::UdotOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class UdotOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
UdotOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.udot", odsAttrs.getContext());
|
||
}
|
||
|
||
UdotOpGenericAdaptorBase(UdotOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class UdotOpGenericAdaptor : public detail::UdotOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::UdotOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_acc = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
UdotOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
UdotOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : UdotOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
UdotOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : UdotOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
UdotOpGenericAdaptor(RangeT values, const UdotOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = UdotOp, typename = std::enable_if_t<std::is_same_v<LateInst, UdotOp>>>
|
||
UdotOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getAcc() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class UdotOpAdaptor : public UdotOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using UdotOpGenericAdaptor::UdotOpGenericAdaptor;
|
||
UdotOpAdaptor(UdotOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class UdotOp : public ::mlir::Op<UdotOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = UdotOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = UdotOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_acc = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.udot");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getAcc() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getAccMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getDst() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static UdotOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static UdotOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static UdotOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static UdotOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static UdotOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static UdotOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static UdotOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static UdotOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::UdotOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::UmmlaIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class UmmlaIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
UmmlaIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.ummla", odsAttrs.getContext());
|
||
}
|
||
|
||
UmmlaIntrOpGenericAdaptorBase(UmmlaIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class UmmlaIntrOpGenericAdaptor : public detail::UmmlaIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::UmmlaIntrOpGenericAdaptorBase;
|
||
public:
|
||
UmmlaIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
UmmlaIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : UmmlaIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
UmmlaIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : UmmlaIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
UmmlaIntrOpGenericAdaptor(RangeT values, const UmmlaIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = UmmlaIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, UmmlaIntrOp>>>
|
||
UmmlaIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class UmmlaIntrOpAdaptor : public UmmlaIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using UmmlaIntrOpGenericAdaptor::UmmlaIntrOpGenericAdaptor;
|
||
UmmlaIntrOpAdaptor(UmmlaIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class UmmlaIntrOp : public ::mlir::Op<UmmlaIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = UmmlaIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = UmmlaIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.ummla");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static UmmlaIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static UmmlaIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static UmmlaIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static UmmlaIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static UmmlaIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static UmmlaIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static UmmlaIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static UmmlaIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::UmmlaIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::UmmlaOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class UmmlaOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
UmmlaOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.ummla", odsAttrs.getContext());
|
||
}
|
||
|
||
UmmlaOpGenericAdaptorBase(UmmlaOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class UmmlaOpGenericAdaptor : public detail::UmmlaOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::UmmlaOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_acc = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
UmmlaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
UmmlaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : UmmlaOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
UmmlaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : UmmlaOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
UmmlaOpGenericAdaptor(RangeT values, const UmmlaOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = UmmlaOp, typename = std::enable_if_t<std::is_same_v<LateInst, UmmlaOp>>>
|
||
UmmlaOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getAcc() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class UmmlaOpAdaptor : public UmmlaOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using UmmlaOpGenericAdaptor::UmmlaOpGenericAdaptor;
|
||
UmmlaOpAdaptor(UmmlaOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class UmmlaOp : public ::mlir::Op<UmmlaOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = UmmlaOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = UmmlaOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_acc = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.ummla");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getAcc() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getAccMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getDst() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static UmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static UmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static UmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static UmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static UmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static UmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static UmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static UmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::UmmlaOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::UsmmlaIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class UsmmlaIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
UsmmlaIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.usmmla", odsAttrs.getContext());
|
||
}
|
||
|
||
UsmmlaIntrOpGenericAdaptorBase(UsmmlaIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class UsmmlaIntrOpGenericAdaptor : public detail::UsmmlaIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::UsmmlaIntrOpGenericAdaptorBase;
|
||
public:
|
||
UsmmlaIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
UsmmlaIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : UsmmlaIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
UsmmlaIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : UsmmlaIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
UsmmlaIntrOpGenericAdaptor(RangeT values, const UsmmlaIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = UsmmlaIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, UsmmlaIntrOp>>>
|
||
UsmmlaIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class UsmmlaIntrOpAdaptor : public UsmmlaIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using UsmmlaIntrOpGenericAdaptor::UsmmlaIntrOpGenericAdaptor;
|
||
UsmmlaIntrOpAdaptor(UsmmlaIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class UsmmlaIntrOp : public ::mlir::Op<UsmmlaIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = UsmmlaIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = UsmmlaIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.usmmla");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static UsmmlaIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static UsmmlaIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static UsmmlaIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static UsmmlaIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value odsArg_0, ::mlir::Value odsArg_1, ::mlir::Value odsArg_2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static UsmmlaIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static UsmmlaIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static UsmmlaIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static UsmmlaIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::UsmmlaIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::UsmmlaOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class UsmmlaOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
UsmmlaOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.usmmla", odsAttrs.getContext());
|
||
}
|
||
|
||
UsmmlaOpGenericAdaptorBase(UsmmlaOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class UsmmlaOpGenericAdaptor : public detail::UsmmlaOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::UsmmlaOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_acc = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
public:
|
||
UsmmlaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
UsmmlaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : UsmmlaOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
UsmmlaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : UsmmlaOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
UsmmlaOpGenericAdaptor(RangeT values, const UsmmlaOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = UsmmlaOp, typename = std::enable_if_t<std::is_same_v<LateInst, UsmmlaOp>>>
|
||
UsmmlaOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getAcc() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSrc1() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSrc2() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class UsmmlaOpAdaptor : public UsmmlaOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using UsmmlaOpGenericAdaptor::UsmmlaOpGenericAdaptor;
|
||
UsmmlaOpAdaptor(UsmmlaOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class UsmmlaOp : public ::mlir::Op<UsmmlaOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::VectorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = UsmmlaOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = UsmmlaOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_acc = 0;
|
||
static constexpr int odsIndex_src1 = 1;
|
||
static constexpr int odsIndex_src2 = 2;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.usmmla");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getAcc() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getSrc2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getAccMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSrc2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getDst() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static UsmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static UsmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type dst, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static UsmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static UsmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value acc, ::mlir::Value src1, ::mlir::Value src2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static UsmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static UsmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static UsmmlaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static UsmmlaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::UsmmlaOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::WhileLTIntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class WhileLTIntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
WhileLTIntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.whilelt", odsAttrs.getContext());
|
||
}
|
||
|
||
WhileLTIntrOpGenericAdaptorBase(WhileLTIntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class WhileLTIntrOpGenericAdaptor : public detail::WhileLTIntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::WhileLTIntrOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_base = 0;
|
||
static constexpr int odsIndex_n = 1;
|
||
public:
|
||
WhileLTIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
WhileLTIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : WhileLTIntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
WhileLTIntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : WhileLTIntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
WhileLTIntrOpGenericAdaptor(RangeT values, const WhileLTIntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = WhileLTIntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, WhileLTIntrOp>>>
|
||
WhileLTIntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getBase() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getN() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class WhileLTIntrOpAdaptor : public WhileLTIntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using WhileLTIntrOpGenericAdaptor::WhileLTIntrOpGenericAdaptor;
|
||
WhileLTIntrOpAdaptor(WhileLTIntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class WhileLTIntrOp : public ::mlir::Op<WhileLTIntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = WhileLTIntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = WhileLTIntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_base = 0;
|
||
static constexpr int odsIndex_n = 1;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.whilelt");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::IntegerType> getBase() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::IntegerType> getN() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getBaseMutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getNMutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value base, ::mlir::Value n);
|
||
static WhileLTIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value base, ::mlir::Value n);
|
||
static WhileLTIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value base, ::mlir::Value n);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value base, ::mlir::Value n);
|
||
static WhileLTIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value base, ::mlir::Value n);
|
||
static WhileLTIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value base, ::mlir::Value n);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static WhileLTIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static WhileLTIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static WhileLTIntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static WhileLTIntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::WhileLTIntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ZipX2IntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ZipX2IntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ZipX2IntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.zip.x2", odsAttrs.getContext());
|
||
}
|
||
|
||
ZipX2IntrOpGenericAdaptorBase(ZipX2IntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ZipX2IntrOpGenericAdaptor : public detail::ZipX2IntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ZipX2IntrOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_v1 = 0;
|
||
static constexpr int odsIndex_v2 = 1;
|
||
public:
|
||
ZipX2IntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ZipX2IntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ZipX2IntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ZipX2IntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ZipX2IntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ZipX2IntrOpGenericAdaptor(RangeT values, const ZipX2IntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ZipX2IntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ZipX2IntrOp>>>
|
||
ZipX2IntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getV1() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getV2() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ZipX2IntrOpAdaptor : public ZipX2IntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ZipX2IntrOpGenericAdaptor::ZipX2IntrOpGenericAdaptor;
|
||
ZipX2IntrOpAdaptor(ZipX2IntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ZipX2IntrOp : public ::mlir::Op<ZipX2IntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ZipX2IntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ZipX2IntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_v1 = 0;
|
||
static constexpr int odsIndex_v2 = 1;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.zip.x2");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getV1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getV2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getV1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getV2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value v1, ::mlir::Value v2);
|
||
static ZipX2IntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value v1, ::mlir::Value v2);
|
||
static ZipX2IntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value v1, ::mlir::Value v2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value v1, ::mlir::Value v2);
|
||
static ZipX2IntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value v1, ::mlir::Value v2);
|
||
static ZipX2IntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value v1, ::mlir::Value v2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ZipX2IntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ZipX2IntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ZipX2IntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ZipX2IntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ZipX2IntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ZipX2Op declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ZipX2OpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ZipX2OpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.zip.x2", odsAttrs.getContext());
|
||
}
|
||
|
||
ZipX2OpGenericAdaptorBase(ZipX2Op op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ZipX2OpGenericAdaptor : public detail::ZipX2OpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ZipX2OpGenericAdaptorBase;
|
||
static constexpr int odsIndex_sourceV1 = 0;
|
||
static constexpr int odsIndex_sourceV2 = 1;
|
||
public:
|
||
ZipX2OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ZipX2OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ZipX2OpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ZipX2OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ZipX2OpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ZipX2OpGenericAdaptor(RangeT values, const ZipX2OpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ZipX2Op, typename = std::enable_if_t<std::is_same_v<LateInst, ZipX2Op>>>
|
||
ZipX2OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getSourceV1() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSourceV2() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ZipX2OpAdaptor : public ZipX2OpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ZipX2OpGenericAdaptor::ZipX2OpGenericAdaptor;
|
||
ZipX2OpAdaptor(ZipX2Op op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ZipX2Op : public ::mlir::Op<ZipX2Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ZipX2OpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ZipX2OpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_sourceV1 = 0;
|
||
static constexpr int odsIndex_sourceV2 = 1;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
void getAsmResultNames(::mlir::OpAsmSetValueNameFn setNameFn);
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.zip.x2");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getSourceV1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getSourceV2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getSourceV1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSourceV2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getResultV1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getResultV2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(1).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value v1, Value v2);
|
||
static ZipX2Op create(::mlir::OpBuilder &builder, ::mlir::Location location, Value v1, Value v2);
|
||
static ZipX2Op create(::mlir::ImplicitLocOpBuilder &builder, Value v1, Value v2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type resultV1, ::mlir::Type resultV2, ::mlir::Value sourceV1, ::mlir::Value sourceV2);
|
||
static ZipX2Op create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type resultV1, ::mlir::Type resultV2, ::mlir::Value sourceV1, ::mlir::Value sourceV2);
|
||
static ZipX2Op create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type resultV1, ::mlir::Type resultV2, ::mlir::Value sourceV1, ::mlir::Value sourceV2);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value sourceV1, ::mlir::Value sourceV2);
|
||
static ZipX2Op create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value sourceV1, ::mlir::Value sourceV2);
|
||
static ZipX2Op create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value sourceV1, ::mlir::Value sourceV2);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ZipX2Op create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ZipX2Op create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ZipX2Op create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ZipX2Op create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
VectorType getVectorType() {
|
||
return ::llvm::cast<VectorType>(getSourceV1().getType());
|
||
}
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ZipX2Op)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ZipX4IntrOp declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ZipX4IntrOpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ZipX4IntrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.intr.zip.x4", odsAttrs.getContext());
|
||
}
|
||
|
||
ZipX4IntrOpGenericAdaptorBase(ZipX4IntrOp op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ZipX4IntrOpGenericAdaptor : public detail::ZipX4IntrOpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ZipX4IntrOpGenericAdaptorBase;
|
||
static constexpr int odsIndex_v1 = 0;
|
||
static constexpr int odsIndex_v2 = 1;
|
||
static constexpr int odsIndex_v3 = 2;
|
||
static constexpr int odsIndex_v4 = 3;
|
||
public:
|
||
ZipX4IntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ZipX4IntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ZipX4IntrOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ZipX4IntrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ZipX4IntrOpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ZipX4IntrOpGenericAdaptor(RangeT values, const ZipX4IntrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ZipX4IntrOp, typename = std::enable_if_t<std::is_same_v<LateInst, ZipX4IntrOp>>>
|
||
ZipX4IntrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getV1() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getV2() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getV3() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
ValueT getV4() {
|
||
return (*getODSOperands(3).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ZipX4IntrOpAdaptor : public ZipX4IntrOpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ZipX4IntrOpGenericAdaptor::ZipX4IntrOpGenericAdaptor;
|
||
ZipX4IntrOpAdaptor(ZipX4IntrOp op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ZipX4IntrOp : public ::mlir::Op<ZipX4IntrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ZipX4IntrOpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ZipX4IntrOpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_v1 = 0;
|
||
static constexpr int odsIndex_v2 = 1;
|
||
static constexpr int odsIndex_v3 = 2;
|
||
static constexpr int odsIndex_v4 = 3;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.intr.zip.x4");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getV1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getV2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getV3() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::VectorType> getV4() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(3).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getV1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getV2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getV3Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getV4Mutable() {
|
||
auto range = getODSOperandIndexAndLength(3);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getRes() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value v1, ::mlir::Value v2, ::mlir::Value v3, ::mlir::Value v4);
|
||
static ZipX4IntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value v1, ::mlir::Value v2, ::mlir::Value v3, ::mlir::Value v4);
|
||
static ZipX4IntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value v1, ::mlir::Value v2, ::mlir::Value v3, ::mlir::Value v4);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value v1, ::mlir::Value v2, ::mlir::Value v3, ::mlir::Value v4);
|
||
static ZipX4IntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value v1, ::mlir::Value v2, ::mlir::Value v3, ::mlir::Value v4);
|
||
static ZipX4IntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value v1, ::mlir::Value v2, ::mlir::Value v3, ::mlir::Value v4);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ZipX4IntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ZipX4IntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ZipX4IntrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ZipX4IntrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
public:
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ZipX4IntrOp)
|
||
|
||
namespace mlir::arm_sve {
|
||
|
||
|
||
//===----------------------------------------------------------------------===//
|
||
// ::mlir::arm_sve::ZipX4Op declarations
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
namespace detail {
|
||
|
||
class ZipX4OpGenericAdaptorBase {
|
||
public:
|
||
using Properties = ::mlir::EmptyProperties;
|
||
protected:
|
||
::mlir::DictionaryAttr odsAttrs;
|
||
::std::optional<::mlir::OperationName> odsOpName;
|
||
Properties properties;
|
||
::mlir::RegionRange odsRegions;
|
||
public:
|
||
ZipX4OpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
|
||
odsOpName.emplace("arm_sve.zip.x4", odsAttrs.getContext());
|
||
}
|
||
|
||
ZipX4OpGenericAdaptorBase(ZipX4Op op);
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
|
||
return {index, 1};
|
||
}
|
||
|
||
const Properties &getProperties() {
|
||
return properties;
|
||
}
|
||
|
||
::mlir::DictionaryAttr getAttributes() {
|
||
return odsAttrs;
|
||
}
|
||
|
||
};
|
||
|
||
} // namespace detail
|
||
template <typename RangeT>
|
||
class ZipX4OpGenericAdaptor : public detail::ZipX4OpGenericAdaptorBase {
|
||
using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
|
||
using Base = detail::ZipX4OpGenericAdaptorBase;
|
||
static constexpr int odsIndex_sourceV1 = 0;
|
||
static constexpr int odsIndex_sourceV2 = 1;
|
||
static constexpr int odsIndex_sourceV3 = 2;
|
||
static constexpr int odsIndex_sourceV4 = 3;
|
||
public:
|
||
ZipX4OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
|
||
|
||
ZipX4OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ZipX4OpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
|
||
|
||
ZipX4OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ZipX4OpGenericAdaptor(values, attrs, Properties{}, {}) {}
|
||
|
||
ZipX4OpGenericAdaptor(RangeT values, const ZipX4OpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
|
||
|
||
template <typename LateInst = ZipX4Op, typename = std::enable_if_t<std::is_same_v<LateInst, ZipX4Op>>>
|
||
ZipX4OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return Base::getODSOperandIndexAndLength(index, odsOperands.size());
|
||
}
|
||
|
||
RangeT getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(odsOperands.begin(), valueRange.first),
|
||
std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
ValueT getSourceV1() {
|
||
return (*getODSOperands(0).begin());
|
||
}
|
||
|
||
ValueT getSourceV2() {
|
||
return (*getODSOperands(1).begin());
|
||
}
|
||
|
||
ValueT getSourceV3() {
|
||
return (*getODSOperands(2).begin());
|
||
}
|
||
|
||
ValueT getSourceV4() {
|
||
return (*getODSOperands(3).begin());
|
||
}
|
||
|
||
RangeT getOperands() {
|
||
return odsOperands;
|
||
}
|
||
|
||
private:
|
||
RangeT odsOperands;
|
||
};
|
||
class ZipX4OpAdaptor : public ZipX4OpGenericAdaptor<::mlir::ValueRange> {
|
||
public:
|
||
using ZipX4OpGenericAdaptor::ZipX4OpGenericAdaptor;
|
||
ZipX4OpAdaptor(ZipX4Op op);
|
||
|
||
::llvm::LogicalResult verify(::mlir::Location loc);
|
||
};
|
||
class ZipX4Op : public ::mlir::Op<ZipX4Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<4>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> {
|
||
public:
|
||
using Op::Op;
|
||
using Op::print;
|
||
using Adaptor = ZipX4OpAdaptor;
|
||
template <typename RangeT>
|
||
using GenericAdaptor = ZipX4OpGenericAdaptor<RangeT>;
|
||
using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
|
||
static constexpr int odsIndex_sourceV1 = 0;
|
||
static constexpr int odsIndex_sourceV2 = 1;
|
||
static constexpr int odsIndex_sourceV3 = 2;
|
||
static constexpr int odsIndex_sourceV4 = 3;
|
||
using Properties = FoldAdaptor::Properties;
|
||
static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
|
||
return {};
|
||
}
|
||
|
||
void getAsmResultNames(::mlir::OpAsmSetValueNameFn setNameFn);
|
||
static constexpr ::llvm::StringLiteral getOperationName() {
|
||
return ::llvm::StringLiteral("arm_sve.zip.x4");
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::operand_range getODSOperands(unsigned index) {
|
||
auto valueRange = getODSOperandIndexAndLength(index);
|
||
return {std::next(getOperation()->operand_begin(), valueRange.first),
|
||
std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getSourceV1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getSourceV2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getSourceV3() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(2).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getSourceV4() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(3).begin());
|
||
}
|
||
|
||
::mlir::OpOperand &getSourceV1Mutable() {
|
||
auto range = getODSOperandIndexAndLength(0);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSourceV2Mutable() {
|
||
auto range = getODSOperandIndexAndLength(1);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSourceV3Mutable() {
|
||
auto range = getODSOperandIndexAndLength(2);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
::mlir::OpOperand &getSourceV4Mutable() {
|
||
auto range = getODSOperandIndexAndLength(3);
|
||
return getOperation()->getOpOperand(range.first);
|
||
}
|
||
|
||
std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
|
||
return {index, 1};
|
||
}
|
||
|
||
::mlir::Operation::result_range getODSResults(unsigned index) {
|
||
auto valueRange = getODSResultIndexAndLength(index);
|
||
return {std::next(getOperation()->result_begin(), valueRange.first),
|
||
std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getResultV1() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getResultV2() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(1).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getResultV3() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(2).begin());
|
||
}
|
||
|
||
::mlir::TypedValue<::mlir::Type> getResultV4() {
|
||
return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(3).begin());
|
||
}
|
||
|
||
static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
|
||
static llvm::hash_code computePropertiesHash(const Properties &prop);
|
||
static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
|
||
static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
|
||
static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
|
||
static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value v1, Value v2, Value v3, Value v4);
|
||
static ZipX4Op create(::mlir::OpBuilder &builder, ::mlir::Location location, Value v1, Value v2, Value v3, Value v4);
|
||
static ZipX4Op create(::mlir::ImplicitLocOpBuilder &builder, Value v1, Value v2, Value v3, Value v4);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type resultV1, ::mlir::Type resultV2, ::mlir::Type resultV3, ::mlir::Type resultV4, ::mlir::Value sourceV1, ::mlir::Value sourceV2, ::mlir::Value sourceV3, ::mlir::Value sourceV4);
|
||
static ZipX4Op create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type resultV1, ::mlir::Type resultV2, ::mlir::Type resultV3, ::mlir::Type resultV4, ::mlir::Value sourceV1, ::mlir::Value sourceV2, ::mlir::Value sourceV3, ::mlir::Value sourceV4);
|
||
static ZipX4Op create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type resultV1, ::mlir::Type resultV2, ::mlir::Type resultV3, ::mlir::Type resultV4, ::mlir::Value sourceV1, ::mlir::Value sourceV2, ::mlir::Value sourceV3, ::mlir::Value sourceV4);
|
||
static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value sourceV1, ::mlir::Value sourceV2, ::mlir::Value sourceV3, ::mlir::Value sourceV4);
|
||
static ZipX4Op create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value sourceV1, ::mlir::Value sourceV2, ::mlir::Value sourceV3, ::mlir::Value sourceV4);
|
||
static ZipX4Op create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value sourceV1, ::mlir::Value sourceV2, ::mlir::Value sourceV3, ::mlir::Value sourceV4);
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ZipX4Op create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static ZipX4Op create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
|
||
static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ZipX4Op create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
static ZipX4Op create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
|
||
::llvm::LogicalResult verifyInvariantsImpl();
|
||
::llvm::LogicalResult verifyInvariants();
|
||
static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
|
||
void print(::mlir::OpAsmPrinter &_odsPrinter);
|
||
void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
|
||
public:
|
||
VectorType getVectorType() {
|
||
return ::llvm::cast<VectorType>(getSourceV1().getType());
|
||
}
|
||
};
|
||
|
||
} // namespace mlir::arm_sve
|
||
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::arm_sve::ZipX4Op)
|
||
|
||
|
||
#endif // GET_OP_CLASSES
|
||
|