[Driver][FPGA][SYCL] Add specific timing diagnostic for FPGA AOT (#3965)

There are cases in which the generation of FPGA device code from 'aoc'
is known to have timing issues.  Add a specific diagnostic from the
driver when this case is encountered.  A special return code (42) is
used to inform the driver of this situation.

Additionally in this situation, we also want to allow for the compilation
to continue so the user can use the generated binary knowing the timing
issue as stated.

Author: mdtoguchi

clang/include/clang/Driver/Job.h

@@ -106,6 +106,7 @@ struct ResponseFileSupport {
 class Command {
 public:
   using ErrorCodeDiagMapTy = llvm::DenseMap<int, std::string>;
+  using ErrorCodeExitMapTy = llvm::DenseMap<int, bool>;
 
 private:
   /// Source - The action which caused the creation of this job.
@@ -132,6 +133,11 @@ class Command {
   ///    "invalid input" error can be ruled out
   ErrorCodeDiagMapTy ErrorCodeDiagMap;
 
+  /// Similar to the container for the diagnostic messages, this container
+  /// is used to signify if the toolchain should error and exit right away
+  /// or if we should continue compilation.
+  ErrorCodeExitMapTy ErrorCodeExitMap;
+
   /// The list of program arguments (not including the implicit first
   /// argument, which will be the executable).
   llvm::opt::ArgStringList Arguments;
@@ -198,11 +204,19 @@ class Command {
   /// returned by the command
   void addDiagForErrorCode(int ErrorCode, StringRef CustomDiag);
 
+  /// Store if the compilation should exit upon a particular error code
+  /// returned by the command
+  void addExitForErrorCode(int ErrorCode, bool Exit);
+
   /// Get the custom driver diagnostic message for a particular error code
   /// if such was stored. Returns an empty string if no diagnostic message
   /// was found for the given error code.
   StringRef getDiagForErrorCode(int ErrorCode) const;
 
+  /// Will the tool exit when a particular error code is encountered. Returns
+  /// true if not set (always exit)
+  bool getWillExitForErrorCode(int ErrorCode) const;
+
   /// getSource - Return the Action which caused the creation of this job.
   const Action &getSource() const { return Source; }
 

clang/lib/Driver/Compilation.cpp

@@ -249,6 +249,10 @@ static bool ActionFailed(const Action *A,
   if (FailingCommands.empty())
     return false;
 
+  for (const auto &CI : FailingCommands)
+    if (!CI.second->getWillExitForErrorCode(CI.first))
+      return false;
+
   // CUDA/HIP/SYCL can have the same input source code compiled multiple times
   // so do not compile again if there are already failures. It is OK to abort
   // the CUDA pipeline on errors.
@@ -285,7 +289,9 @@ void Compilation::ExecuteJobs(const JobList &Jobs,
     if (int Res = ExecuteCommand(Job, FailingCommand)) {
       FailingCommands.push_back(std::make_pair(Res, FailingCommand));
       // Bail as soon as one command fails in cl driver mode.
-      if (TheDriver.IsCLMode())
+      // Do not bail when the tool is setup to allow for continuation upon
+      // failure.
+      if (TheDriver.IsCLMode() && FailingCommand->getWillExitForErrorCode(Res))
         return;
     }
   }

clang/lib/Driver/Job.cpp

@@ -162,13 +162,24 @@ void Command::addDiagForErrorCode(int ErrorCode, StringRef CustomDiag) {
   ErrorCodeDiagMap[ErrorCode] = CustomDiag.str();
 }
 
+void Command::addExitForErrorCode(int ErrorCode, bool Exit) {
+  ErrorCodeExitMap[ErrorCode] = Exit;
+}
+
 StringRef Command::getDiagForErrorCode(int ErrorCode) const {
   auto ErrorCodeDiagIt = ErrorCodeDiagMap.find(ErrorCode);
   if (ErrorCodeDiagIt != ErrorCodeDiagMap.end())
     return ErrorCodeDiagIt->second;
   return StringRef();
 }
 
+bool Command::getWillExitForErrorCode(int ErrorCode) const {
+  auto ErrorCodeExitIt = ErrorCodeExitMap.find(ErrorCode);
+  if (ErrorCodeExitIt != ErrorCodeExitMap.end())
+    return ErrorCodeExitIt->second;
+  return true;
+}
+
 /// Rewrite relative include-like flag paths to absolute ones.
 static void
 rewriteIncludes(const llvm::ArrayRef<const char *> &Args, size_t Idx,

clang/lib/Driver/ToolChains/SYCL.cpp

@@ -85,6 +85,17 @@ const char *SYCL::Linker::constructLLVMSpirvCommand(
   return OutputFileName;
 }
 
+static void addFPGATimingDiagnostic(std::unique_ptr<Command> &Cmd,
+                                    Compilation &C) {
+  const char *Msg = C.getArgs().MakeArgString(
+      "The FPGA image generated during this compile contains timing violations "
+      "and may produce functional errors if used. Refer to the Intel oneAPI "
+      "DPC++ FPGA Optimization Guide section on Timing Failures for more "
+      "information.");
+  Cmd->addDiagForErrorCode(/*ErrorCode*/ 42, Msg);
+  Cmd->addExitForErrorCode(/*ErrorCode*/ 42, false);
+}
+
 void SYCL::constructLLVMForeachCommand(Compilation &C, const JobAction &JA,
                                        std::unique_ptr<Command> InputCommand,
                                        const InputInfoList &InputFiles,
@@ -122,8 +133,14 @@ void SYCL::constructLLVMForeachCommand(Compilation &C, const JobAction &JA,
   SmallString<128> ForeachPath(C.getDriver().Dir);
   llvm::sys::path::append(ForeachPath, "llvm-foreach");
   const char *Foreach = C.getArgs().MakeArgString(ForeachPath);
-  C.addCommand(std::make_unique<Command>(JA, *T, ResponseFileSupport::None(),
-                                         Foreach, ForeachArgs, None));
+
+  auto Cmd = std::make_unique<Command>(JA, *T, ResponseFileSupport::None(),
+                                       Foreach, ForeachArgs, None);
+  // FIXME: Add the FPGA specific timing diagnostic to the foreach call.
+  // The foreach call obscures the return codes from the tool it is calling
+  // to the compiler itself.
+  addFPGATimingDiagnostic(Cmd, C);
+  C.addCommand(std::move(Cmd));
 }
 
 // The list should match pre-built SYCL device library files located in
@@ -530,6 +547,7 @@ void SYCL::fpga::BackendCompiler::ConstructJob(
   const char *Exec = C.getArgs().MakeArgString(ExecPath);
   auto Cmd = std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
                                        Exec, CmdArgs, None);
+  addFPGATimingDiagnostic(Cmd, C);
   if (!ForeachInputs.empty())
     constructLLVMForeachCommand(C, JA, std::move(Cmd), ForeachInputs, Output,
                                 this, ReportOptArg, ForeachExt);

clang/test/Driver/Inputs/SYCL/aoc

@@ -0,0 +1,22 @@
+#!/bin/sh
+## Simple aoc replacement script that returns '42' that is used to test
+## special return code processing for FPGA AOT.
+
+while [[ $# -gt 0 ]] ; do
+  opt="$1"
+  case $opt in
+    -o)
+      shift
+      OUTFILE=$1
+      ;;
+    *)
+      shift
+      ;;
+  esac
+done
+
+if [ "$OUTFILE" != "" ] ; then
+  echo "dummy file contents" > $OUTFILE
+fi
+
+exit 42

clang/test/Driver/sycl-intelfpga-return-check.cpp

@@ -0,0 +1,15 @@
+// REQUIRES: system-linux 
+
+/// Tests behavior with aoc -fintelpga.
+/// Uses a dummy aoc which returns '42' to make sure we properly emit a
+/// diagnostic and also do not stop compilation
+// RUN: env PATH=%S/Inputs/SYCL:$PATH \
+// RUN: not %clangxx -fsycl -fintelfpga -Xshardware %s -v 2>&1 \
+// RUN:  | FileCheck %s -check-prefix ERROR_OUTPUT
+// ERROR_OUTPUT: ld{{.*}} -o a.out
+// ERROR_OUTPUT: The FPGA image generated during this compile contains timing violations
+
+int main()
+{
+  return 0;
+}

llvm/test/tools/llvm-foreach/retain-return-val.c

@@ -0,0 +1,23 @@
+// REQUIRES: system-linux
+// Test that the return value from the called tool is retained.
+// Runs a script within a script so we can retain the return code without
+// the testing infrastructure getting in the way.
+
+// RUN: echo 'Content of first file' > %t1.tgt
+// RUN: echo 'Content of second file' > %t2.tgt
+// RUN: echo "%t1.tgt" > %t.list
+// RUN: echo "%t2.tgt" >> %t.list
+
+// RUN: echo "#!/bin/sh" > %t.sh
+// RUN: echo "cat \$1" >> %t.sh
+// RUN: echo "exit 21" >> %t.sh
+// RUN: chmod 777 %t.sh
+// RUN: echo "#!/bin/sh" > %t2.sh
+// RUN: echo "llvm-foreach --in-replace=\"{}\" --in-file-list=%t.list -- %t.sh \"{}\" > %t.res" >> %t2.sh
+// RUN: echo "echo \$? >> %t.res" >> %t2.sh
+// RUN: chmod 777 %t2.sh
+// RUN: %t2.sh
+// RUN: FileCheck < %t.res %s
+// CHECK: Content of first file
+// CHECK: Content of second file
+// CHECK: 21

llvm/tools/llvm-foreach/llvm-foreach.cpp

@@ -165,6 +165,7 @@ int main(int argc, char **argv) {
   if (!OutputFileList.empty())
     error(EC, "error opening the file '" + OutputFileList + "'");
 
+  int Res = 0;
   std::string ResOutArg;
   std::string IncOutArg;
   std::vector<std::string> ResInArgs(InReplaceArgs.size());
@@ -225,13 +226,15 @@ int main(int argc, char **argv) {
     int Result =
         sys::ExecuteAndWait(Prog, Args, /*Env=*/None, /*Redirects=*/None,
                             /*SecondsToWait=*/0, /*MemoryLimit=*/0, &ErrMsg);
-    if (Result != 0)
-      error(ErrMsg);
+    if (Result != 0) {
+      errs() << "llvm-foreach: " << ErrMsg << '\n';
+      Res = Result;
+    }
   }
 
   if (!OutputFileList.empty()) {
     OS.close();
   }
 
-  return 0;
+  return Res;
 }