From 9ec6b5b749523c1afc69e9727bb74be4733f66b6 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Wed, 15 May 2019 07:54:28 -0700 Subject: [PATCH] Remove some extraneous const qualifiers on Type, and 0b1 -> 1 in tblgen files. (NFC) -- PiperOrigin-RevId: 248332674 --- mlir/g3doc/QuickstartRewrites.md | 2 +- mlir/include/mlir/IR/OpBase.td | 10 +++--- mlir/include/mlir/IR/StandardTypes.h | 22 ++++++------ mlir/include/mlir/IR/Types.h | 28 +++++++-------- mlir/include/mlir/StandardOps/Ops.td | 40 +++++++++++----------- mlir/lib/IR/AsmPrinter.cpp | 4 +-- mlir/lib/IR/StandardTypes.cpp | 6 ++-- mlir/lib/IR/Types.cpp | 4 +-- .../Vectorization/VectorizerTestPass.cpp | 5 ++- 9 files changed, 60 insertions(+), 61 deletions(-) diff --git a/mlir/g3doc/QuickstartRewrites.md b/mlir/g3doc/QuickstartRewrites.md index 6335bd5..db440b2 100644 --- a/mlir/g3doc/QuickstartRewrites.md +++ b/mlir/g3doc/QuickstartRewrites.md @@ -61,7 +61,7 @@ def TFL_LeakyReluOp: TFL_Op<"leaky_relu", [NoSideEffect, SameValueType]>, // TFLite specific attribute that is used when generating the output // flatbuffer. - let hasOptions = 0b1; + let hasOptions = 1; } ``` diff --git a/mlir/include/mlir/IR/OpBase.td b/mlir/include/mlir/IR/OpBase.td index 21bce37..1463da2 100644 --- a/mlir/include/mlir/IR/OpBase.td +++ b/mlir/include/mlir/IR/OpBase.td @@ -481,7 +481,7 @@ class Attr : // Whether the attribute is optional. Typically requires a custom // convertFromStorage method to handle the case where the attribute is // not present. - bit isOptional = 0b0; + bit isOptional = 0; } // Decorates an attribute to have an (unvalidated) default value if not present. @@ -510,7 +510,7 @@ class OptionalAttr : Attr { let returnType = "Optional<" # attr.returnType #">"; let convertFromStorage = "$_self ? " # returnType # "(" # attr.convertFromStorage # ") : (llvm::None)"; - let isOptional = 0b1; + let isOptional = 1; // Remember `attr`'s def name. // TOOD(b/132458159): consider embedding Attr as a field. @@ -923,13 +923,13 @@ class Op props = []> { // TODO(b/120163349): figure out a better way to write canonicalization // patterns in TableGen rules directly instead of using this marker // and C++ implementations. - bit hasCanonicalizer = 0b0; + bit hasCanonicalizer = 0; // Whether this op has a constant folder. - bit hasConstantFolder = 0b0; + bit hasConstantFolder = 0; // Whether this op has a folder. - bit hasFolder = 0b0; + bit hasFolder = 0; // Op traits. list traits = props; diff --git a/mlir/include/mlir/IR/StandardTypes.h b/mlir/include/mlir/IR/StandardTypes.h index 7d8fad5..8043ac6 100644 --- a/mlir/include/mlir/IR/StandardTypes.h +++ b/mlir/include/mlir/IR/StandardTypes.h @@ -71,12 +71,12 @@ enum Kind { } // namespace StandardTypes -inline bool Type::isBF16() const { return getKind() == StandardTypes::BF16; } -inline bool Type::isF16() const { return getKind() == StandardTypes::F16; } -inline bool Type::isF32() const { return getKind() == StandardTypes::F32; } -inline bool Type::isF64() const { return getKind() == StandardTypes::F64; } +inline bool Type::isBF16() { return getKind() == StandardTypes::BF16; } +inline bool Type::isF16() { return getKind() == StandardTypes::F16; } +inline bool Type::isF32() { return getKind() == StandardTypes::F32; } +inline bool Type::isF64() { return getKind() == StandardTypes::F64; } -inline bool Type::isIndex() const { return getKind() == StandardTypes::Index; } +inline bool Type::isIndex() { return getKind() == StandardTypes::Index; } /// Index is a special integer-like type with unknown platform-dependent bit /// width. @@ -126,21 +126,21 @@ public: }; /// Return true if this is an integer type with the specified width. -inline bool Type::isInteger(unsigned width) const { +inline bool Type::isInteger(unsigned width) { if (auto intTy = dyn_cast()) return intTy.getWidth() == width; return false; } -inline bool Type::isIntOrIndex() const { +inline bool Type::isIntOrIndex() { return isa() || isa(); } -inline bool Type::isIntOrIndexOrFloat() const { +inline bool Type::isIntOrIndexOrFloat() { return isa() || isa() || isa(); } -inline bool Type::isIntOrFloat() const { +inline bool Type::isIntOrFloat() { return isa() || isa(); } @@ -174,10 +174,10 @@ public: } /// Return the bitwidth of this float type. - unsigned getWidth() const; + unsigned getWidth(); /// Return the floating semantics of this float type. - const llvm::fltSemantics &getFloatSemantics() const; + const llvm::fltSemantics &getFloatSemantics(); }; /// This is a common base class between Vector, UnrankedTensor, and RankedTensor diff --git a/mlir/include/mlir/IR/Types.h b/mlir/include/mlir/IR/Types.h index 511a988..59db7eb 100644 --- a/mlir/include/mlir/IR/Types.h +++ b/mlir/include/mlir/IR/Types.h @@ -141,36 +141,36 @@ public: unsigned getKind() const; /// Return the LLVMContext in which this type was uniqued. - MLIRContext *getContext() const; + MLIRContext *getContext(); /// Get the dialect this type is registered to. - const Dialect &getDialect() const; + const Dialect &getDialect(); // Convenience predicates. This is only for floating point types, // derived types should use isa/dyn_cast. - bool isIndex() const; - bool isBF16() const; - bool isF16() const; - bool isF32() const; - bool isF64() const; + bool isIndex(); + bool isBF16(); + bool isF16(); + bool isF32(); + bool isF64(); /// Return true if this is an integer type with the specified width. - bool isInteger(unsigned width) const; + bool isInteger(unsigned width); /// Return the bit width of an integer or a float type, assert failure on /// other types. - unsigned getIntOrFloatBitWidth() const; + unsigned getIntOrFloatBitWidth(); /// Return true if this is an integer or index type. - bool isIntOrIndex() const; + bool isIntOrIndex(); /// Return true if this is an integer, index, or float type. - bool isIntOrIndexOrFloat() const; + bool isIntOrIndexOrFloat(); /// Return true of this is an integer or a float type. - bool isIntOrFloat() const; + bool isIntOrFloat(); /// Print the current type. - void print(raw_ostream &os) const; - void dump() const; + void print(raw_ostream &os); + void dump(); friend ::llvm::hash_code hash_value(Type arg); diff --git a/mlir/include/mlir/StandardOps/Ops.td b/mlir/include/mlir/StandardOps/Ops.td index 31c2787..0497b84 100644 --- a/mlir/include/mlir/StandardOps/Ops.td +++ b/mlir/include/mlir/StandardOps/Ops.td @@ -112,13 +112,13 @@ class FloatArithmeticOp traits = []> : def AddFOp : FloatArithmeticOp<"addf"> { let summary = "floating point addition operation"; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; } def AddIOp : IntArithmeticOp<"addi", [Commutative]> { let summary = "integer addition operation"; let hasFolder = 1; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; } def AllocOp : Std_Op<"alloc"> { @@ -158,12 +158,12 @@ def AllocOp : Std_Op<"alloc"> { MemRefType getType() { return getResult()->getType().cast(); } }]; - let hasCanonicalizer = 0b1; + let hasCanonicalizer = 1; } def AndOp : IntArithmeticOp<"and", [Commutative]> { let summary = "integer binary and"; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; let hasFolder = 1; } @@ -271,7 +271,7 @@ def CallIndirectOp : Std_Op<"call_indirect"> { operand_iterator arg_operand_end() { return operand_end(); } }]; - let hasCanonicalizer = 0b1; + let hasCanonicalizer = 1; } def ConstantOp : Std_Op<"constant", [NoSideEffect]> { @@ -306,7 +306,7 @@ def DeallocOp : Std_Op<"dealloc"> { let arguments = (ins MemRef:$memref); - let hasCanonicalizer = 0b1; + let hasCanonicalizer = 1; } def DimOp : Std_Op<"dim", [NoSideEffect]> { @@ -338,7 +338,7 @@ def DimOp : Std_Op<"dim", [NoSideEffect]> { } }]; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; } def DivFOp : FloatArithmeticOp<"divf"> { @@ -347,12 +347,12 @@ def DivFOp : FloatArithmeticOp<"divf"> { def DivISOp : IntArithmeticOp<"divis"> { let summary = "signed integer division operation"; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; } def DivIUOp : IntArithmeticOp<"diviu"> { let summary = "unsigned integer division operation"; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; } def ExtractElementOp : Std_Op<"extract_element", [NoSideEffect]> { @@ -389,7 +389,7 @@ def ExtractElementOp : Std_Op<"extract_element", [NoSideEffect]> { } }]; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; } def MemRefCastOp : CastOp<"memref_cast"> { @@ -426,18 +426,18 @@ def MemRefCastOp : CastOp<"memref_cast"> { def MulFOp : FloatArithmeticOp<"mulf"> { let summary = "foating point multiplication operation"; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; } def MulIOp : IntArithmeticOp<"muli", [Commutative]> { let summary = "integer multiplication operation"; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; let hasFolder = 1; } def OrOp : IntArithmeticOp<"or", [Commutative]> { let summary = "integer binary or"; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; let hasFolder = 1; } @@ -447,12 +447,12 @@ def RemFOp : FloatArithmeticOp<"remf"> { def RemISOp : IntArithmeticOp<"remis"> { let summary = "signed integer division remainder operation"; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; } def RemIUOp : IntArithmeticOp<"remiu"> { let summary = "unsigned integer division remainder operation"; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; } def ReturnOp : Std_Op<"return", [Terminator]> { @@ -481,13 +481,13 @@ def ShlISOp : IntArithmeticOp<"shlis"> { def SubFOp : FloatArithmeticOp<"subf"> { let summary = "floating point subtraction operation"; - let hasConstantFolder = 0b1; + let hasConstantFolder = 1; } def SubIOp : IntArithmeticOp<"subi"> { let summary = "integer subtraction operation"; - let hasConstantFolder = 0b1; - let hasCanonicalizer = 0b1; + let hasConstantFolder = 1; + let hasCanonicalizer = 1; } def TensorCastOp : CastOp<"tensor_cast"> { @@ -518,8 +518,8 @@ def TensorCastOp : CastOp<"tensor_cast"> { def XOrOp : IntArithmeticOp<"xor", [Commutative]> { let summary = "integer binary xor"; - let hasConstantFolder = 0b1; - let hasCanonicalizer = 0b1; + let hasConstantFolder = 1; + let hasCanonicalizer = 1; let hasFolder = 1; } diff --git a/mlir/lib/IR/AsmPrinter.cpp b/mlir/lib/IR/AsmPrinter.cpp index ba0b9b5..807bc93 100644 --- a/mlir/lib/IR/AsmPrinter.cpp +++ b/mlir/lib/IR/AsmPrinter.cpp @@ -1628,12 +1628,12 @@ void Attribute::dump() const { llvm::errs() << "\n"; } -void Type::print(raw_ostream &os) const { +void Type::print(raw_ostream &os) { ModuleState state(getContext()); ModulePrinter(os, state).printType(*this); } -void Type::dump() const { print(llvm::errs()); } +void Type::dump() { print(llvm::errs()); } void AffineMap::dump() const { print(llvm::errs()); diff --git a/mlir/lib/IR/StandardTypes.cpp b/mlir/lib/IR/StandardTypes.cpp index 37071e1..ba7d1d3 100644 --- a/mlir/lib/IR/StandardTypes.cpp +++ b/mlir/lib/IR/StandardTypes.cpp @@ -61,7 +61,7 @@ unsigned IntegerType::getWidth() const { return getImpl()->width; } // Float Type //===----------------------------------------------------------------------===// -unsigned FloatType::getWidth() const { +unsigned FloatType::getWidth() { switch (getKind()) { case StandardTypes::BF16: case StandardTypes::F16: @@ -76,7 +76,7 @@ unsigned FloatType::getWidth() const { } /// Returns the floating semantics for the given type. -const llvm::fltSemantics &FloatType::getFloatSemantics() const { +const llvm::fltSemantics &FloatType::getFloatSemantics() { if (isBF16()) // Treat BF16 like a double. This is unfortunate but BF16 fltSemantics is // not defined in LLVM. @@ -93,7 +93,7 @@ const llvm::fltSemantics &FloatType::getFloatSemantics() const { llvm_unreachable("non-floating point type used"); } -unsigned Type::getIntOrFloatBitWidth() const { +unsigned Type::getIntOrFloatBitWidth() { assert(isIntOrFloat() && "only ints and floats have a bitwidth"); if (auto intType = dyn_cast()) { return intType.getWidth(); diff --git a/mlir/lib/IR/Types.cpp b/mlir/lib/IR/Types.cpp index a8f8c6c..3932e94 100644 --- a/mlir/lib/IR/Types.cpp +++ b/mlir/lib/IR/Types.cpp @@ -27,9 +27,9 @@ using namespace mlir::detail; unsigned Type::getKind() const { return impl->getKind(); } /// Get the dialect this type is registered to. -const Dialect &Type::getDialect() const { return impl->getDialect(); } +const Dialect &Type::getDialect() { return impl->getDialect(); } -MLIRContext *Type::getContext() const { return getDialect().getContext(); } +MLIRContext *Type::getContext() { return getDialect().getContext(); } unsigned Type::getSubclassData() const { return impl->getSubclassData(); } void Type::setSubclassData(unsigned val) { impl->setSubclassData(val); } diff --git a/mlir/lib/Transforms/Vectorization/VectorizerTestPass.cpp b/mlir/lib/Transforms/Vectorization/VectorizerTestPass.cpp index 7b4db1f..81c0099 100644 --- a/mlir/lib/Transforms/Vectorization/VectorizerTestPass.cpp +++ b/mlir/lib/Transforms/Vectorization/VectorizerTestPass.cpp @@ -105,9 +105,8 @@ void VectorizerTestPass::testVectorShapeRatio(llvm::raw_ostream &outs) { VectorType::get(shape, FloatType::getF32(f->getContext())); // Only filter operations that operate on a strict super-vector and have one // return. This makes testing easier. - auto filter = [subVectorType](Operation &op) { - assert(subVectorType.getElementType() == - FloatType::getF32(subVectorType.getContext()) && + auto filter = [&](Operation &op) { + assert(subVectorType.getElementType().isF32() && "Only f32 supported for now"); if (!matcher::operatesOnSuperVectorsOf(op, subVectorType)) { return false; -- 2.7.4