[SYCL] Fix kernel name mangling for CUDA/HIP with Microsoft ABI host

SYCL kernel names are generated during template instantiation using
MangleContext, which produces different encodings based on target ABI.
When host compilation uses Microsoft ABI and device compilation targets
Itanium ABI (CUDA/HIP), this caused runtime kernel lookup failures:

  No kernel named _ZTSZZ21performIncrementationENK... was found

The issue occurred because Sema::PerformPendingInstantiations() used
ASTContext::createMangleContext(), which creates an ABI-specific context
for the primary target. In cross-ABI scenarios (Microsoft host + Itanium
device), this produced inconsistent names between host and device.

Solution:
- Added createSYCLMangleContext() helper that detects Microsoft-to-Itanium
  ABI scenarios
- When detected, uses createDeviceMangleContext() for host compilation to
  ensure Itanium mangling on both sides
- Applied to both host and device compilation phases via
  (LangOpts.SYCLIsHost || LangOpts.SYCLIsDevice) guard

This ensures identical kernel names across compilations, allowing runtime
lookup to succeed.

Fixes CMPLRLLVM-69642

Author: kekaczma

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -7733,9 +7733,31 @@ static void processFunctionInstantiation(Sema &S,
   FD->setInstantiationIsPending(false);
 }
 
+static std::unique_ptr<MangleContext> createSYCLMangleContext(ASTContext &Ctx) {
+  // For SYCL compilation, ensure kernel name mangling is consistent between
+  // host and device compilations when targeting CUDA/HIP backends.
+  // When the host uses Microsoft ABI and device uses Itanium ABI, we need
+  // to use device-aware mangling context on the host side.
+  const TargetInfo *AuxTarget = Ctx.getAuxTargetInfo();
+  if (AuxTarget && Ctx.getTargetInfo().getCXXABI().isMicrosoft() &&
+      AuxTarget->getCXXABI().isItaniumFamily()) {
+    // Host compilation with Microsoft ABI targeting Itanium device
+    return std::unique_ptr<MangleContext>(
+        Ctx.createDeviceMangleContext(*AuxTarget));
+  }
+  // All other cases: use standard mangling for the primary target
+  return std::unique_ptr<MangleContext>(Ctx.createMangleContext());
+}
+
 void Sema::PerformPendingInstantiations(bool LocalOnly, bool AtEndOfTU) {
+  // For SYCL compilation (both host and device), use device-aware mangle
+  // context to ensure consistent kernel name mangling across different
+  // backends (CUDA/HIP) and between host and device compilations.
   std::unique_ptr<MangleContext> MangleCtx(
-      getASTContext().createMangleContext());
+      (LangOpts.SYCLIsHost || LangOpts.SYCLIsDevice)
+          ? createSYCLMangleContext(getASTContext())
+          : std::unique_ptr<MangleContext>(
+                getASTContext().createMangleContext()));
   std::deque<PendingImplicitInstantiation> DelayedImplicitInstantiations;
   while (!PendingLocalImplicitInstantiations.empty() ||
          (!LocalOnly && !PendingInstantiations.empty())) {

sycl/test-e2e/IntermediateLib/multi_lib_app.cpp

@@ -1,6 +1,3 @@
-// UNSUPPORTED: cuda || hip
-// UNSUPPORTED-TRACKER: CMPLRLLVM-69415
-
 // DEFINE: %{fPIC_flag} =  %if windows %{%} %else %{-fPIC%}
 // DEFINE: %{shared_lib_ext} = %if windows %{dll%} %else %{so%}