[Driver][FPGA][SYCL] Add specific timing diagnostic for FPGA AOT

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

@@ -105,7 +105,7 @@ struct ResponseFileSupport {
 /// execute.
 class Command {
 public:
-  using ErrorCodeDiagMapTy = llvm::DenseMap<int, std::string>;
+  using ErrorCodeDiagMapTy = llvm::DenseMap<int, std::pair<std::string, bool>>;
 
 private:
   /// Source - The action which caused the creation of this job.
@@ -122,6 +122,8 @@ class Command {
 
   /// The container for custom driver-set diagnostic messages that are
   /// produced upon particular error codes returned by the command.
+  /// Given a custom diagnostic, also allow for logic to determine if the
+  /// compilation should continue, even with a non-zero return code.
   /// In order to add such a diagnostic for an external tool, consider the
   /// following criteria:
   /// 1) Does the command's executable return different codes upon different
@@ -194,15 +196,20 @@ class Command {
   virtual int Execute(ArrayRef<Optional<StringRef>> Redirects,
                       std::string *ErrMsg, bool *ExecutionFailed) const;
 
-  /// Store a custom driver diagnostic message upon a particular error code
-  /// returned by the command
-  void addDiagForErrorCode(int ErrorCode, StringRef CustomDiag);
+  /// Store a custom driver diagnostic message and if the compilation should
+  /// exit upon a particular error code returned by the command
+  void addDiagForErrorCode(int ErrorCode, StringRef CustomDiag,
+                           bool NoExit = false);
 
   /// 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
+  /// false if not set (always exit)
+  bool getWillNotExitForErrorCode(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->getWillNotExitForErrorCode(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,10 @@ 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->getWillNotExitForErrorCode(Res))
         return;
     }
   }

clang/lib/Driver/Job.cpp

@@ -158,17 +158,26 @@ void Command::buildArgvForResponseFile(
   }
 }
 
-void Command::addDiagForErrorCode(int ErrorCode, StringRef CustomDiag) {
-  ErrorCodeDiagMap[ErrorCode] = CustomDiag.str();
+void Command::addDiagForErrorCode(int ErrorCode, StringRef CustomDiag,
+                                  bool NoExit) {
+  ErrorCodeDiagMap[ErrorCode].first = CustomDiag.str();
+  ErrorCodeDiagMap[ErrorCode].second = NoExit;
 }
 
 StringRef Command::getDiagForErrorCode(int ErrorCode) const {
   auto ErrorCodeDiagIt = ErrorCodeDiagMap.find(ErrorCode);
   if (ErrorCodeDiagIt != ErrorCodeDiagMap.end())
-    return ErrorCodeDiagIt->second;
+    return ErrorCodeDiagIt->second.first;
   return StringRef();
 }
 
+bool Command::getWillNotExitForErrorCode(int ErrorCode) const {
+  auto ErrorCodeDiagIt = ErrorCodeDiagMap.find(ErrorCode);
+  if (ErrorCodeDiagIt != ErrorCodeDiagMap.end())
+    return ErrorCodeDiagIt->second.second;
+  return false;
+}
+
 /// 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

@@ -82,6 +82,16 @@ 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, true);
+}
+
 void SYCL::constructLLVMForeachCommand(Compilation &C, const JobAction &JA,
                                        std::unique_ptr<Command> InputCommand,
                                        const InputInfoList &InputFiles,
@@ -119,8 +129,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
@@ -525,6 +541,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);

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;
 }