[SYCL] Support BYTE_ARRAY property in the offload wrapper.

Signed-off-by: Konstantin S Bobrovsky <[email protected]>

Author: kbobrovs

clang/test/Driver/clang-offload-wrapper-exe.cpp

@@ -4,12 +4,22 @@
 // works, and that the tool generates data properly accessible at runtime.
 
 // --- Prepare test data
-// RUN: echo -e -n 'device binary image\n' > %t.bin
+// - create the first binary image
+// RUN: echo -e -n 'device binary image1\n' > %t.bin
 // RUN: echo -e -n '[Category1]\nint_prop1=1|10\n[Category2]\nint_prop2=1|20\n' > %t.props
 // RUN: echo -e -n 'kernel1\nkernel2\n' > %t.sym
 // RUN: echo -e -n 'Manifest file - arbitrary data generated by the toolchain\n' > %t.mnf
+
+// - create the second binary image with byte array property values
+// RUN: echo -e -n 'device binary image2\n' > %t_1.bin
+// RUN: echo -e -n '[Category3]\n' > %t_1.props
+// RUN: echo -e -n 'kernel1=2|IAAAAAAAAAQA\n' >> %t_1.props
+// RUN: echo -e -n 'kernel2=2|oAAAAAAAAAw///3/wB\n' >> %t_1.props
+
+// - create the batch file input for the wrapper
 // RUN: echo '[Code|Properties|Symbols|Manifest]' > %t.batch
 // RUN: echo %t.bin"|"%t.props"|"%t.sym"|"%t.mnf >> %t.batch
+// RUN: echo %t_1.bin"|"%t_1.props"|""|" >> %t.batch
 // --- Generate "gold" output
 // RUN: cat %t.bin %t.mnf %t.props %t.sym > %t.all
 // --- Create the wrapper object
@@ -22,6 +32,8 @@
 // RUN: %t.batch.exe > %t.batch.exe.out
 // RUN: diff -b %t.batch.exe.out %t.all
 
+#include <assert.h>
+#include <cstring>
 #include <iostream>
 #include <string>
 
@@ -105,31 +117,97 @@ static int getInt(void *Addr) {
   return Ptr[0] | (Ptr[1] << 8) | (Ptr[2] << 16) | (Ptr[3] << 24);
 }
 
-int main(int argc, char **argv) {
-  ASSERT(BinDesc->NumDeviceBinaries == 1, "BinDesc->NumDeviceBinaries");
-  ASSERT(BinDesc->Version == 1, "BinDesc->Version");
+using byte = unsigned char;
+
+static void printProp(const pi_device_binary_property &Prop) {
+  std::cerr << "Property " << Prop->Name << " {\n";
+  std::cerr << "  Type: " << Prop->Type << "\n";
+  if (Prop->Type != 1)
+    std::cerr << "  Size = " << Prop->ValSize << "\n";
+
+  std::cerr << "  Value = ";
+  if (Prop->Type == 1)
+    std::cerr << getInt(&Prop->ValSize);
+  else {
+    std::cerr << " {\n   ";
 
-  for (int I = 0; I < BinDesc->NumDeviceBinaries; ++I) {
-    pi_device_binary Bin = &BinDesc->DeviceBinaries[I];
-    ASSERT(Bin->Kind == 4, "Bin->Kind");
-    ASSERT(Bin->Format == 1, "Bin->Format");
-
-    // dump code
-    std::cout << getString(Bin->BinaryStart, Bin->BinaryEnd);
-    // dump manifest
-    std::cout << std::string(Bin->ManifestStart, Bin->ManifestEnd - Bin->ManifestStart);
-    // dump properties
-    for (pi_device_binary_property_set PropSet = Bin->PropertySetsBegin; PropSet != Bin->PropertySetsEnd; ++PropSet) {
-      std::cout << "[" << PropSet->Name << "]"
-                << "\n";
-
-      for (pi_device_binary_property Prop = PropSet->PropertiesBegin; Prop != PropSet->PropertiesEnd; ++Prop)
-        // values fitting into 64 bits are written into the 'ValAddr' field:
-        std::cout << Prop->Name << "=" << Prop->Type << "|" << getInt(&Prop->ValSize) << "\n";
+    byte *Ptr = (byte *)Prop->ValAddr;
+
+    for (auto I = 0; I < Prop->ValSize && I < 100; ++I) {
+      std::cerr << " 0x" << std::hex << (unsigned int)Ptr[I];
+      std::cerr << std::dec;
+    }
+    std::cerr << "\n  }";
+  }
+  std::cerr << "\n";
+  std::cerr << "}\n";
+}
+
+static int dumpBinary0() {
+  pi_device_binary Bin = &BinDesc->DeviceBinaries[0];
+  ASSERT(Bin->Kind == 4, "Bin->Kind");
+  ASSERT(Bin->Format == 1, "Bin->Format");
+
+  // dump code
+  std::cout << getString(Bin->BinaryStart, Bin->BinaryEnd);
+  // dump manifest
+  std::cout << std::string(Bin->ManifestStart, Bin->ManifestEnd - Bin->ManifestStart);
+  // dump properties
+  for (pi_device_binary_property_set PropSet = Bin->PropertySetsBegin; PropSet != Bin->PropertySetsEnd; ++PropSet) {
+    std::cout << "[" << PropSet->Name << "]"
+              << "\n";
+
+    for (pi_device_binary_property Prop = PropSet->PropertiesBegin; Prop != PropSet->PropertiesEnd; ++Prop) {
+      ASSERT(Prop->Type == 1, "Prop->Type");
+      std::cout << Prop->Name << "=" << Prop->Type << "|" << getInt(&Prop->ValSize) << "\n";
     }
-    // dump symbols
-    for (_pi_offload_entry Entry = Bin->EntriesBegin; Entry != Bin->EntriesEnd; ++Entry)
-      std::cout << Entry->name << "\n";
   }
+  // dump symbols
+  for (_pi_offload_entry Entry = Bin->EntriesBegin; Entry != Bin->EntriesEnd; ++Entry)
+    std::cout << Entry->name << "\n";
   return 0;
-}
+}
+
+// Clang offload wrapper does Base64 decoding on byte array property values, so
+// they can't be dumped as is and compared to the original. Instead, this
+// testcase checks that the byte array in the property value is equal to the
+// pre-decoded byte array.
+static int checkBinary1() {
+  // Decoded from "IAAAAAAAAAQA":
+  const byte Arr0[] = {8, 0, 0, 0, 0, 0, 0, 0, 0x1};
+  // Decoded from "oAAAAAAAAAw///3/wB":
+  const byte Arr1[] = {40, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0x7F, 0xFF, 0x70};
+
+  struct {
+    const byte *Ptr;
+    const size_t Size;
+  } GoldArrays[] = {
+      {Arr0, sizeof(Arr0)},
+      {Arr1, sizeof(Arr1)}};
+  pi_device_binary Bin = &BinDesc->DeviceBinaries[1];
+  ASSERT(Bin->Kind == 4, "Bin->Kind");
+  ASSERT(Bin->Format == 1, "Bin->Format");
+
+  for (pi_device_binary_property_set PropSet = Bin->PropertySetsBegin; PropSet != Bin->PropertySetsEnd; ++PropSet) {
+    int Cnt = 0;
+
+    for (pi_device_binary_property Prop = PropSet->PropertiesBegin; Prop != PropSet->PropertiesEnd; ++Prop, ++Cnt) {
+      ASSERT(Prop->Type == 2, "Prop->Type"); // must be a byte array
+      char *Ptr = reinterpret_cast<char *>(Prop->ValAddr);
+      int Cmp = std::memcmp(Prop->ValAddr, GoldArrays[Cnt].Ptr, GoldArrays[Cnt].Size);
+      ASSERT(Cmp == 0, "byte array property");
+    }
+  }
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  ASSERT(BinDesc->NumDeviceBinaries == 2, "BinDesc->NumDeviceBinaries");
+  ASSERT(BinDesc->Version == 1, "BinDesc->Version");
+
+  if (dumpBinary0() != 0)
+    return 1;
+  if (checkBinary1() != 0)
+    return 1;
+  return 0;
+}

clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp

@@ -610,6 +610,15 @@ class BinaryWrapper {
     return std::make_pair(ImageB, ImageE);
   }
 
+  // Adds given data buffer as constant byte array and returns a constant
+  // pointer to it. The pointer type does not carry size information.
+  Constant *addRawDataToModule(ArrayRef<char> Data, const Twine &Name) {
+    auto *Var = addGlobalArrayVariable(Name, Data);
+    auto *DataPtr = ConstantExpr::getGetElementPtr(Var->getValueType(), Var,
+                                                   getSizetConstPair(0u, 0u));
+    return DataPtr;
+  }
+
   // Creates all necessary data objects for the given image and returns a pair
   // of pointers that point to the beginning and end of the global variable that
   // contains the image data.
@@ -718,6 +727,14 @@ class BinaryWrapper {
             ConstantInt::get(Type::getInt64Ty(C), Prop.second.asUint32());
         break;
       }
+      case llvm::util::PropertyValue::BYTE_ARRAY: {
+        const char *Ptr =
+            reinterpret_cast<const char *>(Prop.second.asRawByteArray());
+        uint64_t Size = Prop.second.getRawByteArraySize();
+        PropValSize = ConstantInt::get(Type::getInt64Ty(C), Size);
+        PropValAddr = addRawDataToModule(ArrayRef<char>(Ptr, Size), "prop_val");
+        break;
+      }
       default:
         llvm_unreachable_internal("unsupported property");
       }