Add SYCL prefix to PropertySet etc.

Signed-off-by: Arvind Sudarsanam <[email protected]>

Author: asudarsa

llvm/include/llvm/Support/PropertySetIO.h renamed to llvm/include/llvm/Support/SYCLPropertySetIO.h

@@ -1,20 +1,20 @@
-//==-- PropertySetIO.h -- models a sequence of property sets and their I/O -==//
+//=- SYCLPropertySetIO.h -- models a sequence of property sets and their I/O =//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 // Models a sequence of property sets and their input and output operations.
-// PropertyValue set format:
-//   '['<PropertyValue set name>']'
+// SYCLPropertyValue set format:
+//   '['<SYCLPropertyValue set name>']'
 //   <property name>=<property type>'|'<property value>
 //   <property name>=<property type>'|'<property value>
 //   ...
-//   '['<PropertyValue set name>']'
+//   '['<SYCLPropertyValue set name>']'
 //   <property name>=<property type>'|'<property value>
 // where
-//   <PropertyValue set name>, <property name> are strings
+//   <SYCLPropertyValue set name>, <property name> are strings
 //   <property type> - string representation of the property type
 //   <property value> - string representation of the property value.
 //
@@ -29,8 +29,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_SUPPORT_PROPERTYSETIO_H
-#define LLVM_SUPPORT_PROPERTYSETIO_H
+#ifndef LLVM_SUPPORT_SYCLPROPERTYSETIO_H
+#define LLVM_SUPPORT_SYCLPROPERTYSETIO_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallString.h"
@@ -44,9 +44,9 @@
 namespace llvm {
 namespace util {
 
-// Represents a property value. PropertyValue name is stored in the encompassing
-// container.
-class PropertyValue {
+// Represents a SYCL property value. SYCLPropertyValue name is stored in the
+// encompassing container.
+class SYCLPropertyValue {
 public:
   // Type of the size of the value. Value size gets serialized along with the
   // value data in some cases for later reading at runtime, so size_t is not
@@ -66,26 +66,27 @@ class PropertyValue {
     return static_cast<Type>(T);
   }
 
-  ~PropertyValue() {}
+  ~SYCLPropertyValue() {}
 
-  PropertyValue() = default;
-  PropertyValue(Type T) : Ty(T) {}
+  SYCLPropertyValue() = default;
+  SYCLPropertyValue(Type T) : Ty(T) {}
 
-  PropertyValue(uint32_t Val) : Ty(UINT32), Val({Val}) {}
-  PropertyValue(const std::byte *Data, SizeTy DataBitSize);
+  SYCLPropertyValue(uint32_t Val) : Ty(UINT32), Val({Val}) {}
+  SYCLPropertyValue(const std::byte *Data, SizeTy DataBitSize);
   template <typename C, typename T = typename C::value_type>
-  PropertyValue(const C &Data)
-      : PropertyValue(reinterpret_cast<const std::byte *>(Data.data()),
-                      Data.size() * sizeof(T) * CHAR_BIT) {}
-  PropertyValue(const llvm::StringRef &Str)
-      : PropertyValue(reinterpret_cast<const std::byte *>(Str.data()),
-                      Str.size() * sizeof(char) * /* bits in one byte */ 8) {}
-  PropertyValue(const PropertyValue &P);
-  PropertyValue(PropertyValue &&P);
+  SYCLPropertyValue(const C &Data)
+      : SYCLPropertyValue(reinterpret_cast<const std::byte *>(Data.data()),
+                          Data.size() * sizeof(T) * CHAR_BIT) {}
+  SYCLPropertyValue(const llvm::StringRef &Str)
+      : SYCLPropertyValue(reinterpret_cast<const std::byte *>(Str.data()),
+                          Str.size() * sizeof(char) *
+                              /* bits in one byte */ 8) {}
+  SYCLPropertyValue(const SYCLPropertyValue &P);
+  SYCLPropertyValue(SYCLPropertyValue &&P);
 
-  PropertyValue &operator=(PropertyValue &&P);
+  SYCLPropertyValue &operator=(SYCLPropertyValue &&P);
 
-  PropertyValue &operator=(const PropertyValue &P);
+  SYCLPropertyValue &operator=(const SYCLPropertyValue &P);
 
   // Get property value as unsigned 32-bit integer
   uint32_t asUint32() const {
@@ -139,14 +140,14 @@ class PropertyValue {
 
   bool isValid() const { return getType() != NONE; }
 
-  // Set property value; the 'T' type must be convertible to a property type tag
+  // Set property value when data type is UINT32_T
   void set(uint32_t V) {
     if (Ty != UINT32)
       llvm_unreachable("invalid type tag for this operation");
     Val = V;
   }
 
-  // Set property value; the 'T' type must be convertible to a property type tag
+  // Set property value when data type is BYTE_ARRAY
   void set(std::byte *V, int DataSize) {
     if (Ty != BYTE_ARRAY)
       llvm_unreachable("invalid type tag for this operation");
@@ -175,19 +176,19 @@ class PropertyValue {
     case BYTE_ARRAY:
       return getRawByteArraySize();
     default:
-      llvm_unreachable_internal("unsupported property type");
+      llvm_unreachable_internal("unsupported SYCL property type");
     }
   }
 
 private:
-  void copy(const PropertyValue &P);
+  void copy(const SYCLPropertyValue &P);
 
   Type Ty = NONE;
   std::variant<uint32_t, std::byte *> Val;
 };
 
-/// Structure for specialization of DenseMap in PropertySetRegistry.
-struct PropertySetKeyInfo {
+/// Structure for specialization of DenseMap in SYCLPropertySetRegistry.
+struct SYCLPropertySetKeyInfo {
   static unsigned getHashValue(const SmallString<16> &K) { return xxHash64(K); }
 
   static SmallString<16> getEmptyKey() { return SmallString<16>(""); }
@@ -197,17 +198,19 @@ struct PropertySetKeyInfo {
   static bool isEqual(StringRef L, StringRef R) { return L == R; }
 };
 
-using PropertyMapTy = DenseMap<SmallString<16>, unsigned, PropertySetKeyInfo>;
+using SYCLPropertyMapTy =
+    DenseMap<SmallString<16>, unsigned, SYCLPropertySetKeyInfo>;
 /// A property set. Preserves insertion order when iterating elements.
-using PropertySet = MapVector<SmallString<16>, PropertyValue, PropertyMapTy>;
+using SYCLPropertySet =
+    MapVector<SmallString<16>, SYCLPropertyValue, SYCLPropertyMapTy>;
 
 /// A registry of property sets. Maps a property set name to its
 /// content.
 ///
 /// The order of keys is preserved and corresponds to the order of insertion.
-class PropertySetRegistry {
+class SYCLPropertySetRegistry {
 public:
-  using MapTy = MapVector<SmallString<16>, PropertySet, PropertyMapTy>;
+  using MapTy = MapVector<SmallString<16>, SYCLPropertySet, SYCLPropertyMapTy>;
 
   // Specific property category names used by tools.
   static constexpr char SYCL_SPECIALIZATION_CONSTANTS[] =
@@ -234,19 +237,19 @@ class PropertySetRegistry {
     auto &PropSet = PropSetMap[Category];
 
     for (const auto &[PropName, PropVal] : Props)
-      PropSet.insert_or_assign(PropName, PropertyValue(PropVal));
+      PropSet.insert_or_assign(PropName, SYCLPropertyValue(PropVal));
   }
 
   /// Adds the given \p PropVal with the given \p PropName into the given \p
   /// Category .
   template <typename T>
   void add(StringRef Category, StringRef PropName, const T &PropVal) {
     auto &PropSet = PropSetMap[Category];
-    PropSet.insert({PropName, PropertyValue(PropVal)});
+    PropSet.insert({PropName, SYCLPropertyValue(PropVal)});
   }
 
   /// Parses from the given \p Buf a property set registry.
-  static Expected<std::unique_ptr<PropertySetRegistry>>
+  static Expected<std::unique_ptr<SYCLPropertySetRegistry>>
   read(const MemoryBuffer *Buf);
 
   /// Dumps the property set registry to the given \p Out stream.
@@ -256,7 +259,7 @@ class PropertySetRegistry {
   MapTy::const_iterator end() const { return PropSetMap.end(); }
 
   /// Retrieves a property set with given \p Name .
-  PropertySet &operator[](StringRef Name) { return PropSetMap[Name]; }
+  SYCLPropertySet &operator[](StringRef Name) { return PropSetMap[Name]; }
   /// Constant access to the underlying map.
   const MapTy &getPropSets() const { return PropSetMap; }
 
@@ -268,4 +271,4 @@ class PropertySetRegistry {
 
 } // namespace llvm
 
-#endif // #define LLVM_SUPPORT_PROPERTYSETIO_H
+#endif // #define LLVM_SUPPORT_SYCLPROPERTYSETIO_H

llvm/lib/Support/CMakeLists.txt

@@ -217,7 +217,7 @@ add_llvm_component_library(LLVMSupport
   Parallel.cpp
   PluginLoader.cpp
   PrettyStackTrace.cpp
-  PropertySetIO.cpp  
+  SYCLPropertySetIO.cpp  
   RandomNumberGenerator.cpp
   Regex.cpp
   RewriteBuffer.cpp

llvm/lib/Support/PropertySetIO.cpp renamed to llvm/lib/Support/SYCLPropertySetIO.cpp

@@ -1,12 +1,12 @@
-//==- PropertySetIO.cpp - models a sequence of property sets and their I/O -==//
+//= SYCLPropertySetIO.cpp - models a sequence of property sets and their I/O =//
 //
 // 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/PropertySetIO.h"
+#include "llvm/Support/SYCLPropertySetIO.h"
 
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/StringExtras.h"
@@ -28,10 +28,10 @@ ::llvm::Error makeError(const Twine &Msg) {
 
 } // anonymous namespace
 
-Expected<std::unique_ptr<PropertySetRegistry>>
-PropertySetRegistry::read(const MemoryBuffer *Buf) {
-  auto Res = std::make_unique<PropertySetRegistry>();
-  PropertySet *CurPropSet = nullptr;
+Expected<std::unique_ptr<SYCLPropertySetRegistry>>
+SYCLPropertySetRegistry::read(const MemoryBuffer *Buf) {
+  auto Res = std::make_unique<SYCLPropertySetRegistry>();
+  SYCLPropertySet *CurPropSet = nullptr;
 
   for (line_iterator LI(*Buf); !LI.is_at_end(); LI++) {
     // See if this line starts a new property set
@@ -60,17 +60,17 @@ PropertySetRegistry::read(const MemoryBuffer *Buf) {
     // Parse type
     if (TypeVal.first.getAsInteger(10, Tint))
       return makeError("invalid property type: " + TypeVal.first);
-    Expected<PropertyValue::Type> Ttag =
-        PropertyValue::getTypeTag(static_cast<int>(Tint.getSExtValue()));
+    Expected<SYCLPropertyValue::Type> Ttag =
+        SYCLPropertyValue::getTypeTag(static_cast<int>(Tint.getSExtValue()));
     StringRef Val = TypeVal.second;
 
     if (!Ttag)
       return Ttag.takeError();
-    PropertyValue Prop(Ttag.get());
+    SYCLPropertyValue Prop(Ttag.get());
 
     // Parse value depending on its type
     switch (Ttag.get()) {
-    case PropertyValue::Type::UINT32: {
+    case SYCLPropertyValue::Type::UINT32: {
       APInt ValV;
       if (Val.getAsInteger(10, ValV))
         return createStringError(std::error_code{},
@@ -79,7 +79,7 @@ PropertySetRegistry::read(const MemoryBuffer *Buf) {
       llvm::errs() << "ARV: read int done\n";
       break;
     }
-    case PropertyValue::Type::BYTE_ARRAY: {
+    case SYCLPropertyValue::Type::BYTE_ARRAY: {
       std::vector<char> Output;
       if (Error Err = decodeBase64(Val, Output))
         return std::move(Err);
@@ -95,18 +95,18 @@ PropertySetRegistry::read(const MemoryBuffer *Buf) {
   if (!CurPropSet)
     return makeError("invalid property set registry");
 
-  return Expected<std::unique_ptr<PropertySetRegistry>>(std::move(Res));
+  return Expected<std::unique_ptr<SYCLPropertySetRegistry>>(std::move(Res));
 }
 
 namespace llvm {
 // Output a property to a stream
-raw_ostream &operator<<(raw_ostream &Out, const PropertyValue &Prop) {
+raw_ostream &operator<<(raw_ostream &Out, const SYCLPropertyValue &Prop) {
   Out << static_cast<int>(Prop.getType()) << '|';
   switch (Prop.getType()) {
-  case PropertyValue::Type::UINT32:
+  case SYCLPropertyValue::Type::UINT32:
     Out << Prop.asUint32();
     break;
-  case PropertyValue::Type::BYTE_ARRAY: {
+  case SYCLPropertyValue::Type::BYTE_ARRAY: {
     auto PropArr = Prop.asByteArray();
     std::vector<std::byte> V(PropArr, PropArr + Prop.getByteArraySize() /
                                                     sizeof(std::byte));
@@ -121,7 +121,7 @@ raw_ostream &operator<<(raw_ostream &Out, const PropertyValue &Prop) {
 }
 } // namespace llvm
 
-void PropertySetRegistry::write(raw_ostream &Out) const {
+void SYCLPropertySetRegistry::write(raw_ostream &Out) const {
   for (const auto &PropSet : PropSetMap) {
     Out << '[' << PropSet.first << "]\n";
 
@@ -133,15 +133,16 @@ void PropertySetRegistry::write(raw_ostream &Out) const {
 namespace llvm {
 namespace util {
 
-template <> PropertyValue::Type PropertyValue::getTypeTag<uint32_t>() {
+template <> SYCLPropertyValue::Type SYCLPropertyValue::getTypeTag<uint32_t>() {
   return UINT32;
 }
 
-template <> PropertyValue::Type PropertyValue::getTypeTag<std::byte *>() {
+template <>
+SYCLPropertyValue::Type SYCLPropertyValue::getTypeTag<std::byte *>() {
   return BYTE_ARRAY;
 }
 
-PropertyValue::PropertyValue(const std::byte *Data, SizeTy DataBitSize)
+SYCLPropertyValue::SYCLPropertyValue(const std::byte *Data, SizeTy DataBitSize)
     : Ty(BYTE_ARRAY) {
   constexpr int ByteSizeInBits = 8;
   SizeTy DataSize = (DataBitSize + (ByteSizeInBits - 1)) / ByteSizeInBits;
@@ -161,11 +162,13 @@ PropertyValue::PropertyValue(const std::byte *Data, SizeTy DataBitSize)
   std::memcpy(ByteArrayVal + SizeFieldSize, Data, DataSize);
 }
 
-PropertyValue::PropertyValue(const PropertyValue &P) { *this = P; }
+SYCLPropertyValue::SYCLPropertyValue(const SYCLPropertyValue &P) { *this = P; }
 
-PropertyValue::PropertyValue(PropertyValue &&P) { *this = std::move(P); }
+SYCLPropertyValue::SYCLPropertyValue(SYCLPropertyValue &&P) {
+  *this = std::move(P);
+}
 
-PropertyValue &PropertyValue::operator=(PropertyValue &&P) {
+SYCLPropertyValue &SYCLPropertyValue::operator=(SYCLPropertyValue &&P) {
   copy(P);
 
   if (P.getType() == BYTE_ARRAY)
@@ -174,32 +177,32 @@ PropertyValue &PropertyValue::operator=(PropertyValue &&P) {
   return *this;
 }
 
-PropertyValue &PropertyValue::operator=(const PropertyValue &P) {
+SYCLPropertyValue &SYCLPropertyValue::operator=(const SYCLPropertyValue &P) {
   if (P.getType() == BYTE_ARRAY)
-    *this = PropertyValue(P.asByteArray(), P.getByteArraySizeInBits());
+    *this = SYCLPropertyValue(P.asByteArray(), P.getByteArraySizeInBits());
   else
     copy(P);
   return *this;
 }
 
-void PropertyValue::copy(const PropertyValue &P) {
+void SYCLPropertyValue::copy(const SYCLPropertyValue &P) {
   Ty = P.Ty;
   Val = P.Val;
 }
 
-constexpr char PropertySetRegistry::SYCL_SPECIALIZATION_CONSTANTS[];
-constexpr char PropertySetRegistry::SYCL_DEVICELIB_REQ_MASK[];
-constexpr char PropertySetRegistry::SYCL_SPEC_CONSTANTS_DEFAULT_VALUES[];
-constexpr char PropertySetRegistry::SYCL_KERNEL_PARAM_OPT_INFO[];
-constexpr char PropertySetRegistry::SYCL_PROGRAM_METADATA[];
-constexpr char PropertySetRegistry::SYCL_MISC_PROP[];
-constexpr char PropertySetRegistry::SYCL_ASSERT_USED[];
-constexpr char PropertySetRegistry::SYCL_EXPORTED_SYMBOLS[];
-constexpr char PropertySetRegistry::SYCL_IMPORTED_SYMBOLS[];
-constexpr char PropertySetRegistry::SYCL_DEVICE_GLOBALS[];
-constexpr char PropertySetRegistry::SYCL_DEVICE_REQUIREMENTS[];
-constexpr char PropertySetRegistry::SYCL_HOST_PIPES[];
-constexpr char PropertySetRegistry::SYCL_VIRTUAL_FUNCTIONS[];
+constexpr char SYCLPropertySetRegistry::SYCL_SPECIALIZATION_CONSTANTS[];
+constexpr char SYCLPropertySetRegistry::SYCL_DEVICELIB_REQ_MASK[];
+constexpr char SYCLPropertySetRegistry::SYCL_SPEC_CONSTANTS_DEFAULT_VALUES[];
+constexpr char SYCLPropertySetRegistry::SYCL_KERNEL_PARAM_OPT_INFO[];
+constexpr char SYCLPropertySetRegistry::SYCL_PROGRAM_METADATA[];
+constexpr char SYCLPropertySetRegistry::SYCL_MISC_PROP[];
+constexpr char SYCLPropertySetRegistry::SYCL_ASSERT_USED[];
+constexpr char SYCLPropertySetRegistry::SYCL_EXPORTED_SYMBOLS[];
+constexpr char SYCLPropertySetRegistry::SYCL_IMPORTED_SYMBOLS[];
+constexpr char SYCLPropertySetRegistry::SYCL_DEVICE_GLOBALS[];
+constexpr char SYCLPropertySetRegistry::SYCL_DEVICE_REQUIREMENTS[];
+constexpr char SYCLPropertySetRegistry::SYCL_HOST_PIPES[];
+constexpr char SYCLPropertySetRegistry::SYCL_VIRTUAL_FUNCTIONS[];
 
 } // namespace util
 } // namespace llvm

llvm/unittests/Support/CMakeLists.txt

@@ -69,7 +69,7 @@ add_llvm_unittest(SupportTests
   PerThreadBumpPtrAllocatorTest.cpp
   ProcessTest.cpp
   ProgramTest.cpp
-  PropertySetIOTest.cpp
+  SYCLPropertySetIOTest.cpp
   RegexTest.cpp
   ReverseIterationTest.cpp
   ReplaceFileTest.cpp