Merge from 'sycl' to 'sycl-web' (8 commits)

Author: iclsrc

.github/workflows/sycl_linux_build_and_test.yml

@@ -172,10 +172,13 @@ jobs:
     outputs:
       lts: ${{ steps.work.outputs.lts }}
     steps:
-    - name: Download scripts
+    - name: Download scripts and configs
       run: |
         wget raw.githubusercontent.com/intel/llvm/${{ github.sha }}/devops/scripts/generate_test_matrix.js
         wget raw.githubusercontent.com/intel/llvm/${{ github.sha }}/devops/test_configs.json
+        wget raw.githubusercontent.com/intel/llvm/sycl/devops/dependencies.json
+        mv dependencies.json dependencies.sycl.json
+        wget raw.githubusercontent.com/intel/llvm/${{ github.sha }}/devops/dependencies.json
     - id: work
       uses: actions/github-script@v6
       name: Generate matrix
@@ -196,6 +199,7 @@ jobs:
         include: ${{ fromJSON(needs.resolve_matrix.outputs.lts) }}
     name: ${{ matrix.name }}
     runs-on: ${{ matrix.runs-on }}
+    env: ${{ matrix.env }}
     container:
       image: ${{ matrix.image }}
       options: ${{ matrix.container_options }}
@@ -208,6 +212,15 @@ jobs:
     - run: cp -r /actions .
     - name: Register cleanup after job is finished
       uses: ./actions/cleanup
+    - name: Install drivers
+      if: env.compute_runtime_tag != ''
+      run: |
+        if [ -e /opt/install_drivers.sh ]; then
+          # TODO pack this script into container
+          wget raw.githubusercontent.com/intel/llvm/${{ github.sha }}/devops/scripts/get_release.py
+          sudo mv get_release.py /opt/
+          sudo -E /opt/install_drivers.sh --all
+        fi
     # FIXME cached_checkout fails here, but works everywhere else
     - uses: actions/checkout@v2
       with:

clang/include/clang/Basic/AttrDocs.td

@@ -3629,6 +3629,7 @@ occur after the first argument of the attribute, the N+2'th argument of the
 attribute will occur after the second argument of the attribute, etc.
 The generated call to ``llvm.ptr.annotation`` will have the following arguments
 in this order:
+
   * First argument is a pointer to the field.
   * A pointer to a string literal in a constant global variable. This will
     always be "sycl-properties".
@@ -3639,6 +3640,7 @@ in this order:
     literals in constant global variables. These pointers to string literals
     occur in pairs. If the second value of a pair was a ``nullptr`` or an empty
     string then the pointer will be a null-pointer.
+
 A pair will not be in the call to ``llvm.ptr.annotation`` if the first value of
 the pair is an empty string.
 

devops/scripts/generate_test_matrix.js

@@ -4,15 +4,45 @@ module.exports = ({core, process}) => {
     if (err) {
       console.log(`Error reading file from disk: ${err}`);
     } else {
+      const driverNew =
+          JSON.parse(fs.readFileSync('./dependencies.json', 'utf8'));
+      const driverOld =
+          JSON.parse(fs.readFileSync('./dependencies.sycl.json', 'utf8'));
       const testConfigs = JSON.parse(data);
       const inputs = JSON.parse(process.env.GHA_INPUTS);
+      const needsDrivers =
+          driverNew["linux"]["compute_runtime"]["version"] !==
+              driverOld["linux"]["compute_runtime"]["version"] ||
+          driverNew["linux"]["igc"]["version"] !==
+              driverOld["linux"]["igc"]["version"] ||
+          driverNew["linux"]["cm"]["version"] !==
+              driverOld["linux"]["cm"]["version"] ||
+          driverNew["linux"]["tbb"]["version"] !==
+              driverOld["linux"]["tbb"]["version"] ||
+          driverNew["linux"]["oclcpu"]["version"] !==
+              driverOld["linux"]["oclcpu"]["version"] ||
+          driverNew["linux"]["fpgaemu"]["version"] !==
+              driverOld["linux"]["fpgaemu"]["version"];
 
       const ltsConfigs = inputs.lts_config.split(';');
 
       const enabledLTSConfigs = [];
 
       testConfigs.lts.forEach(v => {
         if (ltsConfigs.includes(v.config)) {
+          if (needsDrivers) {
+            v["env"] = {
+              "compute_runtime_tag" :
+                  driverNew["linux"]["compute_runtime"]["github_tag"],
+              "igc_tag" : driverNew["linux"]["igc"]["github_tag"],
+              "cm_tag" : driverNew["linux"]["cm"]["github_tag"],
+              "tbb_tag" : driverNew["linux"]["tbb"]["github_tag"],
+              "cpu_tag" : driverNew["linux"]["oclcpu"]["github_tag"],
+              "fpgaemu_tag" : driverNew["linux"]["fpgaemu"]["github_tag"],
+            };
+          } else {
+            v["env"] = {};
+          }
           enabledLTSConfigs.push(v);
         }
       });
@@ -23,6 +53,11 @@ module.exports = ({core, process}) => {
       for (let [key, value] of Object.entries(inputs)) {
         ltsString = ltsString.replaceAll("${{ inputs." + key + " }}", value);
       }
+      if (needsDrivers) {
+        ltsString = ltsString.replaceAll(
+            "ghcr.io/intel/llvm/ubuntu2004_intel_drivers:latest",
+            "ghcr.io/intel/llvm/ubuntu2004_base:latest");
+      }
 
       core.setOutput('lts', ltsString);
     }

devops/scripts/install_drivers.sh

@@ -21,6 +21,7 @@ fi;
 
 InstallTBB () {
   if [ "$TBB_INSTALLED" = false ]; then
+    mkdir -p $INSTALL_LOCATION
     cd $INSTALL_LOCATION
     echo "Installing TBB..."
     echo "TBB version $TBB_TAG"
@@ -54,6 +55,7 @@ InstallIGFX () {
 InstallCPURT () {
   echo "Installing Intel OpenCL CPU Runtime..."
   echo "CPU Runtime version $CPU_TAG"
+  mkdir -p $INSTALL_LOCATION
   cd $INSTALL_LOCATION
   if [ -d "$INSTALL_LOCATION/oclcpu" ]; then
     echo "$INSTALL_LOCATION/oclcpu exists and will be removed!"
@@ -73,12 +75,13 @@ InstallCPURT () {
 InstallFPGAEmu () {
   echo "Installing Intel FPGA Fast Emulator..."
   echo "FPGA Emulator version $FPGA_TAG"
+  mkdir -p $INSTALL_LOCATION
   cd $INSTALL_LOCATION
   if [ -d "$INSTALL_LOCATION/fpgaemu" ]; then
     echo "$INSTALL_LOCATION/fpgaemu exists and will be removed!"
     rm -Rf $INSTALL_LOCATION/oclcpu;
   fi
-  python3 /get_release.py intel/llvm $FPGA_TAG \
+  python3 $LOCATION/get_release.py intel/llvm $FPGA_TAG \
     | grep -E ".*fpgaemu.*tar.gz" \
     | wget -qi - && \
     mkdir fpgaemu && tar -xf *.tar.gz -C fpgaemu && rm *.tar.gz

libclc/utils/libclc-remangler/CMakeLists.txt

@@ -5,6 +5,7 @@ set(LLVM_LINK_COMPONENTS
   Core
   Demangle
   Support
+  TransformUtils
   )
 
 add_clang_tool(libclc-remangler LibclcRemangler.cpp)

libclc/utils/libclc-remangler/LibclcRemangler.cpp

@@ -11,28 +11,28 @@
 // `unsigned long`, and `char` to appear as if they use `long long`,
 // `unsigned long long`, and `signed char`, as is consistent with the primitive
 // types defined by OpenCL C. Following a remangling, the original function
-// mangling will be made an alias to either the remangled function or a function
-// with a suitable function if any exists. In some cases an alias of the
-// remangled function is created for functions where multiple parameters have
-// been replaced, and the replaced values are aliases.
+// mangling will be built as a clone of either the remangled function or a
+// function with a suitable function if any exists. In some cases a clone of
+// the remangled function is created for functions where multiple parameters
+// have been replaced, and the replaced values are aliases.
 //
-// Original Alias Example:
+// Original Clone Example:
 //          If libclc defined a function `f(long)` the mangled name would be
 //          `_Z1fl`. The remangler would rename this function to `_Z1fx`
-//          (`f(long long)`.) If the target uses 64-bit `long`, `_Z1fl` is made
-//          an alias to the old function now under the name `_Z1fx`, whereas if
-//          the target uses 32-bit `long`, `_Z1fl` is made an alias to `_Z1fi`
+//          (`f(long long)`.) If the target uses 64-bit `long`, `_Z1fl` is
+//          cloned from the old function now under the name `_Z1fx`, whereas if
+//          the target uses 32-bit `long`, `_Z1fl` is cloned from `_Z1fi`
 //          (`f(int)`) if such a function exists.
 //
-// Remangled Alias Example:
+// Remangled Clone Example:
 //          In cases where the remangled name squashes valid versions of a
-//          function an alias is created. `f(long, char, signed char)` would be
+//          function a clone is created. `f(long, char, signed char)` would be
 //          mangled to
 //          `_Z1flca`. The remangler would rename this function to `_Z1fyaa`
 //          (`f(long long, signed char, signed char)`). If the target uses a
-//          signed char then a valid alias `_Z1fyca`,
+//          signed char then a valid clone `_Z1fyca`,
 //          (`f(long long, char, signed char)`), is not defined. The remangler
-//          creates an alias of the renamed function,`_Z1fyaa` , to this
+//          creates a clone of the renamed function,`_Z1fyaa` , to this
 //          permutation, `_Z1fyca`.
 //
 //===----------------------------------------------------------------------===//
@@ -58,6 +58,8 @@
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/Utils/Cloning.h"
+#include "llvm/Transforms/Utils/ValueMapper.h"
 
 #include <iostream>
 #include <memory>
@@ -153,7 +155,7 @@ class DefaultAllocator {
 public:
   void reset() { Alloc.reset(); }
 
-  template <typename T, typename... Args> T *makeNode(Args &&... args) {
+  template <typename T, typename... Args> T *makeNode(Args &&...args) {
     return new (Alloc.allocate(sizeof(T))) T(std::forward<Args>(args)...);
   }
 
@@ -478,19 +480,19 @@ class Remangler {
 
 class TargetTypeReplacements {
   SmallDenseMap<const char *, const char *> ParameterTypeReplacements;
-  SmallDenseMap<const char *, const char *> AliasTypeReplacements;
-  SmallDenseMap<const char *, const char *> RemangledAliasTypeReplacements;
+  SmallDenseMap<const char *, const char *> CloneTypeReplacements;
+  SmallDenseMap<const char *, const char *> RemangledCloneTypeReplacements;
 
   void CreateRemangledTypeReplacements() {
     // RemangleTypes which are not aliases or not the exact same alias type
     for (auto &TypeReplacementPair : ParameterTypeReplacements)
-      if (AliasTypeReplacements.find(TypeReplacementPair.getFirst()) ==
-          AliasTypeReplacements.end())
-        RemangledAliasTypeReplacements[TypeReplacementPair.getFirst()] =
+      if (CloneTypeReplacements.find(TypeReplacementPair.getFirst()) ==
+          CloneTypeReplacements.end())
+        RemangledCloneTypeReplacements[TypeReplacementPair.getFirst()] =
             TypeReplacementPair.getSecond();
-      else if (AliasTypeReplacements[TypeReplacementPair.getFirst()] !=
+      else if (CloneTypeReplacements[TypeReplacementPair.getFirst()] !=
                TypeReplacementPair.getSecond())
-        RemangledAliasTypeReplacements[TypeReplacementPair.getFirst()] =
+        RemangledCloneTypeReplacements[TypeReplacementPair.getFirst()] =
             TypeReplacementPair.getSecond();
   }
 
@@ -503,22 +505,22 @@ class TargetTypeReplacements {
     // Replace char with signed char
     ParameterTypeReplacements["char"] = "signed char";
 
-    // Make replaced long functions aliases to either integer or long long
+    // Make replaced long functions clones of either integer or long long
     // variant
     if (LongWidth == SupportedLongWidth::L32) {
-      AliasTypeReplacements["long"] = "int";
-      AliasTypeReplacements["unsigned long"] = "unsigned int";
+      CloneTypeReplacements["long"] = "int";
+      CloneTypeReplacements["unsigned long"] = "unsigned int";
     } else {
-      AliasTypeReplacements["long"] = "long long";
-      AliasTypeReplacements["unsigned long"] = "unsigned long long";
+      CloneTypeReplacements["long"] = "long long";
+      CloneTypeReplacements["unsigned long"] = "unsigned long long";
     }
 
-    // Make replaced char functions aliases to either integer or long long
+    // Make replaced char functions clones of either integer or long long
     // variant
     if (CharSignedness == Signedness::Signed) {
-      AliasTypeReplacements["char"] = "signed char";
+      CloneTypeReplacements["char"] = "signed char";
     } else {
-      AliasTypeReplacements["char"] = "unsigned char";
+      CloneTypeReplacements["char"] = "unsigned char";
     }
 
     CreateRemangledTypeReplacements();
@@ -528,21 +530,21 @@ class TargetTypeReplacements {
     return ParameterTypeReplacements;
   }
 
-  SmallDenseMap<const char *, const char *> getAliasTypeReplacements() {
-    return AliasTypeReplacements;
+  SmallDenseMap<const char *, const char *> getCloneTypeReplacements() {
+    return CloneTypeReplacements;
   }
 
   SmallDenseMap<const char *, const char *>
-  getRemangledAliasTypeReplacements() {
-    return RemangledAliasTypeReplacements;
+  getRemangledCloneTypeReplacements() {
+    return RemangledCloneTypeReplacements;
   }
 };
 
-bool createAliasFromMap(
+bool createCloneFromMap(
     Module *M, std::string originalName,
     const itanium_demangle::Node *functionTree,
     SmallDenseMap<const char *, const char *> TypeReplacements,
-    bool AliaseeTypeReplacement = false) {
+    bool CloneeTypeReplacement = false) {
   Remangler ATR{functionTree, TypeReplacements};
   std::string RemangledName = ATR.remangle();
 
@@ -553,39 +555,41 @@ bool createAliasFromMap(
   if (RemangledName == originalName)
     return true;
 
-  StringRef AliasName, AliaseeName;
-  if (AliaseeTypeReplacement) {
-    AliasName = originalName;
-    AliaseeName = RemangledName;
+  StringRef CloneName, CloneeName;
+  if (CloneeTypeReplacement) {
+    CloneName = originalName;
+    CloneeName = RemangledName;
   } else {
-    AliasName = RemangledName;
-    AliaseeName = originalName;
+    CloneName = RemangledName;
+    CloneeName = originalName;
   }
 
-  Function *Aliasee = M->getFunction(AliaseeName);
-  if (Aliasee) {
-    GlobalAlias::create(AliasName, Aliasee);
+  Function *Clonee = M->getFunction(CloneeName);
+  if (Clonee) {
+    ValueToValueMapTy Dummy;
+    Function *NewF = CloneFunction(Clonee, Dummy);
+    NewF->setName(std::string(CloneName));
   } else if (Verbose) {
-    std::cout << "Could not create alias " << AliasName.data() << " : missing "
-              << AliaseeName.data() << std::endl;
+    std::cout << "Could not create copy " << CloneName.data() << " : missing "
+              << CloneeName.data() << std::endl;
   }
 
   return true;
 }
 
-bool createAliases(Module *M, std::string originalMangledName,
-                   std::string remangledName,
-                   const itanium_demangle::Node *functionTree,
-                   TargetTypeReplacements replacements) {
-  // create alias of original function
-  if (!createAliasFromMap(M, originalMangledName, functionTree,
-                          replacements.getAliasTypeReplacements(),
-                          /* AliaseeTypeReplacement= */ true))
+bool createClones(Module *M, std::string originalMangledName,
+                  std::string remangledName,
+                  const itanium_demangle::Node *functionTree,
+                  TargetTypeReplacements replacements) {
+  // create clone of original function
+  if (!createCloneFromMap(M, originalMangledName, functionTree,
+                          replacements.getCloneTypeReplacements(),
+                          /* CloneeTypeReplacement= */ true))
     return false;
 
-  // create alias from remangled function
-  if (!createAliasFromMap(M, remangledName, functionTree,
-                          replacements.getRemangledAliasTypeReplacements()))
+  // create clone of remangled function
+  if (!createCloneFromMap(M, remangledName, functionTree,
+                          replacements.getRemangledCloneTypeReplacements()))
     return false;
 
   return true;
@@ -621,10 +625,10 @@ bool remangleFunction(Function &func, Module *M,
     }
     func.setName(RemangledName);
 
-    // Make an alias to a suitable function using the old name if there is a
-    // type-mapping and the corresponding aliasee function exists.
-    if (!createAliases(M, MangledName, RemangledName, FunctionTree,
-                       replacements))
+    // Make a clone of a suitable function using the old name if there is a
+    // type-mapping and the corresponding clonee function exists.
+    if (!createClones(M, MangledName, RemangledName, FunctionTree,
+                      replacements))
       return false;
   }
 
@@ -661,10 +665,14 @@ int main(int argc, const char **argv) {
     return 1;
   }
 
-  bool Success = true;
+  std::vector<Function *> FuncList;
   for (auto &Func : M->getFunctionList())
-    Success = remangleFunction(Func, M.get(), Replacements) && Success;
+    FuncList.push_back(&Func);
 
+  bool Success = true;
+  for (auto Func : FuncList) {
+    Success = remangleFunction(*Func, M.get(), Replacements) && Success;
+  }
   // Only fail after all to give as much context as possible.
   if (!Success) {
     errs() << "Failed to remangle all mangled functions in module.\n";