[mlir][NFC] Move several small methods from .cpp to .h to allow more aggressive inlining

[lattner]

These all LGTM, I'd personally keep isProperAncestor outlined, but it isn't widely used so it doesn't really matter.

[rriddle]

In D104756#2834896, @lattner wrote:

These all LGTM, I'd personally keep isProperAncestor outlined, but it isn't widely used so it doesn't really matter.

I've been sitting on this for like a week, and I can't remember which benchmark had this popup. Just moved it back out of line for now.

mlir/include/mlir/IR/Attributes.h

public:
 
   /// Return the type of this attribute.
   Type getType() const;
 
   /// Return the context this attribute belongs to.
   MLIRContext *getContext() const;
 
   /// Get the dialect this attribute is registered to.
-  Dialect &getDialect() const;
+  Dialect &getDialect() const {
+    return impl->getAbstractAttribute().getDialect();
+  }
 
   /// Print the attribute.
   void print(raw_ostream &os) const;
   void dump() const;
 
   /// Get an opaque pointer to the attribute.
   const void *getAsOpaquePointer() const { return impl; }
   /// Construct an attribute from the opaque pointer representation.

mlir/include/mlir/IR/Operation.h

public:
   /// regions. The new operation will have the same number of regions as the
   /// original one, but they will be left empty.
   Operation *cloneWithoutRegions();
 
   /// Returns the operation block that contains this operation.
   Block *getBlock() { return block; }
 
   /// Return the context this operation is associated with.
-  MLIRContext *getContext();
+  MLIRContext *getContext() { return location->getContext(); }
 
   /// Return the dialect this operation is associated with, or nullptr if the
   /// associated dialect is not registered.
-  Dialect *getDialect();
+  Dialect *getDialect() { return getName().getDialect(); }
 
   /// The source location the operation was defined or derived from.
   Location getLoc() { return location; }
 
   /// Set the source location the operation was defined or derived from.
   void setLoc(Location loc) { location = loc; }
 
   /// Returns the region to which the instruction belongs. Returns nullptr if
   /// the instruction is unlinked.
-  Region *getParentRegion();
+  Region *getParentRegion() { return block ? block->getParent() : nullptr; }
 
   /// Returns the closest surrounding operation that contains this operation
   /// or nullptr if this is a top-level operation.
-  Operation *getParentOp();
+  Operation *getParentOp() { return block ? block->getParentOp() : nullptr; }
 
   /// Return the closest surrounding parent operation that is of type 'OpTy'.
   template <typename OpTy> OpTy getParentOfType() {
     auto *op = this;
     while ((op = op->getParentOp()))
       if (auto parentOp = dyn_cast<OpTy>(op))
         return parentOp;
     return OpTy();

mlir/include/mlir/IR/Region.h

public:
   // Misc. utilities
   //===--------------------------------------------------------------------===//
 
   /// Return the region containing this region or nullptr if the region is
   /// attached to a top-level operation.
   Region *getParentRegion();
 
   /// Return the parent operation this region is attached to.
-  Operation *getParentOp();
+  Operation *getParentOp() { return container; }
 
   /// Find the first parent operation of the given type, or nullptr if there is
   /// no ancestor operation.
   template <typename ParentT>
   ParentT getParentOfType() {
     auto *region = this;
     do {
       if (auto parent = dyn_cast_or_null<ParentT>(region->container))

mlir/include/mlir/IR/Types.h

public:
   /// Return a unique identifier for the concrete type. This is used to support
   /// dynamic type casting.
   TypeID getTypeID() { return impl->getAbstractType().getTypeID(); }
 
   /// Return the MLIRContext in which this type was uniqued.
   MLIRContext *getContext() const;
 
   /// Get the dialect this type is registered to.
-  Dialect &getDialect() const;
+  Dialect &getDialect() const { return impl->getAbstractType().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;

mlir/lib/IR/Attributes.cpp

 //===----------------------------------------------------------------------===//
 
 /// Return the type of this attribute.
 Type Attribute::getType() const { return impl->getType(); }
 
 /// Return the context this attribute belongs to.
 MLIRContext *Attribute::getContext() const { return getDialect().getContext(); }
 
-/// Get the dialect this attribute is registered to.
-Dialect &Attribute::getDialect() const {
-  return impl->getAbstractAttribute().getDialect();
-}
-
 //===----------------------------------------------------------------------===//
 // NamedAttribute
 //===----------------------------------------------------------------------===//
 
 bool mlir::operator<(const NamedAttribute &lhs, const NamedAttribute &rhs) {
   return strcmp(lhs.first.data(), rhs.first.data()) < 0;
 }
 bool mlir::operator<(const NamedAttribute &lhs, StringRef rhs) {
   // This is correct even when attr.first.data()[name.size()] is not a zero
   // string terminator, because we only care about a less than comparison.
   // This can't use memcmp, because it doesn't guarantee that it will stop
   // reading both buffers if one is shorter than the other, even if there is
   // a difference.
   return strncmp(lhs.first.data(), rhs.data(), rhs.size()) < 0;
 }

mlir/lib/IR/Operation.cpp

void Operation::destroy() {
   // Operations may have additional prefixed allocation, which needs to be
   // accounted for here when computing the address to free.
   char *rawMem = reinterpret_cast<char *>(this) -
                  llvm::alignTo(prefixAllocSize(), alignof(Operation));
   this->~Operation();
   free(rawMem);
 }
 
-/// Return the context this operation is associated with.
-MLIRContext *Operation::getContext() { return location->getContext(); }
-
-/// Return the dialect this operation is associated with, or nullptr if the
-/// associated dialect is not registered.
-Dialect *Operation::getDialect() { return getName().getDialect(); }
-
-Region *Operation::getParentRegion() {
-  return block ? block->getParent() : nullptr;
-}
-
-Operation *Operation::getParentOp() {
-  return block ? block->getParentOp() : nullptr;
-}
-
 /// Return true if this operation is a proper ancestor of the `other`
 /// operation.
 bool Operation::isProperAncestor(Operation *other) {
   while ((other = other->getParentOp()))
     if (this == other)
       return true;
   return false;
 }

mlir/lib/IR/Region.cpp

iterator_range<Region::args_iterator> Region::addArguments(TypeRange types) {
   return front().addArguments(types);
 }
 
 Region *Region::getParentRegion() {
   assert(container && "region is not attached to a container");
   return container->getParentRegion();
 }
 
-Operation *Region::getParentOp() { return container; }
-
 bool Region::isProperAncestor(Region *other) {
   if (this == other)
     return false;
 
   while ((other = other->getParentRegion())) {
     if (this == other)
       return true;
   }

mlir/lib/IR/Types.cpp

 
 using namespace mlir;
 using namespace mlir::detail;
 
 //===----------------------------------------------------------------------===//
 // Type
 //===----------------------------------------------------------------------===//
 
-Dialect &Type::getDialect() const {
-  return impl->getAbstractType().getDialect();
-}
-
 MLIRContext *Type::getContext() const { return getDialect().getContext(); }
 
 bool Type::isBF16() const { return isa<BFloat16Type>(); }
 bool Type::isF16() const { return isa<Float16Type>(); }
 bool Type::isF32() const { return isa<Float32Type>(); }
 bool Type::isF64() const { return isa<Float64Type>(); }
 bool Type::isF80() const { return isa<Float80Type>(); }
 bool Type::isF128() const { return isa<Float128Type>(); }