[MLIR] Fix OpDefinition::classof check for shared libraries.

[stephenneuendorffer]

Summary

When using MLIR in a shared library, it is possible for the shared library
to load a different, but equivalent version of a class method. As a result,
function pointer comparison is not a reliable check of class equivalence.
This causes problems related to this code in OpDefinition.h:

/// Return true if this "op class" can match against the specified operation.
static bool classof(Operation *op) {
  if (auto *abstractOp = op->getAbstractOperation()) {
    return &classof == abstractOp->classof;
  }
  return op->getName().getStringRef() == ConcreteType::getOperationName();
}

It appears that the intention is to implement the normal LLVM cast<>/isa<>
mechanism, but without a fixed enum of Kinds. Primarily, the operation
name check allows casting based on the operation name, which are assumed
to be unique for an operation class. (Aside: is this enforced anywhere?)
Before this, another, more efficient, check based on pointer equality of
the classof method. Unfortunately, this pointer equality check fails
if/when the classof method is inlined into a shared object (e.g. libLLVM.so)
and also exists in the main executable, resulting in triggering the assert()
inside cast<>.

This patch fixes this method to fall back to the slow, but accurate string
comparison if the function pointer comparison fails.

[mehdi_amini]

I think River fixed it already in D72822 ?

[stephenneuendorffer]

In D72584#1825796, @mehdi_amini wrote:

I think River fixed it already in D72822 ?

Yes, I think that's a better fix.

mlir/include/mlir/IR/OpDefinition.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_OPDEFINITION_H
 #define MLIR_IR_OPDEFINITION_H
 
 #include "mlir/IR/Operation.h"
 #include <type_traits>
+#include "llvm/Support/Debug.h"
 
 namespace mlir {
 class Builder;
 
 namespace OpTrait {
 template <typename ConcreteType> class OneResult;
 }
 
public:
   /// Return the dialect that this refers to.
   Dialect *getDialect() { return getOperation()->getDialect(); }
 
   /// Return the parent Region of this operation.
   Region *getParentRegion() { return getOperation()->getParentRegion(); }
 
   /// Return true if this "op class" can match against the specified operation.
   static bool classof(Operation *op) {
-    if (auto *abstractOp = op->getAbstractOperation())
-      return &classof == abstractOp->classof;
+    if (auto *abstractOp = op->getAbstractOperation()) {
+      if(&classof == abstractOp->classof) return true;
+    }
     return op->getName().getStringRef() == ConcreteType::getOperationName();
   }
 
   /// This is the hook used by the AsmParser to parse the custom form of this
   /// op from an .mlir file.  Op implementations should provide a parse method,
   /// which returns failure.  On success, they should return fill in result with
   /// the fields to use.
   static ParseResult parseAssembly(OpAsmParser &parser,