forked from OSchip/llvm-project
[mlir] Revert "Tighten access of RewritePattern methods."
This reverts commit 02c9050155
.
Painted myself into a corner with -Wvirtual_overload, private access, and final.
Differential Revision: https://reviews.llvm.org/D92855
This commit is contained in:
parent
25f5df7e0b
commit
2a9840900c
|
@ -571,9 +571,11 @@ public:
|
|||
&typeConverter.getContext(), typeConverter,
|
||||
benefit) {}
|
||||
|
||||
private:
|
||||
/// Wrappers around the ConversionPattern methods that pass the derived op
|
||||
/// type.
|
||||
/// Wrappers around the RewritePattern methods that pass the derived op type.
|
||||
void rewrite(Operation *op, ArrayRef<Value> operands,
|
||||
ConversionPatternRewriter &rewriter) const final {
|
||||
rewrite(cast<SourceOp>(op), operands, rewriter);
|
||||
}
|
||||
LogicalResult match(Operation *op) const final {
|
||||
return match(cast<SourceOp>(op));
|
||||
}
|
||||
|
@ -582,10 +584,6 @@ private:
|
|||
ConversionPatternRewriter &rewriter) const final {
|
||||
return matchAndRewrite(cast<SourceOp>(op), operands, rewriter);
|
||||
}
|
||||
void rewrite(Operation *op, ArrayRef<Value> operands,
|
||||
ConversionPatternRewriter &rewriter) const final {
|
||||
rewrite(cast<SourceOp>(op), operands, rewriter);
|
||||
}
|
||||
|
||||
/// Rewrite and Match methods that operate on the SourceOp type. These must be
|
||||
/// overridden by the derived pattern class.
|
||||
|
@ -605,6 +603,10 @@ private:
|
|||
}
|
||||
return failure();
|
||||
}
|
||||
|
||||
private:
|
||||
using ConvertToLLVMPattern::match;
|
||||
using ConvertToLLVMPattern::matchAndRewrite;
|
||||
};
|
||||
|
||||
namespace LLVM {
|
||||
|
@ -634,7 +636,6 @@ public:
|
|||
using ConvertOpToLLVMPattern<SourceOp>::ConvertOpToLLVMPattern;
|
||||
using Super = OneToOneConvertToLLVMPattern<SourceOp, TargetOp>;
|
||||
|
||||
private:
|
||||
/// Converts the type of the result to an LLVM type, pass operands as is,
|
||||
/// preserve attributes.
|
||||
LogicalResult
|
||||
|
@ -654,7 +655,6 @@ public:
|
|||
using ConvertOpToLLVMPattern<SourceOp>::ConvertOpToLLVMPattern;
|
||||
using Super = VectorConvertToLLVMPattern<SourceOp, TargetOp>;
|
||||
|
||||
private:
|
||||
LogicalResult
|
||||
matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
|
||||
ConversionPatternRewriter &rewriter) const override {
|
||||
|
|
|
@ -156,6 +156,17 @@ class RewritePattern : public Pattern {
|
|||
public:
|
||||
virtual ~RewritePattern() {}
|
||||
|
||||
/// Rewrite the IR rooted at the specified operation with the result of
|
||||
/// this pattern, generating any new operations with the specified
|
||||
/// builder. If an unexpected error is encountered (an internal
|
||||
/// compiler error), it is emitted through the normal MLIR diagnostic
|
||||
/// hooks and the IR is left in a valid state.
|
||||
virtual void rewrite(Operation *op, PatternRewriter &rewriter) const;
|
||||
|
||||
/// Attempt to match against code rooted at the specified operation,
|
||||
/// which is the same operation code as getRootKind().
|
||||
virtual LogicalResult match(Operation *op) const;
|
||||
|
||||
/// Attempt to match against code rooted at the specified operation,
|
||||
/// which is the same operation code as getRootKind(). If successful, this
|
||||
/// function will automatically perform the rewrite.
|
||||
|
@ -172,18 +183,6 @@ protected:
|
|||
/// Inherit the base constructors from `Pattern`.
|
||||
using Pattern::Pattern;
|
||||
|
||||
/// Attempt to match against code rooted at the specified operation,
|
||||
/// which is the same operation code as getRootKind().
|
||||
virtual LogicalResult match(Operation *op) const;
|
||||
|
||||
private:
|
||||
/// Rewrite the IR rooted at the specified operation with the result of
|
||||
/// this pattern, generating any new operations with the specified
|
||||
/// builder. If an unexpected error is encountered (an internal
|
||||
/// compiler error), it is emitted through the normal MLIR diagnostic
|
||||
/// hooks and the IR is left in a valid state.
|
||||
virtual void rewrite(Operation *op, PatternRewriter &rewriter) const;
|
||||
|
||||
/// An anchor for the virtual table.
|
||||
virtual void anchor();
|
||||
};
|
||||
|
@ -192,14 +191,12 @@ private:
|
|||
/// matching and rewriting against an instance of a derived operation class as
|
||||
/// opposed to a raw Operation.
|
||||
template <typename SourceOp>
|
||||
class OpRewritePattern : public RewritePattern {
|
||||
public:
|
||||
struct OpRewritePattern : public RewritePattern {
|
||||
/// Patterns must specify the root operation name they match against, and can
|
||||
/// also specify the benefit of the pattern matching.
|
||||
OpRewritePattern(MLIRContext *context, PatternBenefit benefit = 1)
|
||||
: RewritePattern(SourceOp::getOperationName(), benefit, context) {}
|
||||
|
||||
private:
|
||||
/// Wrappers around the RewritePattern methods that pass the derived op type.
|
||||
void rewrite(Operation *op, PatternRewriter &rewriter) const final {
|
||||
rewrite(cast<SourceOp>(op), rewriter);
|
||||
|
|
|
@ -313,6 +313,30 @@ private:
|
|||
/// patterns of this type can only be used with the 'apply*' methods below.
|
||||
class ConversionPattern : public RewritePattern {
|
||||
public:
|
||||
/// Hook for derived classes to implement rewriting. `op` is the (first)
|
||||
/// operation matched by the pattern, `operands` is a list of the rewritten
|
||||
/// operand values that are passed to `op`, `rewriter` can be used to emit the
|
||||
/// new operations. This function should not fail. If some specific cases of
|
||||
/// the operation are not supported, these cases should not be matched.
|
||||
virtual void rewrite(Operation *op, ArrayRef<Value> operands,
|
||||
ConversionPatternRewriter &rewriter) const {
|
||||
llvm_unreachable("unimplemented rewrite");
|
||||
}
|
||||
|
||||
/// Hook for derived classes to implement combined matching and rewriting.
|
||||
virtual LogicalResult
|
||||
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
|
||||
ConversionPatternRewriter &rewriter) const {
|
||||
if (failed(match(op)))
|
||||
return failure();
|
||||
rewrite(op, operands, rewriter);
|
||||
return success();
|
||||
}
|
||||
|
||||
/// Attempt to match and rewrite the IR root at the specified operation.
|
||||
LogicalResult matchAndRewrite(Operation *op,
|
||||
PatternRewriter &rewriter) const final;
|
||||
|
||||
/// Return the type converter held by this pattern, or nullptr if the pattern
|
||||
/// does not require type conversion.
|
||||
TypeConverter *getTypeConverter() const { return typeConverter; }
|
||||
|
@ -336,46 +360,19 @@ protected:
|
|||
MatchAnyOpTypeTag tag)
|
||||
: RewritePattern(benefit, tag), typeConverter(&typeConverter) {}
|
||||
|
||||
private:
|
||||
/// Hook for derived classes to implement rewriting. `op` is the (first)
|
||||
/// operation matched by the pattern, `operands` is a list of the rewritten
|
||||
/// operand values that are passed to `op`, `rewriter` can be used to emit the
|
||||
/// new operations. This function should not fail. If some specific cases of
|
||||
/// the operation are not supported, these cases should not be matched.
|
||||
virtual void rewrite(Operation *op, ArrayRef<Value> operands,
|
||||
ConversionPatternRewriter &rewriter) const {
|
||||
llvm_unreachable("unimplemented rewrite");
|
||||
}
|
||||
|
||||
void rewrite(Operation *op, PatternRewriter &rewriter) const final {
|
||||
llvm_unreachable("never called");
|
||||
}
|
||||
|
||||
/// Hook for derived classes to implement combined matching and rewriting.
|
||||
virtual LogicalResult
|
||||
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
|
||||
ConversionPatternRewriter &rewriter) const {
|
||||
if (failed(match(op)))
|
||||
return failure();
|
||||
rewrite(op, operands, rewriter);
|
||||
return success();
|
||||
}
|
||||
|
||||
/// Attempt to match and rewrite the IR root at the specified operation.
|
||||
LogicalResult matchAndRewrite(Operation *op,
|
||||
PatternRewriter &rewriter) const final;
|
||||
|
||||
protected:
|
||||
/// An optional type converter for use by this pattern.
|
||||
TypeConverter *typeConverter = nullptr;
|
||||
|
||||
private:
|
||||
using RewritePattern::rewrite;
|
||||
};
|
||||
|
||||
/// OpConversionPattern is a wrapper around ConversionPattern that allows for
|
||||
/// matching and rewriting against an instance of a derived operation class as
|
||||
/// opposed to a raw Operation.
|
||||
template <typename SourceOp>
|
||||
class OpConversionPattern : public ConversionPattern {
|
||||
public:
|
||||
struct OpConversionPattern : public ConversionPattern {
|
||||
OpConversionPattern(MLIRContext *context, PatternBenefit benefit = 1)
|
||||
: ConversionPattern(SourceOp::getOperationName(), benefit, context) {}
|
||||
OpConversionPattern(TypeConverter &typeConverter, MLIRContext *context,
|
||||
|
@ -383,7 +380,6 @@ public:
|
|||
: ConversionPattern(SourceOp::getOperationName(), benefit, typeConverter,
|
||||
context) {}
|
||||
|
||||
private:
|
||||
/// Wrappers around the ConversionPattern methods that pass the derived op
|
||||
/// type.
|
||||
void rewrite(Operation *op, ArrayRef<Value> operands,
|
||||
|
@ -413,6 +409,9 @@ private:
|
|||
rewrite(op, operands, rewriter);
|
||||
return success();
|
||||
}
|
||||
|
||||
private:
|
||||
using ConversionPattern::matchAndRewrite;
|
||||
};
|
||||
|
||||
/// Add a pattern to the given pattern list to convert the signature of a FuncOp
|
||||
|
|
Loading…
Reference in New Issue