[Driver][SYCL] Compile source file for integration header generation (#20818)

When compiler for preprocessing only, the preprocessing step that occurs
does not generate the integration header/footer information that is used
during the host compilation step. To generate the integration
information in this case, the driver inserts an additional compilation
step that creates the files to be consumed at the host step.

The compilation step to produce the integration information is using the
generated preprocessed file. For cases where there are build warnings
that are emitted during this step, use of -Werror will cause the
compilation to fail. These diagnostics are typically suppressed when not
performing preprocess only compilations, but due to the fact that the
build step against the preprocessed file does not know to suppress the
diagnostics from system headers, compilation behaviors are at a
disconnect.

To fix this, the behavior when creating a preprocessed file (i.e. when
we are using -E and stopping compilation), the driver will now compile
the original source file instead of the preprocessed file.

Author: mdtoguchi

clang/lib/Driver/Driver.cpp

@@ -5061,14 +5061,19 @@ class OffloadingActionBuilder final {
                llvm::zip(SYCLDeviceActions, SYCLTargetInfoList)) {
             Action *&A = std::get<0>(TargetActionInfo);
             auto &TargetInfo = std::get<1>(TargetActionInfo);
-            A = C.getDriver().ConstructPhaseAction(C, Args, CurPhase, A,
-                                                   AssociatedOffloadKind);
-            if (SYCLDeviceOnly)
+            Action *PreprocAction = C.getDriver().ConstructPhaseAction(
+                C, Args, CurPhase, A, AssociatedOffloadKind);
+            if (SYCLDeviceOnly) {
+              A = PreprocAction;
               continue;
+            }
             // Add an additional compile action to generate the integration
-            // header.
+            // header. This action compiles the source file instead of the
+            // generated preprocessed file to allow for control of the
+            // diagnostics that could come from the system headers.
             Action *CompileAction =
                 C.MakeAction<CompileJobAction>(A, types::TY_Nothing);
+            A = PreprocAction;
             DA.add(*CompileAction, *TargetInfo.TC, TargetInfo.BoundArch,
                    Action::OFK_SYCL);
           }
@@ -8001,8 +8006,15 @@ Action *Driver::BuildOffloadingActions(Compilation &C,
               if (isa<PreprocessJobAction>(A)) {
                 PackagerActions.push_back(OA);
                 A->setCannotBeCollapsedWithNextDependentAction();
-                Action *CompileAction =
-                    C.MakeAction<CompileJobAction>(A, types::TY_Nothing);
+                // The input to the compilation job is the preprocessed job.
+                // Take that input action (it should be one input) which is
+                // the source file and compile that file to generate the
+                // integration header/footer.
+                ActionList PreprocInputs = A->getInputs();
+                assert(PreprocInputs.size() == 1 &&
+                       "Single input size to preprocess action expected.");
+                Action *CompileAction = C.MakeAction<CompileJobAction>(
+                    PreprocInputs.front(), types::TY_Nothing);
                 DDeps.add(*CompileAction, *TC, BoundArch, Action::OFK_SYCL);
               }
             });

clang/test/Driver/sycl-offload-nvptx.cpp

@@ -106,7 +106,7 @@
 // RUN: | FileCheck -check-prefix=CHK-PREPROC %s
 // CHK-PREPROC: 1: preprocessor, {0}, c++-cpp-output, (device-sycl, sm_[[CUDA_VERSION:[0-9.]+]])
 // CHK-PREPROC: 2: offload, "device-sycl (nvptx64-nvidia-cuda:sm_[[CUDA_VERSION]])" {1}, c++-cpp-output
-// CHK-PREPROC: 4: compiler, {1}, none, (device-sycl, sm_[[CUDA_VERSION]])
+// CHK-PREPROC: 4: compiler, {0}, none, (device-sycl, sm_[[CUDA_VERSION]])
 //
 // RUN: not %clangxx -### -std=c++11 -target x86_64-unknown-linux-gnu -fsycl \
 // RUN: -fsycl-targets=nvptx64-nvidia-cuda --cuda-path=%S/Inputs/no/CUDA/path/here \

clang/test/Driver/sycl-preprocess-old-model.cpp

@@ -22,7 +22,7 @@
 // PREPROC_PHASES: 1: preprocessor, {0}, c++-cpp-output, (device-sycl)
 // PREPROC_PHASES: 2: offload, "device-sycl (spir64-unknown-unknown)" {1}, c++-cpp-output
 // PREPROC_PHASES: 3: input, "[[INPUT]]", c++, (host-sycl)
-// PREPROC_PHASES: 4: compiler, {1}, none, (device-sycl)
+// PREPROC_PHASES: 4: compiler, {0}, none, (device-sycl)
 // PREPROC_PHASES: 5: offload, "host-sycl (x86_64-unknown-linux-gnu)" {3}, "device-sycl (spir64-unknown-unknown)" {4}, c++
 // PREPROC_PHASES: 6: preprocessor, {5}, c++-cpp-output, (host-sycl)
 // PREPROC_PHASES: 7: clang-offload-bundler, {2, 6}, c++-cpp-output, (host-sycl)

clang/test/Driver/sycl-preprocess.cpp

@@ -24,7 +24,7 @@
 // PREPROC_PHASES: 1: preprocessor, {0}, c++-cpp-output, (host-sycl)
 // PREPROC_PHASES: 2: input, "[[INPUT]]", c++, (device-sycl)
 // PREPROC_PHASES: 3: preprocessor, {2}, c++-cpp-output, (device-sycl)
-// PREPROC_PHASES: 4: compiler, {3}, none, (device-sycl)
+// PREPROC_PHASES: 4: compiler, {2}, none, (device-sycl)
 // PREPROC_PHASES: 5: offload, "device-sycl (spir64-unknown-unknown)" {3}, c++-cpp-output
 // PREPROC_PHASES: 6: llvm-offload-binary, {5, 1}, c++-cpp-output
 // PREPROC_PHASES: 7: offload, "host-sycl ([[TARGET]])" {1}, "device-sycl (spir64-unknown-unknown)" {3}, "device-sycl (spir64-unknown-unknown)" {4}, " ([[TARGET]])" {6}, c++-cpp-output