This interface contains the necessary components to provide the same builtin behavior that terminators have. This will be used in future revisions to remove many of the hardcoded constraints placed on successors and successor operands. The interface initially contains three methods:
```c++
// Return a set of values corresponding to the operands for successor 'index', or None if the operands do not correspond to materialized values.
Optional<OperandRange> getSuccessorOperands(unsigned index);
// Return true if this terminator can have it's successor operands erased.
bool canEraseSuccessorOperand();
// Erase the operand of a successor. This is only valid to call if 'canEraseSuccessorOperand' returns true.
void eraseSuccessorOperand(unsigned succIdx, unsigned opIdx);
```
Differential Revision: https://reviews.llvm.org/D75314
mlir_tablegen(CallInterfaces.cpp.inc -gen-op-interface-defs)
add_public_tablegen_target(MLIRCallOpInterfacesIncGen)
+set(LLVM_TARGET_DEFINITIONS ControlFlowInterfaces.td)
+mlir_tablegen(ControlFlowInterfaces.h.inc -gen-op-interface-decls)
+mlir_tablegen(ControlFlowInterfaces.cpp.inc -gen-op-interface-defs)
+add_public_tablegen_target(MLIRControlFlowInterfacesIncGen)
+
set(LLVM_TARGET_DEFINITIONS InferTypeOpInterface.td)
mlir_tablegen(InferTypeOpInterface.h.inc -gen-op-interface-decls)
mlir_tablegen(InferTypeOpInterface.cpp.inc -gen-op-interface-defs)
--- /dev/null
+//===- ControlFlowInterfaces.h - ControlFlow Interfaces ---------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the definitions of the branch interfaces defined in
+// `ControlFlowInterfaces.td`.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_ANALYSIS_CONTROLFLOWINTERFACES_H
+#define MLIR_ANALYSIS_CONTROLFLOWINTERFACES_H
+
+#include "mlir/IR/OpDefinition.h"
+
+namespace mlir {
+class BranchOpInterface;
+
+namespace detail {
+/// Erase an operand from a branch operation that is used as a successor
+/// operand. `operandIndex` is the operand within `operands` to be erased.
+void eraseBranchSuccessorOperand(OperandRange operands, unsigned operandIndex,
+ Operation *op);
+
+/// Return the `BlockArgument` corresponding to operand `operandIndex` in some
+/// successor if `operandIndex` is within the range of `operands`, or None if
+/// `operandIndex` isn't a successor operand index.
+Optional<BlockArgument>
+getBranchSuccessorArgument(Optional<OperandRange> operands,
+ unsigned operandIndex, Block *successor);
+
+/// Verify that the given operands match those of the given successor block.
+LogicalResult verifyBranchSuccessorOperands(Operation *op, unsigned succNo,
+ Optional<OperandRange> operands);
+} // namespace detail
+
+#include "mlir/Analysis/ControlFlowInterfaces.h.inc"
+} // end namespace mlir
+
+#endif // MLIR_ANALYSIS_CONTROLFLOWINTERFACES_H
--- /dev/null
+//===-- ControlFlowInterfaces.td - ControlFlow Interfaces --*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains a set of interfaces that can be used to define information
+// about control flow operations, e.g. branches.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_ANALYSIS_CONTROLFLOWINTERFACES
+#define MLIR_ANALYSIS_CONTROLFLOWINTERFACES
+
+include "mlir/IR/OpBase.td"
+
+//===----------------------------------------------------------------------===//
+// BranchOpInterface
+//===----------------------------------------------------------------------===//
+
+def BranchOpInterface : OpInterface<"BranchOpInterface"> {
+ let description = [{
+ This interface provides information for branching terminator operations,
+ i.e. terminator operations with successors.
+ }];
+ let methods = [
+ InterfaceMethod<[{
+ Returns a set of values that correspond to the arguments to the
+ successor at the given index. Returns None if the operands to the
+ successor are non-materialized values, i.e. they are internal to the
+ operation.
+ }],
+ "Optional<OperandRange>", "getSuccessorOperands", (ins "unsigned":$index)
+ >,
+ InterfaceMethod<[{
+ Return true if this operation can erase an operand to a successor block.
+ }],
+ "bool", "canEraseSuccessorOperand"
+ >,
+ InterfaceMethod<[{
+ Erase the operand at `operandIndex` from the `index`-th successor. This
+ should only be called if `canEraseSuccessorOperand` returns true.
+ }],
+ "void", "eraseSuccessorOperand",
+ (ins "unsigned":$index, "unsigned":$operandIndex), [{}],
+ /*defaultImplementation=*/[{
+ ConcreteOp *op = static_cast<ConcreteOp *>(this);
+ Optional<OperandRange> operands = op->getSuccessorOperands(index);
+ assert(operands && "unable to query operands for successor");
+ detail::eraseBranchSuccessorOperand(*operands, operandIndex, *op);
+ }]
+ >,
+ InterfaceMethod<[{
+ Returns the `BlockArgument` corresponding to operand `operandIndex` in
+ some successor, or None if `operandIndex` isn't a successor operand
+ index.
+ }],
+ "Optional<BlockArgument>", "getSuccessorBlockArgument",
+ (ins "unsigned":$operandIndex), [{
+ Operation *opaqueOp = op;
+ for (unsigned i = 0, e = opaqueOp->getNumSuccessors(); i != e; ++i) {
+ if (Optional<BlockArgument> arg = detail::getBranchSuccessorArgument(
+ op.getSuccessorOperands(i), operandIndex,
+ opaqueOp->getSuccessor(i)))
+ return arg;
+ }
+ return llvm::None;
+ }]
+ >
+ ];
+
+ let verify = [{
+ auto concreteOp = cast<ConcreteOpType>($_op);
+ for (unsigned i = 0, e = $_op->getNumSuccessors(); i != e; ++i) {
+ Optional<OperandRange> operands = concreteOp.getSuccessorOperands(i);
+ if (failed(detail::verifyBranchSuccessorOperands($_op, i, operands)))
+ return failure();
+ }
+ return success();
+ }];
+}
+
+#endif // MLIR_ANALYSIS_CONTROLFLOWINTERFACES
#ifndef MLIR_DIALECT_LLVMIR_LLVMDIALECT_H_
#define MLIR_DIALECT_LLVMIR_LLVMDIALECT_H_
+#include "mlir/Analysis/ControlFlowInterfaces.h"
#include "mlir/IR/Dialect.h"
#include "mlir/IR/Function.h"
#include "mlir/IR/OpDefinition.h"
#define LLVMIR_OPS
include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
+include "mlir/Analysis/ControlFlowInterfaces.td"
class LLVM_Builder<string builder> {
string llvmBuilder = builder;
def LLVM_FPTruncOp : LLVM_CastOp<"fptrunc", "CreateFPTrunc">;
// Call-related operations.
-def LLVM_InvokeOp : LLVM_Op<"invoke", [Terminator]>,
+def LLVM_InvokeOp : LLVM_Op<"invoke", [
+ DeclareOpInterfaceMethods<BranchOpInterface>, Terminator
+ ]>,
Arguments<(ins OptionalAttr<FlatSymbolRefAttr>:$callee,
Variadic<LLVM_Type>)>,
Results<(outs Variadic<LLVM_Type>)> {
}
// Terminators.
-def LLVM_BrOp : LLVM_TerminatorOp<"br", []> {
+def LLVM_BrOp : LLVM_TerminatorOp<"br",
+ [DeclareOpInterfaceMethods<BranchOpInterface>]> {
let successors = (successor AnySuccessor:$dest);
let assemblyFormat = "$dest attr-dict";
}
-def LLVM_CondBrOp : LLVM_TerminatorOp<"cond_br", []> {
+def LLVM_CondBrOp : LLVM_TerminatorOp<"cond_br",
+ [DeclareOpInterfaceMethods<BranchOpInterface>]> {
let arguments = (ins LLVMI1:$condition);
let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
let assemblyFormat = "$condition `,` successors attr-dict";
include "mlir/Dialect/SPIRV/SPIRVBase.td"
include "mlir/Analysis/CallInterfaces.td"
+include "mlir/Analysis/ControlFlowInterfaces.td"
// -----
-def SPV_BranchOp : SPV_Op<"Branch", [InFunctionScope, Terminator]> {
+def SPV_BranchOp : SPV_Op<"Branch",[
+ DeclareOpInterfaceMethods<BranchOpInterface>, InFunctionScope,
+ Terminator]> {
let summary = "Unconditional branch to target block.";
let description = [{
// -----
-def SPV_BranchConditionalOp : SPV_Op<"BranchConditional",
- [InFunctionScope, Terminator]> {
+def SPV_BranchConditionalOp : SPV_Op<"BranchConditional", [
+ DeclareOpInterfaceMethods<BranchOpInterface>, InFunctionScope,
+ Terminator]> {
let summary = [{
If Condition is true, branch to true block, otherwise branch to false
block.
#ifndef MLIR_DIALECT_SPIRV_SPIRVOPS_H_
#define MLIR_DIALECT_SPIRV_SPIRVOPS_H_
+#include "mlir/Analysis/ControlFlowInterfaces.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
#include "mlir/IR/Function.h"
#include "llvm/Support/PointerLikeTypeTraits.h"
#define MLIR_DIALECT_STANDARDOPS_IR_OPS_H
#include "mlir/Analysis/CallInterfaces.h"
+#include "mlir/Analysis/ControlFlowInterfaces.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/Dialect.h"
#include "mlir/IR/OpImplementation.h"
#define STANDARD_OPS
include "mlir/Analysis/CallInterfaces.td"
+include "mlir/Analysis/ControlFlowInterfaces.td"
include "mlir/IR/OpAsmInterface.td"
def Std_Dialect : Dialect {
// BranchOp
//===----------------------------------------------------------------------===//
-def BranchOp : Std_Op<"br", [Terminator]> {
+def BranchOp : Std_Op<"br",
+ [DeclareOpInterfaceMethods<BranchOpInterface>, Terminator]> {
let summary = "branch operation";
let description = [{
The "br" operation represents a branch operation in a function.
// CondBranchOp
//===----------------------------------------------------------------------===//
-def CondBranchOp : Std_Op<"cond_br", [Terminator]> {
+def CondBranchOp : Std_Op<"cond_br",
+ [DeclareOpInterfaceMethods<BranchOpInterface>, Terminator]> {
let summary = "conditional branch operation";
let description = [{
The "cond_br" operation represents a conditional branch operation in a
type_range getTypes() const { return {begin(), end()}; }
auto getType() const { return getTypes(); }
+ /// Return the operand index of the first element of this range. The range
+ /// must not be empty.
+ unsigned getBeginOperandIndex() const;
+
private:
/// See `detail::indexed_accessor_range_base` for details.
static OpOperand *offset_base(OpOperand *object, ptrdiff_t index) {
AffineAnalysis.cpp
AffineStructures.cpp
CallGraph.cpp
+ ControlFlowInterfaces.cpp
Dominance.cpp
InferTypeOpInterface.cpp
Liveness.cpp
add_llvm_library(MLIRAnalysis
CallGraph.cpp
+ ControlFlowInterfaces.cpp
InferTypeOpInterface.cpp
Liveness.cpp
SliceAnalysis.cpp
add_dependencies(MLIRAnalysis
MLIRAffineOps
MLIRCallOpInterfacesIncGen
+ MLIRControlFlowInterfacesIncGen
MLIRTypeInferOpInterfaceIncGen
MLIRLoopOps
)
add_dependencies(MLIRLoopAnalysis
MLIRAffineOps
MLIRCallOpInterfacesIncGen
+ MLIRControlFlowInterfacesIncGen
MLIRTypeInferOpInterfaceIncGen
MLIRLoopOps
)
--- /dev/null
+//===- ControlFlowInterfaces.h - ControlFlow Interfaces -------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Analysis/ControlFlowInterfaces.h"
+#include "mlir/IR/StandardTypes.h"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// ControlFlowInterfaces
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Analysis/ControlFlowInterfaces.cpp.inc"
+
+//===----------------------------------------------------------------------===//
+// BranchOpInterface
+//===----------------------------------------------------------------------===//
+
+/// Erase an operand from a branch operation that is used as a successor
+/// operand. 'operandIndex' is the operand within 'operands' to be erased.
+void mlir::detail::eraseBranchSuccessorOperand(OperandRange operands,
+ unsigned operandIndex,
+ Operation *op) {
+ assert(operandIndex < operands.size() &&
+ "invalid index for successor operands");
+
+ // Erase the operand from the operation.
+ size_t fullOperandIndex = operands.getBeginOperandIndex() + operandIndex;
+ op->eraseOperand(fullOperandIndex);
+
+ // If this operation has an OperandSegmentSizeAttr, keep it up to date.
+ auto operandSegmentAttr =
+ op->getAttrOfType<DenseElementsAttr>("operand_segment_sizes");
+ if (!operandSegmentAttr)
+ return;
+
+ // Find the segment containing the full operand index and decrement it.
+ // TODO: This seems like a general utility that could be added somewhere.
+ SmallVector<int32_t, 4> values(operandSegmentAttr.getValues<int32_t>());
+ unsigned currentSize = 0;
+ for (unsigned i = 0, e = values.size(); i != e; ++i) {
+ currentSize += values[i];
+ if (fullOperandIndex < currentSize) {
+ --values[i];
+ break;
+ }
+ }
+ op->setAttr("operand_segment_sizes",
+ DenseIntElementsAttr::get(operandSegmentAttr.getType(), values));
+}
+
+/// Returns the `BlockArgument` corresponding to operand `operandIndex` in some
+/// successor if 'operandIndex' is within the range of 'operands', or None if
+/// `operandIndex` isn't a successor operand index.
+Optional<BlockArgument> mlir::detail::getBranchSuccessorArgument(
+ Optional<OperandRange> operands, unsigned operandIndex, Block *successor) {
+ // Check that the operands are valid.
+ if (!operands || operands->empty())
+ return llvm::None;
+
+ // Check to ensure that this operand is within the range.
+ unsigned operandsStart = operands->getBeginOperandIndex();
+ if (operandIndex < operandsStart ||
+ operandIndex >= (operandsStart + operands->size()))
+ return llvm::None;
+
+ // Index the successor.
+ unsigned argIndex = operandIndex - operandsStart;
+ return successor->getArgument(argIndex);
+}
+
+/// Verify that the given operands match those of the given successor block.
+LogicalResult
+mlir::detail::verifyBranchSuccessorOperands(Operation *op, unsigned succNo,
+ Optional<OperandRange> operands) {
+ if (!operands)
+ return success();
+
+ // Check the count.
+ unsigned operandCount = operands->size();
+ Block *destBB = op->getSuccessor(succNo);
+ if (operandCount != destBB->getNumArguments())
+ return op->emitError() << "branch has " << operandCount
+ << " operands for successor #" << succNo
+ << ", but target block has "
+ << destBB->getNumArguments();
+
+ // Check the types.
+ auto operandIt = operands->begin();
+ for (unsigned i = 0; i != operandCount; ++i, ++operandIt) {
+ if ((*operandIt).getType() != destBB->getArgument(i).getType())
+ return op->emitError() << "type mismatch for bb argument #" << i
+ << " of successor #" << succNo;
+ }
+ return success();
+}
ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/LLVMIR
)
-add_dependencies(MLIRLLVMIR MLIRLLVMOpsIncGen MLIRLLVMConversionsIncGen MLIROpenMP LLVMFrontendOpenMP LLVMAsmParser LLVMCore LLVMSupport)
+add_dependencies(MLIRLLVMIR MLIRControlFlowInterfacesIncGen MLIRLLVMOpsIncGen MLIRLLVMConversionsIncGen MLIROpenMP LLVMFrontendOpenMP LLVMAsmParser LLVMCore LLVMSupport)
target_link_libraries(MLIRLLVMIR LLVMAsmParser LLVMCore LLVMSupport LLVMFrontendOpenMP MLIROpenMP MLIRIR)
add_mlir_dialect_library(MLIRNVVMIR
}
//===----------------------------------------------------------------------===//
+// LLVM::BrOp
+//===----------------------------------------------------------------------===//
+
+Optional<OperandRange> BrOp::getSuccessorOperands(unsigned index) {
+ assert(index == 0 && "invalid successor index");
+ return getOperands();
+}
+
+bool BrOp::canEraseSuccessorOperand() { return true; }
+
+//===----------------------------------------------------------------------===//
+// LLVM::CondBrOp
+//===----------------------------------------------------------------------===//
+
+Optional<OperandRange> CondBrOp::getSuccessorOperands(unsigned index) {
+ assert(index < getNumSuccessors() && "invalid successor index");
+ return index == 0 ? trueDestOperands() : falseDestOperands();
+}
+
+bool CondBrOp::canEraseSuccessorOperand() { return true; }
+
+//===----------------------------------------------------------------------===//
// Printing/parsing for LLVM::LoadOp.
//===----------------------------------------------------------------------===//
}
///===----------------------------------------------------------------------===//
-/// Verifying/Printing/Parsing for LLVM::InvokeOp.
+/// LLVM::InvokeOp
///===----------------------------------------------------------------------===//
+Optional<OperandRange> InvokeOp::getSuccessorOperands(unsigned index) {
+ assert(index < getNumSuccessors() && "invalid successor index");
+ return index == 0 ? normalDestOperands() : unwindDestOperands();
+}
+
+bool InvokeOp::canEraseSuccessorOperand() { return true; }
+
static LogicalResult verify(InvokeOp op) {
if (op.getNumResults() > 1)
return op.emitOpError("must have 0 or 1 result");
)
add_dependencies(MLIRSPIRV
+ MLIRControlFlowInterfacesIncGen
MLIRSPIRVAvailabilityIncGen
MLIRSPIRVCanonicalizationIncGen
MLIRSPIRVEnumAvailabilityIncGen
}
//===----------------------------------------------------------------------===//
+// spv.BranchOp
+//===----------------------------------------------------------------------===//
+
+Optional<OperandRange> spirv::BranchOp::getSuccessorOperands(unsigned index) {
+ assert(index == 0 && "invalid successor index");
+ return getOperands();
+}
+
+bool spirv::BranchOp::canEraseSuccessorOperand() { return true; }
+
+//===----------------------------------------------------------------------===//
// spv.BranchConditionalOp
//===----------------------------------------------------------------------===//
+Optional<OperandRange>
+spirv::BranchConditionalOp::getSuccessorOperands(unsigned index) {
+ assert(index < 2 && "invalid successor index");
+ return index == kTrueIndex ? getTrueBlockArguments()
+ : getFalseBlockArguments();
+}
+
+bool spirv::BranchConditionalOp::canEraseSuccessorOperand() { return true; }
+
static ParseResult parseBranchConditionalOp(OpAsmParser &parser,
OperationState &state) {
auto &builder = parser.getBuilder();
add_dependencies(MLIRStandardOps
MLIRCallOpInterfacesIncGen
+ MLIRControlFlowInterfacesIncGen
MLIREDSC
MLIRIR
MLIRStandardOpsIncGen
void BranchOp::setDest(Block *block) { return setSuccessor(block); }
void BranchOp::eraseOperand(unsigned index) {
- getOperation()->eraseSuccessorOperand(0, index);
+ getOperation()->eraseOperand(index);
}
void BranchOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
results.insert<SimplifyBrToBlockWithSinglePred>(context);
}
+Optional<OperandRange> BranchOp::getSuccessorOperands(unsigned index) {
+ assert(index == 0 && "invalid successor index");
+ return getOperands();
+}
+
+bool BranchOp::canEraseSuccessorOperand() { return true; }
+
//===----------------------------------------------------------------------===//
// CallOp
//===----------------------------------------------------------------------===//
results.insert<SimplifyConstCondBranchPred>(context);
}
+Optional<OperandRange> CondBranchOp::getSuccessorOperands(unsigned index) {
+ assert(index < getNumSuccessors() && "invalid successor index");
+ return index == trueIndex ? getTrueOperands() : getFalseOperands();
+}
+
+bool CondBranchOp::canEraseSuccessorOperand() { return true; }
+
//===----------------------------------------------------------------------===//
// Constant*Op
//===----------------------------------------------------------------------===//
return success();
}
-static LogicalResult verifySuccessor(Operation *op, unsigned succNo) {
- Operation::operand_range operands = op->getSuccessorOperands(succNo);
- unsigned operandCount = op->getNumSuccessorOperands(succNo);
- Block *destBB = op->getSuccessor(succNo);
- if (operandCount != destBB->getNumArguments())
- return op->emitError() << "branch has " << operandCount
- << " operands for successor #" << succNo
- << ", but target block has "
- << destBB->getNumArguments();
-
- auto operandIt = operands.begin();
- for (unsigned i = 0, e = operandCount; i != e; ++i, ++operandIt) {
- if ((*operandIt).getType() != destBB->getArgument(i).getType())
- return op->emitError() << "type mismatch for bb argument #" << i
- << " of successor #" << succNo;
- }
-
- return success();
-}
-
static LogicalResult verifyTerminatorSuccessors(Operation *op) {
auto *parent = op->getParentRegion();
// Verify that the operands lines up with the BB arguments in the successor.
- for (unsigned i = 0, e = op->getNumSuccessors(); i != e; ++i) {
- auto *succ = op->getSuccessor(i);
+ for (Block *succ : op->getSuccessors())
if (succ->getParent() != parent)
return op->emitError("reference to block defined in another region");
- if (failed(verifySuccessor(op, i)))
- return failure();
- }
return success();
}
OperandRange::OperandRange(Operation *op)
: OperandRange(op->getOpOperands().data(), op->getNumOperands()) {}
+/// Return the operand index of the first element of this range. The range
+/// must not be empty.
+unsigned OperandRange::getBeginOperandIndex() const {
+ assert(!empty() && "range must not be empty");
+ return base->getOperandNumber();
+}
+
//===----------------------------------------------------------------------===//
// ResultRange
TestPatterns.cpp
)
add_dependencies(MLIRTestDialect
+ MLIRControlFlowInterfacesIncGen
MLIRTestOpsIncGen
MLIRTypeInferOpInterfaceIncGen
)
}
//===----------------------------------------------------------------------===//
+// TestBranchOp
+//===----------------------------------------------------------------------===//
+
+Optional<OperandRange> TestBranchOp::getSuccessorOperands(unsigned index) {
+ assert(index == 0 && "invalid successor index");
+ return getOperands();
+}
+
+bool TestBranchOp::canEraseSuccessorOperand() { return true; }
+
+//===----------------------------------------------------------------------===//
// Test IsolatedRegionOp - parse passthrough region arguments.
//===----------------------------------------------------------------------===//
#define MLIR_TESTDIALECT_H
#include "mlir/Analysis/CallInterfaces.h"
+#include "mlir/Analysis/ControlFlowInterfaces.h"
#include "mlir/Analysis/InferTypeOpInterface.h"
#include "mlir/Dialect/Traits.h"
#include "mlir/IR/Dialect.h"
include "mlir/IR/OpBase.td"
include "mlir/IR/OpAsmInterface.td"
+include "mlir/Analysis/ControlFlowInterfaces.td"
include "mlir/Analysis/CallInterfaces.td"
include "mlir/Analysis/InferTypeOpInterface.td"
]> {
let arguments = (ins AnyTensor, AnyTensor);
let results = (outs AnyTensor);
+
+ let extraClassDeclaration = [{
+ LogicalResult reifyReturnTypeShapes(OpBuilder &builder,
+ SmallVectorImpl<Value> &shapes);
+ }];
}
def IsNotScalar : Constraint<CPred<"$0.getType().getRank() != 0">>;
(I32ElementsAttrOp ConstantAttr<I32ElementsAttr, "0">),
[(IsNotScalar $attr)]>;
-def TestBranchOp : TEST_Op<"br", [Terminator]> {
+def TestBranchOp : TEST_Op<"br",
+ [DeclareOpInterfaceMethods<BranchOpInterface>, Terminator]> {
let successors = (successor AnySuccessor:$target);
}
continue;
auto interface = opTrait->getOpInterface();
for (auto method : interface.getMethods()) {
- // Don't declare if the method has a body.
- if (method.getBody())
+ // Don't declare if the method has a body or a default implementation.
+ if (method.getBody() || method.getDefaultImplementation())
continue;
std::string args;
llvm::raw_string_ostream os(args);
projects / platform / upstream / llvm.git / commitdiff