[Support] Add OpauqeDataStore

[beanz]

Summary

There are places in LLVM where data needs to be communicated between
layers that lack a good place to store the data. This leads to leaky
abstractions, or sometimes just using void*.

This data type can provide a type-safe alternative. The OpaqueDataStore
stores elements by type and can regurgitate them on demand. The object
holding the OpaqueDataStore requires no visibility to the types stored
within it, the classes for the stored data are only required to be
available at the points where the data is accessed.

I intend to use this in a subsequent patch to attach data to the
LLVMContext from inside the DirectX backend. The data being attached
should have the same lifetime as the LLVMContext, does not invalidate
(unless the context is destroyed), and should not be part of the IR
library.

[beanz]

Somehow accidentally uploaded this twice :(

llvm/include/llvm/Support/OpaqueDataStore.h

+//===-- llvm/Support/OpaqueDataStore.h --------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_OPAQUEDATASTORE_H
+#define LLVM_SUPPORT_OPAQUEDATASTORE_H
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+
+#include <memory>
+
+namespace llvm {
+class raw_ostream;
+
+/// Base class for StoredData.
+class StoredDataBase {
+public:
+  /// Must have a virtual destructor because it is used polymorphically.
+  virtual ~StoredDataBase() = default;
+
+  // Returns the class ID for this type.
+  static const void *classID() { return &ID; }
+
+  // Check whether this instance is a subclass of the class identified by
+  // ClassID.
+  virtual bool isA(const void *const ClassID) const {
+    return ClassID == classID();
+  }
+
+private:
+  virtual void anchor();
+
+  static char ID;
+};
+
+/// Template base helper for StoredData types
+template <typename ThisDataT, typename ParentDataT = StoredDataBase>
+class StoredDataInfo : public ParentDataT {
+public:
+  using ParentDataT::ParentDataT; // inherit constructors
+
+  /// Return the class ID for the metadata type.
+  static const void *classID() { return &ThisDataT::ID; }
+
+  /// Implement isA for this type and check the parent type as well.
+  bool isA(const void *const ClassID) const override {
+    return ClassID == classID() || ParentDataT::isA(ClassID);
+  }
+};
+
+/// Class for storing opaque type-safe data
+class OpaqueDataStore {
+public:
+  OpaqueDataStore() = default;
+
+  template <class... Mods> OpaqueDataStore(Mods... Ms) {
+    add(std::move(Ms)...);
+  }
+
+  /// Get an entry of the specified DataStore type, or insert a new default
+  /// constructed entry.
+  template <typename DataT> DataT &get() {
+    auto It = llvm::find_if(Storage,
+                            [](const std::unique_ptr<StoredDataBase> &Entry) {
+                              return Entry->isA(DataT::classID());
+                            });
+    if (It == Storage.end())
+      return insert<DataT>();
+    return *(DataT *)It->get();
+  }
+
+  /// Get an entry of the specified OpaqueDataStore type if it is stored. Unlike
+  /// get, this method does not construct an entry if it does not already exist,
+  /// but will return an empty optional instead.
+  template <typename DataT> llvm::Optional<const DataT *> find() const {
+    auto It = llvm::find_if(Storage,
+                            [](const std::unique_ptr<StoredDataBase> &Entry) {
+                              return Entry->isA(DataT::classID());
+                            });
+    if (It == Storage.end())
+      return {};
+    return {reinterpret_cast<DataT *>(It->get())};
+  }
+
+  /// Get an entry of the specified OpaqueDataStore type if it is stored. Unlike
+  /// get, this method does not construct an entry if it does not already exist,
+  /// but will return an empty optional instead.
+  template <typename DataT> llvm::Optional<DataT *> find() {
+    auto It = llvm::find_if(Storage,
+                            [](const std::unique_ptr<StoredDataBase> &Entry) {
+                              return Entry->isA(DataT::classID());
+                            });
+    if (It == Storage.end())
+      return {};
+    return {reinterpret_cast<DataT *>(It->get())};
+  }
+
+  template <typename DataT> bool contains() const {
+    return (bool)find<DataT>();
+  }
+
+  /// Returns the size of the OpaqueDataStore collection
+  size_t size() const { return Storage.size(); }
+
+private:
+  /// Insert a new StoredData entry into this collection, and only called via
+  /// get()
+  template <typename DataT, typename... ArgTs> DataT &insert(ArgTs &&...Args) {
+    return *(DataT *)Storage
+                .insert(Storage.end(),
+                        std::make_unique<DataT>(std::forward<ArgTs>(Args)...))
+                ->get();
+  }
+
+  template <typename T, class... Mods> void add(T D, Mods... Ms) {
+    add(std::move(D));
+    add(std::move(Ms)...);
+  }
+
+  /// Get an entry of the specified StoredData type, or insert a new default
+  /// constructed entry.
+  template <typename DataT> DataT &add(DataT D) {
+    assert(!contains<DataT>() && "adding arguments of the same type");
+    return insert<DataT>(std::move(D));
+  }
+
+  SmallVector<std::unique_ptr<StoredDataBase>, 8> Storage;
+};
+
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_OPAQUEDATASTORE_H

llvm/lib/Support/CMakeLists.txt

add_llvm_component_library(LLVMSupport
   MathExtras.cpp
   MemAlloc.cpp
   MemoryBuffer.cpp
   MemoryBufferRef.cpp
   MD5.cpp
   MSP430Attributes.cpp
   MSP430AttributeParser.cpp
   NativeFormatting.cpp
+  OpaqueDataStore.cpp
   OptimizedStructLayout.cpp
   Optional.cpp
   Parallel.cpp
   PluginLoader.cpp
   PrettyStackTrace.cpp
   RandomNumberGenerator.cpp
   Regex.cpp
   RISCVAttributes.cpp

llvm/lib/Support/OpaqueDataStore.cpp

+//===-- lib/Support/OpaqueDataStore.cpp -------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/OpaqueDataStore.h"
+
+using namespace llvm;
+
+void StoredDataBase::anchor() {}
+
+char StoredDataBase::ID = 0;

llvm/unittests/Support/CMakeLists.txt

add_llvm_unittest(SupportTests
   MatchersTest.cpp
   MD5Test.cpp
   ManagedStatic.cpp
   MathExtrasTest.cpp
   MemoryBufferRefTest.cpp
   MemoryBufferTest.cpp
   MemoryTest.cpp
   NativeFormatTests.cpp
+  OpaqueDataStoreTests.cpp
   OptimizedStructLayoutTest.cpp
   ParallelTest.cpp
   Path.cpp
   ProcessTest.cpp
   ProgramTest.cpp
   RegexTest.cpp
   ReverseIterationTest.cpp
   ReplaceFileTest.cpp

llvm/unittests/Support/OpaqueDataStoreTests.cpp

+//===- llvm/unittest/Support/DataStoreTests.cpp ---------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/OpaqueDataStore.h"
+
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+class DummyData : public StoredDataInfo<DummyData> {
+public:
+  DummyData() {}
+  static char ID;
+  uint32_t Value;
+};
+char DummyData::ID = 0;
+
+TEST(DataStoreTests, AddData) {
+  OpaqueDataStore Data;
+  EXPECT_FALSE(Data.contains<DummyData>());
+
+  DummyData &V1 = Data.get<DummyData>();
+  EXPECT_TRUE(Data.contains<DummyData>());
+
+  DummyData &V2 = Data.get<DummyData>();
+  EXPECT_EQ(Data.size(), 1ull);
+
+  V1.Value = 0xFEEDFACE;
+  EXPECT_EQ(V2.Value, 0xFEEDFACE);
+}