WIP

```c++

int main() {
  const char *src = R"""(
// #include <stdio.h>

namespace syclext = sycl::ext::oneapi;
namespace syclexp = sycl::ext::oneapi::experimental;

extern "C"
SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::single_task_kernel))
void foo(int *p) {
  *p = 42;
}
)""";

  jit_compiler::InMemoryFile SrcFile{"a.cpp", src};
  std::vector<jit_compiler::InMemoryFile> IncludeFiles{
      {"/fake_includes/assert.h", "#pragma once\n#define assert(...)\n"}
  };

  std::vector<const char *> opts = {
      "--stdlib=libc++", "-D_LIBCPP_REMOVE_TRANSITIVE_INCLUDES"
      , "-include", "stdio.h"
      // "-Xclang", "-isystem-after", "-Xclang", "/sycl-jit-toolchain/lib/clang/22/include/libc"
      // ,
      // "-isystem-after=/sycl-jit-toolchain/lib/clang/22/include/libc"
  };
  {
    auto Res = jit_compiler::calculateHash(SrcFile, IncludeFiles, opts,
                                           jit_compiler::BinaryFormat::SPIRV);
    std::cerr << "Failed: " << std::boolalpha << Res.failed() << std::endl;
  }

  {
    auto Res = jit_compiler::compileSYCL(SrcFile, IncludeFiles, opts,
                                         {nullptr, 0}, false,
                                         jit_compiler::BinaryFormat::SPIRV);
    std::cerr << (int)Res.getErrorCode() << std::endl;
    std::cerr << Res.getBuildLog() << std::endl;

  }
}
```

Author: aelovikov-intel

clang/lib/Driver/ToolChains/SYCL.cpp

@@ -2083,6 +2083,9 @@ void SYCLToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
 void SYCLToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &Args,
                                                  ArgStringList &CC1Args) const {
   HostTC.AddClangCXXStdlibIncludeArgs(Args, CC1Args);
+  if (GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) {
+    addSystemInclude(Args, CC1Args, "/sycl-jit-toolchain/include/libc");
+  }
 }
 
 SanitizerMask SYCLToolChain::getSupportedSanitizers() const {

sycl-jit/jit-compiler/CMakeLists.txt

@@ -65,8 +65,7 @@ endforeach()
 if ("libc" IN_LIST LLVM_ENABLE_RUNTIMES)
   list(APPEND SYCL_JIT_RUNTIME_RESOURCE_DEPS libc)
   list(APPEND SYCL_JIT_PREPARE_RUNTIME_RESOURCE_COMMANDS
-    # COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR}/runtimes/runtimes-bins --target libc
-    COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_BINARY_DIR}/runtimes/runtimes-bins/libc/include ${SYCL_JIT_RESOURCE_INSTALL_DIR}
+    COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_BINARY_DIR}/runtimes/runtimes-bins/libc/include ${SYCL_JIT_RESOURCE_INSTALL_DIR}/include/libc
   )
 endif()
 

sycl-jit/jit-compiler/lib/rtc/DeviceCompilation.cpp

@@ -59,6 +59,8 @@
 #include <memory>
 #include <sstream>
 
+#include <iostream>
+
 using namespace clang;
 using namespace clang::tooling;
 using namespace clang::driver;
@@ -216,6 +218,9 @@ class SYCLToolchain {
                        FileManager *Files,
                        std::shared_ptr<PCHContainerOperations> PCHContainerOps,
                        DiagnosticConsumer *DiagConsumer) override {
+      for (auto &arg : Invocation->getCC1CommandLine())
+        std::cerr << " " << arg;
+      std::cerr << std::endl;
       // Create a compiler instance to handle the actual work.
       CompilerInstance Compiler(std::move(Invocation),
                                 std::move(PCHContainerOps));
@@ -278,6 +283,14 @@ class SYCLToolchain {
     CommandLine.emplace_back(ClangXXExe);
     transform(ASL, std::back_inserter(CommandLine),
               [](const char *AS) { return std::string{AS}; });
+
+
+    // CommandLine.push_back("--stdlib=libc++");
+    // CommandLine.push_back("-D_LIBCPP_REMOVE_TRANSITIVE_INCLUDES");
+    // CommandLine.push_back("-include");
+    // CommandLine.push_back("stdio.h");
+
+
     CommandLine.emplace_back(SourceFilePath);
     return CommandLine;
   }
@@ -543,9 +556,16 @@ class SYCLToolchain {
     std::vector<std::string> CommandLine =
         createCommandLine(UserArgList, Format, SourceFilePath);
 
+#if 1
     auto FS = llvm::makeIntrusiveRefCnt<llvm::vfs::OverlayFileSystem>(
         llvm::vfs::getRealFileSystem());
     FS->pushOverlay(getToolchainFS());
+#else
+    auto FS = llvm::makeIntrusiveRefCnt<llvm::vfs::OverlayFileSystem>(
+        getToolchainFS());
+#endif
+
+
     if (FSOverlay)
       FS->pushOverlay(std::move(FSOverlay));
 
@@ -704,10 +724,12 @@ Expected<std::string> jit_compiler::calculateHash(
       Opts.ShowCPP = 1;
       Opts.MinimizeWhitespace = 1;
       // Make cache key insensitive to virtual source file and header locations.
-      Opts.ShowLineMarkers = 0;
+      Opts.ShowLineMarkers = 1;
 
       DoPrintPreprocessedInput(CI.getPreprocessor(), &PreprocessStream, Opts);
 
+      std::cout << PreprocessedSource << std::endl;
+
       Hasher.update(PreprocessedSource);
     }
 

sycl/include/sycl/ext/oneapi/properties/property.hpp

@@ -119,7 +119,7 @@ template <> struct is_property_key_of<foo, SYCL_OBJ> : std::true_type {};
 
 #pragma once
 
-#include <iosfwd>      // for nullptr_t
+#include <cstddef>     // for nullptr_t
 #include <stdint.h>    // for uint32_t
 #include <type_traits> // for false_type