/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ |* *| |* Interface Definitions *| |* *| |* Automatically generated file, do not edit! *| |* *| \*===----------------------------------------------------------------------===*/ /// Return the source tensor operand. ::mlir::OpOperand &mlir::SubsetExtractionOpInterface::getSourceOperand() { … } /// Return "true" if this op and the given candidate subset op operate on /// equivalent subsets. Return "false" if the two subsets are disjoint /// or cannot be proven to be equivalent. /// /// This interface method does not have to be implemented if /// `getAccessedHyperrectangularSlice` is implemented. bool mlir::SubsetExtractionOpInterface::operatesOnEquivalentSubset(::mlir::SubsetOpInterface candidate, ::llvm::function_ref<bool(Value, Value)> equivalenceFn) { … } /// Return "true" if this op and the given candidate subset op operate on /// disjoint subsets. Return "false" if the two subsets are equivalent, /// overlapping or cannot be proven to be disjoint. /// /// This interface method does not have to be implemented if /// `getAccessedHyperrectangularSlice` is implemented. bool mlir::SubsetExtractionOpInterface::operatesOnDisjointSubset(::mlir::SubsetOpInterface candidate, ::llvm::function_ref<bool(Value, Value)> equivalenceFn) { … } /// If this op operates on a hyperrectangular subset, return a /// description of the subset in terms of offsets, sizes and strides. /// Otherwise, return "failure". /// /// This interface method is a convenience method for the most common case /// of hyperrectangular subset ops. It is optional. If it is implemented, /// `operatesOnEquivalentSubset` and `operatesOnDisjointSubset` do not /// have to be implemented. ::mlir::FailureOr<::mlir::HyperrectangularSlice> mlir::SubsetExtractionOpInterface::getAccessedHyperrectangularSlice() { … } /// Return the source operand. The source operand can have any type. ::mlir::OpOperand &mlir::SubsetInsertionOpInterface::getSourceOperand() { … } /// Return the destination operand. The destination operand must be a /// tensor. /// /// This function does not have to be implemented for destination style /// ops that have exactly one "init" operand. ::mlir::OpOperand &mlir::SubsetInsertionOpInterface::getDestinationOperand() { … } /// Return the updated destination result. /// /// This function does not have to be implemented for destination style /// ops. ::mlir::OpResult mlir::SubsetInsertionOpInterface::getUpdatedDestination() { … } /// Return "true" if this operation inserts into a subset that is /// equivalent to the subset defined by `candidate`. /// /// Two subsets are "equivalent" and "same" if they can bufferize to the /// same buffer views/aliases. If they are "equivalent", the tensor IR /// may be expressed in terms of different SSA values (but they could /// bufferize to MemRef SSA values that can CSE without breaking /// correctness). `equivalenceFn` should return "true" if the two given /// values are equivalent. /// /// Example: /// ``` /// // The subset of the SubsetInsertionOpInterface op %1 is equivalent to /// // the subset defined by %2 (but not "same"): /// %0 = arith.select %c, %t, %t : tensor<?xf32> /// %1 = tensor.insert_slice %x into %0[0][5][1] /// : tensor<5xf32> into tensor<?xf32> /// %2 = tensor.extract_slice %t[0][5][1] : tensor<?xf32> to tensor<5xf32> /// /// // The subset of the SubsetInsertionOpInterface op %1 is equivalent to /// // and "same" as the subset defined by %2. /// %1 = tensor.insert_slice %x into %t[0][5][1] /// : tensor<5xf32> into tensor<?xf32> /// %2 = tensor.extract_slice %t[0][5][1] : tensor<?xf32> to tensor<5xf32> /// ``` /// /// Note: By default, this function calls /// `SubsetOpInterface::operatesOnEquivalentSubset`. bool mlir::SubsetInsertionOpInterface::isEquivalentSubset(::mlir::Value candidate, ::llvm::function_ref<bool(Value, Value)> equivalenceFn) { … } /// Return the subset of the destination tensor that this operation /// inserts into. /// /// Example: /// ``` /// // SubsetOpInterface op: /// %0 = tensor.insert_slice %t0 into %t1[%pos][5][1] /// : tensor<5xf32> into tensor<?xf32> /// // Subset (built by this function): /// %1 = tensor.extract_slice %t1[%pos][5][1] /// : tensor<?xf32> to tensor<5xf32> /// ``` /// /// Note: Implementations do not necessarily have to build new IR. They /// may return existing SSA values. ::mlir::Value mlir::SubsetInsertionOpInterface::buildSubsetExtraction(::mlir::OpBuilder & builder, Location loc) { … } /// Return all SSA values that are needed (i.e., must be in scope) at the /// insertion of the builder when calling `buildSubsetExtraction`. Users /// of `buildSubsetExtraction` can use this helper method to find a /// suitable insertion point. /// /// Example: The SSA values needed to build the subset in the example of /// `buildSubsetExtraction` are %t1 and %pos. ::llvm::SmallVector<::mlir::Value> mlir::SubsetInsertionOpInterface::getValuesNeededToBuildSubsetExtraction() { … } /// Return "true" if this op and the given candidate subset op operate on /// equivalent subsets. Return "false" if the two subsets are disjoint /// or cannot be proven to be equivalent. /// /// This interface method does not have to be implemented if /// `getAccessedHyperrectangularSlice` is implemented. bool mlir::SubsetInsertionOpInterface::operatesOnEquivalentSubset(::mlir::SubsetOpInterface candidate, ::llvm::function_ref<bool(Value, Value)> equivalenceFn) { … } /// Return "true" if this op and the given candidate subset op operate on /// disjoint subsets. Return "false" if the two subsets are equivalent, /// overlapping or cannot be proven to be disjoint. /// /// This interface method does not have to be implemented if /// `getAccessedHyperrectangularSlice` is implemented. bool mlir::SubsetInsertionOpInterface::operatesOnDisjointSubset(::mlir::SubsetOpInterface candidate, ::llvm::function_ref<bool(Value, Value)> equivalenceFn) { … } /// If this op operates on a hyperrectangular subset, return a /// description of the subset in terms of offsets, sizes and strides. /// Otherwise, return "failure". /// /// This interface method is a convenience method for the most common case /// of hyperrectangular subset ops. It is optional. If it is implemented, /// `operatesOnEquivalentSubset` and `operatesOnDisjointSubset` do not /// have to be implemented. ::mlir::FailureOr<::mlir::HyperrectangularSlice> mlir::SubsetInsertionOpInterface::getAccessedHyperrectangularSlice() { … } /// Return "true" if this op and the given candidate subset op operate on /// equivalent subsets. Return "false" if the two subsets are disjoint /// or cannot be proven to be equivalent. /// /// This interface method does not have to be implemented if /// `getAccessedHyperrectangularSlice` is implemented. bool mlir::SubsetOpInterface::operatesOnEquivalentSubset(::mlir::SubsetOpInterface candidate, ::llvm::function_ref<bool(Value, Value)> equivalenceFn) { … } /// Return "true" if this op and the given candidate subset op operate on /// disjoint subsets. Return "false" if the two subsets are equivalent, /// overlapping or cannot be proven to be disjoint. /// /// This interface method does not have to be implemented if /// `getAccessedHyperrectangularSlice` is implemented. bool mlir::SubsetOpInterface::operatesOnDisjointSubset(::mlir::SubsetOpInterface candidate, ::llvm::function_ref<bool(Value, Value)> equivalenceFn) { … } /// If this op operates on a hyperrectangular subset, return a /// description of the subset in terms of offsets, sizes and strides. /// Otherwise, return "failure". /// /// This interface method is a convenience method for the most common case /// of hyperrectangular subset ops. It is optional. If it is implemented, /// `operatesOnEquivalentSubset` and `operatesOnDisjointSubset` do not /// have to be implemented. ::mlir::FailureOr<::mlir::HyperrectangularSlice> mlir::SubsetOpInterface::getAccessedHyperrectangularSlice() { … }
Codebase Browser
llvm