Reinstate llvm.compiler.used removal at SPL

For spirv remove the llvm.compiler.used symbol at sycl-post-link. This
is because we use llvm-spirv for lowering, not the SPIR-V backend.

Author: hdelan

llvm/tools/sycl-post-link/sycl-post-link.cpp

@@ -572,6 +572,70 @@ static bool removeSYCLKernelsConstRefArray(Module &M) {
   return true;
 }
 
+// Removes all device_global variables from the llvm.compiler.used global
+// variable. A device_global with internal linkage will be in llvm.compiler.used
+// to avoid the compiler wrongfully removing it during optimizations. However,
+// as an effect the device_global variables will also be distributed across
+// binaries, even if llvm.compiler.used has served its purpose. To avoid
+// polluting other binaries with unused device_global variables, we remove them
+// from llvm.compiler.used and erase them if they have no further uses.
+static bool removeDeviceGlobalFromCompilerUsed(Module &M) {
+  GlobalVariable *GV = M.getGlobalVariable("llvm.compiler.used");
+  if (!GV)
+    return false;
+
+  // Erase the old llvm.compiler.used. A new one will be created at the end if
+  // there are other values in it (other than device_global).
+  assert(GV->user_empty() && "Unexpected llvm.compiler.used users");
+  Constant *Initializer = GV->getInitializer();
+  const auto *VAT = cast<ArrayType>(GV->getValueType());
+  GV->setInitializer(nullptr);
+  GV->eraseFromParent();
+
+  // Destroy the initializer. Keep the operands so we keep the ones we need.
+  SmallVector<Constant *, 8> IOperands;
+  for (auto It = Initializer->op_begin(); It != Initializer->op_end(); It++)
+    IOperands.push_back(cast<Constant>(*It));
+  assert(llvm::isSafeToDestroyConstant(Initializer) &&
+         "Cannot remove initializer of llvm.compiler.used global");
+  Initializer->destroyConstant();
+
+  // Iterate through all operands. If they are device_global then we drop them
+  // and erase them if they have no uses afterwards. All other values are kept.
+  SmallVector<Constant *, 8> NewOperands;
+  for (auto It = IOperands.begin(); It != IOperands.end(); It++) {
+    Constant *Op = *It;
+    auto *DG = dyn_cast<GlobalVariable>(Op->stripPointerCasts());
+
+    // If it is not a device_global we keep it.
+    if (!DG || !isDeviceGlobalVariable(*DG)) {
+      NewOperands.push_back(Op);
+      continue;
+    }
+
+    // Destroy the device_global operand.
+    if (llvm::isSafeToDestroyConstant(Op))
+      Op->destroyConstant();
+
+    // Remove device_global if it no longer has any uses.
+    if (!DG->isConstantUsed())
+      DG->eraseFromParent();
+  }
+
+  // If we have any operands left from the original llvm.compiler.used we create
+  // a new one with the new size.
+  if (!NewOperands.empty()) {
+    ArrayType *ATy = ArrayType::get(VAT->getElementType(), NewOperands.size());
+    GlobalVariable *NGV =
+        new GlobalVariable(M, ATy, false, GlobalValue::AppendingLinkage,
+                           ConstantArray::get(ATy, NewOperands), "");
+    NGV->setName("llvm.compiler.used");
+    NGV->setSection("llvm.metadata");
+  }
+
+  return true;
+}
+
 SmallVector<module_split::ModuleDesc, 2>
 handleESIMD(module_split::ModuleDesc &&MDesc, bool &Modified,
             bool &SplitOccurred) {
@@ -719,6 +783,13 @@ processInputModule(std::unique_ptr<Module> M) {
   // actions.
   Modified |= removeSYCLKernelsConstRefArray(*M.get());
 
+  // There may be device_global variables kept alive in "llvm.compiler.used"
+  // to keep the optimizer from wrongfully removing them. llvm.compiler.used
+  // symbols are usually removed at backend lowering, but this is handled here
+  // for SPIR-V since SYCL compilation uses llvm-spirv, not the SPIR-V backend.
+  if (auto Triple = M->getTargetTriple().find("spir") != std::string::npos)
+    Modified |= removeDeviceGlobalFromCompilerUsed(*M.get());
+
   // Instrument each image scope device globals if the module has been
   // instrumented by sanitizer pass.
   if (isModuleUsingAsan(*M))