[mlir] Rename getInputs->getDpsInputs and getOutputs->getDpsInits in DPS interface.

[pifon2a]

Summary

https://discourse.llvm.org/t/rfc-interface-for-destination-style-ops/64056

[pifon2a]

Rebase

[pifon2a]

Rebase

[mravishankar]

Thanks Alex. Ill cherry pick it and give it a whirl. Might have to change the name of many of the methods of the DPS interface. Ill send out a follow up!

mlir/include/mlir/Dialect/Bufferization/IR/DstBufferizableOpInterfaceImpl.h

assert(isa<DestinationStyleOpInterface>(op) &&
            "expected that op implements DestinationStyleOpInterface");
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
                                const AnalysisState &state) const {
     // Only outputs bufferize to a memory write.
     auto dstOp = cast<DestinationStyleOpInterface>(op);
-    return dstOp.isOutput(&opOperand);
+    return dstOp.isDpsInit(&opOperand);
   }
 
   SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     // Output operands alias with their respective tied OpResults.
     auto dstOp = cast<DestinationStyleOpInterface>(op);
-    if (dstOp.isOutput(&opOperand))
+    if (dstOp.isDpsInit(&opOperand))
       return {dstOp.getTiedOpResult(&opOperand)};
     return {};
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     assert(isa<DestinationStyleOpInterface>(op) &&
            "expected that op implements DestinationStyleOpInterface");
     return BufferRelation::Equivalent;
   }
 };
 
 } // namespace bufferization
 } // namespace mlir
 
 #endif // MLIR_DIALECT_BUFFERIZATION_IR_DSTBUFFERIZABLEOPINTERFACEIMPL_H_

mlir/include/mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h

struct LinalgDependenceGraphElem {
     // Return the indexing map of the operand/result in `opView` specified in
     // the owning LinalgOp. If the owner is not a LinalgOp returns llvm::None.
     static Optional<AffineMap> getIndexingMap(OpView opView) {
       auto owner = dyn_cast<LinalgOp>(getOwner(opView));
       if (!owner)
         return llvm::None;
       if (OpOperand *operand = opView.dyn_cast<OpOperand *>())
         return owner.getMatchingIndexingMap(operand);
-      return owner.getMatchingIndexingMap(owner.getOutputOperand(
+      return owner.getMatchingIndexingMap(owner.getDpsInitOperand(
           opView.get<Value>().cast<OpResult>().getResultNumber()));
     }
     // Return the operand number if the `opView` is an OpOperand *. Otherwise
     // return llvm::None.
     static Optional<unsigned> getOperandNumber(OpView opView) {
       if (OpOperand *operand = opView.dyn_cast<OpOperand *>())
         return operand->getOperandNumber();
       return llvm::None;

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

InterfaceMethod<
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         auto iters = $_op.getIteratorTypesArray();
         return iters.size() == 1 &&
                getNumIterators(getReductionIteratorTypeName(), iters) == 1;
       }]>,
     //===------------------------------------------------------------------===//
-    // Input and Output arguments handling.
+    // Input and Init arguments handling.
     //===------------------------------------------------------------------===//
     InterfaceMethod<
       /*desc=*/[{
         Return true if the payload uses the value loaded from `opOperand`. This
         is useful to avoid loading from "write-only" memory that may be
         uninitialized, as well as properly cloning "read-write" operands.
       }],
       /*retTy=*/"bool",
InterfaceMethod<
         Return true if `opOperand` is an init tensor. This is true when it is
         an output tensor operand whose value is used in the payload region.
       }],
       /*retTy=*/"bool",
       /*methodName=*/"isInitTensor",
       /*args=*/(ins "OpOperand *":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        if (!$_op.isOutput(opOperand))
+        if (!$_op.isDpsInit(opOperand))
           return false;
         return payloadUsesValueFromOperand(opOperand);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the `opOperand` rank or zero for scalars.
       }],
InterfaceMethod<
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         // MLIR currently does not support dependent interfaces or interface
         // inheritance. By construction all ops with StructuredOpInterface must
         // implement DestinationStyleOpInterface.
         // TODO: reevalute the need for a cast when a better mechanism exists.
         return getBlock()->getArguments().take_front(
             cast<DestinationStyleOpInterface>(*this->getOperation())
-                .getNumInputs());
+                .getNumDpsInputs());
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the output block arguments of the region.
       }],
       /*retTy=*/"Block::BlockArgListType",
       /*methodName=*/"getRegionOutputArgs",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         // MLIR currently does not support dependent interfaces or interface
         // inheritance. By construction all ops with StructuredOpInterface must
         // implement DestinationStyleOpInterface.
         // TODO: reevalute the need for a cast when a better mechanism exists.
         return getBlock()->getArguments().take_back(
             cast<DestinationStyleOpInterface>(*this->getOperation())
-                .getNumOutputs());
+                .getNumDpsInits());
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the `opOperand` shape or an empty vector for scalars.
       }],
       /*retTy=*/"ArrayRef<int64_t>",
       /*methodName=*/"getShape",
InterfaceMethod<
         auto indexingMaps =
           $_op.getIndexingMaps().template getAsValueRange<AffineMapAttr>();
         // MLIR currently does not support dependent interfaces or interface
         // inheritance. By construction all ops with StructuredOpInterface must
         // implement DestinationStyleOpInterface.
         // TODO: reevalute the need for a cast when a better mechanism exists.
         return *(indexingMaps.begin() +
                  cast<DestinationStyleOpInterface>(*this->getOperation())
-                     .getNumInputs() +
+                     .getNumDpsInputs() +
                  result.getResultNumber());
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the value yielded by the region corresponding to an output
         `opOperand`.
       }],
       /*retTy=*/"OpOperand *",
       /*methodName=*/"getMatchingYieldValue",
       /*args=*/(ins "OpOperand*":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(opOperand->getOwner() == this->getOperation());
         // MLIR currently does not support dependent interfaces or interface
         // inheritance. By construction all ops with StructuredOpInterface must
         // implement DestinationStyleOpInterface.
         // TODO: reevalute the need for a cast when a better mechanism exists.
         int64_t resultIndex =
             opOperand->getOperandNumber() -
             cast<DestinationStyleOpInterface>(*this->getOperation())
-                .getNumInputs();
+                .getNumDpsInputs();
         assert(resultIndex >= 0 &&
                resultIndex < this->getOperation()->getNumResults());
         Operation *yieldOp = getBlock()->getTerminator();
         return &yieldOp->getOpOperand(resultIndex);
       }]
     >,
     //===------------------------------------------------------------------===//
     // Other interface methods.
let extraClassDeclaration = [{
     // Forwarding functions to access interface methods from the
     // DestinationStyleOpInterface.
     // MLIR currently does not support dependent interfaces or interface
     // inheritance. By construction all ops with StructuredOpInterface must
     // implement DestinationStyleOpInterface.
     // TODO: reevalute the need for a cast when a better mechanism exists.
     //========================================================================//
 
-    int64_t getNumInputs() {
+    int64_t getNumDpsInputs() {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
-          .getNumInputs();
+          .getNumDpsInputs();
     }
 
-    int64_t getNumOutputs() {
+    int64_t getNumDpsInits() {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
-          .getNumOutputs();
+          .getNumDpsInits();
     }
 
-    OpOperandVector getInputOperands() {
+    OpOperandVector getDpsInputOperands() {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
-          .getInputOperands();
+          .getDpsInputOperands();
     }
 
-    OpOperand *getInputOperand(int64_t i) {
+    OpOperand *getDpsInputOperand(int64_t i) {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
-          .getInputOperand(i);
+          .getDpsInputOperand(i);
     }
 
-    void setOutputOperand(int64_t i, Value value) {
+    void setDpsInitOperand(int64_t i, Value value) {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
-          .setOutputOperand(i, value);
+          .setDpsInitOperand(i, value);
     }
 
-    OpOperandVector getOutputOperands() {
+    OpOperandVector getDpsInitOperands() {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
-          .getOutputOperands();
+          .getDpsInitOperands();
     }
 
-    OpOperand *getOutputOperand(int64_t i) {
+    OpOperand *getDpsInitOperand(int64_t i) {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
-          .getOutputOperand(i);
+          .getDpsInitOperand(i);
     }
 
-    bool isInput(OpOperand *opOperand) {
+    bool isDpsInput(OpOperand *opOperand) {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
-          .isInput(opOperand);
+          .isDpsInput(opOperand);
     }
 
-    bool isOutput(OpOperand *opOperand) {
+    bool isDpsInit(OpOperand *opOperand) {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
-          .isOutput(opOperand);
+          .isDpsInit(opOperand);
     }
 
     bool isScalar(OpOperand *opOperand) {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
           .isScalar(opOperand);
     }
 
     OpResult getTiedOpResult(OpOperand *opOperand) {

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

std::string getLibraryCallName() {
         getLibraryCall()->str() : "op_has_no_registered_library_name";
     }
 
     static std::function<void(ImplicitLocOpBuilder &,
                               Block &, ArrayRef<NamedAttribute>)>
     getRegionBuilder() {
       return nullptr;
     }
-    std::pair<int64_t, int64_t> getOutputsPositionRange() {
+    std::pair<int64_t, int64_t> getDpsInitsPositionRange() {
       int64_t getNumOperands = this->getNumOperands();
       return {getNumOperands - getOutputs().size(), getNumOperands};
     }
   }];
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
   let hasFolder = 1;
let extraClassDeclaration = structuredOpsBaseDecls # [{
     // Implement functions necessary for LinalgStructuredInterface.
     SmallVector<StringRef> getIteratorTypesArray();
     ArrayAttr getIndexingMaps();
     std::string getLibraryCallName() {
       return "op_has_no_registered_library_name";
     }
 
     // Implement functions necessary for DestinationStyleOpInterface.
-    std::pair<int64_t, int64_t> getOutputsPositionRange() {
+    std::pair<int64_t, int64_t> getDpsInitsPositionRange() {
       int64_t getNumOperands = this->getNumOperands();
       return {getNumOperands - 1, getNumOperands};
     }
     OpOperandVector getOpOperandsMatchingBBargs() {
-      return getInputOperands();
+      return getDpsInputOperands();
     }
 
     bool payloadUsesValueFromOperand(OpOperand * opOperand) {
-      if (isOutput(opOperand)) return false;
+      if (isDpsInit(opOperand)) return false;
       return !getMatchingBlockArgument(opOperand).use_empty();
     }
 
     static std::function<void(mlir::ImplicitLocOpBuilder &, mlir::Block &,
                               mlir::ArrayRef<mlir::NamedAttribute>)>
     getRegionBuilder() {
       return nullptr;
     }
let extraClassDeclaration = structuredOpsBaseDecls # [{
     }
 
     // Implement functions necessary for DestinationStyleOpInterface.
     static std::function<void(mlir::ImplicitLocOpBuilder &, mlir::Block &,
                               mlir::ArrayRef<mlir::NamedAttribute>)>
     getRegionBuilder() {
       return nullptr;
     }
-    std::pair<int64_t, int64_t> getOutputsPositionRange() {
+    std::pair<int64_t, int64_t> getDpsInitsPositionRange() {
       return {getInits().size(), getNumOperands()};
     }
   }];
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
let extraClassDeclaration = structuredOpsBaseDecls # [{
     // Declare functions necessary for LinalgStructuredInterface.
     SmallVector<StringRef> getIteratorTypesArray();
     ArrayAttr getIndexingMaps();
     std::string getLibraryCallName() {
       return "op_has_no_registered_library_name";
     }
 
     // Implement functions necessary for DestinationStyleOpInterface.
-    std::pair<int64_t, int64_t> getOutputsPositionRange() {
+    std::pair<int64_t, int64_t> getDpsInitsPositionRange() {
       int64_t getNumOperands = this->getNumOperands();
       return {getNumOperands - 1, getNumOperands};
     }
 
     static std::function<void(mlir::ImplicitLocOpBuilder &, mlir::Block &,
         mlir::ArrayRef<mlir::NamedAttribute>)>
       getRegionBuilder();
 

mlir/include/mlir/Dialect/Tensor/IR/TensorOps.td

def Tensor_InsertOp : Tensor_Op<"insert", [
   let builders = [
     OpBuilder<(ins "Value":$scalar, "Value":$dest,
       CArg<"ValueRange", "{}">:$indices), [{
       auto resType = dest.getType();
       build($_builder, $_state, resType, scalar, dest, indices);
     }]>];
 
   let extraClassDeclaration = [{
-    std::pair<int64_t, int64_t> getOutputsPositionRange() {
+    std::pair<int64_t, int64_t> getDpsInitsPositionRange() {
       return {1, 2};  // `dest` operand
     }
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
std::array<unsigned, 3> getArrayAttrMaxRanks() {
       unsigned rank = getType().getRank();
       return {rank, rank, rank};
     }
 
     /// Return the number of leading operands before the `offsets`, `sizes` and
     /// and `strides` operands.
     static unsigned getOffsetSizeAndStrideStartOperandIndex() { return 2; }
 
-    std::pair<int64_t, int64_t> getOutputsPositionRange() {
+    std::pair<int64_t, int64_t> getDpsInitsPositionRange() {
       return {1, 2};  // `dest` operand
     }
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 }

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

OpBuilder<(ins "Value":$vector,
                    CArg<"Optional<ArrayRef<bool>>", "::llvm::None">:$inBounds)>,
   ];
 
   let extraClassDeclaration = [{
     /// This method is added to maintain uniformity with load/store
     ///  ops of other dialects.
     Value getValue() { return getVector(); }
 
-    std::pair<int64_t, int64_t> getOutputsPositionRange() {
+    std::pair<int64_t, int64_t> getDpsInitsPositionRange() {
       return {1, 2};  // `source` operand
     }
   }];
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;

mlir/include/mlir/Interfaces/DestinationStyleOpInterface.td

 //===- DestinationStyleOpInterface.td ----------------------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DESTINATIONSTYLEOPINTERFACE
 #define MLIR_DESTINATIONSTYLEOPINTERFACE
 
 include "mlir/IR/OpBase.td"
 
 def DestinationStyleOpInterface : OpInterface<"DestinationStyleOpInterface"> {
   let description = [{
-    Ops that are in destination style have designated output operands, which act
-    as initial tensor values for the results of the operation or the output
+    Ops that are in destination style have designated init operands, which act
+    as initial tensor values for the results of the operation or the init
     buffers to which the results of the op will be written.
 
-    Output operands must be ranked tensors or ranked memrefs. Input operands can
-    have any type. All non-output operands are inputs.
+    Init operands must be ranked tensors or ranked memrefs. Input operands can
+    have any type. All non-init operands are DPS inputs.
 
-    It is assumed that the output operands of the op are the operands at
-    position [start, end). The positions are defined by getOutputsPositionRange
-    method. All non-output operands are "inputs" of the DPS op.
+    It is assumed that the init operands of the op are the operands at
+    position [start, end). The positions are defined by getDpsInitsPositionRange
+    method.
 
     If the op has "tensor semantics", then the input operands are either scalars
-    or ranked tensors. The output operands are ranked tensors and every tensor
-    output is tied to a corresponding tensor OpResult in a 1-to-1 fashion.
-    The i-th output tensor is tied to the i-th OpResult. The op may not have any
-    additional OpResults. Output operands and their tied OpResults have the same
+    or ranked tensors. The init operands are ranked tensors and every tensor
+    init is tied to a corresponding tensor OpResult in a 1-to-1 fashion.
+    The i-th init tensor is tied to the i-th OpResult. The op may not have any
+    additional OpResults. Init operands and their tied OpResults have the same
     type.
 
     If the op has "buffer semantics", then the input operands are either ranked
     memrefs or other non-tensor types, e.g. scalar types. Furthermore, the
-    output operands are ranked memrefs and the op has no results.
+    init operands are ranked memrefs and the op has no results.
 
     Destination-passing style abstraction makes certain transformations easier.
     For example, tiling implementation can extract/insert slices from/into the
     destination of an op and use the resulting shaped value as an iter_arg in
     the surrounding loop structure. As another example, bufferization does not
     have to allocate new buffers for destinations (in case of in-place
     bufferization) and can directly reuse the existing destination buffer.
 
     Example of a destination style op: `%r = tensor.insert_slice %t into %d`,
-    where `%t` is the single input and `%d` is the single output. `%d` is tied
+    where `%t` is the single input and `%d` is the single init. `%d` is tied
     to `%r`.
 
     Example of an op that is not in destination style: `%r = tensor.pad %t`.
     This op is not in destination style because `%r` and `%t` have different
     shape.
 
     Each op that wants to implement DestinationStyleOpInterface needs to define
-    the getOutputsPositionRange() method.
+    the getDpsInitsPositionRange() method.
   }];
 
   let cppNamespace = "::mlir";
 
   let methods = [
     // This method has to be defined for every DPS op.
     InterfaceMethod<
-      /*desc=*/"Return start and end indices of the output operands range.",
+      /*desc=*/"Return start and end indices of the init operands range.",
       /*retTy=*/"std::pair<int64_t, int64_t>",
-      /*methodName=*/"getOutputsPositionRange",
+      /*methodName=*/"getDpsInitsPositionRange",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/""
     >,
     //===------------------------------------------------------------------===//
     // Operands handling.
     //===------------------------------------------------------------------===//
     // The operand list is assumed to start with the input operands and end
-    // with the output operands. Therefore, all methods to access the inputs
-    // and outputs can be expressed if the number of output operands is know.
+    // with the init operands. Therefore, all methods to access the inputs
+    // and inits can be expressed if the number of init operands is know.
     InterfaceMethod<
-      /*desc=*/"Return the number of outputs.",
+      /*desc=*/"Return the number of inits.",
       /*retTy=*/"int64_t",
-      /*methodName=*/"getNumOutputs",
+      /*methodName=*/"getNumDpsInits",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        auto [start, end] = $_op.getOutputsPositionRange();
+        auto [start, end] = $_op.getDpsInitsPositionRange();
         return end - start;
       }]
     >,
     InterfaceMethod<
-      /*desc=*/"Return the output operands.",
+      /*desc=*/"Return the init operands.",
       /*retTy=*/"OpOperandVector",
-      /*methodName=*/"getOutputOperands",
+      /*methodName=*/"getDpsInitOperands",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        auto [start, end] = $_op.getOutputsPositionRange();
+        auto [start, end] = $_op.getDpsInitsPositionRange();
 
         OpOperandVector result;
         result.reserve(end - start);
         for (int i = start; i < end; ++i)
           result.push_back(&$_op->getOpOperand(i));
         return result;
       }]
     >,
     InterfaceMethod<
-      /*desc=*/"Return the `i`-th output operand.",
+      /*desc=*/"Return the `i`-th init operand.",
       /*retTy=*/"OpOperand *",
-      /*methodName=*/"getOutputOperand",
+      /*methodName=*/"getDpsInitOperand",
       /*args=*/(ins "int64_t":$i),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        assert(i >= 0 && i < $_op.getNumOutputs());
-        auto [start, end] = $_op.getOutputsPositionRange();
+        assert(i >= 0 && i < $_op.getNumDpsInits());
+        auto [start, end] = $_op.getDpsInitsPositionRange();
         return &$_op->getOpOperand(start + i);
       }]
     >,
     InterfaceMethod<
-      /*desc=*/"Set the `i`-th output operand.",
+      /*desc=*/"Set the `i`-th init operand.",
       /*retTy=*/"void",
-      /*methodName=*/"setOutputOperand",
+      /*methodName=*/"setDpsInitOperand",
       /*args=*/(ins "int64_t":$i, "Value":$value),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        assert(i >= 0 && i < $_op.getNumOutputs());
-        auto [start, end] = $_op.getOutputsPositionRange();
+        assert(i >= 0 && i < $_op.getNumDpsInits());
+        auto [start, end] = $_op.getDpsInitsPositionRange();
         $_op->setOperand(start + i, value);
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the number of inputs.",
       /*retTy=*/"int64_t",
-      /*methodName=*/"getNumInputs",
+      /*methodName=*/"getNumDpsInputs",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return $_op.getNumOperands() - $_op.getNumOutputs();
+        return $_op.getNumOperands() - $_op.getNumDpsInits();
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the input operands.",
       /*retTy=*/"OpOperandVector",
-      /*methodName=*/"getInputOperands",
+      /*methodName=*/"getDpsInputOperands",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        auto [start, end] = $_op.getOutputsPositionRange();
-        int64_t numOutputs = end - start;
+        auto [start, end] = $_op.getDpsInitsPositionRange();
+        int64_t numInits = end - start;
         int64_t numOperands = $_op.getNumOperands();
 
         OpOperandVector result;
-        result.reserve(numOperands - numOutputs);
+        result.reserve(numOperands - numInits);
         for (int i = 0; i < start; ++i)
           result.push_back(&$_op->getOpOperand(i));
         for (int i = end; i < numOperands; ++i)
           result.push_back(&$_op->getOpOperand(end + i));
 
         return result;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{ Return the `i`-th input operand.  }],
       /*retTy=*/"OpOperand *",
-      /*methodName=*/"getInputOperand",
+      /*methodName=*/"getDpsInputOperand",
       /*args=*/(ins "int64_t":$i),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        assert(i >= 0 && i < getNumInputs());
-        auto [start, end] = $_op.getOutputsPositionRange();
+        assert(i >= 0 && i < getNumDpsInputs());
+        auto [start, end] = $_op.getDpsInitsPositionRange();
         return &$_op->getOpOperand(i < start ? i : i + end - start) ;
       }]
     >,
     //===------------------------------------------------------------------===//
-    // Input and Output arguments handling.
+    // Input and DpsInit arguments handling.
     //===------------------------------------------------------------------===//
     InterfaceMethod<
       /*desc=*/"Return true if `opOperand` is an input.",
       /*retTy=*/"bool",
-      /*methodName=*/"isInput",
+      /*methodName=*/"isDpsInput",
       /*args=*/(ins "OpOperand *":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        auto [start, end] = $_op.getOutputsPositionRange();
+        auto [start, end] = $_op.getDpsInitsPositionRange();
         auto operandNumber = opOperand->getOperandNumber();
         return operandNumber < start || operandNumber >= end;
       }]
     >,
     InterfaceMethod<
-      /*desc=*/"Return true if `opOperand` is an output.",
+      /*desc=*/"Return true if `opOperand` is an init.",
       /*retTy=*/"bool",
-      /*methodName=*/"isOutput",
+      /*methodName=*/"isDpsInit",
       /*args=*/(ins "OpOperand *":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        auto [start, end] = $_op.getOutputsPositionRange();
+        auto [start, end] = $_op.getDpsInitsPositionRange();
         auto operandNumber = opOperand->getOperandNumber();
         return operandNumber >= start && operandNumber < end;
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return true if the `opOperand` is a scalar value.",
       /*retTy=*/"bool",
       /*methodName=*/"isScalar",
       /*args=*/(ins "OpOperand *":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(opOperand->getOwner() == $_op.getOperation());
         return !opOperand->get().getType().template isa<ShapedType>();
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the OpResult that is tied to the given OpOperand.",
       /*retTy=*/"OpResult",
       /*methodName=*/"getTiedOpResult",
       /*args=*/(ins "OpOperand *":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(opOperand->getOwner() == $_op.getOperation());
 
-        auto [start, end] = $_op.getOutputsPositionRange();
+        auto [start, end] = $_op.getDpsInitsPositionRange();
         int64_t resultIndex = opOperand->getOperandNumber() - start;
         assert(resultIndex >= 0 &&
                resultIndex < $_op->getNumResults() );
         return $_op->getResult(resultIndex);
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the OpOperand that is tied to the given OpResult.",
       /*retTy=*/"OpOperand *",
       /*methodName=*/"getTiedOpOperand",
       /*args=*/(ins "OpResult":$opResult),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(opResult.getDefiningOp() == $_op.getOperation());
-        return $_op.getOutputOperand(opResult.getResultNumber());
+        return $_op.getDpsInitOperand(opResult.getResultNumber());
       }]
     >,
     //===------------------------------------------------------------------===//
     // Other interface methods.
     //===------------------------------------------------------------------===//
     InterfaceMethod<
-      /*desc=*/"Return whether the op has only ranked MemRef inputs/outputs.",
+      /*desc=*/"Return whether the op has only ranked MemRef input/inits.",
       /*retTy=*/"bool",
       /*methodName=*/"hasBufferSemantics",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op->getNumResults() == 0 &&
           llvm::all_of($_op->getOpOperands(),
             [&](OpOperand &opOperand) {
               return isScalar(&opOperand) ||
                      opOperand.get().getType().template isa<MemRefType>();
             });
       }]
     >,
     InterfaceMethod<
-      /*desc=*/"Return whether the op has only ranked tensor inputs/outputs.",
+      /*desc=*/"Return whether the op has only ranked tensor inputs/inits.",
       /*retTy=*/"bool",
       /*methodName=*/"hasTensorSemantics",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return llvm::all_of($_op->getOpOperands(),
           [&](OpOperand &opOperand) {
             return isScalar(&opOperand) ||
                    opOperand.get().getType().template isa<RankedTensorType>();
           });
       }]
     >,
     //===------------------------------------------------------------------===//
     // Other static interface methods.
     //===------------------------------------------------------------------===//
     InterfaceMethod<
       /*desc=*/[{
         Clone the current operation with the given location and operands. This
         is used to abstract away the optional underlying region creation. This
-        does not change the balance between input, output_buffer and
+        does not change the balance between input, init_buffer and
         init_tensors operands.
       }],
       /*retTy=*/"Operation *",
       /*methodName=*/"clone",
       (ins "OpBuilder &":$b, "Location":$loc, "TypeRange":$resultTypes,
            "ValueRange":$operands),
       [{
         BlockAndValueMapping bvm;
         OperationState state(
           loc, ConcreteOp::getOperationName(), operands, resultTypes,
           $_op->getAttrs());
         for (Region &r : $_op->getRegions())
           r.cloneInto(state.addRegion(), bvm);
         return b.create(state);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Clone the current operation with the given location, operands
         and BlockAndValueMapping but leave the regions empty. This is
         used to abstract away the optional underlying region creation.
-        This does not change the balance between input, output_buffer
+        This does not change the balance between input, init_buffer
         and init_tensors operands.
       }],
       /*retTy=*/"Operation *",
       /*methodName=*/"cloneWithoutRegions",
       (ins "OpBuilder &":$b, "Location":$loc, "TypeRange":$resultTypes,
            "ValueRange":$operands),
       [{
         OperationState state(

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp

SingleWorkgroupReduction::matchAsPerformingReduction(
     linalg::GenericOp genericOp) {
   Operation *op = genericOp.getOperation();
 
   // Make sure the linalg.generic is working on memrefs.
   if (!genericOp.hasBufferSemantics())
     return llvm::None;
 
   // Make sure this is reduction with one input and one output.
-  if (genericOp.getNumInputs() != 1 || genericOp.getNumOutputs() != 1)
+  if (genericOp.getNumDpsInputs() != 1 || genericOp.getNumDpsInits() != 1)
     return llvm::None;
 
   auto originalInputType = op->getOperand(0).getType().cast<MemRefType>();
   auto originalOutputType = op->getOperand(1).getType().cast<MemRefType>();
 
   // Make sure the original input has one dimension.
   if (!originalInputType.hasStaticShape() || originalInputType.getRank() != 1)
     return llvm::None;

mlir/lib/Dialect/Linalg/Analysis/DependenceAnalysis.cpp

if (iter == dependencesIntoGraphs[dt].end())
     return llvm::make_range(nullptr, nullptr);
   return llvm::make_range(iter->second.begin(), iter->second.end());
 }
 
 void LinalgDependenceGraph::addDependencesBetween(LinalgOp src, LinalgOp dst) {
   LLVM_DEBUG(dbgs() << "addDependencesBetween " << *src.getOperation()
                     << " and " << *dst.getOperation() << "\n");
   if (src.hasTensorSemantics() && dst.hasTensorSemantics()) {
-    for (OpOperand *dstOpOperand : dst.getInputOperands()) {
+    for (OpOperand *dstOpOperand : dst.getDpsInputOperands()) {
       if (!dstOpOperand->get().getType().isa<RankedTensorType>())
         continue;
       // Check if the operand is defined by the src.
       auto definingOp = dstOpOperand->get().getDefiningOp<LinalgOp>();
       if (definingOp && definingOp == src)
         addDependenceElem(DependenceType::RAW, dstOpOperand->get(),
                           dstOpOperand);
     }
-    for (OpOperand *dstOpOperand : dst.getOutputOperands()) {
+    for (OpOperand *dstOpOperand : dst.getDpsInitOperands()) {
       // Check if the operand is defined by the src.
       auto definingOp = dstOpOperand->get().getDefiningOp<LinalgOp>();
       if (definingOp && definingOp == src) {
         if (dst.isInitTensor(dstOpOperand)) {
           addDependenceElem(DependenceType::RAW, dstOpOperand->get(),
                             dstOpOperand);
         }
         addDependenceElem(DependenceType::WAW, dstOpOperand->get(),
                           dstOpOperand);
       }
     }
     return;
   }
   assert(src.hasBufferSemantics() && dst.hasBufferSemantics() &&
          "unhandled dependence tracking for mixed buffer/tensor operations");
-  for (OpOperand *srcOpOperand : src.getOutputOperands()) { // W
+  for (OpOperand *srcOpOperand : src.getDpsInitOperands()) { // W
     // RAW graph
-    for (OpOperand *dstOpOperand : dst.getInputOperands()) { // R
+    for (OpOperand *dstOpOperand : dst.getDpsInputOperands()) { // R
       if (!dstOpOperand->get().getType().isa<MemRefType>())
         continue;
       if (aliases.alias(srcOpOperand->get(), dstOpOperand->get())) // RAW alias
         addDependenceElem(DependenceType::RAW, srcOpOperand, dstOpOperand);
     }
     // WAW graph
-    for (OpOperand *dstOpOperand : dst.getOutputOperands())        // W
+    for (OpOperand *dstOpOperand : dst.getDpsInitOperands())       // W
       if (aliases.alias(srcOpOperand->get(), dstOpOperand->get())) // WAW alias
         addDependenceElem(DependenceType::WAW, srcOpOperand, dstOpOperand);
   }
-  for (OpOperand *srcOpOperand : src.getInputOperands()) { // R
+  for (OpOperand *srcOpOperand : src.getDpsInputOperands()) { // R
     if (!srcOpOperand->get().getType().isa<MemRefType>())
       continue;
     // RAR graph
-    for (OpOperand *dstOpOperand : dst.getInputOperands()) { // R
+    for (OpOperand *dstOpOperand : dst.getDpsInputOperands()) { // R
       if (!dstOpOperand->get().getType().isa<MemRefType>())
         continue;
       if (aliases.alias(srcOpOperand->get(), dstOpOperand->get())) // RAR alias
         addDependenceElem(DependenceType::RAR, srcOpOperand, dstOpOperand);
     }
     // WAR graph
-    for (OpOperand *dstOpOperand : dst.getOutputOperands())        // W
+    for (OpOperand *dstOpOperand : dst.getDpsInitOperands())       // W
       if (aliases.alias(srcOpOperand->get(), dstOpOperand->get())) // WAR alias
         addDependenceElem(DependenceType::WAR, srcOpOperand, dstOpOperand);
   }
 }
 
 SmallVector<Operation *, 8>
 LinalgDependenceGraph::findCoveringDependences(LinalgOp srcLinalgOp,
                                                LinalgOp dstLinalgOp) const {

mlir/lib/Dialect/Linalg/IR/LinalgInterfaces.cpp

enum class MatchContractionResult {
   NoReduction,
   NotProjectedPermutations,
   NotAddMul
 };
 static MatchContractionResult isContractionInterfaceImpl(Operation *op) {
   auto linalgOp = dyn_cast<linalg::LinalgOp>(op);
   if (!linalgOp)
     return MatchContractionResult::NotLinalgOp;
-  if (linalgOp.getNumInputs() != 2 || linalgOp.getNumOutputs() != 1)
+  if (linalgOp.getNumDpsInputs() != 2 || linalgOp.getNumDpsInits() != 1)
     return MatchContractionResult::WrongNumOperands;
   auto mapRange = linalgOp.getIndexingMapsArray();
   if (linalgOp.getNumReductionLoops() == 0)
     return MatchContractionResult::NoReduction;
   if (llvm::any_of(mapRange,
                    [](AffineMap m) { return !m.isProjectedPermutation(); }))
     return MatchContractionResult::NotProjectedPermutations;
   // TODO: more fields than add/mul.
enum class MatchConvolutionResult {
   OutputDimsNotParallel,
   NonOutputDimNotReduction
 };
 
 static MatchConvolutionResult isConvolutionInterfaceImpl(Operation *op) {
   auto linalgOp = dyn_cast<linalg::LinalgOp>(op);
   if (!linalgOp)
     return MatchConvolutionResult::NotLinalgOp;
-  if (linalgOp.getNumInputs() < 2 || linalgOp.getNumOutputs() != 1)
+  if (linalgOp.getNumDpsInputs() < 2 || linalgOp.getNumDpsInits() != 1)
     return MatchConvolutionResult::WrongNumOperands;
 
   auto indexingMaps = linalgOp.getIndexingMapsArray();
 
   // Check the input indexing map has the right form.
   ConvAccessExprWalker inputExprWalker;
   if (llvm::any_of(indexingMaps[0].getResults(),
                    [&inputExprWalker](AffineExpr expr) {
enum class MatchFillResult {
   WrongNumOperands,
   NotScalarInput
 };
 
 static MatchFillResult isFillInterfaceImpl(Operation *op) {
   auto linalgOp = dyn_cast<linalg::LinalgOp>(op);
   if (!linalgOp)
     return MatchFillResult::NotLinalgOp;
-  if (linalgOp.getNumInputs() != 1 || linalgOp.getNumOutputs() != 1)
+  if (linalgOp.getNumDpsInputs() != 1 || linalgOp.getNumDpsInits() != 1)
     return MatchFillResult::WrongNumOperands;
 
-  OpOperand *value = linalgOp.getInputOperand(0);
+  OpOperand *value = linalgOp.getDpsInputOperand(0);
   if (!linalgOp.isScalar(value))
     return MatchFillResult::NotScalarInput;
 
   return MatchFillResult::Success;
 }
 
 LogicalResult mlir::linalg::detail::verifyFillInterface(Operation *op) {
   auto res = isFillInterfaceImpl(op);

 private:
   llvm::SmallBitVector positions;
 };
 
 static std::pair<int64_t, int64_t>
 getResultsPositionInLoopsToShapeMap(LinalgOp &op) {
   int64_t inputRankSum = 0;
   int64_t outputRankSum = 0;
-  for (OpOperand *input : op.getInputOperands())
+  for (OpOperand *input : op.getDpsInputOperands())
     inputRankSum += op.getRank(input);
-  for (OpOperand *output : op.getOutputOperands())
+  for (OpOperand *output : op.getDpsInitOperands())
     outputRankSum += op.getRank(output);
   return {inputRankSum, inputRankSum + outputRankSum};
 }
 
 LogicalResult
 LinalgOp::reifyResultShapes(OpBuilder &b,
                             ReifiedRankedShapedTypeDims &reifiedReturnShapes) {
   // An example that helps understand the logic below.
LinalgOp::reifyResultShapes(OpBuilder &b,
   Location loc = getOperation()->getLoc();
   IRRewriter rewriter(b);
   SmallVector<OpFoldResult> allResultDimValues =
       makeComposedFoldedMultiResultAffineApply(
           rewriter, loc, resultShapesFromInputShapesMap,
           createFlatListOfOperandDims(b, loc));
   int64_t pos = 0;
   ArrayRef<AffineExpr> shapeExprs = resultShapesFromInputShapesMap.getResults();
-  for (OpOperand *opOperand : getOutputOperands()) {
+  for (OpOperand *opOperand : getDpsInitOperands()) {
     SmallVector<Value> shapes;
     for (int64_t dim : llvm::seq<int64_t>(0, getRank(opOperand))) {
       if (checkDimExpr.visit(shapeExprs[pos]))
         shapes.push_back(createOrFoldDimOp(b, loc, opOperand->get(), dim));
       else
         shapes.push_back(
             getValueOrCreateConstantIndexOp(b, loc, allResultDimValues[pos]));
       pos++;

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

for (auto attr : (*this)->getAttrs())
     if (genericAttrNamesSet.count(attr.getName().strref()) > 0)
       genericAttrs.push_back(attr);
   if (!genericAttrs.empty()) {
     auto genericDictAttr = DictionaryAttr::get(getContext(), genericAttrs);
     p << genericDictAttr;
   }
 
   // Printing is shared with named ops, except for the region and attributes
-  printCommonStructuredOpParts(p, SmallVector<Value>(getInputOperands()),
-                               SmallVector<Value>(getOutputOperands()));
+  printCommonStructuredOpParts(p, SmallVector<Value>(getDpsInputOperands()),
+                               SmallVector<Value>(getDpsInitOperands()));
 
   genericAttrNames.push_back("operand_segment_sizes");
   genericAttrNamesSet.insert(genericAttrNames.back());
 
   bool hasExtraAttrs = false;
   for (NamedAttribute n : (*this)->getAttrs()) {
     if ((hasExtraAttrs = !genericAttrNamesSet.contains(n.getName().strref())))
       break;
effects.emplace_back(MemoryEffects::Write::get(), operand->get(),
                          SideEffects::DefaultResource::get());
   }
 }
 
 void GenericOp::getEffects(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects) {
   getGenericEffectsImpl(effects, getOperation()->getResults(),
-                        getInputOperands(), getOutputOperands());
+                        getDpsInputOperands(), getDpsInitOperands());
 }
 
 static bool isResultValueDead(linalg::GenericOp genericOp, OpResult result) {
   if (!result.use_empty())
     return false;
   // If out operand not used in payload, we can drop it.
   OpOperand *outputOpOperand =
-      genericOp.getOutputOperand(result.getResultNumber());
+      genericOp.getDpsInitOperand(result.getResultNumber());
   if (!genericOp.payloadUsesValueFromOperand(outputOpOperand))
     return true;
 
   // The out operand that is part of a payload can be dropped if
   // these conditions are met:
   // - Result from out operand is dead.
   // - User of arg is yield.
   // - outArg data is not being used by other outArgs.
private:
   // - The preserved input operands list (by reference).
   llvm::SmallDenseMap<unsigned, unsigned>
   deduplicateInputOperands(GenericOp genericOp,
                            SmallVector<OpOperand *> &droppedOpOperands,
                            SmallVector<Value> &newInputOperands,
                            SmallVector<AffineMap> &newIndexingMaps) const {
     llvm::SmallDenseMap<unsigned, unsigned> origToNewPos;
     llvm::SmallDenseMap<std::pair<Value, AffineMap>, unsigned> dedupedInputs;
-    for (const auto &en : llvm::enumerate(genericOp.getInputOperands())) {
+    for (const auto &en : llvm::enumerate(genericOp.getDpsInputOperands())) {
       OpOperand *inputOpOperand = en.value();
       // Check if operand is dead and if dropping the indexing map makes the
       // loops to shape computation invalid.
       if (!genericOp.payloadUsesValueFromOperand(inputOpOperand)) {
         // Add the current operands to the list of potentially droppable
         // operands. If it cannot be dropped, this needs to be popped back.
         droppedOpOperands.push_back(inputOpOperand);
         if (genericOp.canOpOperandsBeDropped(droppedOpOperands))
deduplicateOutputOperands(GenericOp genericOp,
                             SmallVector<Value> &newOutputOperands,
                             SmallVector<AffineMap> &newIndexingMaps) const {
     llvm::SmallDenseMap<unsigned, unsigned> origToNewPos;
     llvm::SmallDenseMap<std::tuple<Value, AffineMap, Value>, unsigned>
         dedupedOutpts;
     // If the op doesnt have tensor semantics, keep all the outputs as
     // preserved.
     if (!genericOp.hasTensorSemantics()) {
-      for (const auto &en : llvm::enumerate(genericOp.getOutputOperands())) {
+      for (const auto &en : llvm::enumerate(genericOp.getDpsInitOperands())) {
         origToNewPos[en.index()] = newOutputOperands.size();
         newOutputOperands.push_back(en.value()->get());
         newIndexingMaps.push_back(genericOp.getMatchingIndexingMap(en.value()));
       }
       return origToNewPos;
     }
     // Output argument can be dropped if the result has
     // - no users, and
     // - it is not used in the payload, and
     // - the corresponding indexing maps are not needed for loop bound
     //   computation.
     auto yieldOp = cast<YieldOp>(genericOp.getBody()->getTerminator());
     for (const auto &outputOpOperand :
-         llvm::enumerate(genericOp.getOutputOperands())) {
+         llvm::enumerate(genericOp.getDpsInitOperands())) {
       OpResult result = genericOp.getTiedOpResult(outputOpOperand.value());
       AffineMap indexingMap =
           genericOp.getMatchingIndexingMap(outputOpOperand.value());
       auto key = std::make_tuple(outputOpOperand.value()->get(), indexingMap,
                                  yieldOp->getOperand(outputOpOperand.index()));
       if (isResultValueDead(genericOp, result)) {
         // Check if the opoperand can be dropped without affecting loop
         // bound computation. Add the operand to the list of dropped op
auto updateReplacements =
             if (it == map.end())
               continue;
             OpOperand *newOperand = newOperands[it->second];
             replacements[origOperand.value()->getOperandNumber()] =
                 newOpBlock->getArgument(newOperand->getOperandNumber());
           }
         };
 
-    OpOperandVector origInputOperands = genericOp.getInputOperands();
-    OpOperandVector newInputOperands = newOp.getInputOperands();
+    OpOperandVector origInputOperands = genericOp.getDpsInputOperands();
+    OpOperandVector newInputOperands = newOp.getDpsInputOperands();
     updateReplacements(origInputOperands, newInputOperands, origInsToNewInsPos);
 
-    OpOperandVector origOutputOperands = genericOp.getOutputOperands();
-    OpOperandVector newOutputOperands = newOp.getOutputOperands();
+    OpOperandVector origOutputOperands = genericOp.getDpsInitOperands();
+    OpOperandVector newOutputOperands = newOp.getDpsInitOperands();
     updateReplacements(origOutputOperands, newOutputOperands,
                        origOutsToNewOutsPos);
 
     // Drop the unused yield args.
-    if (newOp.getNumOutputs() != genericOp.getNumOutputs()) {
+    if (newOp.getNumDpsInits() != genericOp.getNumDpsInits()) {
       OpBuilder::InsertionGuard g(rewriter);
       YieldOp origYieldOp = cast<YieldOp>(origOpBlock->getTerminator());
       rewriter.setInsertionPoint(origYieldOp);
 
-      SmallVector<Value> newYieldVals(newOp.getNumOutputs(), nullptr);
+      SmallVector<Value> newYieldVals(newOp.getNumDpsInits(), nullptr);
       for (const auto &yieldOpOperands :
            llvm::enumerate(origYieldOp.getValues())) {
         auto it = origOutsToNewOutsPos.find(yieldOpOperands.index());
         if (it == origOutsToNewOutsPos.end())
           continue;
         newYieldVals[it->second] = yieldOpOperands.value();
       }
       rewriter.replaceOpWithNewOp<YieldOp>(origYieldOp, newYieldVals);
LogicalResult matchAndRewrite(GenericOp genericOp,
     if (!llvm::hasSingleElement(body))
       return failure();
     auto yieldOp = dyn_cast<linalg::YieldOp>(body.getTerminator());
     if (!yieldOp)
       return failure();
 
     // In the buffer case, we need to check exact buffer equality.
     if (genericOp.hasBufferSemantics()) {
-      if (genericOp.getNumInputs() == 1 && genericOp.getNumOutputs() == 1 &&
-          genericOp.getInputOperand(0)->get() ==
-              genericOp.getOutputOperand(0)->get()) {
+      if (genericOp.getNumDpsInputs() == 1 && genericOp.getNumDpsInits() == 1 &&
+          genericOp.getDpsInputOperand(0)->get() ==
+              genericOp.getDpsInitOperand(0)->get()) {
         rewriter.eraseOp(genericOp);
         return success();
       }
       return failure();
     }
 
     // Mixed semantics is not supported yet.
     if (!genericOp.hasTensorSemantics())
LogicalResult matchAndRewrite(GenericOp genericOp,
 
     // If the op doesnt have tensor semantics, preserve the outputs as is.
     if (!genericOp.hasTensorSemantics())
       return failure();
 
     bool hasRemovedCycles = false;
     // Iterate over output operands and remove any unused cycles.
     for (const auto &outputOpOperand :
-         llvm::enumerate(genericOp.getOutputOperands())) {
+         llvm::enumerate(genericOp.getDpsInitOperands())) {
 
       // Check that result from out operand is dead.
       Value result = genericOp.getResult(outputOpOperand.index());
       if (!result.use_empty())
         continue;
 
       // Check that outputArg has one use in cycle.
       BlockArgument outputArg =
if (parser.parseRegion(*body, regionArgs))
     return failure();
 
   return success();
 }
 
 void MapOp::print(OpAsmPrinter &p) {
   p.increaseIndent();
   printCommonStructuredOpPartsWithNewLine(
-      p, SmallVector<Value>(getInputOperands()),
-      SmallVector<Value>(getOutputOperands()));
+      p, SmallVector<Value>(getDpsInputOperands()),
+      SmallVector<Value>(getDpsInitOperands()));
   p.printOptionalAttrDict((*this)->getAttrs());
 
   p.printNewline();
   p << "(";
   llvm::interleaveComma(getMapper().getArguments(), p,
                         [&](auto arg) { p.printRegionArgument(arg); });
   p << ") ";
 
for (const auto &[bbArgType, inputArg] :
     auto inputElemType = inputArg.getType().cast<ShapedType>().getElementType();
     if (bbArgType != inputElemType) {
       return emitOpError() << "expected element type of input " << inputElemType
                            << " to match bbArg type " << bbArgType;
     }
   }
 
   // The shape of each input must match the shape of the output.
-  auto outputShape =
-      getOutputOperand(0)->get().getType().cast<ShapedType>().getShape();
+  auto outputShape = getInit().getType().cast<ShapedType>().getShape();
   for (Type inputArgType : TypeRange{getInputs()}) {
     auto inputElemShape = inputArgType.cast<ShapedType>().getShape();
     if (inputElemShape != outputShape) {
       return emitOpError() << "expected shape of input (" << inputElemShape
                            << ") to match shape of output (" << outputShape
                            << ")";
     }
   }
ArrayAttr MapOp::getIndexingMaps() {
   return builder.getAffineMapArrayAttr(SmallVector<AffineMap>(
       numIndexingMaps, builder.getMultiDimIdentityMap(rank)));
 }
 
 void MapOp::getEffects(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects) {
   getGenericEffectsImpl(effects, getOperation()->getResults(),
-                        getInputOperands(), getOutputOperands());
+                        getDpsInputOperands(), getDpsInitOperands());
 }
 
 //===----------------------------------------------------------------------===//
 // ReduceOp
 //===----------------------------------------------------------------------===//
 
 void ReduceOp::getAsmBlockArgumentNames(Region &region,
                                         OpAsmSetValueNameFn setNameFn) {
SmallVector<StringRef> ReduceOp::getIteratorTypesArray() {
   for (int64_t reductionDim : getDimensions())
     iteratorTypes[reductionDim] = getReductionIteratorTypeName();
   return iteratorTypes;
 }
 
 ArrayAttr ReduceOp::getIndexingMaps() {
   int64_t inputRank = getInputs()[0].getType().cast<ShapedType>().getRank();
   SmallVector<AffineMap> affineMaps(
-      getNumInputs(),
+      getNumDpsInputs(),
       AffineMap::getMultiDimIdentityMap(inputRank, getContext()));
   AffineMap resultMap =
       AffineMap::getMultiDimIdentityMap(inputRank, getContext())
           .dropResults(getDimensions());
-  for (int64_t i = 0, e = getNumOutputs(); i < e; ++i)
+  for (int64_t i = 0, e = getNumDpsInits(); i < e; ++i)
     affineMaps.push_back(resultMap);
   return Builder(getContext()).getAffineMapArrayAttr(affineMaps);
 }
 
 void ReduceOp::getEffects(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects) {
   getGenericEffectsImpl(effects, getOperation()->getResults(),
-                        getInputOperands(), getOutputOperands());
+                        getDpsInputOperands(), getDpsInitOperands());
 }
 
 static ParseResult parseDenseI64ArrayAttr(OpAsmParser &parser,
                                           NamedAttrList &attributes,
                                           StringRef attributeName) {
   if (parser.parseKeyword(attributeName) || parser.parseEqual())
     return failure();
 

 static void printDenseI64ArrayAttr(OpAsmPrinter &p, StringRef attributeName,
                                    ArrayRef<int64_t> attributeValue) {
   p << attributeName << " = [" << attributeValue << "] ";
 }
 
 void ReduceOp::print(OpAsmPrinter &p) {
   p.increaseIndent();
   printCommonStructuredOpPartsWithNewLine(
-      p, SmallVector<Value>(getInputOperands()),
-      SmallVector<Value>(getOutputOperands()));
+      p, SmallVector<Value>(getDpsInputOperands()),
+      SmallVector<Value>(getDpsInitOperands()));
   p.printNewline();
+
   printDenseI64ArrayAttr(p, getDimensionsAttrName(), getDimensions());
   p.printOptionalAttrDict((*this)->getAttrs(), {getDimensionsAttrName()});
 
   p.printNewline();
   p << "(";
   llvm::interleaveComma(getCombiner().getArguments(), p,
                         [&](auto arg) { p.printRegionArgument(arg); });
   p << ") ";
 
   p.printRegion(getCombiner(), /*printEntryBlockArgs=*/false);
   p.decreaseIndent();
 }
 
 LogicalResult ReduceOp::verify() {
   ArrayRef<int64_t> dimensionsRef = getDimensions();
 
-  for (int64_t i = 1; i < getNumInputs(); ++i) {
+  for (int64_t i = 1; i < getNumDpsInputs(); ++i) {
     if (getInputs()[i].getType().cast<ShapedType>().getShape() !=
         getInputs()[0].getType().cast<ShapedType>().getShape()) {
       return emitOpError() << "expects all inputs to have the same shapes. "
                               "Shape at input-index "
                            << i
                            << " is not equal to the shape at input-index 0.";
     }
   }
-  for (int64_t i = 1; i < getNumOutputs(); ++i) {
+  for (int64_t i = 1; i < getNumDpsInits(); ++i) {
     if (getInits()[i].getType().cast<ShapedType>().getShape() !=
         getInits()[0].getType().cast<ShapedType>().getShape()) {
       return emitOpError() << "expects all outputs to have the same shapes. "
                               "Shape at output-index "
                            << i
                            << " is not equal to the shape at output-index 0.";
     }
   }
if (inputElementType != bbArg.getType())
       return emitOpError()
              << "input element type " << inputElementType
              << " does not match corresponding block argument type "
              << bbArg.getType();
   }
 
   // Check that the last block arguments match the element type of the outputs.
   for (auto [output, bbArg] :
-       llvm::zip(getOutputOperands(),
-                 block->getArguments().take_back(getNumOutputs()))) {
+       llvm::zip(getDpsInitOperands(),
+                 block->getArguments().take_back(getNumDpsInits()))) {
     auto outputElementType =
         output->get().getType().cast<ShapedType>().getElementType();
     if (outputElementType != bbArg.getType())
       return emitOpError()
              << "output element type " << outputElementType
              << " does not match corresponding block argument type "
              << bbArg.getType();
   }
void TransposeOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   if (!getResults().empty())
     setNameFn(getResults().front(), "transposed");
 }
 
 void TransposeOp::print(OpAsmPrinter &p) {
   p.increaseIndent();
   printCommonStructuredOpPartsWithNewLine(
-      p, SmallVector<Value>(getInputOperands()),
-      SmallVector<Value>(getOutputOperands()));
+      p, SmallVector<Value>(getDpsInputOperands()),
+      SmallVector<Value>(getDpsInitOperands()));
   p.printNewline();
+
   printDenseI64ArrayAttr(p, getPermutationAttrName(), getPermutation());
   p.printOptionalAttrDict((*this)->getAttrs(), {getPermutationAttrName()});
   p.decreaseIndent();
 }
 
 LogicalResult TransposeOp::verify() {
   ArrayRef<int64_t> permutationRef = getPermutation();
 
return builder.getAffineMapArrayAttr(
        AffineMap::getPermutationMap(
            llvm::to_vector_of<unsigned>(getPermutation()), getContext())});
 }
 
 void TransposeOp::getEffects(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects) {
   getGenericEffectsImpl(effects, getOperation()->getResults(),
-                        getInputOperands(), getOutputOperands());
+                        getDpsInputOperands(), getDpsInitOperands());
 }
 
 //===----------------------------------------------------------------------===//
 // YieldOp
 //===----------------------------------------------------------------------===//
 
 void linalg::YieldOp::print(OpAsmPrinter &p) {
   if (getNumOperands() > 0)
return failure(parser.parseOperandList(opInfo) ||
                  parser.parseOptionalAttrDict(result.attributes) ||
                  (!opInfo.empty() && parser.parseColonTypeList(types)) ||
                  parser.resolveOperands(opInfo, types, loc, result.operands));
 }
 
 // Check the operand number and types must match the element types of the
 // LinalgOp interface's shaped operands.
 static LogicalResult verifyYield(linalg::YieldOp op, LinalgOp linalgOp) {
-  if (op.getNumOperands() != linalgOp.getNumOutputs())
+  if (op.getNumOperands() != linalgOp.getNumDpsInits())
     return op.emitOpError("expected number of yield values (")
-           << linalgOp.getNumOutputs()
+           << linalgOp.getNumDpsInits()
            << ") to match the number of operands of the enclosing "
            << "LinalgOp (" << op.getNumOperands() << ")";
 
   for (OpOperand &opOperand : op->getOpOperands()) {
     OpOperand *outputOperand =
-        linalgOp.getOutputOperand(opOperand.getOperandNumber());
+        linalgOp.getDpsInitOperand(opOperand.getOperandNumber());
     Type elementType = getElementTypeOrSelf(outputOperand->get().getType());
     if (opOperand.get().getType() != elementType)
       return op.emitOpError("type of yield operand ")
              << (opOperand.getOperandNumber() + 1) << " ("
              << opOperand.get().getType() << ") doesn't match "
              << "the element type of the enclosing linalg.generic op ("
              << elementType << ")";
   }
LogicalResult matchAndRewrite(LinalgOp op,
     if (!hasTensorCastOperand)
       return failure();
 
     SmallVector<Type, 4> newResultTypes;
     newResultTypes.reserve(op->getNumResults());
     SmallVector<Value, 4> newOperands;
     newOperands.reserve(op->getNumOperands());
     // Inputs may fold.
-    for (auto *input : op.getInputOperands()) {
+    for (auto *input : op.getDpsInputOperands()) {
       auto tensorCastOp = input->get().getDefiningOp<tensor::CastOp>();
       newOperands.push_back(canFoldIntoConsumerOp(tensorCastOp)
                                 ? tensorCastOp.getSource()
                                 : input->get());
     }
     // Init tensors may fold, in which case the resultType must also change.
-    for (auto *output : op.getOutputOperands()) {
+    for (auto *output : op.getDpsInitOperands()) {
       auto tensorCastOp = output->get().getDefiningOp<tensor::CastOp>();
       bool fold = canFoldIntoConsumerOp(tensorCastOp);
       newOperands.push_back(fold ? tensorCastOp.getOperand() : output->get());
       newResultTypes.push_back(newOperands.back().getType());
     }
     // Clone op.
     Operation *newOp =
         op.clone(rewriter, op->getLoc(), newResultTypes, newOperands);
LogicalResult matchAndRewrite(tensor::CastOp castOp,
     OpResult resultValue = castOp.getSource().cast<OpResult>();
     unsigned resultNumber = resultValue.getResultNumber();
     auto resultType = castOp->getResult(0).getType().cast<RankedTensorType>();
     // Replace the `outs` for the result with a `tensor.cast`. This cast is now
     // going from a more dynamic shape to a less dynamic shape. If the producer
     // for this cast, i.e. producer of the out operand, is also an operation
     // that folds with tensor.cast consumer (like this pattern), the cast will
     // continue to propagate as far up the stack as it can go.
-    OpOperand *outOperand = linalgOp.getOutputOperand(resultNumber);
+    OpOperand *outOperand = linalgOp.getDpsInitOperand(resultNumber);
     Value newOperand =
         rewriter.create<tensor::CastOp>(loc, resultType, outOperand->get());
-    SmallVector<Value> newOperands{linalgOp.getInputOperands()};
-    SmallVector<Value> outputOperands{linalgOp.getOutputOperands()};
+    SmallVector<Value> newOperands{linalgOp.getDpsInputOperands()};
+    SmallVector<Value> outputOperands{linalgOp.getDpsInitOperands()};
     outputOperands[resultNumber] = newOperand;
     newOperands.append(outputOperands.begin(), outputOperands.end());
 
     SmallVector<Type> resultTypes(linalgOp->result_type_begin(),
                                   linalgOp->result_type_end());
     resultTypes[resultNumber] = resultType;
     Operation *newOp = linalgOp.clone(rewriter, loc, resultTypes, newOperands);
 
static void createNewOperandWithStaticSizes(
     SmallVector<Value> &newOperands, SmallVector<Type> &resultTypes,
     bool &changeNeeded) {
   Value src = opOperand->get();
   newOperands.push_back(src);
   if (linalgOp.isScalar(opOperand))
     return;
   auto sourceType = src.getType().cast<RankedTensorType>();
   Type resultType = sourceType;
-  if (sourceType.hasStaticShape() && linalgOp.isOutput(opOperand)) {
+  if (sourceType.hasStaticShape() && linalgOp.isDpsInit(opOperand)) {
     resultTypes.push_back(resultType);
     return;
   }
   ArrayRef<int64_t> sourceShape = sourceType.getShape();
   AffineMap sourceMap = linalgOp.getMatchingIndexingMap(opOperand);
   SmallVector<int64_t> newShape;
   // If operand is updated with new shape, `newOperandNeeded` will be
   // true.
static void createNewOperandWithStaticSizes(
   if (newOperandNeeded) {
     changeNeeded = true;
     // Get the new operand value given its size and element type by
     // casting it.
     Value newOperand = rewriter.create<tensor::CastOp>(loc, resultType, src);
     unsigned index = opOperand->getOperandNumber();
     newOperands[index] = newOperand;
   }
-  if (linalgOp.isOutput(opOperand))
+  if (linalgOp.isDpsInit(opOperand))
     resultTypes.push_back(resultType);
 }
 
 /// Static shapes for the operands can be inferred if any one of the operands
 /// have a static shape. This can be done by referring to the affine dim
 /// expressions for the operand.
 struct InferStaticShapeOfOperands : public OpInterfaceRewritePattern<LinalgOp> {
   using OpInterfaceRewritePattern<LinalgOp>::OpInterfaceRewritePattern;
LogicalResult matchAndRewrite(LinalgOp linalgOp,
 
     SmallVector<Value> newOperands;
     SmallVector<Type> resultTypes;
 
     // `changeNeeded` is `false` if the operands of `linalgOp` require no
     // change in their types.
     bool changeNeeded = false;
     newOperands.reserve(linalgOp->getNumOperands());
-    resultTypes.reserve(linalgOp.getNumOutputs());
+    resultTypes.reserve(linalgOp.getNumDpsInits());
 
     // Iterate over all the operands and update the static sizes.
     for (OpOperand &opOperand : linalgOp->getOpOperands()) {
       createNewOperandWithStaticSizes(loc, rewriter, &opOperand,
                                       affineExprToSize, linalgOp, newOperands,
                                       resultTypes, changeNeeded);
     }
 

mlir/lib/Dialect/Linalg/Transforms/BubbleUpExtractSlice.cpp

LogicalResult matchAndRewrite(tensor::ExtractSliceOp sliceOp,
 
     // TODO: we might relax this if we want heuristics to detect that all uses
     // are small portion of the output.
     if (!linalgOp->hasOneUse()) {
       return rewriter.notifyMatchFailure(sliceOp,
                                          "expected single use of linalg op");
     }
 
-    if (linalgOp.getNumOutputs() != 1) {
+    if (linalgOp.getNumDpsInits() != 1) {
       return rewriter.notifyMatchFailure(sliceOp,
                                          "expected single output of linalg op");
     }
 
     if (!linalgOp.hasTensorSemantics()) {
       return rewriter.notifyMatchFailure(sliceOp,
                                          "expected tensor of linalg op");
     }
 
     if (!sliceOp.hasUnitStride())
       return rewriter.notifyMatchFailure(sliceOp, "expected unit stride");
 
     if (sliceOp.getType().getRank() != sliceOp.getSourceType().getRank()) {
       return rewriter.notifyMatchFailure(sliceOp, "expected no rank reduction");
     }
 
-    OpOperand *outOperand = linalgOp.getOutputOperand(0);
+    OpOperand *outOperand = linalgOp.getDpsInitOperand(0);
     AffineMap indexingMap = linalgOp.getMatchingIndexingMap(outOperand);
     if (!indexingMap.isProjectedPermutation()) {
       return rewriter.notifyMatchFailure(
           sliceOp, "expected a projected permutation for output");
     }
 
     auto linalgLoc = linalgOp.getLoc();
     SmallVector<OpFoldResult> allShapeSizes =
LogicalResult matchAndRewrite(tensor::ExtractSliceOp sliceOp,
 
     SmallVector<Value> valuesToTile = linalgOp->getOperands();
     SmallVector<Value> tiledOperands =
         makeTiledShapes(rewriter, linalgLoc, linalgOp, valuesToTile,
                         tileOffsets, tileSizes, sizeBounds,
                         /*omitPartialTileCheck=*/true);
 
     SmallVector<Type, 4> resultTensorTypes;
-    for (OpOperand *opOperand : linalgOp.getOutputOperands())
+    for (OpOperand *opOperand : linalgOp.getDpsInitOperands())
       resultTensorTypes.push_back(
           tiledOperands[opOperand->getOperandNumber()].getType());
 
     Operation *newOp =
         linalgOp.clone(rewriter, linalgLoc, resultTensorTypes, tiledOperands);
     rewriter.replaceOp(sliceOp, newOp->getResults());
     return success();
   }
 };
 } // namespace
 
 void mlir::linalg::populateBubbleUpExtractSliceOpPatterns(
     RewritePatternSet &patterns) {
   auto *context = patterns.getContext();
   patterns.add<BubbleUpExtractSliceOpPattern>(context);
 }

mlir/lib/Dialect/Linalg/Transforms/BufferizableOpInterfaceImpl.cpp

bufferizeDestinationStyleOpInterface(RewriterBase &rewriter,
 
   // Ensure op has only tensors. Allow mixed tensor-buffer mode on a per-need
   // basis.
   if (!op.hasTensorSemantics())
     return op->emitError() << "op does not have tensor semantics";
 
   // New input operands for the cloned op.
   SmallVector<Value> newInputBuffers;
-  newInputBuffers.reserve(op.getNumInputs());
-  for (OpOperand *opOperand : op.getInputOperands()) {
+  newInputBuffers.reserve(op.getNumDpsInputs());
+  for (OpOperand *opOperand : op.getDpsInputOperands()) {
     if (op.isScalar(opOperand)) {
       newInputBuffers.push_back(opOperand->get());
       continue;
     }
     FailureOr<Value> buffer = getBuffer(rewriter, opOperand->get(), options);
     if (failed(buffer))
       return failure();
     newInputBuffers.push_back(*buffer);
   }
 
   // New output operands for the cloned op.
   SmallVector<Value> newOutputBuffers;
   for (OpResult opResult : op->getOpResults()) {
-    OpOperand *opOperand = op.getOutputOperand(opResult.getResultNumber());
+    OpOperand *opOperand = op.getDpsInitOperand(opResult.getResultNumber());
     FailureOr<Value> resultBuffer =
         getBuffer(rewriter, opOperand->get(), options);
     if (failed(resultBuffer))
       return failure();
     newOutputBuffers.push_back(*resultBuffer);
   }
 
   // Merge input/output operands.
struct LinalgOpInterface
   }
 
   SmallVector<OpOperand *>
   getAliasingOpOperand(Operation *op, OpResult opResult,
                        const AnalysisState &state) const {
     auto genericOp = cast<DestinationStyleOpInterface>(op);
 
     // The i-th OpResult may alias with the i-th "out" tensor.
-    return {genericOp.getOutputOperand(opResult.getResultNumber())};
+    return {genericOp.getDpsInitOperand(opResult.getResultNumber())};
   }
 
   SmallVector<OpResult> getAliasingOpResult(Operation *op, OpOperand &opOperand,
                                             const AnalysisState &state) const {
     auto genericOp = cast<DestinationStyleOpInterface>(op);
 
     // The i-th "out" tensor may alias with the i-th OpResult.
-    if (genericOp.isOutput(&opOperand))
+    if (genericOp.isDpsInit(&opOperand))
       return {genericOp.getTiedOpResult(&opOperand)};
     return {};
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const AnalysisState &state) const {
     return BufferRelation::Equivalent;
   }

mlir/lib/Dialect/Linalg/Transforms/ConstantFold.cpp

FoldConstantBase(MLIRContext *context, const ControlFusionFn &controlFn,
       : OpRewritePattern<GenericOp>(context, benefit), controlFn(controlFn) {}
 
   LogicalResult matchAndRewrite(GenericOp genericOp,
                                 PatternRewriter &rewriter) const override {
     if (genericOp.hasBufferSemantics())
       return failure();
 
     // Only support ops generating one output for now.
-    if (genericOp.getNumOutputs() != 1)
+    if (genericOp.getNumDpsInits() != 1)
       return failure();
 
     auto outputType = genericOp.getResultTypes().front().dyn_cast<ShapedType>();
     // Require the output types to be static given that we are generating
     // constants.
     if (!outputType || !outputType.hasStaticShape())
       return failure();
 
LogicalResult matchAndRewrite(GenericOp genericOp,
     // it simplifies input/output access greatly: we can do the data shuffling
     // entirely in the compiler, without needing to turn all indices into
     // Values, and then do affine apply on them, and then match back the
     // constant again.
     if (!llvm::all_of(genericOp.getIndexingMapsArray(),
                       [](AffineMap map) { return map.isPermutation(); }))
       return failure();
 
-    for (OpOperand *operand : genericOp.getOutputOperands()) {
+    for (OpOperand *operand : genericOp.getDpsInitOperands()) {
       if (genericOp.payloadUsesValueFromOperand(operand))
         return failure();
     }
 
     // Further check the indexing maps are okay for the ConcreteType.
     if (!static_cast<const ConcreteType *>(this)->matchIndexingMaps(genericOp))
       return failure();
 
     // Defer to the concrete type to check the region and discover the
     // computation inside.
     RegionComputationFn computeFn =
         static_cast<const ConcreteType *>(this)->getRegionComputeFn(genericOp);
     if (!computeFn)
       return failure();
 
     // All inputs should be constants.
-    int numInputs = genericOp.getNumInputs();
+    int numInputs = genericOp.getNumDpsInputs();
     SmallVector<DenseIntOrFPElementsAttr> inputValues(numInputs);
-    for (const auto &en : llvm::enumerate(genericOp.getInputOperands())) {
+    for (const auto &en : llvm::enumerate(genericOp.getDpsInputOperands())) {
       if (!matchPattern(en.value()->get(),
                         m_Constant(&inputValues[en.index()])))
         return failure();
     }
 
     // Identified this as a potential candidate for folding. Now check the
     // policy to see whether we are allowed to proceed.
-    for (OpOperand *operand : genericOp.getInputOperands()) {
+    for (OpOperand *operand : genericOp.getDpsInputOperands()) {
       if (!controlFn(operand))
         return failure();
     }
 
     auto linalgOp = cast<LinalgOp>(genericOp.getOperation());
     SmallVector<int64_t, 4> loopBounds = linalgOp.computeStaticLoopSizes();
     int64_t numElements = outputType.getNumElements();
 

mlir/lib/Dialect/Linalg/Transforms/DecomposeLinalgOps.cpp

for (auto *user : scalarOpResult.getUsers()) {
             break;
           }
         }
         assert(resultNumber && "unable to find use of a value in its user");
         break;
       }
     }
     if (resultNumber) {
-      newInitValues.push_back(genericOp.getOutputOperand(*resultNumber)->get());
+      newInitValues.push_back(
+          genericOp.getDpsInitOperand(*resultNumber)->get());
       OpResult result = genericOp.getResult(*resultNumber).cast<OpResult>();
       newResultTypes.push_back(result.getType());
       peeledGenericOpIndexingMaps.push_back(
           genericOp.getIndexingMapMatchingResult(result));
       continue;
     }
 
     // Fall back path, use an `init_tensor` and identity indexing map.
DecomposeLinalgOp::createResidualGenericOp(GenericOp genericOp,
   for (auto resultNum :
        llvm::seq<unsigned>(origNumResults, peeledGenericOpNumResults))
     extraIns.push_back(peeledGenericOp->getResult(resultNum));
   residualGenericOpOperands.append(extraIns);
 
   /// Add indexing maps for the newly added operands. Use the same map
   /// as those used for the new results of the peeledGenericOp.
   auto indexingMaps = llvm::to_vector(
-      llvm::map_range(genericOp.getInputOperands(), [&](OpOperand *operand) {
+      llvm::map_range(genericOp.getDpsInputOperands(), [&](OpOperand *operand) {
         return genericOp.getMatchingIndexingMap(operand);
       }));
   for (auto resultNum :
        llvm::seq<unsigned>(origNumResults, peeledGenericOpNumResults)) {
     OpResult result = peeledGenericOp.getResult(resultNum).cast<OpResult>();
     indexingMaps.push_back(
         peeledGenericOp.getIndexingMapMatchingResult(result));
   }
-  for (OpOperand *outOperand : genericOp.getOutputOperands())
+  for (OpOperand *outOperand : genericOp.getDpsInitOperands())
     indexingMaps.push_back(genericOp.getMatchingIndexingMap(outOperand));
 
   auto indexingMapAttr = rewriter.getAffineMapArrayAttr(indexingMaps);
   return rewriter.create<GenericOp>(
       genericOp->getLoc(), genericOp->getResultTypes(),
       residualGenericOpOperands, genericOp.getOutputs(), indexingMapAttr,
       genericOp.getIteratorTypes(), /*doc=*/nullptr, /*libraryCall=*/nullptr,
       [](OpBuilder, Location, ValueRange) {});
DecomposeLinalgOp::matchAndRewrite(GenericOp genericOp,
   // TODO: this could be generalized to handle `linalg.generic` with buffer
   // operands too but requires allocation for intermediates. Punt on this for
   // now.
   if (!genericOp.hasTensorSemantics()) {
     return rewriter.notifyMatchFailure(
         genericOp, "only operations with tensor semantics are handled");
   }
 
-  if (llvm::any_of(genericOp.getOutputOperands(), [&](OpOperand *outOperand) {
+  if (llvm::any_of(genericOp.getDpsInitOperands(), [&](OpOperand *outOperand) {
         return !genericOp.getMatchingIndexingMap(outOperand).isPermutation();
       })) {
     return rewriter.notifyMatchFailure(
         genericOp, "unhandled decomposition of generic op with out operand not "
                    "accessed using a permutation");
   }
 
   /// If the op has only a single statement (apart from the yield), do nothing.
auto *yieldOp = residualGenericOpBody->getTerminator();
     yieldedVals.append(llvm::to_vector(
         llvm::map_range(peeledScalarOperation->getResults(),
                         [](OpResult opr) -> Value { return opr; })));
     rewriter.create<YieldOp>(genericOp.getLoc(), yieldedVals);
   }
 
   /// In the split operations, replace block arguments uses that refer to
   /// original operation to the block arguments of the newly created operation.
-  unsigned origNumInputs = genericOp.getNumInputs();
+  unsigned origNumInputs = genericOp.getNumDpsInputs();
   for (const auto &inputBlockArg :
        llvm::enumerate(genericOp.getBody()->getArguments())) {
     Value residualOpReplacementArg =
         residualGenericOpBody->getArgument(inputBlockArg.index());
     inputBlockArg.value().replaceUsesWithIf(
         residualOpReplacementArg, [&](OpOperand &use) {
           return use.getOwner()->getBlock() == residualGenericOpBody;
         });

mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp

LogicalResult matchAndRewrite(GenericOp genericOp,
     SmallVector<Value, 4> newInputs = insertReshapes(genericOp.getInputs());
     SmallVector<Value, 4> newOutputs = insertReshapes(genericOp.getOutputs());
 
     // If any result type changes, insert a reshape to convert from the original
     // type to the new type.
     SmallVector<Type, 4> resultTypes;
     resultTypes.reserve(genericOp.getNumResults());
     for (unsigned i : llvm::seq<unsigned>(0, genericOp.getNumResults()))
-      resultTypes.push_back(newInputOutputTypes[i + genericOp.getNumInputs()]);
+      resultTypes.push_back(
+          newInputOutputTypes[i + genericOp.getNumDpsInputs()]);
     GenericOp replacementOp = rewriter.create<GenericOp>(
         loc, resultTypes, newInputs, newOutputs, newIndexingMaps,
         genericOp.getIteratorTypesArray());
     rewriter.inlineRegionBefore(genericOp.getRegion(),
                                 replacementOp.getRegion(),
                                 replacementOp.getRegion().begin());
 
     // If any result tensor has a modified shape, then add reshape to recover
     // the original shape.
     SmallVector<Value, 4> resultReplacements;
     for (const auto &result : llvm::enumerate(replacementOp.getResults())) {
-      unsigned index = result.index() + replacementOp.getNumInputs();
+      unsigned index = result.index() + replacementOp.getNumDpsInputs();
       auto origResultType = genericOp.getResult(result.index()).getType();
 
       auto newResult = maybeExpand(result.value(), origResultType,
                                    reassociationMaps[index], loc, rewriter);
       assert(newResult &&
              "unexpected output type other than ranked MemRef or Tensor");
       resultReplacements.push_back(newResult);
     }

mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp

bool mlir::linalg::areElementwiseOpsFusable(OpOperand *fusedOperand) {
 
   // Verify that
   // - the producer has all "parallel" iterator type.
   if (producer.getNumParallelLoops() != producer.getNumLoops())
     return false;
 
   // Only allow fusing the producer of an input operand for now.
   // TODO: allow fusing the producer of an output operand.
-  if (!consumer.isInput(fusedOperand))
+  if (!consumer.isDpsInput(fusedOperand))
     return false;
 
   // Get the consumer index map. The number of results of the consumer index
   // map must match the number of loops of the producer.
   AffineMap consumerIndexMap = consumer.getMatchingIndexingMap(fusedOperand);
   if (consumerIndexMap.getNumResults() != producer.getNumLoops())
     return false;
 
   // Finally the index_map for the result must be invertible. For now just
   // verify it is a permutation.
   AffineMap producerResultIndexMap =
-      producer.getMatchingIndexingMap(producer.getOutputOperand(0));
+      producer.getMatchingIndexingMap(producer.getDpsInitOperand(0));
   if (!producerResultIndexMap.isPermutation())
     return false;
 
   // Ensure that the fusion does not remove size information required to
   // get the loop bounds. For non-reduction generics, this is trivially the
   // case due to the output operand. For reductions, we need to check that after
   // the fusion, each loop dimension has at least one input that defines it.
   if ((consumer.getNumReductionLoops())) {
for (auto pair :
          llvm::zip(consumer->getOperands(), consumer.getIndexingMapsArray())) {
       Value operand = std::get<0>(pair);
       if (operand == fusedOperand->get())
         continue;
       AffineMap operandMap = std::get<1>(pair);
       addToCoveredDims(operandMap);
     }
 
-    for (OpOperand *operand : producer.getInputOperands()) {
+    for (OpOperand *operand : producer.getDpsInputOperands()) {
       AffineMap newIndexingMap =
           getIndexingMapOfProducerOperandsInCoordinatesOfFusedOp(
               operand, producerResultIndexMap, consumerIndexMap);
       addToCoveredDims(newIndexingMap);
     }
     if (!coveredDims.all())
       return false;
   }
for (IndexOp indexOp :
          llvm::make_early_inc_range(producerBlock.getOps<IndexOp>())) {
       Value newIndex = rewriter.create<mlir::AffineApplyOp>(
           producer.getLoc(),
           consumerToProducerLoopsMap.getSubMap(indexOp.getDim()), fusedIndices);
       mapper.map(indexOp.getResult(), newIndex);
     }
   }
   // TODO: allow fusing the producer of an output operand.
-  assert(consumer.isInput(fusedOperand) &&
+  assert(consumer.isDpsInput(fusedOperand) &&
          "expected producer of input operand");
   // 3. Consumer input operands up to consumerIdx (exclusive).
   for (BlockArgument bbArg : consumerBlock.getArguments().take_front(
            fusedOperand->getOperandNumber())) // input assumption.
     mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType(), bbArg.getLoc()));
 
   // Replacing consumerIdx requires getting the cloned, yielded, value from
   // the (cloned) producer block. This happens in step 9.
 
   // 4. Splice in producer's input operands.
   for (BlockArgument bbArg :
-       producerBlock.getArguments().take_front(producer.getNumInputs()))
+       producerBlock.getArguments().take_front(producer.getNumDpsInputs()))
     mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType(), bbArg.getLoc()));
 
   // 5. Remaining consumer's input operands (drop past index `consumerIdx`).
   for (BlockArgument bbArg :
        consumerBlock.getArguments()
-           .take_front(consumer.getNumInputs())
+           .take_front(consumer.getNumDpsInputs())
            .drop_front(fusedOperand->getOperandNumber() + 1))
     mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType(), bbArg.getLoc()));
 
   // 6. All of the producer's output operands
   for (BlockArgument bbArg :
-       producerBlock.getArguments().take_back(producer.getNumOutputs()))
+       producerBlock.getArguments().take_back(producer.getNumDpsInits()))
     mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType(), bbArg.getLoc()));
 
   // 7. All of consumer's output operands.
   for (BlockArgument bbArg :
-       consumerBlock.getArguments().take_back(consumer.getNumOutputs()))
+       consumerBlock.getArguments().take_back(consumer.getNumDpsInits()))
     mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType(), bbArg.getLoc()));
 
   // 8. Clone all producer operations except for the yield and index operations
   // to the fused operation.
   for (auto &op : producerBlock.without_terminator()) {
     if (!isa<IndexOp>(op))
       rewriter.clone(op, mapper);
   }

 mlir::linalg::fuseElementwiseOps(RewriterBase &rewriter,
                                  OpOperand *fusedOperand) {
   assert(areElementwiseOpsFusable(fusedOperand) &&
          "expected elementwise operation pre-conditions to pass");
   auto producerResult = fusedOperand->get().cast<OpResult>();
   auto producer = cast<GenericOp>(producerResult.getOwner());
   auto consumer = cast<GenericOp>(fusedOperand->getOwner());
   // TODO: allow fusing the producer of an output operand.
-  assert(consumer.isInput(fusedOperand) &&
+  assert(consumer.isDpsInput(fusedOperand) &&
          "expected producer of input operand");
 
   // Compute the fused operands list and indexing maps.
   SmallVector<Value> fusedInputOperands, fusedOutputOperands;
   SmallVector<Type> fusedResultTypes;
   SmallVector<AffineMap> fusedIndexMaps;
-  fusedInputOperands.reserve(producer.getNumInputs() + consumer.getNumInputs());
-  fusedOutputOperands.reserve(producer.getNumOutputs() +
-                              consumer.getNumOutputs());
-  fusedResultTypes.reserve(producer.getNumOutputs() + consumer.getNumOutputs());
+  fusedInputOperands.reserve(producer.getNumDpsInputs() +
+                             consumer.getNumDpsInputs());
+  fusedOutputOperands.reserve(producer.getNumDpsInits() +
+                              consumer.getNumDpsInits());
+  fusedResultTypes.reserve(producer.getNumDpsInits() +
+                           consumer.getNumDpsInits());
   fusedIndexMaps.reserve(producer->getNumOperands() +
                          consumer->getNumOperands());
   // In the following, numbering matches that of `generateFusedTensorOpRegion`.
   // 3. Consumer input operands/maps up to consumerIdx (exclusive).
-  auto consumerInputs = consumer.getInputOperands();
+  auto consumerInputs = consumer.getDpsInputOperands();
   auto *it = llvm::find_if(consumerInputs, [&](OpOperand *operand) {
     return operand == fusedOperand;
   });
   assert(it != consumerInputs.end() && "expected to find the consumer operand");
   for (OpOperand *opOperand : llvm::make_range(consumerInputs.begin(), it)) {
     fusedInputOperands.push_back(opOperand->get());
     fusedIndexMaps.push_back(consumer.getMatchingIndexingMap(opOperand));
   }
   // 4. Splice in producer's input operands/maps.
   AffineMap producerResultIndexMap =
       producer.getIndexingMapMatchingResult(producerResult);
-  for (OpOperand *opOperand : producer.getInputOperands()) {
+  for (OpOperand *opOperand : producer.getDpsInputOperands()) {
     fusedInputOperands.push_back(opOperand->get());
     // Compute indexing maps for the producer args in the fused operation.
     AffineMap map = getIndexingMapOfProducerOperandsInCoordinatesOfFusedOp(
         opOperand, producerResultIndexMap,
         consumer.getMatchingIndexingMap(fusedOperand));
     fusedIndexMaps.push_back(map);
   }
   // 5. Remaining consumer's input operands/maps (drop past index
   // `consumerIdx`).
   for (OpOperand *opOperand :
        llvm::make_range(std::next(it), consumerInputs.end())) {
     fusedInputOperands.push_back(opOperand->get());
     fusedIndexMaps.push_back(consumer.getMatchingIndexingMap(opOperand));
   }
 
   // 6. Collect all of the producer outputs.
-  for (OpOperand *opOperand : producer.getOutputOperands()) {
+  for (OpOperand *opOperand : producer.getDpsInitOperands()) {
     fusedOutputOperands.push_back(opOperand->get());
     AffineMap map = getIndexingMapOfProducerOperandsInCoordinatesOfFusedOp(
         opOperand, producerResultIndexMap,
         consumer.getMatchingIndexingMap(fusedOperand));
     fusedIndexMaps.push_back(map);
     fusedResultTypes.push_back(opOperand->get().getType());
   }
 
   // 7. All of consumer's output operands (skip operands: added by the builder).
-  for (OpOperand *opOperand : consumer.getOutputOperands()) {
+  for (OpOperand *opOperand : consumer.getDpsInitOperands()) {
     fusedOutputOperands.push_back(opOperand->get());
     fusedIndexMaps.push_back(consumer.getMatchingIndexingMap(opOperand));
     fusedResultTypes.push_back(opOperand->get().getType());
   }
 
   // Generate the fused op.
   auto fusedOp = rewriter.create<GenericOp>(
       consumer.getLoc(), fusedResultTypes, fusedInputOperands,
SmallVector<AffineMap, 4> expandedOpIndexingMaps = llvm::to_vector<4>(
         return getIndexingMapInExpandedOp(rewriter, m, expansionInfo);
       }));
 
   // Set insertion point to the generic op.
   OpBuilder::InsertionGuard g(rewriter);
   rewriter.setInsertionPoint(genericOp);
 
   SmallVector<Value> expandedOpOperands;
-  expandedOpOperands.reserve(genericOp.getNumInputs());
-  for (OpOperand *opOperand : genericOp.getInputOperands()) {
+  expandedOpOperands.reserve(genericOp.getNumDpsInputs());
+  for (OpOperand *opOperand : genericOp.getDpsInputOperands()) {
     if (opOperand == fusableOpOperand) {
       expandedOpOperands.push_back(isExpanding ? expandingReshapeOp.getSrc()
                                                : collapsingReshapeOp.getSrc());
       continue;
     }
     if (auto opOperandType =
             opOperand->get().getType().dyn_cast<RankedTensorType>()) {
       AffineMap indexingMap = genericOp.getMatchingIndexingMap(opOperand);
if (auto opOperandType =
         continue;
       }
     }
     expandedOpOperands.push_back(opOperand->get());
   }
 
   Location loc = genericOp.getLoc();
   SmallVector<Value> outputs;
-  for (OpOperand *opOperand : genericOp.getOutputOperands()) {
+  for (OpOperand *opOperand : genericOp.getDpsInitOperands()) {
     AffineMap indexingMap = genericOp.getMatchingIndexingMap(opOperand);
     auto opOperandType = opOperand->get().getType().cast<RankedTensorType>();
     RankedTensorType expandedOutputType =
         getExpandedType(opOperandType, indexingMap, expansionInfo);
     if (expandedOutputType != opOperand->get().getType()) {
       SmallVector<ReassociationIndices> reassociation =
           getReassociationForExpansion(indexingMap, expansionInfo);
       if (failed(reshapeLikeShapesAreCompatible(
fuseWithReshapeByExpansion(GenericOp genericOp, Operation *reshapeOp,
   // reshape folded into its consumer.
   SmallVector<Value> resultVals;
   for (OpResult opResult : genericOp->getOpResults()) {
     int64_t resultNumber = opResult.getResultNumber();
     if (resultTypes[resultNumber] != opResult.getType()) {
       SmallVector<ReassociationIndices> reassociation =
           getReassociationForExpansion(
               genericOp.getMatchingIndexingMap(
-                  genericOp.getOutputOperand(resultNumber)),
+                  genericOp.getDpsInitOperand(resultNumber)),
               expansionInfo);
       resultVals.push_back(rewriter.create<tensor::CollapseShapeOp>(
           genericOp.getLoc(), opResult.getType(),
           fusedOp->getResult(resultNumber), reassociation));
     } else {
       resultVals.push_back(fusedOp->getResult(resultNumber));
     }
   }
public:
   FoldWithProducerReshapeOpByExpansion(MLIRContext *context,
                                        ControlFusionFn foldReshapes,
                                        PatternBenefit benefit = 1)
       : OpRewritePattern<GenericOp>(context, benefit),
         controlFoldingReshapes(std::move(foldReshapes)) {}
 
   LogicalResult matchAndRewrite(GenericOp genericOp,
                                 PatternRewriter &rewriter) const override {
-    for (OpOperand *opOperand : genericOp.getInputOperands()) {
+    for (OpOperand *opOperand : genericOp.getDpsInputOperands()) {
       tensor::CollapseShapeOp reshapeOp =
           opOperand->get().getDefiningOp<tensor::CollapseShapeOp>();
       if (!reshapeOp)
         continue;
       // Fold only if
       // - The tensor reshape op is folding.
       // - All constraints of fusing with reshape by expansion are met.
       if (!isFusableWithReshapeByDimExpansion(genericOp, opOperand) ||
LogicalResult matchAndRewrite(tensor::ExpandShapeOp reshapeOp,
     auto producer = dyn_cast<GenericOp>(producerResult.getOwner());
     if (!producer) {
       return rewriter.notifyMatchFailure(reshapeOp,
                                          "producer not a generic op");
     }
 
     if (!isFusableWithReshapeByDimExpansion(
             producer,
-            producer.getOutputOperand(producerResult.getResultNumber()))) {
+            producer.getDpsInitOperand(producerResult.getResultNumber()))) {
       return rewriter.notifyMatchFailure(
           reshapeOp, "failed preconditions of fusion with producer generic op");
     }
 
     if (!controlFoldingReshapes(&reshapeOp->getOpOperand(0))) {
       return rewriter.notifyMatchFailure(reshapeOp,
                                          "fusion blocked by control function");
     }
 
     Optional<SmallVector<Value>> replacementValues = fuseWithReshapeByExpansion(
         producer, reshapeOp,
-        producer.getOutputOperand(producerResult.getResultNumber()), rewriter);
+        producer.getDpsInitOperand(producerResult.getResultNumber()), rewriter);
     if (!replacementValues) {
       return rewriter.notifyMatchFailure(reshapeOp,
                                          "fusion by expansion failed");
     }
 
     // Find the replacement for the reshape op. Since the replacements have the
     // same type as the returns of the original generic op, the consumer reshape
     // op can be replaced by the source of the collapse_shape op that defines

 // the reshape cannot be fused with the generic op by collapsing the op
 // dimensions since the indexing maps will have to contain mods and divs
 // to preserve the accesses pattern. When no dimensions of the iteration
 // space are collapsable and empty vector is returned.
 static SmallVector<ReassociationIndices>
 getCollapsableIterationSpaceDims(GenericOp genericOp, OpOperand *fusableOperand,
                                  ArrayRef<ReassociationIndices> reassociation) {
   // Some basic checks for this fusion to be valid.
-  if (!genericOp.hasTensorSemantics() || genericOp.getNumOutputs() != 1)
+  if (!genericOp.hasTensorSemantics() || genericOp.getNumDpsInits() != 1)
     return {};
 
   if (!llvm::all_of(genericOp.getIndexingMapsArray(), [](AffineMap map) {
         return map.isProjectedPermutation();
       })) {
     return {};
   }
 
static FailureOr<SmallVector<Value>> collapseGenericOpIterationDims(
   auto indexingMaps = llvm::to_vector(
       llvm::map_range(genericOp.getIndexingMapsArray(), [&](AffineMap map) {
         return getCollapsedOpIndexingMap(map, collapsingInfo);
       }));
 
   Location loc = genericOp->getLoc();
 
   // Get the input operands.
-  auto inputOperands = llvm::to_vector(
-      llvm::map_range(genericOp.getInputOperands(), [&](OpOperand *opOperand) {
+  auto inputOperands = llvm::to_vector(llvm::map_range(
+      genericOp.getDpsInputOperands(), [&](OpOperand *opOperand) {
         return getCollapsedOpOperand(loc, genericOp, opOperand, collapsingInfo,
                                      rewriter);
       }));
 
   // Get the output operands and result types.
   SmallVector<Type> resultTypes;
   SmallVector<Value> outputOperands;
-  resultTypes.reserve(genericOp.getNumOutputs());
-  outputOperands.reserve(genericOp.getNumOutputs());
-  for (OpOperand *output : genericOp.getOutputOperands()) {
+  resultTypes.reserve(genericOp.getNumDpsInits());
+  outputOperands.reserve(genericOp.getNumDpsInits());
+  for (OpOperand *output : genericOp.getDpsInitOperands()) {
     Value newOutput =
         getCollapsedOpOperand(loc, genericOp, output, collapsingInfo, rewriter);
     outputOperands.push_back(newOutput);
     resultTypes.push_back(newOutput.getType());
   }
 
   // Create the generic op.
   auto collapsedGenericOp = rewriter.create<linalg::GenericOp>(

 public:
   FoldScalarOrSplatConstant(MLIRContext *context, PatternBenefit benefit = 1)
       : OpRewritePattern<GenericOp>(context, benefit) {}
 
   LogicalResult matchAndRewrite(GenericOp genericOp,
                                 PatternRewriter &rewriter) const override {
     if (!genericOp.hasTensorSemantics())
       return failure();
-    for (OpOperand *opOperand : genericOp.getInputOperands()) {
+    for (OpOperand *opOperand : genericOp.getDpsInputOperands()) {
       Operation *def = opOperand->get().getDefiningOp();
       TypedAttr constantAttr;
       auto isScalarOrSplatConstantOp = [&constantAttr](Operation *def) -> bool {
         {
           DenseElementsAttr splatAttr;
           if (matchPattern(def, m_Constant<DenseElementsAttr>(&splatAttr)) &&
               splatAttr.isSplat() &&
               splatAttr.getType().getElementType().isIntOrFloat()) {
for (OpOperand *opOperand : genericOp.getDpsInputOperands()) {
 
       // The operands and the indexing_maps of the fused operation the same as
       // the operands and indexing_maps of the generic operations with the
       // values at the constant index dropped.
       SmallVector<AffineMap> fusedIndexMaps;
       SmallVector<Value> fusedOperands;
       SmallVector<Location> fusedLocs{genericOp.getLoc()};
       fusedIndexMaps.reserve(genericOp->getNumOperands());
-      fusedOperands.reserve(genericOp.getNumInputs());
-      fusedLocs.reserve(fusedLocs.size() + genericOp.getNumInputs());
-      for (OpOperand *inputOperand : genericOp.getInputOperands()) {
+      fusedOperands.reserve(genericOp.getNumDpsInputs());
+      fusedLocs.reserve(fusedLocs.size() + genericOp.getNumDpsInputs());
+      for (OpOperand *inputOperand : genericOp.getDpsInputOperands()) {
         if (inputOperand == opOperand)
           continue;
         Value inputValue = inputOperand->get();
         fusedIndexMaps.push_back(
             genericOp.getMatchingIndexingMap(inputOperand));
         fusedOperands.push_back(inputValue);
         fusedLocs.push_back(inputValue.getLoc());
       }
-      for (OpOperand *outputOperand : genericOp.getOutputOperands())
+      for (OpOperand *outputOperand : genericOp.getDpsInitOperands())
         fusedIndexMaps.push_back(
             genericOp.getMatchingIndexingMap(outputOperand));
 
       // Check if the operation shapes to loops map is computable.
       if (!inversePermutation(concatAffineMaps(fusedIndexMaps))) {
         return rewriter.notifyMatchFailure(
             genericOp, "fused op loop bound computation failed");
       }

 struct RemoveOutsDependency : public OpRewritePattern<GenericOp> {
   using OpRewritePattern<GenericOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(GenericOp op,
                                 PatternRewriter &rewriter) const override {
     rewriter.startRootUpdate(op);
     bool modifiedOutput = false;
     Location loc = op.getLoc();
-    for (OpOperand *opOperand : op.getOutputOperands()) {
+    for (OpOperand *opOperand : op.getDpsInitOperands()) {
       if (!op.payloadUsesValueFromOperand(opOperand)) {
         Value operandVal = opOperand->get();
         auto operandType = operandVal.getType().dyn_cast<RankedTensorType>();
         if (!operandType)
           continue;
 
         // If outs is sparse, leave it to the sparse compiler.
         if (sparse_tensor::getSparseTensorEncoding(operandVal.getType()))
struct FoldFillWithGenericOp : public OpRewritePattern<GenericOp> {
   using OpRewritePattern<GenericOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(GenericOp genericOp,
                                 PatternRewriter &rewriter) const override {
     if (!genericOp.hasTensorSemantics())
       return failure();
     bool fillFound = false;
     Block &payload = genericOp.getRegion().front();
-    for (OpOperand *opOperand : genericOp.getInputOperands()) {
+    for (OpOperand *opOperand : genericOp.getDpsInputOperands()) {
       if (!genericOp.payloadUsesValueFromOperand(opOperand))
         continue;
       FillOp fillOp = opOperand->get().getDefiningOp<FillOp>();
       if (!fillOp)
         continue;
       fillFound = true;
       payload.getArgument(opOperand->getOperandNumber())
           .replaceAllUsesWith(fillOp.value());

mlir/lib/Dialect/Linalg/Transforms/FusePadOpWithLinalgProducer.cpp

LogicalResult matchAndRewrite(tensor::PadOp padOp,
     }
     SmallVector<OpFoldResult> strides(offsets.size(), rewriter.getIndexAttr(1));
     auto slice = rewriter.create<tensor::ExtractSliceOp>(
         loc, fillTensor.getResult(0), offsets, sizes, strides);
 
     // Clone the generic op.
     auto clonedOp =
         cast<linalg::GenericOp>(rewriter.clone(*linalgOp.getOperation()));
-    clonedOp.setOutputOperand(resultNumber, slice.getResult());
+    clonedOp.setDpsInitOperand(resultNumber, slice.getResult());
 
     // Insert it back into the result of the fill.
     rewriter.replaceOpWithNewOp<tensor::InsertSliceOp>(
         padOp, clonedOp.getResult(resultNumber), fillTensor.getResult(0),
         offsets, sizes, strides);
     return success();
   }
 };
 } // namespace
 
 void mlir::linalg::populateFuseTensorPadWithProducerLinalgOpPatterns(
     RewritePatternSet &patterns) {
   patterns.add<FusePadOp>(patterns.getContext());
 }

mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp

clonedShapes.append(makeTiledShapes(
       /**omitPartialTileCheck=*/false));
 
   // Iterate over the results in order.
   // Extract the subtensor type from the linearized range.
   // Since we do not enforce any canonicalizations on the fly, this is always
   // fully dynamic at construction time.
   SmallVector<Type, 4> resultTypes;
   resultTypes.reserve(producer->getNumResults());
-  for (OpOperand *operand : producer.getOutputOperands()) {
+  for (OpOperand *operand : producer.getDpsInitOperands()) {
     auto tensorType = operand->get().getType().dyn_cast<RankedTensorType>();
     if (!tensorType)
       continue;
     unsigned rank = tensorType.getRank();
     SmallVector<int64_t, 4> staticOffsetsVector(
         rank, ShapedType::kDynamicStrideOrOffset);
     SmallVector<int64_t, 4> staticSizesVector(rank, ShapedType::kDynamicSize);
     SmallVector<int64_t, 4> staticStridesVector(

 // Encode structural fusion safety preconditions.
 // Some of these will be lifted in the future with better analysis.
 static bool isStructurallyFusableProducer(LinalgOp producer, Value consumedView,
                                           LinalgOp consumer) {
   assert(producer.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
   assert(consumer.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
-  if (producer.getNumOutputs() != 1) {
+  if (producer.getNumDpsInits() != 1) {
     LLVM_DEBUG(llvm::dbgs() << "\nNot structurally fusable (multi-output)");
     return false;
   }
   // Only fuse when the producer block dominates.
   DominanceInfo dom(producer.getOperation());
   if (!dom.dominates(producer->getBlock(), consumer->getBlock())) {
     LLVM_DEBUG(
         llvm::dbgs()
if (consumerOpOperand.get().getParentBlock() ==
       producerOpResult.getParentBlock())
     return failure();
 
   // Insert fused `producer` just before `consumer`.
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(consumerOp);
   LLVM_DEBUG(llvm::dbgs() << "Fuse into consumer: " << *consumerOp << "\n");
   OpOperand *opOperand =
-      producerOp.getOutputOperand(producerOpResult.getResultNumber());
+      producerOp.getDpsInitOperand(producerOpResult.getResultNumber());
   LinalgOp fusedProducer =
       fuse(b, producerOp, producerOp.getMatchingIndexingMap(opOperand),
            consumerOpOperand);
 
   // Replace use.
   // Canonicalizations are not guaranteed to have happened before constructing
   // `fusedProducer`. In the tensor case this can result in temporary type
   // mismatches. Insert a `tensor.cast` op to propagate the transformation
   // invariant that types are compatible.
   Value def = fusedProducer->getResult(producerOpResult.getResultNumber());
   Type consumerType = consumerOpOperand.get().getType();
   if (consumerType != def.getType())
     def = b.create<tensor::CastOp>(fusedProducer.getLoc(), consumerType, def);
   consumerOpOperand.set(def);
   return FusionInfo{cast<LinalgOp>(producerOpResult.getOwner()), fusedProducer};
 }

mlir/lib/Dialect/Linalg/Transforms/FusionOnTensors.cpp

 static SmallVector<int64_t>
 getTiledProducerLoops(OpResult producerResult,
                       ArrayRef<int64_t> tiledSliceDimIndices) {
   LinalgOp producerOp = producerResult.getOwner();
 
   // Get the indexing map of the `producerOp` output operand that matches
   // ´producerResult´.
   AffineMap producerIndexingMap = producerOp.getMatchingIndexingMap(
-      producerOp.getOutputOperand(producerResult.getResultNumber()));
+      producerOp.getDpsInitOperand(producerResult.getResultNumber()));
 
   // Keep only the tiled result slice dimensions of `producerIndexingMap`.
   AffineMap tiledProducerIndexingSubMap =
       producerIndexingMap.getSubMap(SmallVector<unsigned>(
           tiledSliceDimIndices.begin(), tiledSliceDimIndices.end()));
 
   // Compute the producer loop indices mapped to the tiled result slice
   // dimensions. As the output indexing map of structured operations are
static LinalgOp getTiledProducer(OpBuilder &b, OpResult producerResult,
 
   // Output fusion has to update the iteration arguments of the tile loop nest.
   // In particular, the iteration argument of the outermost tile loop needs to
   // be set to the producer output instead of the producer result and `clonedOp`
   // shall use the existing `sliceOp` result instead of the tiled producer
   // output operand.
   if (iterArg) {
     OpOperand *outputOperand =
-        producerOp.getOutputOperand(producerResult.getResultNumber());
+        producerOp.getDpsInitOperand(producerResult.getResultNumber());
     iterArg->set(outputOperand->get());
     tiledOperands[outputOperand->getOperandNumber()] = sliceOp.getResult();
   }
 
   // Clone the producer using the tiled producer operands.
   TypeRange resultTypes = ValueRange(tiledOperands)
-                              .take_back(producerOp.getNumOutputs())
+                              .take_back(producerOp.getNumDpsInits())
                               .getTypes();
   LinalgOp clonedOp = producerOp.clone(b, loc, resultTypes, tiledOperands);
 
   // Shift all IndexOp results by the tile offset.
   offsetIndices(b, clonedOp, allIvs);
 
   return clonedOp;
 }

mlir/lib/Dialect/Linalg/Transforms/Generalization.cpp

static LogicalResult generalizeNamedOpPrecondition(LinalgOp linalgOp) {
   return success();
 }
 
 FailureOr<GenericOp> mlir::linalg::generalizeNamedOp(RewriterBase &rewriter,
                                                      LinalgOp linalgOp) {
   if (failed(generalizeNamedOpPrecondition(linalgOp)))
     return rewriter.notifyMatchFailure(linalgOp, "preconditions not met");
 
-  SmallVector<Value> inputs = linalgOp.getInputOperands();
-  SmallVector<Value> outputs = linalgOp.getOutputOperands();
+  SmallVector<Value> inputs = linalgOp.getDpsInputOperands();
+  SmallVector<Value> outputs = linalgOp.getDpsInitOperands();
   SmallVector<AffineMap> indexingMaps = linalgOp.getIndexingMapsArray();
   SmallVector<StringRef> iterators = linalgOp.getIteratorTypesArray();
   SmallVector<Type> resultTypes = linalgOp.hasTensorSemantics()
                                       ? TypeRange(ValueRange(outputs))
                                       : TypeRange{};
 
   // All named ops have a region attached that can be inlined.
   assert(linalgOp->getNumRegions() == 1 &&

mlir/lib/Dialect/Linalg/Transforms/HoistPadding.cpp

private:
   bool valid;
 };
 
 /// Return true if all uses of `padOp` are an input tensor of some
 /// LinalgOp.
 static bool isOnlyUsedAsInputOfLinalgOp(tensor::PadOp padOp) {
   for (OpOperand &use : padOp.getResult().getUses()) {
     auto linalgUser = dyn_cast<linalg::LinalgOp>(use.getOwner());
-    if (!linalgUser || !linalgUser.isInput(&use)) {
+    if (!linalgUser || !linalgUser.isDpsInput(&use)) {
       LLVM_DEBUG(DBGS() << "Found a use of " << *(padOp)
                         << "\nthat is not an input tensor of a LinalgOp, "
                         << "cannot hoist\n"
                         << *(use.getOwner()) << "\n");
       return false;
     }
   }
   return true;

mlir/lib/Dialect/Linalg/Transforms/InlineScalarOperands.cpp

struct InlineScalarOperands : public OpRewritePattern<GenericOp> {
   LogicalResult matchAndRewrite(GenericOp genericOp,
                                 PatternRewriter &rewriter) const override {
     if (!genericOp.hasTensorSemantics())
       return failure();
 
     SmallVector<size_t> scalarOperands;
     SmallVector<AffineMap> newIndexingMaps;
     SmallVector<Value> newOperands;
-    for (OpOperand *opOperand : genericOp.getInputOperands()) {
+    for (OpOperand *opOperand : genericOp.getDpsInputOperands()) {
       AffineMap map = genericOp.getMatchingIndexingMap(opOperand);
-      if (genericOp.isInput(opOperand) && map.isConstant()) {
+      if (genericOp.isDpsInput(opOperand) && map.isConstant()) {
         scalarOperands.emplace_back(opOperand->getOperandNumber());
       } else {
         newIndexingMaps.emplace_back(map);
         newOperands.emplace_back(opOperand->get());
       }
     }
 
     if (scalarOperands.empty())
       return failure();
 
-    for (OpOperand *opOperand : genericOp.getOutputOperands())
+    for (OpOperand *opOperand : genericOp.getDpsInitOperands())
       newIndexingMaps.emplace_back(genericOp.getMatchingIndexingMap(opOperand));
 
     Location loc = genericOp->getLoc();
     SmallVector<Value> outputOperands = genericOp.getOutputs();
     auto newOp = rewriter.create<GenericOp>(
         loc, genericOp->getResultTypes(), newOperands, outputOperands,
         newIndexingMaps, genericOp.getIteratorTypesArray());
     rewriter.cloneRegionBefore(genericOp.getRegion(), newOp.getRegion(),
                                newOp.getRegion().begin());
 
     Block *body = newOp.getBody();
     PatternRewriter::InsertionGuard guard(rewriter);
     rewriter.setInsertionPointToStart(body);
 
     for (auto idx : llvm::reverse(scalarOperands)) {
-      OpOperand *opOperand = genericOp.getInputOperand(idx);
+      OpOperand *opOperand = genericOp.getDpsInputOperand(idx);
       AffineMap map = genericOp.getMatchingIndexingMap(opOperand);
       SmallVector<int64_t> indices = map.getConstantResults();
       SmallVector<Value> indicesValues;
       for (auto idx : indices)
         indicesValues.emplace_back(
             rewriter.create<arith::ConstantIndexOp>(loc, idx));
       Value extractedValue = rewriter.create<tensor::ExtractOp>(
           loc, opOperand->get(), indicesValues);

mlir/lib/Dialect/Linalg/Transforms/Loops.cpp

static void emitScalarImplementation(OpBuilder &b, Location loc,
   SmallVector<Value> indexedValues;
   indexedValues.reserve(linalgOp->getNumOperands());
 
   auto allIvsPlusDims = SmallVector<Value>(allIvs.begin(), allIvs.end());
 
   // TODO: Avoid the loads if the corresponding argument of the
   // region has no uses.
   // 1.a. Emit load from input operand or for scalars access the operand itself.
-  for (OpOperand *inputOperand : linalgOp.getInputOperands()) {
+  for (OpOperand *inputOperand : linalgOp.getDpsInputOperands()) {
     if (linalgOp.isScalar(inputOperand)) {
       indexedValues.push_back(inputOperand->get());
       continue;
     }
     auto indexing = makeCanonicalAffineApplies(
         b, loc, linalgOp.getMatchingIndexingMap(inputOperand), allIvsPlusDims);
     indexedValues.push_back(
         b.create<LoadOpTy>(loc, inputOperand->get(), indexing));
   }
   // 1.b. Emit load from output views.
-  for (OpOperand *outputOperand : linalgOp.getOutputOperands()) {
+  for (OpOperand *outputOperand : linalgOp.getDpsInitOperands()) {
     SmallVector<Value> indexing = makeCanonicalAffineApplies(
         b, loc, linalgOp.getMatchingIndexingMap(outputOperand), allIvsPlusDims);
     indexedValues.push_back(
         b.create<LoadOpTy>(loc, outputOperand->get(), indexing));
   }
 
   // TODO: When a region inliner exists, use it.
   // 2. Inline region, currently only works for a single basic block.
   // 3. Emit store.
   SmallVector<SmallVector<Value>, 8> indexing;
   SmallVector<Value> outputBuffers;
-  for (OpOperand *outputOperand : linalgOp.getOutputOperands()) {
+  for (OpOperand *outputOperand : linalgOp.getDpsInitOperands()) {
     if (!outputOperand->get().getType().isa<MemRefType>())
       continue;
     indexing.push_back(makeCanonicalAffineApplies(
         b, loc, linalgOp.getMatchingIndexingMap(outputOperand),
         allIvsPlusDims));
     outputBuffers.push_back(outputOperand->get());
   }
   inlineRegionAndEmitStore<LoadOpTy, StoreOpTy>(b, loc, linalgOp, indexedValues,

mlir/lib/Dialect/Linalg/Transforms/NamedOpConversions.cpp

 namespace {
 struct SimplifyDepthwiseConvOp
     : public OpRewritePattern<DepthwiseConv2DNhwcHwcmOp> {
   using OpRewritePattern<DepthwiseConv2DNhwcHwcmOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(DepthwiseConv2DNhwcHwcmOp op,
                                 PatternRewriter &rewriter) const override {
     Operation *operation = op.getOperation();
-    Value input = op.getInputOperand(0)->get();
-    Value kernel = op.getInputOperand(1)->get();
-    Value init = op.getOutputOperand(0)->get();
+    Value input = op.getDpsInputOperand(0)->get();
+    Value kernel = op.getDpsInputOperand(1)->get();
+    Value init = op.getDpsInitOperand(0)->get();
 
     auto stride = op.getStrides();
     auto dilation = op.getDilations();
 
     return matchAndReplaceDepthwiseConv(operation, input, kernel, nullptr,
                                         nullptr, init, stride, dilation,
                                         rewriter);
   }
 };
 
 struct SimplifyDepthwiseConvQOp
     : public OpRewritePattern<DepthwiseConv2DNhwcHwcmQOp> {
   using OpRewritePattern<DepthwiseConv2DNhwcHwcmQOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(DepthwiseConv2DNhwcHwcmQOp op,
                                 PatternRewriter &rewriter) const override {
     Operation *operation = op.getOperation();
-    Value input = op.getInputOperand(0)->get();
-    Value kernel = op.getInputOperand(1)->get();
-    Value iZp = op.getInputOperand(2)->get();
-    Value kZp = op.getInputOperand(3)->get();
-    Value init = op.getOutputOperand(0)->get();
+    Value input = op.getDpsInputOperand(0)->get();
+    Value kernel = op.getDpsInputOperand(1)->get();
+    Value iZp = op.getDpsInputOperand(2)->get();
+    Value kZp = op.getDpsInputOperand(3)->get();
+    Value init = op.getDpsInitOperand(0)->get();
 
     auto stride = op.getStrides();
     auto dilation = op.getDilations();
 
     return matchAndReplaceDepthwiseConv(operation, input, kernel, iZp, kZp,
                                         init, stride, dilation, rewriter);
   }
 };

mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp

for (OpOperand &opOperand : op->getOpOperands()) {
     int64_t operandNumber = opOperand.getOperandNumber();
     if (options.subViews.count(operandNumber) != 0) {
       if (options.useFullTileBuffers[opOperand.get()])
         opViews.push_back(
             (*promotedBuffersAndViews)[operandNumber].fullLocalView);
       else
         opViews.push_back(
             (*promotedBuffersAndViews)[operandNumber].partialLocalView);
-      if (operandNumber >= op.getNumInputs())
+      if (operandNumber >= op.getNumDpsInputs())
         writebackViews.emplace_back(std::make_pair(
             opOperand.get(),
             (*promotedBuffersAndViews)[operandNumber].partialLocalView));
     } else {
       opViews.push_back(opOperand.get());
     }
   }
   op->setOperands(0, opViews.size(), opViews);

mlir/lib/Dialect/Linalg/Transforms/SplitReduction.cpp

FailureOr<SplitReductionResult> mlir::linalg::splitReduction(
   Attribute identity = getNeutralElement(reductionOp);
   if (!identity)
     return b.notifyMatchFailure(op, "Unknown identity value for the reduction");
 
   Location loc = op->getLoc();
   SmallVector<Value> newInputs;
   SmallVector<AffineMap> newMaps;
   // Calculate the new shapes and indexing maps of the input operands.
-  for (OpOperand *operand : op.getInputOperands()) {
+  for (OpOperand *operand : op.getDpsInputOperands()) {
     AffineMap map = op.getMatchingIndexingMap(operand);
     SmallVector<int64_t> newShape;
     SmallVector<AffineExpr> exprs;
     SmallVector<ReassociationIndices> reassociation;
     unsigned index = 0;
     for (unsigned idx : llvm::seq<unsigned>(0, map.getNumResults())) {
       unsigned dim = map.getDimPosition(idx);
       if (reductionDim == dim) {
for (OpOperand *operand : op.getDpsInputOperands()) {
     Value newInput = b.create<tensor::ExpandShapeOp>(
         loc, newType, operand->get(), reassociation);
     newInputs.push_back(newInput);
   }
 
   // Calculate the new output map and shape, we insert the new dimension based
   // on the index returned by `controlSplitReductionFn`.
   SmallVector<int64_t> newOutputShape;
-  AffineMap oldOutputMap = op.getMatchingIndexingMap(op.getOutputOperand(0));
-  ArrayRef<int64_t> oldShape = op.getShape(op.getOutputOperand(0));
+  AffineMap oldOutputMap = op.getMatchingIndexingMap(op.getDpsInitOperand(0));
+  ArrayRef<int64_t> oldShape = op.getShape(op.getDpsInitOperand(0));
   SmallVector<AffineExpr> outputExpr;
   for (unsigned idx :
        llvm::seq<unsigned>(0, oldOutputMap.getNumResults() + 1)) {
     if (idx == insertSplitDimension) {
       newOutputShape.push_back(ratio);
       if (control.innerParallel) {
         outputExpr.push_back(b.getAffineDimExpr(reductionDim + 1));
       } else {
if (insertSplitDimension == i) {
       reductionIteratorTypes.push_back(getParallelIteratorTypeName());
     }
   }
   AffineMap outputMap = AffineMap::get(intermRank, 0, exprs, op.getContext());
   SmallVector<AffineMap> reductionMaps = {inputMap, outputMap};
 
   auto reduction = b.create<GenericOp>(
       loc, op->getResultTypes(), ValueRange({genericOp.getResult(0)}),
-      SmallVector<Value>{op.getOutputOperands()}, reductionMaps,
+      SmallVector<Value>{op.getDpsInitOperands()}, reductionMaps,
       reductionIteratorTypes,
       [reductionOp](OpBuilder &b, Location loc, ValueRange inputs) {
         Operation *clonedReductionOp = b.clone(*reductionOp);
         clonedReductionOp->setOperand(0, inputs[0]);
         clonedReductionOp->setOperand(1, inputs[1]);
         b.create<linalg::YieldOp>(loc, clonedReductionOp->getResult(0));
       });
   b.replaceOp(op, reduction.getResults());
FailureOr<SplitReductionResult> mlir::linalg::splitReductionByScaling(
   SmallVector<Attribute> neutralElements = llvm::to_vector<4>(
       llvm::map_range(combinerOps, [&](Operation *reductionOp) {
         return getNeutralElement(reductionOp);
       }));
   if (!llvm::all_of(neutralElements, [](Attribute attr) { return attr; }))
     return b.notifyMatchFailure(op, "unknown reduction neutral");
 
   // TODO: relax this when multi-reduction support is available.
-  if (op.getNumOutputs() != static_cast<int64_t>(neutralElements.size()))
+  if (op.getNumDpsInits() != static_cast<int64_t>(neutralElements.size()))
     return b.notifyMatchFailure(op, "expect one reduction per output");
 
   // Rewrite part.
   // Step 1. Build the intermediate outputs filled with the proper
   // neutralElements. Such outputs are of the same shape with an extra dimension
   // inserted at `insertSplitDimension`.
   //
   // Consider a minimal example where `k` is reduced:
   //     O(i, j) += I(i, j, k)
   // Assume i=3, j=5, k=128, splitFactor=16 and insertSplitDimension=0.
   // The compute is rewritten as:
   //   a. O_i(kk, i, j) += I(i, j, 16 * k + kk)
   //   b. O(i, j) += O_i(kk, i, j)
   // The intermediate tensor O_i is of shape (128/16)x3x5 == 8x3x5.
   Location loc = op->getLoc();
   MLIRContext *context = op.getContext();
   // For now assume outputs are 1-1 with reduction neutralElements.
   // TODO: generalize when multi-reduction support is available.
   SmallVector<Value> newOutputs;
-  newOutputs.reserve(op.getNumOutputs());
+  newOutputs.reserve(op.getNumDpsInits());
   SmallVector<Operation *> emptyOrAllocTensorOps;
   SmallVector<linalg::FillOp> fillOps;
-  fillOps.reserve(op.getNumOutputs());
-  for (auto it : llvm::zip(op.getOutputOperands(), neutralElements)) {
+  fillOps.reserve(op.getNumDpsInits());
+  for (auto it : llvm::zip(op.getDpsInitOperands(), neutralElements)) {
     Value rankedTensor = std::get<0>(it)->get();
     auto t = rankedTensor.getType().cast<RankedTensorType>();
     RankedTensorType newT = RankedTensorType::Builder(t).insertDim(
         reductionDimSize / splitFactor, insertSplitDimension);
     SmallVector<Value> dims =
         tensor::createDynamicDimValues(b, loc, rankedTensor);
     Value emptyOrAllocTensor;
     if (useAlloc) {
for (auto it : llvm::zip(op.getDpsInitOperands(), neutralElements)) {
     newOutputs.push_back(fillOps.back().getResult(0));
     emptyOrAllocTensorOps.push_back(emptyOrAllocTensor.getDefiningOp());
   }
 
   // Step 2. Reindex / expand indexing maps.
   // Reindex existing input indexings: k -> k * splitFactor + k'.
   SmallVector<AffineMap> newMaps;
   newMaps.reserve(op->getNumOperands() + 1);
-  for (OpOperand *o : op.getInputOperands())
+  for (OpOperand *o : op.getDpsInputOperands())
     newMaps.push_back(scaleReductionDim(op, *o, reductionDimPos, splitFactor));
   // Provision a new indexing for the shape-only tensor.
   auto nDims = op.getNumLoops() + 1;
   auto redDim = getAffineDimExpr(reductionDimPos, context);
   auto redDimP1 = getAffineDimExpr(reductionDimPos + 1, context);
   newMaps.push_back(AffineMap::get(nDims, 0, {redDim, redDimP1}, context));
   // Expand existing output indexings.
   // TODO: a subset of these may not reduce along reducePos and should be
   // reindexed: k -> k * splitFactor + k', when multi-reduction support is
   // available.
-  for (OpOperand *o : op.getOutputOperands())
+  for (OpOperand *o : op.getDpsInitOperands())
     newMaps.push_back(insertParallelDim(op, *o, reductionDimPos,
                                         reductionDimSize / splitFactor));
 
   // Step 3. Handle operands.
   // Compute the new input tensors.
-  SmallVector<Value> newInputs(op.getInputOperands());
+  SmallVector<Value> newInputs(op.getDpsInputOperands());
   // Add a single shape-only tensor to carry the dimensions without resorting to
   // more complex inversions.
   newInputs.push_back(b.create<tensor::EmptyOp>(
       loc, ArrayRef<int64_t>{reductionDimSize / splitFactor, splitFactor},
       b.getIntegerType(1)));
   // Output tensors are already good to go.
 
   // Step 4. Create the new op matching the original op with an extra parallel
FailureOr<SplitReductionResult> mlir::linalg::splitReductionByScaling(
   // Step 5. Create new reduction ops that only reduce the newly added
   // dimensions from the previous op.
   // For now assume outputs are 1-1 with reduction ops.
   // TODO: a subset of these may not reduce in the first place and do not
   // require a new op, when multi-reduction support is available.
   // TODO: all results can be handled in a single GenericOp, when
   // multi-reduction support is available.
   SmallVector<LinalgOp> results;
-  for (auto it : llvm::zip(genericOp->getResults(), op.getOutputOperands(),
+  for (auto it : llvm::zip(genericOp->getResults(), op.getDpsInitOperands(),
                            combinerOps)) {
     Value reindexedOutput = std::get<0>(it);
     Value originalOutput = std::get<1>(it)->get();
     auto originalOutputType = originalOutput.getType().cast<RankedTensorType>();
     Operation *combinerOp = std::get<2>(it);
 
     AffineMap map = b.getMultiDimIdentityMap(originalOutputType.getRank() + 1);
     SmallVector<AffineMap> indexingMaps = {

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

static FailureOr<ForeachThreadTilingResult> tileToForeachThreadOpImpl(
 
   // Clone the tileable op and update its destination operands to use the output
   // bbArgs of the ForeachThreadOp.
   ArrayRef<BlockArgument> destBbArgs =
       foreachThreadOp.getOutputBlockArguments();
   Operation *clonedOp = b.clone(*op.getOperation());
   auto destinationStyleOp = dyn_cast<DestinationStyleOpInterface>(clonedOp);
   if (destinationStyleOp) {
-    for (OpOperand *outOperand : destinationStyleOp.getOutputOperands()) {
+    for (OpOperand *outOperand : destinationStyleOp.getDpsInitOperands()) {
       auto *it = llvm::find(dest, outOperand->get());
       assert(it != dest.end() && "dest operand not found in dest");
       unsigned destNum = std::distance(dest.begin(), it);
       outOperand->set(destBbArgs[destNum]);
     }
   }
 
   // Tile the cloned op and delete the clone.

mlir/lib/Dialect/Linalg/Transforms/TilingInterfaceImpl.cpp

for (auto &op : body->without_terminator()) {
     }
     b.clone(op, map);
   }
 
   Operation *terminator = body->getTerminator();
   Location loc = terminator->getLoc();
   for (const auto &operand : llvm::enumerate(terminator->getOperands())) {
     Value toStore = map.lookupOrDefault(operand.value());
-    OpOperand *storeInto = linalgOp.getOutputOperand(operand.index());
+    OpOperand *storeInto = linalgOp.getDpsInitOperand(operand.index());
     auto indices = getIndicesForAccess(
         b, loc, linalgOp.getMatchingIndexingMap(storeInto), ivs);
-    b.create<memref::StoreOp>(loc, toStore,
-                              linalgOp.getOutputOperand(operand.index())->get(),
-                              indices);
+    b.create<memref::StoreOp>(
+        loc, toStore, linalgOp.getDpsInitOperand(operand.index())->get(),
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // External Model for implementing `TilingInterface` for `LinalgOp`s.
 //===----------------------------------------------------------------------===//
 
getResultTilePosition(Operation *op, OpBuilder &b, unsigned resultNumber,
 
     AffineExpr d0;
     bindDims(b.getContext(), d0);
     SmallVector<OpFoldResult> subShapeSizes =
         llvm::to_vector(llvm::map_range(sizes, [&](OpFoldResult ofr) {
           return makeComposedFoldedAffineApply(b, loc, d0 - 1, ofr);
         }));
 
-    OpOperand *outOperand = linalgOp.getOutputOperand(resultNumber);
+    OpOperand *outOperand = linalgOp.getDpsInitOperand(resultNumber);
     SliceParameters sliceParams = computeSliceParameters(
         b, loc, outOperand->get(), sizes,
         linalgOp.getMatchingIndexingMap(outOperand), offsets,
         /*ubs*/ {}, subShapeSizes, true);
     resultOffsets = sliceParams.offsets;
     resultSizes = sliceParams.sizes;
     return success();
   }

mlir/lib/Dialect/Linalg/Transforms/Transforms.cpp

if (auto typedAttr = paddingAttr.dyn_cast<TypedAttr>())
     paddingType = typedAttr.getType();
   Value paddingValue =
       b.create<arith::ConstantOp>(opToPad.getLoc(), paddingType, paddingAttr);
 
   // Follow the use-def chain if `currOpOperand` is defined by a LinalgOp.
   OpOperand *currOpOperand = opOperand;
   while (auto linalgOp = currOpOperand->get().getDefiningOp<LinalgOp>()) {
     OpResult result = currOpOperand->get().cast<OpResult>();
-    currOpOperand = linalgOp.getOutputOperand(result.getResultNumber());
+    currOpOperand = linalgOp.getDpsInitOperand(result.getResultNumber());
   }
 
   // Fail if `currOpOperand` is not defined by an ExtractSliceOp.
   auto sliceOp = currOpOperand->get().getDefiningOp<tensor::ExtractSliceOp>();
   if (!sliceOp)
     return failure();
 
   // Compute the dropped dimensions if `sliceOp` is ranke-reducing.
linalg::rewriteAsPaddedOp(OpBuilder &b, LinalgOp opToPad,
   if (failed(cast<ReifyRankedShapedTypeOpInterface>(opToPad.getOperation())
                  .reifyResultShapes(b, reifiedResultShapes)))
     return failure();
   assert(reifiedResultShapes.size() == opToPad->getNumResults() &&
          "expected same number of results");
 
   // Clone `opToPad` to operate on the statically padded shapes.
   auto resultTensorTypes =
-      ValueRange(newOperands).take_back(opToPad.getNumOutputs()).getTypes();
+      ValueRange(newOperands).take_back(opToPad.getNumDpsInits()).getTypes();
   paddedOp = opToPad.clone(b, loc, resultTensorTypes, newOperands);
 
   // Recover the slice out of the new static results. This keeps the original
   // linalg op around because it uses the dims of the original results.
   SmallVector<Value> paddedSubviewResults;
   paddedSubviewResults.reserve(opToPad->getNumResults());
   for (const auto &en : llvm::enumerate(paddedOp->getResults())) {
     Value paddedResult = en.value();

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

 /// nullptr otherwise. Multiple reduction operations would impose an
 /// ordering between reduction dimensions and is currently unsupported in
 /// Linalg. This limitation is motivated by the fact that e.g. min(max(X)) !=
 /// max(min(X))
 // TODO: use in LinalgOp verification, there is a circular dependency atm.
 static Operation *matchLinalgReduction(OpOperand *outputOperand) {
   auto linalgOp = cast<LinalgOp>(outputOperand->getOwner());
   unsigned outputPos =
-      outputOperand->getOperandNumber() - linalgOp.getNumInputs();
+      outputOperand->getOperandNumber() - linalgOp.getNumDpsInputs();
   // Only single combiner operations are supported for now.
   SmallVector<Operation *, 4> combinerOps;
   if (!matchReduction(linalgOp.getRegionOutputArgs(), outputPos, combinerOps) ||
       combinerOps.size() != 1)
     return nullptr;
 
   // Return the combiner operation.
   return combinerOps[0];
vectorizeLinalgYield(OpBuilder &b, Operation *op,
   auto yieldOp = dyn_cast<linalg::YieldOp>(op);
   if (!yieldOp)
     return VectorizationResult{VectorizationStatus::Failure, nullptr};
   for (const auto &outputs : llvm::enumerate(yieldOp.getValues())) {
     // TODO: Scan for an opportunity for reuse.
     // TODO: use a map.
     Value vectorValue = bvm.lookup(outputs.value());
     Value newResult = buildVectorWrite(
-        b, vectorValue, linalgOp.getOutputOperand(outputs.index()));
+        b, vectorValue, linalgOp.getDpsInitOperand(outputs.index()));
     if (newResult)
       newResults.push_back(newResult);
   }
   return VectorizationResult{VectorizationStatus::NoReplace, nullptr};
 }
 
 /// Helper function to vectorize the index operations of a `linalgOp`. Return
 /// VectorizationStatus::NewOp to signal the vectorization algorithm that it
vectorizeOneOp(OpBuilder &b, LinalgOp linalgOp, Operation *op,
   // 3. Only ElementwiseMappable are allowed in the generic vectorization.
   if (!OpTrait::hasElementwiseMappableTraits(op))
     return VectorizationResult{VectorizationStatus::Failure, nullptr};
 
   // 4 . Check if the operation is a reduction.
   SmallVector<std::pair<Value, Value>> reductionOperands;
   for (Value operand : op->getOperands()) {
     auto arg = operand.dyn_cast<BlockArgument>();
-    if (!arg || arg.getArgNumber() < linalgOp.getNumInputs())
+    if (!arg || arg.getArgNumber() < linalgOp.getNumDpsInputs())
       continue;
     SmallVector<Operation *> reductionOps;
     Value reduceValue = matchReduction(
         linalgOp.getRegionOutputArgs(),
-        arg.getArgNumber() - linalgOp.getNumInputs(), reductionOps);
+        arg.getArgNumber() - linalgOp.getNumDpsInputs(), reductionOps);
     if (!reduceValue)
       continue;
     reductionOperands.push_back(std::make_pair(reduceValue, operand));
   }
   if (!reductionOperands.empty()) {
     assert(reductionOperands.size() == 1);
     Operation *reduceOp =
         reduceIfNeeded(b, linalgOp, op, reductionOperands[0].first,
vectorizeAsLinalgGeneric(OpBuilder &b, LinalgOp linalgOp,
 
   // 2. Values defined above the region can only be broadcast for now. Make them
   // map to themselves.
   BlockAndValueMapping bvm;
   SetVector<Value> valuesSet;
   mlir::getUsedValuesDefinedAbove(linalgOp->getRegion(0), valuesSet);
   bvm.map(valuesSet.getArrayRef(), valuesSet.getArrayRef());
 
-  if (linalgOp.getNumOutputs() == 0)
+  if (linalgOp.getNumDpsInits() == 0)
     return failure();
 
   // TODO: the common vector shape is equal to the static loop sizes only when
   // all indexing maps are projected permutations. For convs and stencils the
   // logic will need to evolve.
   SmallVector<int64_t> commonVectorShape = linalgOp.computeStaticLoopSizes();
 
   // 3. Turn all BBArgs into vector.transfer_read / load.
   Location loc = linalgOp.getLoc();
   Value zero = b.create<arith::ConstantIndexOp>(loc, 0);
   for (OpOperand *opOperand : linalgOp.getOpOperandsMatchingBBargs()) {
     BlockArgument bbarg = linalgOp.getMatchingBlockArgument(opOperand);
     if (linalgOp.isScalar(opOperand)) {
       bvm.map(bbarg, opOperand->get());
       continue;
     }
     VectorType readType;
     AffineMap map;
     // TODO: can we keep this simplification?
     // if (linalgOp.getShape(&opOperand).empty()) {
     //   readType = VectorType::get({}, bbarg.getType());
     // } else {
-    if (opOperand->getOperandNumber() < linalgOp.getNumInputs()) {
+    if (opOperand->getOperandNumber() < linalgOp.getNumDpsInputs()) {
       map = inverseAndBroadcastProjectedPermutation(
           linalgOp.getMatchingIndexingMap(opOperand));
       readType = VectorType::get(commonVectorShape,
                                  getElementTypeOrSelf(opOperand->get()));
     } else {
       map = inversePermutation(
           reindexIndexingMap(linalgOp.getMatchingIndexingMap(opOperand)));
       readType = VectorType::get(map.compose(linalgOp.getShape(opOperand)),

 
 // TODO: probably need some extra checks for reduction followed by consumer
 // ops that may not commute (e.g. linear reduction + non-linear instructions).
 static LogicalResult reductionPreconditions(LinalgOp op) {
   if (llvm::none_of(op.getIteratorTypesArray(), isReductionIterator)) {
     LDBG("reduction precondition failed: no reduction iterator");
     return failure();
   }
-  for (OpOperand *opOperand : op.getOutputOperands()) {
+  for (OpOperand *opOperand : op.getDpsInitOperands()) {
     AffineMap indexingMap = op.getMatchingIndexingMap(opOperand);
     if (indexingMap.isPermutation())
       continue;
 
     Operation *reduceOp = matchLinalgReduction(opOperand);
     if (!reduceOp || !getCombinerOpKind(reduceOp)) {
       LDBG("reduction precondition failed: reduction detection failed");
       return failure();

 /// ```
 /// kw is unrolled, w is unrolled iff dilationW > 1.
 struct Conv1DGenerator : public StructuredGenerator<LinalgOp> {
   Conv1DGenerator(OpBuilder &builder, LinalgOp linalgOp, int strideW,
                   int dilationW)
       : StructuredGenerator<LinalgOp>(builder, linalgOp), strideW(strideW),
         dilationW(dilationW) {
     // Determine whether `linalgOp` can be generated with this generator
-    if (linalgOp.getNumInputs() != 2 || linalgOp.getNumOutputs() != 1)
+    if (linalgOp.getNumDpsInputs() != 2 || linalgOp.getNumDpsInits() != 1)
       return;
-    lhsShaped = linalgOp.getInputOperand(0)->get();
-    rhsShaped = linalgOp.getInputOperand(1)->get();
-    resShaped = linalgOp.getOutputOperand(0)->get();
+    lhsShaped = linalgOp.getDpsInputOperand(0)->get();
+    rhsShaped = linalgOp.getDpsInputOperand(1)->get();
+    resShaped = linalgOp.getDpsInitOperand(0)->get();
     lhsShapedType = lhsShaped.getType().dyn_cast<ShapedType>();
     rhsShapedType = rhsShaped.getType().dyn_cast<ShapedType>();
     resShapedType = resShaped.getType().dyn_cast<ShapedType>();
     if (!lhsShapedType || !rhsShapedType || !resShapedType)
       return;
     if (lhsShapedType.getRank() != 3 ||
         (rhsShapedType.getRank() != 2 && rhsShapedType.getRank() != 3) ||
         resShapedType.getRank() != 3)
       return;
 
     // Check for reduction `add` preceded by `mul`.
-    Operation *reduceOp = matchLinalgReduction(linalgOp.getOutputOperand(0));
+    Operation *reduceOp = matchLinalgReduction(linalgOp.getDpsInitOperand(0));
     if (!reduceOp)
       return;
     llvm::Optional<vector::CombiningKind> maybeKind;
     maybeKind = getCombinerOpKind(reduceOp);
     if (!maybeKind || *maybeKind != vector::CombiningKind::ADD)
       return;
     // Check for single `mul` predecessor. The `mul` operands must be block
     // arguments or extension of block arguments.

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

 bool isElementwise(LinalgOp op) {
   if (op.getNumLoops() != op.getNumParallelLoops())
     return false;
 
   if (!allIndexingsAreProjectedPermutation(op))
     return false;
 
   // TODO: relax the restrictions on indexing map.
-  for (OpOperand *opOperand : op.getOutputOperands()) {
+  for (OpOperand *opOperand : op.getDpsInitOperands()) {
     if (!op.getMatchingIndexingMap(opOperand).isPermutation())
       return false;
   }
   return hasOnlyScalarElementwiseOp(op->getRegion(0));
 }
 
 bool isParallelIterator(StringRef iteratorType) {
   return iteratorType == getParallelIteratorTypeName();
Value makeComposedPadHighOp(OpBuilder &b, Location loc, RankedTensorType type,
 
   // Search the `source` use-def chain for padded LinalgOps.
   Value current = sliceOp.getSource();
   while (current) {
     auto linalgOp = current.getDefiningOp<LinalgOp>();
     if (!linalgOp)
       break;
     OpResult opResult = current.cast<OpResult>();
-    current = linalgOp.getOutputOperand(opResult.getResultNumber())->get();
+    current = linalgOp.getDpsInitOperand(opResult.getResultNumber())->get();
   }
   auto padOp = current ? current.getDefiningOp<tensor::PadOp>() : nullptr;
 
   // Exit if the search fails to match a tensor::PadOp at the end of the matched
   // LinalgOp sequence.
   if (!padOp)
     return tensor::createPadHighOp(type, source, pad, nofold, loc, b);
 
function_ref<scf::ValueVector(OpBuilder &, Location, ValueRange,
                                   ValueRange)>
         bodyBuilderFn,
     ArrayRef<linalg::ProcInfo> procInfo) {
   assert((procInfo.empty() || (procInfo.size() == loopRanges.size())) &&
          "expected as many entries for proc info as number of loops, even if "
          "they are null entries");
   SmallVector<Value> iterArgInitValues = linalgOp.hasBufferSemantics()
                                              ? SmallVector<Value>{}
-                                             : linalgOp.getOutputOperands();
+                                             : linalgOp.getDpsInitOperands();
 
   SmallVector<Value, 4> lbs, ubs, steps;
   unpackRanges(b, loc, loopRanges, lbs, ubs, steps);
   LoopNest loopNest = mlir::scf::buildLoopNest(
       b, loc, lbs, ubs, steps, iterArgInitValues,
       [&](OpBuilder &b, Location loc, ValueRange ivs, ValueRange iterArgs) {
         assert(iterArgs.size() == iterArgInitValues.size() &&
                "expect the number of output tensors and iter args to match");
         SmallVector<Value> operandValuesToUse = linalgOp->getOperands();
         if (!iterArgs.empty()) {
-          operandValuesToUse = linalgOp.getInputOperands();
+          operandValuesToUse = linalgOp.getDpsInputOperands();
           operandValuesToUse.append(iterArgs.begin(), iterArgs.end());
         }
         return bodyBuilderFn(b, loc, ivs, operandValuesToUse);
       });
 
   if (loopNest.loops.empty() || procInfo.empty())
     return;
 
void GenerateLoopNest<AffineForOp>::doit(
     OpBuilder &b, Location loc, ArrayRef<Range> loopRanges, LinalgOp linalgOp,
     ArrayRef<StringRef> iteratorTypes,
     function_ref<scf::ValueVector(OpBuilder &, Location, ValueRange,
                                   ValueRange)>
         bodyBuilderFn,
     ArrayRef<linalg::ProcInfo> /*procInfo*/) {
   SmallVector<Value> iterArgInitValues = linalgOp.hasBufferSemantics()
                                              ? SmallVector<Value>{}
-                                             : linalgOp.getOutputOperands();
+                                             : linalgOp.getDpsInitOperands();
   assert(iterArgInitValues.empty() && "unexpected AffineForOp init values");
   SmallVector<Value, 4> lbs, ubs, steps;
   unpackRanges(b, loc, loopRanges, lbs, ubs, steps);
 
   // Affine loops require constant steps.
   SmallVector<int64_t, 4> constantSteps;
   constantSteps.reserve(steps.size());
   for (Value v : steps) {
void GenerateLoopNest<scf::ParallelOp>::doit(
     OpBuilder &b, Location loc, ArrayRef<Range> loopRanges, LinalgOp linalgOp,
     ArrayRef<StringRef> iteratorTypes,
     function_ref<scf::ValueVector(OpBuilder &, Location, ValueRange,
                                   ValueRange)>
         bodyBuilderFn,
     ArrayRef<linalg::ProcInfo> procInfo) {
   SmallVector<Value> iterArgInitValues = linalgOp.hasBufferSemantics()
                                              ? SmallVector<Value>{}
-                                             : linalgOp.getOutputOperands();
+                                             : linalgOp.getDpsInitOperands();
   assert(iterArgInitValues.empty() && "unexpected ParallelOp init values");
   // This function may be passed more iterator types than ranges.
   assert(iteratorTypes.size() >= loopRanges.size() &&
          "expected iterator type for all ranges");
   assert((procInfo.empty() || (procInfo.size() == loopRanges.size())) &&
          "expected proc information for all loops when present");
   iteratorTypes = iteratorTypes.take_front(loopRanges.size());
   SmallVector<Value, 8> lbsStorage, ubsStorage, stepsStorage, ivs;
SmallVector<OpFoldResult> computeTileSizes(OpBuilder &b, Location loc,
   }
   return sizes;
 }
 
 SmallVector<Type> getTensorOutputTypes(LinalgOp op, ValueRange operands) {
   if (op.hasBufferSemantics())
     return {};
   return llvm::to_vector(
-      llvm::map_range(op.getOutputOperands(), [&](OpOperand *opOperand) {
+      llvm::map_range(op.getDpsInitOperands(), [&](OpOperand *opOperand) {
         return operands[opOperand->getOperandNumber()].getType();
       }));
 }
 
 SmallVector<Value> insertSlicesBack(OpBuilder &builder, Location loc,
                                     LinalgOp op, ValueRange operands,
                                     ValueRange results) {
   if (op.hasBufferSemantics())
     return {};
   SmallVector<Value> tensorResults;
   tensorResults.reserve(results.size());
   // Insert a insert_slice for each output tensor.
   unsigned resultIdx = 0;
-  for (OpOperand *opOperand : op.getOutputOperands()) {
+  for (OpOperand *opOperand : op.getDpsInitOperands()) {
     // TODO: use an interface/adaptor to avoid leaking position in
     // `tiledOperands`.
     Value outputTensor = operands[opOperand->getOperandNumber()];
     if (auto sliceOp = outputTensor.getDefiningOp<tensor::ExtractSliceOp>()) {
       Value inserted = builder.create<tensor::InsertSliceOp>(
           loc, sliceOp.getSource().getType(), results[resultIdx],
           sliceOp.getSource(), sliceOp.getOffsets(), sliceOp.getSizes(),
           sliceOp.getStrides(), sliceOp.getStaticOffsets(),
for (OpOperand &opOperand : linalgOp->getOpOperands()) {
     // Use `opOperand` as is if it is not tiled and not an output tensor. Having
     // an extract/insert slice pair for all output tensors simplifies follow up
     // transformations such as padding and bufferization since the
     // extract/insert slice pairs make the accessed iteration argument
     // subdomains explicit.
 
     Type operandType = opOperand.get().getType();
     if (!isTiled(map, tileSizes) && !(operandType.isa<RankedTensorType>() &&
-                                      linalgOp.isOutput(&opOperand))) {
+                                      linalgOp.isDpsInit(&opOperand))) {
       allSliceParams.push_back(llvm::None);
       LLVM_DEBUG(llvm::dbgs()
                  << ": not tiled: use shape: " << operandType << "\n");
       continue;
     }
     LLVM_DEBUG(llvm::dbgs() << ": tiled: figure out subshape...\n");
 
     allSliceParams.push_back(computeSliceParameters(

mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp

FailureOr<SmallVector<Value>> replacementOr = yieldTiledValues(
       rewriter, destinationTensors, tilingResult.tiledOp->getResults(),
       resultOffsetsList, resultSizesList, tilingResult.loops);
   if (failed(replacementOr))
     return rewriter.notifyMatchFailure(op, "failed to yield replacement");
 
   if (auto dstOp =
           dyn_cast<DestinationStyleOpInterface>(tilingResult.tiledOp)) {
     auto innerMostLoop = tilingResult.loops.back();
-    SmallVector<Value> destinationTensors = dstOp.getOutputOperands();
+    SmallVector<Value> destinationTensors = dstOp.getDpsInitOperands();
     assert(destinationTensors.size() ==
                innerMostLoop.getRegionIterArgs().size() &&
            "unexpected number of outputs");
     updateDestinationOperandsForTiledOp(rewriter, destinationTensors,
                                         innerMostLoop.getRegionIterArgs());
   }
 
   tilingResult.replacements = replacementOr.value();
if (iterArgNumber) {
         outerMostLoop.setIterArg(
             iterArgNumber.value(),
             dstOp.getTiedOpOperand(fusableProducer)->get());
       }
       if (auto dstOp = fusedProducerValue.value()
                            .getDefiningOp<DestinationStyleOpInterface>()) {
         scf::ForOp innerMostLoop = tileAndFuseResult.loops.back();
         updateDestinationOperandsForTiledOp(
-            rewriter, dstOp.getOutputOperand(resultNumber)->get(),
+            rewriter, dstOp.getDpsInitOperand(resultNumber)->get(),
             innerMostLoop.getRegionIterArgs()[iterArgNumber.value()]);
       }
     }
   }
   return tileAndFuseResult;
 }
 
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp

 /// Rewriting rule that converts direct yield of zero with initial allocation.
 struct FoldInvariantYield : public OpRewritePattern<GenericOp> {
 public:
   using OpRewritePattern<GenericOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(GenericOp op,
                                 PatternRewriter &rewriter) const override {
     if (!op.hasTensorSemantics() || op.getNumResults() != 1 ||
-        !isAlloc(op.getOutputOperand(0), /*isZero=*/false) || !isZeroYield(op))
+        !isAlloc(op.getDpsInitOperand(0), /*isZero=*/false) || !isZeroYield(op))
       return failure();
     auto outputType = op.getResult(0).getType().cast<RankedTensorType>();
     // Yielding zero on newly allocated (all-zero) sparse tensors can be
     // optimized out directly (regardless of dynamic or static size).
     if (getSparseTensorEncoding(outputType)) {
-      rewriter.replaceOp(op, op.getOutputOperand(0)->get());
+      rewriter.replaceOp(op, op.getDpsInitOperand(0)->get());
       return success();
     }
     // Incorporate zero value into allocation copy.
     if (!outputType.hasStaticShape())
       return failure();
     Value zero = constantZero(rewriter, op.getLoc(), op.getResult(0).getType());
     AllocTensorOp a =
-        op.getOutputOperand(0)->get().getDefiningOp<AllocTensorOp>();
+        op.getDpsInitOperand(0)->get().getDefiningOp<AllocTensorOp>();
     rewriter.updateRootInPlace(a, [&]() { a.getCopyMutable().assign(zero); });
-    rewriter.replaceOp(op, op.getOutputOperand(0)->get());
+    rewriter.replaceOp(op, op.getDpsInitOperand(0)->get());
     return success();
   }
 };
 
 /// Rewriting rule that converts two kernels:
 ///
 ///      T(i,j) = SUM(k, A(i,j,k) * B(i,j,k) * ... )
 ///      X(i,j) = S(i,j) * T(i,j)

 /// since intermediate results may be nullified.
 struct FuseSparseMultiplyOverAdd : public OpRewritePattern<GenericOp> {
 public:
   using OpRewritePattern<GenericOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(GenericOp op,
                                 PatternRewriter &rewriter) const override {
     // Check consumer.
-    if (!op.hasTensorSemantics() || op.getNumInputs() != 2 ||
+    if (!op.hasTensorSemantics() || op.getNumDpsInputs() != 2 ||
         op.getNumResults() != 1 ||
         op.getNumParallelLoops() != op.getNumLoops() ||
-        !op.getMatchingIndexingMap(op.getOutputOperand(0)).isIdentity() ||
-        !op.getMatchingIndexingMap(op.getInputOperand(0)).isIdentity() ||
-        !op.getMatchingIndexingMap(op.getInputOperand(1)).isIdentity())
+        !op.getMatchingIndexingMap(op.getDpsInitOperand(0)).isIdentity() ||
+        !op.getMatchingIndexingMap(op.getDpsInputOperand(0)).isIdentity() ||
+        !op.getMatchingIndexingMap(op.getDpsInputOperand(1)).isIdentity())
       return failure();
     // Find consuming OP2(sparse, other) or OP2(other, sparse). The other
     // operand can be sparse or dense, since the point of this rewriting rule
     // is detecting a situation in which *more* sparsity is introduced into
     // a computation, be it already sparse or still dense.
     unsigned other = 0;
-    if (isSparseTensor(op.getInputOperand(0)))
+    if (isSparseTensor(op.getDpsInputOperand(0)))
       other = 1;
-    else if (!isSparseTensor(op.getInputOperand(1)))
+    else if (!isSparseTensor(op.getDpsInputOperand(1)))
       return failure();
     // Check producer.
     auto prod = dyn_cast_or_null<GenericOp>(
-        op.getInputOperand(other)->get().getDefiningOp());
+        op.getDpsInputOperand(other)->get().getDefiningOp());
     if (!prod || !prod.hasTensorSemantics() || prod.getNumResults() != 1 ||
         !prod.getResult(0).hasOneUse())
       return failure();
     // Sampling consumer and sum of multiplication chain producer.
-    if (!isAlloc(op.getOutputOperand(0), /*isZero=*/false) ||
-        !isAlloc(prod.getOutputOperand(0), /*isZero=*/true) ||
+    if (!isAlloc(op.getDpsInitOperand(0), /*isZero=*/false) ||
+        !isAlloc(prod.getDpsInitOperand(0), /*isZero=*/true) ||
         !isSampling(op) || !isSumOfMul(prod))
       return failure();
     // Modify operand structure of producer and consumer.
     Location loc = prod.getLoc();
     SmallVector<Value> inputOps = prod.getInputs();
     SmallVector<Value> outputOps = op.getOutputs();
     SmallVector<AffineMap> fusedIndexMaps = prod.getIndexingMapsArray();
-    inputOps.push_back(op.getInputOperand(1 - other)->get());
+    inputOps.push_back(op.getDpsInputOperand(1 - other)->get());
     fusedIndexMaps.push_back(fusedIndexMaps.back()); // mimic other
     // Fuse producer and consumer into a new generic op.
     auto fusedOp = rewriter.create<GenericOp>(
         loc, op.getResult(0).getType(), inputOps, outputOps,
         rewriter.getAffineMapArrayAttr(fusedIndexMaps), prod.getIteratorTypes(),
         /*doc=*/nullptr, /*library_call=*/nullptr);
     Block &prodBlock = prod.getRegion().front();
     Block &consBlock = op.getRegion().front();
for (auto &op : prodBlock.without_terminator())
         rewriter.clone(op, mapper);
       }
     mapper.map(consBlock.getArgument(other), fusedBlock->back().getResult(0));
     mapper.map(last, rewriter.clone(*sampler, mapper)->getResult(0));
     last = rewriter.clone(*acc, mapper)->getResult(0);
     rewriter.create<linalg::YieldOp>(loc, last);
     // Force initial value on merged allocation for dense outputs.
     if (!getSparseTensorEncoding(op.getResult(0).getType())) {
-      Value init = prod.getOutputOperand(0)
+      Value init = prod.getDpsInitOperand(0)
                        ->get()
                        .getDefiningOp<AllocTensorOp>()
                        .getCopy();
       AllocTensorOp a =
-          op.getOutputOperand(0)->get().getDefiningOp<AllocTensorOp>();
+          op.getDpsInitOperand(0)->get().getDefiningOp<AllocTensorOp>();
       rewriter.updateRootInPlace(a, [&]() { a.getCopyMutable().assign(init); });
     }
     // Replace consumer with fused operation. Old producer
     // and consumer ops will be removed by DCE.
     rewriter.replaceOp(op, fusedOp->getResults());
     return success();
   }
 

mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp

 /// Since all sparse input tensors are admissible, we just need to check
 /// whether the out tensor in the tensor expression codegen is admissible.
 /// Sets `sparseOut` to the tensor and `outerParNest` to the outer injective
 /// nesting depth when a "truly dynamic" sparse tensor output occurs.
 static bool isAdmissibleTensorExp(Merger &merger, linalg::GenericOp op,
                                   std::vector<unsigned> &topSort, unsigned exp,
                                   OpOperand **sparseOut,
                                   unsigned &outerParNest) {
-  OpOperand *lhs = op.getOutputOperand(0);
+  OpOperand *lhs = op.getDpsInitOperand(0);
   unsigned tensor = lhs->getOperandNumber();
   auto enc = getSparseTensorEncoding(lhs->get().getType());
   // An non-annotated output tensor is assumed dense, and becomes a random
   // access n-dim memref. Admissible since insertions cannot occur.
   if (!enc)
     return true;
   // An all-dense annotated "sparse" output tensor becomes a linearized random
   // access 1-dim memref. Also admissible since insertions cannot occur.

 //===----------------------------------------------------------------------===//
 // Sparse compiler synthesis methods (statements and expressions).
 //===----------------------------------------------------------------------===//
 
 /// Local bufferization of all dense and sparse data structures.
 static void genBuffers(Merger &merger, CodeGen &codegen, OpBuilder &builder,
                        linalg::GenericOp op) {
   Location loc = op.getLoc();
-  assert(op.getNumOperands() == op.getNumInputs() + 1);
+  assert(op.getNumOperands() == op.getNumDpsInputs() + 1);
 
   codegen.loopEmitter.initializeLoopEmit(
       builder, loc,
       /// Generates buffer for the output tensor.
       /// Note that all sparse kernels assume that when all elements are written
       /// to (viz. x(i) = y(i) * z(i)), the output buffer is already initialized
       /// to all zeroes and only nonzeroes values are computed and written out.
       /// For updates (viz. x(i) += y(i) * z(i)), only nonzeroes values are used
       /// for the updates and no assumption on the original contents of the
       /// output buffer is necessary.
       [&op](OpBuilder &builder, Location loc, Value memref,
             Value tensor) -> Value {
         // Must not be a sparse tensor.
         assert(!getSparseTensorEncoding(tensor.getType()));
-        OpOperand *lhs = op.getOutputOperand(0);
+        OpOperand *lhs = op.getDpsInitOperand(0);
         // Two output tensors references should pointed to the same object.
         assert(lhs->get() == tensor);
         bool isInit = op.isInitTensor(lhs);
         // An output tensor can simply materialize from the buffer of the tensor
         // that appears in the outs() clause. For updates, this has the
         // advantage that only the nonzero value are involved in the
         // computation, keeping the operation O(nnz). In all other cases, we are
         // forced to zero out the buffer to enforce the assumption above, which
static void genTensorStore(Merger &merger, CodeGen &codegen, OpBuilder &builder,
                            linalg::GenericOp op, unsigned exp, Value rhs) {
   Location loc = op.getLoc();
   // Test if this is a scalarized reduction.
   if (codegen.redVal) {
     updateReduc(merger, codegen, rhs);
     return;
   }
   // Store during insertion.
-  OpOperand *t = op.getOutputOperand(0);
+  OpOperand *t = op.getDpsInitOperand(0);
   if (t == codegen.sparseOut) {
     if (!rhs) {
       // Only unary and binary are allowed to return uninitialized rhs
       // to indicate missing output.
       assert(merger.exp(exp).kind == kUnary || merger.exp(exp).kind == kBinary);
     } else if (merger.exp(exp).kind == kSelect) {
       scf::IfOp ifOp = builder.create<scf::IfOp>(loc, rhs);
       builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
if (merger.exp(exp).kind == Kind::kTensor) {
     for (unsigned d = 0, rank = map.getNumResults(); d < rank; d++) {
       AffineExpr a = map.getResult(toOrigDim(enc, d));
       if (!isInvariantAffine(codegen, a, ldx, atLevel))
         return; // still in play
     }
     // All exhausted at this level (atLevel denotes exactly at this level).
     if (!atLevel)
       return;
-    OpOperand *lhs = op.getOutputOperand(0);
+    OpOperand *lhs = op.getDpsInitOperand(0);
     if (lhs == &t) {
       // Start or end a scalarized reduction
       if (atStart) {
         Kind kind = merger.exp(last).kind;
         Value load = kind == Kind::kReduce
                          ? getCustomRedId(merger.exp(last).op)
                          : genTensorLoad(merger, codegen, builder, op, exp);
         codegen.redKind = getReduction(kind);
static void genStmt(Merger &merger, CodeGen &codegen, RewriterBase &rewriter,
 
   // End a loop sequence.
   endLoopSeq(merger, codegen, rewriter, op, exp, at, idx, ldx);
 }
 
 /// Converts the result computed by the sparse kernel into the required form.
 static void genResult(Merger &merger, CodeGen &codegen, RewriterBase &rewriter,
                       linalg::GenericOp op) {
-  OpOperand *lhs = op.getOutputOperand(0);
+  OpOperand *lhs = op.getDpsInitOperand(0);
   Type resType = lhs->get().getType();
   if (getSparseTensorEncoding(resType)) {
     // The sparse tensor rematerializes from the original sparse tensor's
     // underlying sparse storage format.
     rewriter.replaceOpWithNewOp<LoadOp>(op, resType, lhs->get(),
                                         codegen.sparseOut == lhs);
   } else {
     // To rematerialize an non-annotated tensor, simply load it

 public:
   GenericOpSparsifier(MLIRContext *context, SparsificationOptions o)
       : OpRewritePattern<linalg::GenericOp>(context), options(o) {}
 
   LogicalResult matchAndRewrite(linalg::GenericOp op,
                                 PatternRewriter &rewriter) const override {
     // Detects sparse annotations and translate the per-dimension sparsity
     // information for all tensors to loop indices in the kernel.
-    if (op.getNumOutputs() != 1)
+    if (op.getNumDpsInits() != 1)
       return failure();
     unsigned numTensors = op->getNumOperands();
     unsigned numLoops = op.getNumLoops();
     Merger merger(numTensors, numLoops);
     if (!findSparseAnnotations(merger, op))
       return failure();
 
     // Builds the tensor expression for the Linalg operation in SSA form.

 private:
   // Last resort cycle resolution.
   LogicalResult resolveCycle(Merger &merger, PatternRewriter &rewriter,
                              linalg::GenericOp op) const {
     // Compute topological sort while leaving out every
     // sparse input tensor in succession until an acylic
     // iteration graph results.
     std::vector<unsigned> topSort;
-    for (OpOperand *t : op.getInputOperands()) {
+    for (OpOperand *t : op.getDpsInputOperands()) {
       unsigned tensor = t->getOperandNumber();
       Value tval = t->get();
       auto srcEnc = getSparseTensorEncoding(tval.getType());
       if (!srcEnc ||
           !computeIterationGraph(merger, op, topSort, SortMask::kSparseOnly, t))
         continue;
       // Found an input tensor that resolves the cycle by inserting a
       // conversion into a sparse tensor that adheres to the iteration

mlir/lib/Interfaces/DestinationStyleOpInterface.cpp

OpOperandVector::operator SmallVector<Value>() {
   return result;
 }
 
 LogicalResult detail::verifyDestinationStyleOpInterface(Operation *op) {
   DestinationStyleOpInterface dstStyleOp =
       cast<DestinationStyleOpInterface>(op);
 
   SmallVector<OpOperand *> outputBufferOperands, outputTensorOperands;
-  for (OpOperand *operand : dstStyleOp.getOutputOperands()) {
+  for (OpOperand *operand : dstStyleOp.getDpsInitOperands()) {
     Type type = operand->get().getType();
     if (type.isa<MemRefType>()) {
       outputBufferOperands.push_back(operand);
     } else if (type.isa<RankedTensorType>()) {
       outputTensorOperands.push_back(operand);
     } else {
       return op->emitOpError("expected that operand #")
              << operand->getOperandNumber()
              << " is a ranked tensor or a ranked memref";
     }
   }
 
   // Expect at least one output operand.
-  int64_t numInputs = dstStyleOp.getNumInputs();
-  int64_t numOutputs = dstStyleOp.getNumOutputs();
-  if (numOutputs == 0)
+  int64_t numInputs = dstStyleOp.getNumDpsInputs();
+  int64_t numInits = dstStyleOp.getNumDpsInits();
+  if (numInits == 0)
     return op->emitOpError("expected at least one output operand");
-  if (failed(OpTrait::impl::verifyNOperands(op, numInputs + numOutputs)))
+  if (failed(OpTrait::impl::verifyNOperands(op, numInputs + numInits)))
     return failure();
   // Verify the number of results matches the number of output tensors.
   if (op->getNumResults() != outputTensorOperands.size())
     return op->emitOpError("expected the number of results (")
            << op->getNumResults()
            << ") to be equal to the number of output tensors ("
            << outputTensorOperands.size() << ")";
 

mlir/test/lib/Dialect/Linalg/TestLinalgElementwiseFusion.cpp

 
 using namespace mlir;
 
 static void addOperands(Operation *op, SetVector<Value> &operandSet) {
   if (!op)
     return;
   TypeSwitch<Operation *, void>(op)
       .Case<linalg::LinalgOp>([&](linalg::LinalgOp linalgOp) {
-        SmallVector<Value> inputOperands{linalgOp.getInputOperands()};
+        SmallVector<Value> inputOperands{linalgOp.getDpsInputOperands()};
         operandSet.insert(inputOperands.begin(), inputOperands.end());
       })
       .Default([&](Operation *operation) {
         operandSet.insert(operation->operand_begin(), operation->operand_end());
       });
 }
 
 template <int limit = 3>
if (controlFuseByExpansion) {
               }
             }
 
             Operation *consumer = fusedOperand->getOwner();
             if (auto expandOp = dyn_cast<tensor::ExpandShapeOp>(consumer)) {
               if (expandOp->hasOneUse()) {
                 OpOperand &use = *expandOp->getUses().begin();
                 auto linalgOp = dyn_cast<linalg::LinalgOp>(use.getOwner());
-                if (linalgOp && linalgOp.isOutput(&use))
+                if (linalgOp && linalgOp.isDpsInit(&use))
                   return true;
               }
               return false;
             }
             return true;
           };
 
       linalg::populateFoldReshapeOpsByExpansionPatterns(fusionPatterns,

mlir/test/lib/Dialect/Linalg/TestLinalgFusionTransforms.cpp

for (OpOperand &opOperand : linalgOp->getOpOperands()) {
         auto *originalOp = info->originalProducer.getOperation();
         eraseSet.insert(originalOp);
         auto *originalOpInLinalgOpsVector =
             std::find(linalgOps.begin(), linalgOps.end(), originalOp);
         *originalOpInLinalgOpsVector = info->fusedProducer.getOperation();
         changed = true;
       } else if (opOperand.get().getType().isa<RankedTensorType>()) {
         // Tile and Fuse tensor input.
-        if (opOperand.getOperandNumber() >= linalgOp.getNumInputs())
+        if (opOperand.getOperandNumber() >= linalgOp.getNumDpsInputs())
           continue;
         auto info = fuseProducerOfTensor(b, opOperand);
         if (failed(info))
           continue;
         auto *originalOp = info->originalProducer.getOperation();
         auto *originalOpInLinalgOpsVector =
             std::find(linalgOps.begin(), linalgOps.end(), originalOp);
         *originalOpInLinalgOpsVector = info->fusedProducer.getOperation();

mlir/test/lib/Dialect/Test/TestOps.td

let extraClassDeclaration = [{
     mlir::ArrayAttr getIndexingMaps() {
       return getOperation()->getAttrOfType<mlir::ArrayAttr>("indexing_maps");
     }
 
     std::string getLibraryCallName() {
       return "";
     }
 
-    std::pair<int64_t, int64_t> getOutputsPositionRange() {
+    std::pair<int64_t, int64_t> getDpsInitsPositionRange() {
       int64_t getNumOperands = this->getNumOperands();
       return {getNumOperands - 1, getNumOperands};
     }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Test LinalgFillOpInterface.
let extraClassDeclaration = [{
     mlir::ArrayAttr getIndexingMaps() {
       return getOperation()->getAttrOfType<mlir::ArrayAttr>("indexing_maps");
     }
 
     std::string getLibraryCallName() {
       return "";
     }
 
-    std::pair<int64_t, int64_t> getOutputsPositionRange() {
+    std::pair<int64_t, int64_t> getDpsInitsPositionRange() {
       int64_t getNumOperands = this->getNumOperands();
       return {getNumOperands - 1, getNumOperands};
     }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Test Ops with Default-Valued String Attributes

mlir/test/mlir-linalg-ods-gen/test-linalg-ods-yaml-gen.yaml

value: !ScalarExpression
         kind: type
         fn_name: cast_signed
         type_var: U
         operands:
         - !ScalarExpression
           scalar_arg: value
 
 #       IMPL:  Test3Op::getIteratorTypesArray() {
-#  IMPL-NEXT:    int64_t rank = getRank(getOutputOperand(0));
+#  IMPL-NEXT:    int64_t rank = getRank(getDpsInitOperand(0));
 
 #       IMPL:  Test3Op::getIndexingMaps() {
 #  IMPL-NEXT:    MLIRContext *context = getContext();
 #  IMPL-NEXT:    AffineMap scalarMap = AffineMap::get(getNumParallelLoops(), 0, context);
 #  IMPL-NEXT:    AffineMap tensorMap = AffineMap::getMultiDimIdentityMap(
 
 # @linalg_structured_op
 # def test4(O=TensorDef(T, S.M, S.N, output=True),

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp

let extraClassDeclaration = structuredOpsBaseDecls # [{{
       static void regionBuilder(ImplicitLocOpBuilder &b,
                                 Block &block, ArrayRef<NamedAttribute> attrs);
       static std::function<void(ImplicitLocOpBuilder &,
                                 Block &, ArrayRef<NamedAttribute>)>
       getRegionBuilder() {{
         return regionBuilder;
       }
 
-      std::pair<int64_t, int64_t> getOutputsPositionRange() {{
+      std::pair<int64_t, int64_t> getDpsInitsPositionRange() {{
         int64_t getNumOperands = this->getNumOperands();
         return {{getNumOperands - 1, getNumOperands};
       }
 
       // Generic methods.
       static unsigned getNumRegionArgs();
       std::string getLibraryCallName();
       {7}

 )FMT";
 
 // The getIteratorTypesArray() method for rank polymorphic structured ops.
 // Parameters:
 // {0}: Class name
 static const char rankPolyStructuredOpIteratorTypesFormat[] =
     R"FMT(
 SmallVector<StringRef> {0}::getIteratorTypesArray() {{
-  int64_t rank = getRank(getOutputOperand(0));
+  int64_t rank = getRank(getDpsInitOperand(0));
   return SmallVector<StringRef>(rank, getParallelIteratorTypeName());
 }
 )FMT";
 
 // The indexing_maps() method for structured ops. Parameters:
 // {0}: Class name
 // {1}: Comma-separated list of dimension variable names.
 // {2}: Statements

 LogicalResult {0}::fold(ArrayRef<Attribute>,
                         SmallVectorImpl<OpFoldResult> &) {{
   return memref::foldMemRefCast(*this);
 }
 void {0}::getEffects(SmallVectorImpl<
     SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) {{
       if (hasTensorSemantics()) return;
       getGenericEffectsImpl(effects,
-        getOperation()->getResults(), getInputOperands(), getOutputOperands());
+        getOperation()->getResults(), getDpsInputOperands(), getDpsInitOperands());
 }
 )FMT";
 
 // Implementation of parse/print.
 // Parameters:
 // {0}: Class name
 static const char structuredOpParserFormat[] = R"FMT(
 ParseResult {0}::parse(OpAsmParser &parser, OperationState &result) {{