hacking on typeid

[makslevental]

snip

[makslevental]

format test

mlir/include/mlir/Support/TypeID.h

const void *getAsOpaquePointer() const {
     return static_cast<const void *>(storage);
   }
   static TypeID getFromOpaquePointer(const void *pointer) {
     return TypeID(reinterpret_cast<const Storage *>(pointer));
   }
 
   /// Enable hashing TypeID.
   friend ::llvm::hash_code hash_value(TypeID id);
+  int hackTypeID;
 
 private:
   TypeID(const Storage *storage) : storage(storage) {}
 
   /// The storage of this type info object.
   const Storage *storage;
 
   friend class TypeIDAllocator;
 };
 
 /// Enable hashing TypeID.
 inline ::llvm::hash_code hash_value(TypeID id) {
-  return DenseMapInfo<const TypeID::Storage *>::getHashValue(id.storage);
+  //  return DenseMapInfo<const TypeID::Storage *>::getHashValue(id.storage);
+  return id.hackTypeID;
 }
 
 //===----------------------------------------------------------------------===//
 // TypeIDResolver
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 /// This class provides a fallback for resolving TypeIDs. It uses the string

 
 // Declare/define an explicit specialization for TypeID: this forces the
 // compiler to emit a strong definition for a class and controls which
 // translation unit and shared object will actually have it.
 // This can be useful to turn to a link-time failure what would be in other
 // circumstances a hard-to-catch runtime bug when a TypeID is hidden in two
 // different shared libraries and instances of the same class only gets the same
 // TypeID inside a given DSO.
-#define MLIR_DECLARE_EXPLICIT_TYPE_ID(CLASS_NAME)                              \
+#define MLIR_DECLARE_EXPLICIT_TYPE_ID_2_ARGS(CLASS_NAME, HACKTYPEID)           \
   namespace mlir {                                                             \
   namespace detail {                                                           \
   template <>                                                                  \
   class TypeIDResolver<CLASS_NAME> {                                           \
   public:                                                                      \
-    static TypeID resolveTypeID() { return id; }                               \
+    static TypeID resolveTypeID() {                                            \
+      id.hackTypeID = hackTypeID;                                              \
+      return id;                                                               \
+    }                                                                          \
+    static const int hackTypeID;                                               \
                                                                                \
   private:                                                                     \
     static SelfOwningTypeID id;                                                \
   };                                                                           \
   } /* namespace detail */                                                     \
   } /* namespace mlir */
 
-#define MLIR_DEFINE_EXPLICIT_TYPE_ID(CLASS_NAME)                               \
+#define MLIR_DECLARE_EXPLICIT_TYPE_ID(CLASS_NAME)                              \
+  MLIR_DECLARE_EXPLICIT_TYPE_ID_2_ARGS(CLASS_NAME, 1)
+
+#define MLIR_DEFINE_EXPLICIT_TYPE_ID_2_ARGS(CLASS_NAME, HACKTYPEID)            \
   namespace mlir {                                                             \
   namespace detail {                                                           \
   SelfOwningTypeID TypeIDResolver<CLASS_NAME>::id = {};                        \
+  const int TypeIDResolver<CLASS_NAME>::hackTypeID = HACKTYPEID;               \
   } /* namespace detail */                                                     \
   } /* namespace mlir */
 
+#define MLIR_DEFINE_EXPLICIT_TYPE_ID(CLASS_NAME)                               \
+  MLIR_DEFINE_EXPLICIT_TYPE_ID_2_ARGS(CLASS_NAME, 1)
+
 // Declare/define an explicit, **internal**, specialization of TypeID for the
 // given class. This is useful for providing an explicit specialization of
 // TypeID for a class that is known to be internal to a specific library. It
 // should be placed within a public section of the declaration of the class.
-#define MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(CLASS_NAME)               \
+#define MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID_2_ARGS(CLASS_NAME,        \
+                                                            HACKTYPEID)        \
   static ::mlir::TypeID resolveTypeID() {                                      \
     static ::mlir::SelfOwningTypeID id;                                        \
+    id.hackTypeID = HACKTYPEID;                                                \
     return id;                                                                 \
   }                                                                            \
   static_assert(                                                               \
       ::mlir::detail::InlineTypeIDResolver::has_resolve_typeid<                \
           CLASS_NAME>::value,                                                  \
       "`MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID` must be placed in a "    \
       "public section of `" #CLASS_NAME "`");
 
+#define MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(CLASS_NAME)               \
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID_2_ARGS(CLASS_NAME, 1)
+
 //===----------------------------------------------------------------------===//
 // TypeIDAllocator
 //===----------------------------------------------------------------------===//
 
 /// This class provides a way to define new TypeIDs at runtime.
 /// When the allocator is destructed, all allocated TypeIDs become invalid and
 /// therefore should not be used.
 class TypeIDAllocator {
public:
   SelfOwningTypeID &operator=(const SelfOwningTypeID &) = delete;
   SelfOwningTypeID(SelfOwningTypeID &&) = delete;
   SelfOwningTypeID &operator=(SelfOwningTypeID &&) = delete;
 
   /// Implicitly converts to the owned TypeID.
   operator TypeID() const { return getTypeID(); }
 
   /// Return the TypeID owned by this object.
-  TypeID getTypeID() const { return TypeID::getFromOpaquePointer(this); }
+  TypeID getTypeID() const {
+    auto t = TypeID::getFromOpaquePointer(this);
+    t.hackTypeID = hackTypeID;
+    return t;
+  }
+  int hackTypeID;
 };
 
 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // Builtin TypeIDs
 //===----------------------------------------------------------------------===//
 

mlir/include/mlir/TableGen/CodeGenHelpers.h

 #define MLIR_TABLEGEN_CODEGENHELPERS_H
 
 #include "mlir/TableGen/Dialect.h"
 #include "mlir/TableGen/Format.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include <iostream>
 
 namespace llvm {
 class RecordKeeper;
 } // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 class Constraint;

 std::string stringify(T &&t) {
   return detail::stringifier<std::remove_reference_t<std::remove_const_t<T>>>::
       apply(std::forward<T>(t));
 }
 
 } // namespace tblgen
 } // namespace mlir
 
+int nextCounterVal();
+void lock();
+void unlock();
+int findLast(const std::string &filename);
+
 #endif // MLIR_TABLEGEN_CODEGENHELPERS_H

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

if (defs.empty())
 
     // Emit the declarations.
     for (const AttrOrTypeDef &def : defs)
       DefGen(def).emitDecl(os);
   }
   // Emit the TypeID explicit specializations to have a single definition for
   // each of these.
   for (const AttrOrTypeDef &def : defs)
-    if (!def.getDialect().getCppNamespace().empty())
-      os << "MLIR_DECLARE_EXPLICIT_TYPE_ID("
+    if (!def.getDialect().getCppNamespace().empty()) {
+      auto n = nextCounterVal();
+      std::cout << "nextCounterVal" << n << "\n";
+      os << "MLIR_DECLARE_EXPLICIT_TYPE_ID_2_ARGS("
          << def.getDialect().getCppNamespace() << "::" << def.getCppClassName()
-         << ")\n";
+         << ", " << n << ")\n";
+    }
 
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // GEN: Def List
 //===----------------------------------------------------------------------===//
 
bool DefGenerator::emitDefs(StringRef selectedDialect) {
   emitParsePrintDispatch(defs);
   for (const AttrOrTypeDef &def : defs) {
     {
       NamespaceEmitter ns(os, def.getDialect());
       DefGen gen(def);
       gen.emitDef(os);
     }
     // Emit the TypeID explicit specializations to have a single symbol def.
-    if (!def.getDialect().getCppNamespace().empty())
-      os << "MLIR_DEFINE_EXPLICIT_TYPE_ID("
+    if (!def.getDialect().getCppNamespace().empty()) {
+      auto n = nextCounterVal();
+      std::cout << "nextCounterVal" << n << "\n";
+      os << "MLIR_DEFINE_EXPLICIT_TYPE_ID_2_ARGS("
          << def.getDialect().getCppNamespace() << "::" << def.getCppClassName()
-         << ")\n";
+         << ", " << n << ")\n";
+    }
   }
 
   Dialect firstDialect = defs.front().getDialect();
 
   // Emit the default parser/printer for Attributes if the dialect asked for it.
   if (isAttrGenerator && firstDialect.useDefaultAttributePrinterParser()) {
     NamespaceEmitter nsEmitter(os, firstDialect);
     if (firstDialect.isExtensible()) {
genTypeDefs("gen-typedef-defs", "Generate TypeDef definitions",
                   return generator.emitDefs(typeDialect);
                 });
 static mlir::GenRegistration
     genTypeDecls("gen-typedef-decls", "Generate TypeDef declarations",
                  [](const llvm::RecordKeeper &records, raw_ostream &os) {
                    TypeDefGenerator generator(records, os);
                    return generator.emitDecls(typeDialect);
                  });
+
+#include <errno.h>
+#include <fcntl.h>
+#include <iostream>
+#include <stdio.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <fstream>
+#include <iostream>
+
+static int fd;
+std::vector<int> counterVals(100000);
+
+int findLast(const std::string &filename) {
+  int last;
+  if (std::ifstream file{filename}) {
+    if (file >> last) {
+      int temp = 0;
+      while (file >> temp)
+        last = temp;
+      return last;
+    }
+    // if at least two numbers were read from the file
+    return -1;
+  }
+  // return -1 if the file doesn't open or the file doesn't read properly
+  return -1;
+}
+
+int nextCounterVal() {
+  auto next = counterVals.back() + 1;
+  std::cout << "next " << next << "\n";
+  counterVals.emplace_back(next);
+  return next;
+}
+
+void lock() {
+  char path[] = "/tmp/hacktypeid.txt";
+  fd = open(path, O_RDONLY | O_CREAT);
+  if (fd != -1) {
+    if (flock(fd, LOCK_EX) == 0) {
+      std::cout << "The file was locked" << std::endl;
+    } else {
+      perror("The file was not locked.");
+      exit(EXIT_FAILURE);
+    }
+
+    int lastNumber = findLast(path);
+    std::cout << "last number: " << lastNumber << "\n";
+    counterVals.emplace_back(lastNumber);
+  } else {
+    perror("Error opening file during lock.");
+    exit(EXIT_FAILURE);
+  }
+}
+
+void unlock() {
+  std::ofstream ofile;
+  ofile.open("/tmp/hacktypeid.txt",
+             std::ios::app); // app is append which means it
+  // will put the text at the end
+  counterVals.shrink_to_fit();
+  std::cout << "number new counter vals " << counterVals.size() << "\n";
+  for (int i = 1; i < counterVals.size(); ++i) {
+    auto c = counterVals[i];
+    if (c > 0)
+      ofile << c << "\n";
+  }
+
+  ofile.close();
+  if (flock(fd, LOCK_UN) == 0) {
+    std::cout << "The file was unlocked." << std::endl;
+  } else {
+    perror("The file was not unlocked.");
+    exit(EXIT_FAILURE);
+  }
+  close(fd);
+}

mlir/tools/mlir-tblgen/DialectGen.cpp

// Emit all nested namespaces.
     if (dialect.hasOperationInterfaceFallback())
       os << operationInterfaceFallbackDecl;
     if (std::optional<StringRef> extraDecl = dialect.getExtraClassDeclaration())
       os << *extraDecl;
 
     // End the dialect decl.
     os << "};\n";
   }
-  if (!dialect.getCppNamespace().empty())
-    os << "MLIR_DECLARE_EXPLICIT_TYPE_ID(" << dialect.getCppNamespace()
-       << "::" << dialect.getCppClassName() << ")\n";
+  if (!dialect.getCppNamespace().empty()) {
+    auto n = nextCounterVal();
+    std::cout << "nextCounterVal " << n << "\n";
+    os << "MLIR_DECLARE_EXPLICIT_TYPE_ID_2_ARGS(" << dialect.getCppNamespace()
+       << "::" << dialect.getCppClassName() << ", " << n << ")\n";
+  }
 }
 
 static bool emitDialectDecls(const llvm::RecordKeeper &recordKeeper,
                              raw_ostream &os) {
   emitSourceFileHeader("Dialect Declarations", os);
 
   auto dialectDefs = recordKeeper.getAllDerivedDefinitions("Dialect");
   if (dialectDefs.empty())

 {0}::~{0}() = default;
 
 )";
 
 static void emitDialectDef(Dialect &dialect, raw_ostream &os) {
   std::string cppClassName = dialect.getCppClassName();
 
   // Emit the TypeID explicit specializations to have a single symbol def.
-  if (!dialect.getCppNamespace().empty())
-    os << "MLIR_DEFINE_EXPLICIT_TYPE_ID(" << dialect.getCppNamespace()
-       << "::" << cppClassName << ")\n";
+  if (!dialect.getCppNamespace().empty()) {
+    auto n = nextCounterVal();
+    std::cout << "nextCounterVal" << n << "\n";
+    os << "MLIR_DEFINE_EXPLICIT_TYPE_ID_2_ARGS(" << dialect.getCppNamespace()
+       << "::" << cppClassName << ", " << n << ")\n";
+  }
 
   // Emit all nested namespaces.
   NamespaceEmitter nsEmitter(os, dialect);
 
   /// Build the list of dependent dialects.
   std::string dependentDialectRegistrations;
   {
     llvm::raw_string_ostream dialectsOs(dependentDialectRegistrations);

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

if (emitDecl) {
       {
         NamespaceEmitter emitter(os, op.getCppNamespace());
         os << formatv(opCommentHeader, op.getQualCppClassName(),
                       "declarations");
         OpOperandAdaptorEmitter::emitDecl(op, staticVerifierEmitter, os);
         OpEmitter::emitDecl(op, os, staticVerifierEmitter);
       }
       // Emit the TypeID explicit specialization to have a single definition.
-      if (!op.getCppNamespace().empty())
-        os << "MLIR_DECLARE_EXPLICIT_TYPE_ID(" << op.getCppNamespace()
-           << "::" << op.getCppClassName() << ")\n\n";
+      if (!op.getCppNamespace().empty()) {
+        auto n = nextCounterVal();
+        std::cout << "nextCounterVal" << n << "\n";
+        os << "MLIR_DECLARE_EXPLICIT_TYPE_ID_2_ARGS(" << op.getCppNamespace()
+           << "::" << op.getCppClassName() << ", " << n << ")\n\n";
+      }
     } else {
       {
         NamespaceEmitter emitter(os, op.getCppNamespace());
         os << formatv(opCommentHeader, op.getQualCppClassName(), "definitions");
         OpOperandAdaptorEmitter::emitDef(op, staticVerifierEmitter, os);
         OpEmitter::emitDef(op, os, staticVerifierEmitter);
       }
       // Emit the TypeID explicit specialization to have a single definition.
-      if (!op.getCppNamespace().empty())
-        os << "MLIR_DEFINE_EXPLICIT_TYPE_ID(" << op.getCppNamespace()
-           << "::" << op.getCppClassName() << ")\n\n";
+      if (!op.getCppNamespace().empty()) {
+        auto n = nextCounterVal();
+        std::cout << "nextCounterVal" << n << "\n";
+        os << "MLIR_DEFINE_EXPLICIT_TYPE_ID_2_ARGS(" << op.getCppNamespace()
+           << "::" << op.getCppClassName() << ", " << n << ")\n\n";
+      }
     }
   }
 }
 
 // Emits a comma-separated list of the ops.
 static void emitOpList(const std::vector<Record *> &defs, raw_ostream &os) {
   IfDefScope scope("GET_OP_LIST", os);
 

mlir/tools/mlir-tblgen/PassGen.cpp

 
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Pass.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
+#include "mlir/TableGen/CodeGenHelpers.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 static llvm::cl::OptionCategory passGenCat("Options for -gen-pass-decls");
 static llvm::cl::opt<std::string>
     groupName("name", llvm::cl::desc("The name of this group of passes"),
               llvm::cl::cat(passGenCat));

 //===----------------------------------------------------------------------===//
 
 /// The code snippet used to generate the start of a pass base class.
 ///
 /// {0}: The def name of the pass record.
 /// {1}: The base class for the pass.
 /// {2): The command line argument for the pass.
 /// {3}: The dependent dialects registration.
+/// {4}: HackTypeID
 const char *const baseClassBegin = R"(
 template <typename DerivedT>
 class {0}Base : public {1} {
 public:
   using Base = {0}Base;
 
   {0}Base() : {1}(::mlir::TypeID::get<DerivedT>()) {{}
   {0}Base(const {0}Base &other) : {1}(other) {{}
public:
   /// Return the dialect that must be loaded in the context before this pass.
   void getDependentDialects(::mlir::DialectRegistry &registry) const override {
     {4}
   }
 
   /// Explicitly declare the TypeID for this class. We declare an explicit private
   /// instantiation because Pass classes should only be visible by the current
   /// library.
-  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID({0}Base<DerivedT>)
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID_2_ARGS({0}Base<DerivedT>, {5})
 
 )";
 
 /// Registration for a single dependent dialect, to be inserted for each
 /// dependent dialect in the `getDependentDialects` above.
 const char *const dialectRegistrationTemplate = R"(
   registry.insert<{0}>();
 )";
static void emitPassDefs(const Pass &pass, raw_ostream &os) {
   std::string dependentDialectRegistrations;
   {
     llvm::raw_string_ostream dialectsOs(dependentDialectRegistrations);
     for (StringRef dependentDialect : pass.getDependentDialects())
       dialectsOs << llvm::formatv(dialectRegistrationTemplate,
                                   dependentDialect);
   }
 
+  auto n = nextCounterVal();
+
   os << "namespace impl {\n";
-  os << llvm::formatv(baseClassBegin, passName, pass.getBaseClass(),
-                      pass.getArgument(), pass.getSummary(),
-                      dependentDialectRegistrations);
+  os << llvm::formatv(baseClassBegin,
+                      passName,
+                      pass.getBaseClass(),
+                      pass.getArgument(),
+                      pass.getSummary(),
+                      dependentDialectRegistrations,
+                      n);
 
   if (ArrayRef<PassOption> options = pass.getOptions(); !options.empty()) {
     os.indent(2) << llvm::formatv(
         "{0}Base(const {0}Options &options) : {0}Base() {{\n", passName);
 
     for (const PassOption &opt : pass.getOptions())
       os.indent(4) << llvm::formatv("{0} = options.{0};\n",
                                     opt.getCppVariableName());
public:
   /// Return the dialect that must be loaded in the context before this pass.
   void getDependentDialects(::mlir::DialectRegistry &registry) const override {
     {4}
   }
 
   /// Explicitly declare the TypeID for this class. We declare an explicit private
   /// instantiation because Pass classes should only be visible by the current
   /// library.
-  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID({0}Base<DerivedT>)
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID_2_ARGS({0}Base<DerivedT>, {5})
 
 protected:
 )";
 
 // TODO: Drop old pass declarations.
 /// Emit a backward-compatible declaration of the pass base class.
 static void emitOldPassDecl(const Pass &pass, raw_ostream &os) {
   StringRef defName = pass.getDef()->getName();
   std::string dependentDialectRegistrations;
   {
     llvm::raw_string_ostream dialectsOs(dependentDialectRegistrations);
     for (StringRef dependentDialect : pass.getDependentDialects())
       dialectsOs << llvm::formatv(dialectRegistrationTemplate,
                                   dependentDialect);
   }
-  os << llvm::formatv(oldPassDeclBegin, defName, pass.getBaseClass(),
-                      pass.getArgument(), pass.getSummary(),
-                      dependentDialectRegistrations);
+  auto n = nextCounterVal();
+  os << llvm::formatv(oldPassDeclBegin,
+                      defName,
+                      pass.getBaseClass(),
+                      pass.getArgument(),
+                      pass.getSummary(),
+                      dependentDialectRegistrations,
+                      n
+                      );
   emitPassOptionDecls(pass, os);
   emitPassStatisticDecls(pass, os);
   os << "};\n";
 }
 
 static void emitPasses(const llvm::RecordKeeper &recordKeeper,
                        raw_ostream &os) {
   std::vector<Pass> passes = getPasses(recordKeeper);

mlir/tools/mlir-tblgen/mlir-tblgen.cpp

 //===- mlir-tblgen.cpp - Top-Level TableGen implementation for MLIR -------===//
 //
 // 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 main function for MLIR's TableGen.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/TableGen/CodeGenHelpers.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/Tools/mlir-tblgen/MlirTblgenMain.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace llvm;
 using namespace mlir;
 
 // Generator that prints records.
 GenRegistration printRecords("print-records", "Print all records to stdout",
                              [](const RecordKeeper &records, raw_ostream &os) {
                                os << records;
                                return false;
                              });
-
-int main(int argc, char **argv) { return MlirTblgenMain(argc, argv); }
+int main(int argc, char **argv) {
+  lock();
+  auto t = MlirTblgenMain(argc, argv);
+  unlock();
+  return t;
+}