Merge branch 'sycl' into update_l0_tag_again

Author: KseniyaTikhomirova

.github/workflows/sycl-linux-precommit.yml

@@ -62,6 +62,42 @@ jobs:
       e2e_binaries_artifact: e2e_bin
       e2e_binaries_preview_artifact: e2e_bin_preview
 
+  # Build and run native cpu e2e tests separately as cannot currently
+  # build all the e2e tests
+  build_run_native_cpu_e2e_tests:
+    if: ${{ always() && !cancelled() && needs.build.outputs.build_conclusion == 'success' }}  
+    runs-on: [Linux, build]
+    needs: [build]
+    container:
+      image: ghcr.io/intel/llvm/sycl_ubuntu2404_nightly:latest
+      options: -u 1001:1001
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          sparse-checkout: |
+            devops/
+
+      # download build artefact
+      - name: Download toolchain
+        uses: actions/download-artifact@v4
+        with:
+          name: sycl_linux_default
+      - name: Extract SYCL toolchain
+        shell: bash
+        run: |
+          mkdir toolchain
+          tar -xf llvm_sycl.tar.zst -C toolchain
+          rm llvm_sycl.tar.zst
+      - name: Build and run E2E tests
+        uses: ./devops/actions/run-tests/e2e
+        with:
+          ref: ${{ inputs.ref || github.sha }}
+          testing_mode: full
+          target_devices: native_cpu:cpu
+          sycl_compiler: $GITHUB_WORKSPACE/toolchain/bin/clang++
+          extra_lit_opts: --param sycl_build_targets="native_cpu"
+          extra_cmake_args: -DSYCL_TEST_E2E_TARGETS="native_cpu:cpu" -DSYCL_TEST_E2E_STANDALONE=ON
+
   # If a PR changes CUDA adapter, run the build on Ubuntu 22.04 as well.
   # Ubuntu 22.04 container has CUDA 12.1 installed while Ubuntu 24.0 image
   # has CUDA 12.6.1 installed.

.github/workflows/sycl-linux-run-tests.yml

@@ -235,7 +235,7 @@ jobs:
     - name: Reset Intel GPU
       uses: ./devops/actions/reset_gpu
     - name: Install drivers
-      if: inputs.install_igc_driver == 'true' || inputs.install_dev_igc_driver == 'true'
+      if: inputs.e2e_binaries_artifact != 'in-container' && (inputs.install_igc_driver == 'true' || inputs.install_dev_igc_driver == 'true')
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |

clang/include/clang/Sema/Sema.h

@@ -9183,7 +9183,13 @@ class Sema final : public SemaBase {
   };
 
   /// Compute the mangling number context for a lambda expression or
-  /// block literal. Also return the extra mangling decl if any.
+  /// block literal that appears in the specified declaration context in
+  /// consideration of the current expression evaluation and template
+  /// instantiation contexts. If the mangling context requires external linkage,
+  /// then a mangling number context is returned in the first tuple
+  /// element. If the mangling context is non-normal (specialized for
+  /// lambda and block types relative to other entities), the overriding
+  /// declaration is returned in the second tuple element.
   ///
   /// \param DC - The DeclContext containing the lambda expression or
   /// block literal.

clang/lib/AST/ASTContext.cpp

@@ -13356,6 +13356,7 @@ MangleNumberingContext &
 ASTContext::getManglingNumberContext(const DeclContext *DC) {
   assert(LangOpts.CPlusPlus);  // We don't need mangling numbers for plain C.
   std::unique_ptr<MangleNumberingContext> &MCtx = MangleNumberingContexts[DC];
+  DC = DC->getPrimaryContext();
   if (!MCtx)
     MCtx = createMangleNumberingContext();
   return *MCtx;

clang/lib/Driver/ToolChains/Clang.cpp

@@ -10097,8 +10097,13 @@ void OffloadWrapper::ConstructJob(Compilation &C, const JobAction &JA,
     // clang-offload-wrapper
     //   -o=<outputfile>.bc
     //   -host=x86_64-pc-linux-gnu -kind=sycl
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
     //   -format=spirv <inputfile1>.spv <manifest1>(optional)
     //   -format=spirv <inputfile2>.spv <manifest2>(optional)
+#else
+    //   -format=spirv <inputfile1>.spv
+    //   -format=spirv <inputfile2>.spv
+#endif
     //  ...
     ArgStringList WrapperArgs;
 
@@ -10163,6 +10168,12 @@ void OffloadWrapper::ConstructJob(Compilation &C, const JobAction &JA,
     WrapperArgs.push_back(
         C.getArgs().MakeArgString(Twine("-kind=") + Twine(Kind)));
 
+    // Enable preview breaking changes in clang-offload-wrapper,
+    // in case it needs to introduce any ABI breaking changes.
+    // For example, changes in offload binary descriptor format.
+    if (C.getArgs().hasArg(options::OPT_fpreview_breaking_changes))
+      WrapperArgs.push_back("-fpreview-breaking-changes");
+
     assert((Inputs.size() > 0) && "no inputs for clang-offload-wrapper");
     assert(((Inputs[0].getType() != types::TY_Tempfiletable) ||
             (Inputs.size() == 1)) &&
@@ -11580,6 +11591,12 @@ void LinkerWrapper::ConstructJob(Compilation &C, const JobAction &JA,
           Args.MakeArgString("--wrapper-jobs=" + Twine(NumThreads)));
   }
 
+  // Enable preview breaking changes in clang-linker-wrapper,
+  // in case it needs to introduce any ABI breaking changes.
+  // For example, changes in offload binary descriptor format.
+  if (Args.hasArg(options::OPT_fpreview_breaking_changes))
+    CmdArgs.push_back("-fpreview-breaking-changes");
+
   const char *Exec =
       Args.MakeArgString(getToolChain().GetProgramPath("clang-linker-wrapper"));
 

clang/lib/Sema/SemaLambda.cpp

@@ -356,7 +356,14 @@ Sema::getCurrentMangleNumberContext(const DeclContext *DC) {
       return std::make_tuple(&Context.getManglingNumberContext(DC), nullptr);
     }
 
-    return std::make_tuple(nullptr, nullptr);
+    if (ManglingContextDecl) {
+      // Lambdas defined in the initializer of a local variable are mangled
+      // in the enclosing function context.
+      if (auto *VD = dyn_cast<VarDecl>(ManglingContextDecl);
+          VD && !VD->hasGlobalStorage())
+        ManglingContextDecl = nullptr;
+    }
+    return std::make_tuple(nullptr, ManglingContextDecl);
   }
 
   case NonInlineInModulePurview:

clang/lib/Sema/SemaSYCL.cpp

@@ -6626,10 +6626,12 @@ class FreeFunctionPrinter {
   raw_ostream &O;
   PrintingPolicy &Policy;
   bool NSInserted = false;
+  ASTContext &Context;
 
 public:
-  FreeFunctionPrinter(raw_ostream &O, PrintingPolicy &PrintPolicy)
-      : O(O), Policy(PrintPolicy) {}
+  FreeFunctionPrinter(raw_ostream &O, PrintingPolicy &PrintPolicy,
+                      ASTContext &Context)
+      : O(O), Policy(PrintPolicy), Context(Context) {}
 
   /// Emits the function declaration of template free function.
   /// \param FTD The function declaration to print.
@@ -6826,18 +6828,42 @@ class FreeFunctionPrinter {
       CTN.getAsTemplateDecl()->printQualifiedName(ParmListOstream);
       ParmListOstream << "<";
 
-      auto SpecArgs = TST->template_arguments();
-      auto DeclArgs = CTST->template_arguments();
+      ArrayRef<TemplateArgument> SpecArgs = TST->template_arguments();
+      ArrayRef<TemplateArgument> DeclArgs = CTST->template_arguments();
+
+      auto TemplateArgPrinter = [&](const TemplateArgument &Arg) {
+        if (Arg.getKind() != TemplateArgument::ArgKind::Expression ||
+            Arg.isInstantiationDependent()) {
+          Arg.print(Policy, ParmListOstream, /* IncludeType = */ false);
+          return;
+        }
+
+        Expr *E = Arg.getAsExpr();
+        assert(E && "Failed to get an Expr for an Expression template arg?");
+        if (E->getType().getTypePtr()->isScopedEnumeralType()) {
+          // Scoped enumerations can't be implicitly cast from integers, so
+          // we don't need to evaluate them.
+          Arg.print(Policy, ParmListOstream, /* IncludeType = */ false);
+          return;
+        }
+
+        Expr::EvalResult Res;
+        [[maybe_unused]] bool Success =
+            Arg.getAsExpr()->EvaluateAsConstantExpr(Res, Context);
+        assert(Success && "invalid non-type template argument?");
+        assert(!Res.Val.isAbsent() && "couldn't read the evaulation result?");
+        Res.Val.printPretty(ParmListOstream, Policy, Arg.getAsExpr()->getType(),
+                            &Context);
+      };
 
       for (size_t I = 0, E = std::max(DeclArgs.size(), SpecArgs.size()),
                   SE = SpecArgs.size();
            I < E; ++I) {
         if (I != 0)
           ParmListOstream << ", ";
-        if (I < SE) // A specialized argument exists, use it
-          SpecArgs[I].print(Policy, ParmListOstream, false /* IncludeType */);
-        else // Print a canonical form of a default argument
-          DeclArgs[I].print(Policy, ParmListOstream, false /* IncludeType */);
+        // If we have a specialized argument, use it. Otherwise fallback to a
+        // default argument.
+        TemplateArgPrinter(I < SE ? SpecArgs[I] : DeclArgs[I]);
       }
 
       ParmListOstream << ">";
@@ -7236,7 +7262,7 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
     // template arguments that match default template arguments while printing
     // template-ids, even if the source code doesn't reference them.
     Policy.EnforceDefaultTemplateArgs = true;
-    FreeFunctionPrinter FFPrinter(O, Policy);
+    FreeFunctionPrinter FFPrinter(O, Policy, S.getASTContext());
     if (FTD) {
       FFPrinter.printFreeFunctionDeclaration(FTD);
       if (const auto kind = K.SyclKernel->getTemplateSpecializationKind();

clang/test/CodeGen/unnamed-types.cpp

@@ -0,0 +1,66 @@
+// This test checks that lambdas assigned to variables (including inline and
+// templated cases) in the same namespace are uniquely mangled and callable via
+// template functions. It ensures that the compiler generates distinct symbols
+// for each lambda and resolves them correctly in function calls.
+
+// RUN: %clang_cc1 -O0 -triple x86_64-unknown-unknown \
+// RUN: -emit-llvm  %s -o - | FileCheck %s
+
+// RUN: %clang_cc1 -O0 -triple x86_64-pc-windows-msvc \
+// RUN: -emit-llvm %s -o - | FileCheck %s --check-prefix=MSVC
+
+namespace QL {
+  auto dg1 = [] { return 1; };
+  inline auto dg_inline1 = [] { return 1; };
+}
+
+namespace QL {
+  auto dg2 = [] { return 2; };
+  template<int N>
+  auto dg_template = [] { return N; };
+}
+
+using namespace QL;
+template<typename T>
+void f(T t) {
+  t();
+}
+
+void g() {
+  f(dg1);
+  f(dg2);
+  f(dg_inline1);
+  f(dg_template<3>);
+}
+
+// CHECK: @_ZN2QL3dg1E = internal global %class.anon undef, align 1
+// CHECK: @_ZN2QL3dg2E = internal global %class.anon.0 undef, align 1
+// CHECK: @_ZN2QL10dg_inline1E = linkonce_odr global %class.anon.2 undef, comdat, align 1
+// CHECK: @_ZN2QL11dg_templateILi3EEE = linkonce_odr global %class.anon.4 undef, comdat, align 1
+
+// MSVC: @"?dg1@QL@@3V<lambda_0>@1@A" = internal global %class.anon undef, align 1
+// MSVC: @"?dg2@QL@@3V<lambda_1>@1@A" = internal global %class.anon.0 undef, align 1
+// MSVC: @"?dg_inline1@QL@@3V<lambda_1>@01@A" = linkonce_odr dso_local global %class.anon.2 undef, comdat, align 1
+// MSVC: @"??$dg_template@$02@QL@@3V<lambda_1>@01@A" = linkonce_odr dso_local global %class.anon.4 undef, comdat, align 1
+
+
+// CHECK: define internal void @"_Z1fIN2QL3$_0EEvT_"
+// CHECK: call noundef i32 @"_ZNK2QL3$_0clEv"
+// CHECK: define internal void @"_Z1fIN2QL3$_1EEvT_"
+// CHECK: define linkonce_odr void @_Z1fIN2QL10dg_inline1MUlvE_EEvT_
+// CHECK: call noundef i32 @_ZNK2QL10dg_inline1MUlvE_clEv
+// CHECK: define linkonce_odr void @_Z1fIN2QL11dg_templateILi3EEMUlvE_EEvT_
+// CHECK: call noundef i32 @_ZNK2QL11dg_templateILi3EEMUlvE_clEv
+// CHECK: define internal noundef i32 @"_ZNK2QL3$_0clEv"
+// CHECK: define internal noundef i32 @"_ZNK2QL3$_1clEv"
+// CHECK: define linkonce_odr noundef i32 @_ZNK2QL10dg_inline1MUlvE_clEv
+// CHECK: define linkonce_odr noundef i32 @_ZNK2QL11dg_templateILi3EEMUlvE_clEv
+
+// MSVC: define linkonce_odr dso_local void @"??$f@V<lambda_1>@dg_inline1@QL@@@@YAXV<lambda_1>@dg_inline1@QL@@@Z"
+// MSVC: call noundef i32 @"??R<lambda_1>@dg_inline1@QL@@QEBA?A?<auto>@@XZ"
+// MSVC: define linkonce_odr dso_local void @"??$f@V<lambda_1>@?$dg_template@$02@QL@@@@YAXV<lambda_1>@?$dg_template@$02@QL@@@Z"
+// MSVC: call noundef i32 @"??R<lambda_1>@?$dg_template@$02@QL@@QEBA?A?<auto>@@XZ"
+// MSVC: define internal noundef i32 @"??R<lambda_0>@QL@@QEBA?A?<auto>@@XZ"
+// MSVC: define internal noundef i32 @"??R<lambda_1>@QL@@QEBA?A?<auto>@@XZ"
+// MSVC: define linkonce_odr dso_local noundef i32 @"??R<lambda_1>@dg_inline1@QL@@QEBA?A?<auto>@@XZ"
+// MSVC: define linkonce_odr dso_local noundef i32 @"??R<lambda_1>@?$dg_template@$02@QL@@QEBA?A?<auto>@@XZ"

clang/test/CodeGenCUDA/anon-ns.cu

@@ -26,14 +26,14 @@
 
 // HIP-DAG: define weak_odr {{.*}}void @[[KERN:_ZN12_GLOBAL__N_16kernelEv\.intern\.b04fd23c98500190]](
 // HIP-DAG: define weak_odr {{.*}}void @[[KTX:_Z2ktIN12_GLOBAL__N_11XEEvT_\.intern\.b04fd23c98500190]](
-// HIP-DAG: define weak_odr {{.*}}void @[[KTL:_Z2ktIN12_GLOBAL__N_1UlvE_EEvT_\.intern\.b04fd23c98500190]](
+// HIP-DAG: define weak_odr {{.*}}void @[[KTL:_Z2ktIN12_GLOBAL__N_16lambdaMUlvE_EEvT_.intern\.b04fd23c98500190]](
 // HIP-DAG: @[[VM:_ZN12_GLOBAL__N_12vmE\.static\.b04fd23c98500190]] = addrspace(1) externally_initialized global
 // HIP-DAG: @[[VC:_ZN12_GLOBAL__N_12vcE\.static\.b04fd23c98500190]] = addrspace(4) externally_initialized constant
 // HIP-DAG: @[[VT:_Z2vtIN12_GLOBAL__N_11XEE\.static\.b04fd23c98500190]] = addrspace(1) externally_initialized global
 
 // CUDA-DAG: define weak_odr {{.*}}void @[[KERN:_ZN12_GLOBAL__N_16kernelEv__intern__b04fd23c98500190]](
 // CUDA-DAG: define weak_odr {{.*}}void @[[KTX:_Z2ktIN12_GLOBAL__N_11XEEvT___intern__b04fd23c98500190]](
-// CUDA-DAG: define weak_odr {{.*}}void @[[KTL:_Z2ktIN12_GLOBAL__N_1UlvE_EEvT___intern__b04fd23c98500190]](
+// CUDA-DAG: define weak_odr {{.*}}void @[[KTL:_Z2ktIN12_GLOBAL__N_16lambdaMUlvE_EEvT___intern__b04fd23c98500190]](
 // CUDA-DAG: @[[VC:_ZN12_GLOBAL__N_12vcE__static__b04fd23c98500190]] = addrspace(4) externally_initialized constant
 // CUDA-DAG: @[[VT:_Z2vtIN12_GLOBAL__N_11XEE__static__b04fd23c98500190]] = addrspace(1) externally_initialized global
 

clang/test/CodeGenSYCL/free-function-kernel-expr-as-template-arg.cpp

@@ -0,0 +1,110 @@
+// RUN: %clang_cc1 -fsycl-is-device -internal-isystem %S/Inputs -triple spir64-unknown-unknown -sycl-std=2020 -fsycl-int-header=%t.h %s
+// RUN: FileCheck -input-file=%t.h %s
+//
+// The purpose of this test is to ensure that forward declarations of free
+// function kernels are emitted properly.
+// However, this test checks a specific scenario:
+// - free function argument is a template which accepts constant expressions as
+//   arguments
+
+constexpr int A = 2;
+constexpr int B = 3;
+
+namespace ns {
+
+constexpr int C = 4;
+
+struct Foo {
+  static constexpr int D = 5;
+};
+
+enum non_class_enum {
+  VAL_A,
+  VAL_B
+};
+
+enum class class_enum {
+  VAL_A,
+  VAL_B
+};
+
+enum non_class_enum_typed : int {
+  VAL_C,
+  VAL_D
+};
+
+enum class class_enum_typed : int {
+  VAL_C,
+  VAL_D
+};
+
+constexpr int bar(int arg) {
+  return arg + 42;
+}
+
+} // namespace ns
+
+template<int V>
+struct Arg {};
+
+template<ns::non_class_enum V>
+struct Arg2 {};
+
+template<ns::non_class_enum_typed V>
+struct Arg3 {};
+
+template<ns::class_enum V>
+struct Arg4 {};
+
+template<ns::class_enum_typed V>
+struct Arg5 {};
+
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 2)]]
+void constant(Arg<1>) {}
+
+// CHECK: void constant(Arg<1> );
+
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 2)]]
+void constexpr_v(Arg<A>) {}
+
+// CHECK: void constexpr_v(Arg<2> );
+
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 2)]]
+void constexpr_expr(Arg<A * B>) {}
+
+// CHECK: void constexpr_expr(Arg<6> );
+
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 2)]]
+void constexpr_ns(Arg<ns::C>) {}
+
+// CHECK: void constexpr_ns(Arg<4> );
+
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 2)]]
+void constexpr_ns2(Arg<ns::Foo::D>) {}
+
+// CHECK: void constexpr_ns2(Arg<5> );
+
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 2)]]
+void constexpr_ns2(Arg2<ns::non_class_enum::VAL_A>) {}
+
+// CHECK: void constexpr_ns2(Arg2<ns::VAL_A> );
+
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 2)]]
+void constexpr_ns2(Arg3<ns::non_class_enum_typed::VAL_C>) {}
+
+// CHECK: void constexpr_ns2(Arg3<ns::VAL_C> );
+
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 2)]]
+void constexpr_ns2(Arg4<ns::class_enum::VAL_A>) {}
+
+// CHECK: void constexpr_ns2(Arg4<ns::class_enum::VAL_A> );
+
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 2)]]
+void constexpr_ns2(Arg5<ns::class_enum_typed::VAL_C>) {}
+
+// CHECK: void constexpr_ns2(Arg5<ns::class_enum_typed::VAL_C> );
+
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 2)]]
+void constexpr_call(Arg<ns::bar(B)>) {}
+
+// CHECK: void constexpr_call(Arg<45> );