WIP [clang] adds capabilities for SARIF to be written to file

[cjdb]

Summary

The original -fdiagnostics-format=sarif wrote directly to standard
error. This commit renames that mode to sarif-stderr and introduces a
sarif-file mode that allows the compiler to write .sarif files to
the current working directory. It also removes SARIF as an option so
that there's a single canonical approach for each option.

IMPORTANT: There are two different designs for writing SARIF to file, so I've pulled the common parts of the design out into their own patch. This ensures it only gets reviewed once, and so that the divergence is apparent in the other two patches. Once a design is settled on, this patch will be joined with the selected design.

Depends on D145201.

[cjdb]

adds dependency

[cjdb]

tidies up some stuff that I overlooked

[cjdb]

merges in D145438. This patch is ready for review now.

[erichkeane]

Patch topic needs "WIP" out of it I think?

Just some WIP comments, I don't believe I'd be the one to approve this anyway.

clang/include/clang/Basic/DiagnosticOptions.h

109

typically Clang uses the 'American' spelling of things.

110

I'm a touch disturbed by there being 3 very similar file names with very similar comments here. Is there a reason we need all 3?

clang/include/clang/Driver/Options.td

5851

Another 'TODO' here?

clang/include/clang/Frontend/CompilerInstance.h

610

This comment seems inaccurate.

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

39

What do we do with the DiagnosticsOptions here? Does this have to be a pointer, instead of a ref?

EDIT: I see the rest of the printers seem to do this, but I don't know if we ever have a case where these are null. I guess having them consistent here is important, but if the next person came through and made these all 'refs', it would be nice :)

clang/lib/Driver/ToolChains/Clang.cpp

4036

are we intentionally getting rid of the SARIF spellings intentionally? If so, and because we have this warning, should we report they are no longer supported?

clang/lib/Frontend/CompilerInstance.cpp

357

Oh my... I'll leave it to the Clang code owner/driver code owner (@jansvoboda11) to decide what they think of this.

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

37

Isn't TargetPath a 'Path'? If so, are you just creating a dot-file? Aren't those really nasty on Windows, and not a nice thing to do here on Linux?

45

I know these are nice/readable/etc, but llvm doesn't use these.

Also, you KNOW what EC equals here: it is a default constructed std::error_code, so the 'if' condition here is always hit. I suspect just removing the whole body and replacing with an llvm_unreachable is appropriate instead.

[cjdb]

clang/include/clang/Basic/DiagnosticOptions.h

110

Agreed. I tried to get this to work with -serialize-diagnostics but that seems to activate a path that causes a different diagnostic engine to take over based on the value of DiagnosticSerializationFile. I didn't notice DiagnosticLogFile, so I'll see what happens if that is used.

clang/lib/Driver/ToolChains/Clang.cpp

4036

Yes. SARIF support isn't documented at all, and as such, I suspect the number of people who know about it (and use it for more than simple curiosity) would be hand-countable, so I'm not sure that it's worth the effort?

(The reason it's not documented is because I forgot to ask for that last year, but that's currently to our advantage.)

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

37

TargetPath should be a filename, not a directory. When implicit, this is whatever the compiler will generate as its target program. When explicit... I should probably add a check and diagnostic for this.

45

I'm not sure this code is unreachable, hence the assert message. If the file can't be opened for some reason, it's not appropriate for Clang to simply crash.

[vaibhav.y]

clang/lib/Tooling/SarifLinker.cpp

21

Is this for link diagnostics reported as SARIF?

[kolrami]

Hi @cjdb , I would be interested in this change also since GCC supports the same sarif-stderr and sarif-file options. Is there a further plan that it might be integrated?

[aaron.ballman]

@cjdb -- how would you like to proceed with this review? There's already quite a bit of discussion on the current Phab patch set, but it seems unlikely that we'd be able to wrap everything up by the Nov 15th deadline. But then again, GitHub has no ability to do stacked patches and so moving the review there might be an even bigger challenge. (No pressure, it's also totally fine to say "I have to abandon this for now".)

clang/include/clang/Basic/DiagnosticDriverKinds.td

def err_drv_invalid_format_dxil_validator_version : Error<
   "Format of validator version is \"<major>.<minor>\" (ex:\"1.4\").">;
 def err_drv_invalid_empty_dxil_validator_version : Error<
   "invalid validator version : %0\n"
   "If validator major version is 0, minor version must also be 0.">;
 
 def warn_drv_sarif_format_unstable : Warning<
   "diagnostic formatting in SARIF mode is currently unstable">,
   InGroup<DiagGroup<"sarif-format-unstable">>;
+def warn_drv_implicit_diagnostics_format_file : Warning<
+  "'-fdiagnostics-file-path' should be set when using '-fdiagnostics-format=%0'">,
+  InGroup<DiagGroup<"implicit-diagnostics-format-file">>;
+def err_drv_diagnostics_format_file_fsyntax_only : Error<
+  "'-fdiagnostics-file-path' must be set when combining '-fsyntax-only' with "
+  "'-fdiagnostics-format=%0'">;
 
 def err_drv_riscv_unsupported_with_linker_relaxation : Error<
   "%0 is unsupported with RISC-V linker relaxation (-mrelax)">;
 
 def err_drv_loongarch_invalid_mfpu_EQ : Error<
   "invalid argument '%0' to -mfpu=; must be one of: 64, 32, none, 0 (alias for none)">;
 }

clang/include/clang/Basic/DiagnosticOptions.h

 /// Options for controlling the compiler diagnostics engine.
 class DiagnosticOptions : public RefCountedBase<DiagnosticOptions>{
   friend bool ParseDiagnosticArgs(DiagnosticOptions &, llvm::opt::ArgList &,
                                   clang::DiagnosticsEngine *, bool);
 
   friend class CompilerInvocation;
 
 public:
-  enum TextDiagnosticFormat { Clang, MSVC, Vi, SARIF };
+  enum TextDiagnosticFormat { Clang, MSVC, Vi, SARIFStderr, SARIFFile };
 
   // Default values.
   enum {
     DefaultTabStop = 8,
     MaxTabStop = 100,
     DefaultMacroBacktraceLimit = 6,
     DefaultTemplateBacktraceLimit = 10,
     DefaultConstexprBacktraceLimit = 10,

 
 public:
   /// The file to log diagnostic output to.
   std::string DiagnosticLogFile;
 
   /// The file to serialize diagnostics to (non-appending).
   std::string DiagnosticSerializationFile;
 
+  /// The file to serialise text diagnostics to (non-appending).
+  std::string FilePath;
+
   /// The list of -W... options used to alter the diagnostic mappings, with the
   /// prefixes removed.
   std::vector<std::string> Warnings;
 
   /// The list of prefixes from -Wundef-prefix=... used to generate warnings
   /// for undefined macros.
   std::vector<std::string> UndefPrefixes;
 

clang/include/clang/Basic/DiagnosticOptions.def

 DIAGOPT(ShowParseableFixits, 1, 0) /// Show machine parseable fix-its.
 DIAGOPT(ShowPresumedLoc, 1, 0)  /// Show presumed location for diagnostics.
 DIAGOPT(ShowOptionNames, 1, 0)  /// Show the option name for mappable
                                 /// diagnostics.
 DIAGOPT(ShowNoteIncludeStack, 1, 0) /// Show include stacks for notes.
 VALUE_DIAGOPT(ShowCategories, 2, 0) /// Show categories: 0 -> none, 1 -> Number,
                                     /// 2 -> Full Name.
 
-ENUM_DIAGOPT(Format, TextDiagnosticFormat, 2, Clang) /// Format for diagnostics:
+ENUM_DIAGOPT(Format, TextDiagnosticFormat, 3, Clang) /// Format for diagnostics:
 
 DIAGOPT(ShowColors, 1, 0)       /// Show diagnostics with ANSI color sequences.
 DIAGOPT(UseANSIEscapeCodes, 1, 0)
 ENUM_DIAGOPT(ShowOverloads, OverloadsShown, 1,
              Ovl_All)    /// Overload candidates to show.
 DIAGOPT(VerifyDiagnostics, 1, 0) /// Check that diagnostics match the expected
                                  /// diagnostics, indicated by markers in the
                                  /// input source file.

clang/include/clang/Driver/Options.td

 defm diagnostics_show_option : BoolFOption<"diagnostics-show-option",
     DiagnosticOpts<"ShowOptionNames">, DefaultTrue,
     NegFlag<SetFalse, [CC1Option]>, PosFlag<SetTrue, [], "Print option name with mappable diagnostics">>;
 defm diagnostics_show_note_include_stack : BoolFOption<"diagnostics-show-note-include-stack",
     DiagnosticOpts<"ShowNoteIncludeStack">, DefaultFalse,
     PosFlag<SetTrue, [], "Display include stacks for diagnostic notes">,
     NegFlag<SetFalse>, BothFlags<[CC1Option]>>;
 def fdiagnostics_format_EQ : Joined<["-"], "fdiagnostics-format=">, Group<f_clang_Group>;
+def fdiagnostics_file_path_EQ : Joined<["-"], "fdiagnostics-file-path=">, Group<f_clang_Group>;
 def fdiagnostics_show_category_EQ : Joined<["-"], "fdiagnostics-show-category=">, Group<f_clang_Group>;
 def fdiagnostics_show_template_tree : Flag<["-"], "fdiagnostics-show-template-tree">,
     Group<f_Group>, Flags<[CC1Option]>,
     HelpText<"Print a template comparison tree for differing templates">,
     MarshallingInfoFlag<DiagnosticOpts<"ShowTemplateTree">>;
 def fdiscard_value_names : Flag<["-"], "fdiscard-value-names">, Group<f_clang_Group>,
   HelpText<"Discard value names in LLVM IR">, Flags<[NoXarchOption]>;
 def fno_discard_value_names : Flag<["-"], "fno-discard-value-names">, Group<f_clang_Group>,
def diagnostic_log_file : Separate<["-"], "diagnostic-log-file">,
   HelpText<"Filename (or -) to log diagnostics to">,
   MarshallingInfoString<DiagnosticOpts<"DiagnosticLogFile">>;
 def diagnostic_serialized_file : Separate<["-"], "serialize-diagnostic-file">,
   MetaVarName<"<filename>">,
   HelpText<"File for serializing diagnostics in a binary format">;
 
 def fdiagnostics_format : Separate<["-"], "fdiagnostics-format">,
   HelpText<"Change diagnostic formatting to match IDE and command line tools">,
-  Values<"clang,msvc,vi,sarif,SARIF">,
-  NormalizedValuesScope<"DiagnosticOptions">, NormalizedValues<["Clang", "MSVC", "Vi", "SARIF", "SARIF"]>,
+  Values<"clang,msvc,vi,sarif-stderr,sarif-file">,
+  NormalizedValuesScope<"DiagnosticOptions">, NormalizedValues<["Clang", "MSVC", "Vi", "SARIFStderr", "SARIFFile"]>,
   MarshallingInfoEnum<DiagnosticOpts<"Format">, "Clang">;
+def fdiagnostics_file_path : Separate<["-"], "fdiagnostics-file-path">,
+  HelpText<"FIX BEFORE MERGING">,
+  MarshallingInfoString<DiagnosticOpts<"FilePath">>;
 def fdiagnostics_show_category : Separate<["-"], "fdiagnostics-show-category">,
   HelpText<"Print diagnostic category">,
   Values<"none,id,name">,
   NormalizedValues<["0", "1", "2"]>,
   MarshallingInfoEnum<DiagnosticOpts<"ShowCategories">, "0">;
 def fno_diagnostics_use_presumed_location : Flag<["-"], "fno-diagnostics-use-presumed-location">,
   HelpText<"Ignore #line directives when displaying diagnostic locations">,
   MarshallingInfoNegativeFlag<DiagnosticOpts<"ShowPresumedLoc">>;

clang/include/clang/Frontend/CompilerInstance.h

public:
   /// allocating one if one is not provided.
   ///
   /// \param Client If non-NULL, a diagnostic client that will be
   /// attached to (and, then, owned by) the DiagnosticsEngine inside this AST
   /// unit.
   ///
   /// \param ShouldOwnClient If Client is non-NULL, specifies whether
   /// the diagnostic object should take ownership of the client.
+  ///
+  /// \param ToFile Determines if Clang should write diagnostics to a file.
   void createDiagnostics(DiagnosticConsumer *Client = nullptr,
-                         bool ShouldOwnClient = true);
+                         bool ShouldOwnClient = true, StringRef Output = "");
 
   /// Create a DiagnosticsEngine object with a the TextDiagnosticPrinter.
   ///
   /// If no diagnostic client is provided, this creates a
   /// DiagnosticConsumer that is owned by the returned diagnostic
   /// object, if using directly the caller is responsible for
   /// releasing the returned DiagnosticsEngine's client eventually.
   ///
   /// \param Opts - The diagnostic options; note that the created text
   /// diagnostic object contains a reference to these options.
   ///
   /// \param Client If non-NULL, a diagnostic client that will be
   /// attached to (and, then, owned by) the returned DiagnosticsEngine
   /// object.
   ///
   /// \param CodeGenOpts If non-NULL, the code gen options in use, which may be
   /// used by some diagnostics printers (for logging purposes only).
   ///
+  /// \param TargetPath Path to the target that Clang is currently producing.
+  /// This will be used as the prefix of any file that Clang may write
+  /// diagnostics to (e.g. `-fdiagnostics-format=sarif-file -o /tmp/hello` would
+  /// lead to there being a file called `/tmp/hello.sarif`).
+  ///
   /// \return The new object on success, or null on failure.
-  static IntrusiveRefCntPtr<DiagnosticsEngine>
-  createDiagnostics(DiagnosticOptions *Opts,
-                    DiagnosticConsumer *Client = nullptr,
-                    bool ShouldOwnClient = true,
-                    const CodeGenOptions *CodeGenOpts = nullptr);
+  static IntrusiveRefCntPtr<DiagnosticsEngine> createDiagnostics(
+      DiagnosticOptions *Opts, DiagnosticConsumer *Client = nullptr,
+      bool ShouldOwnClient = true, const CodeGenOptions *CodeGenOpts = nullptr,
+      StringRef TargetPath = "");
 
   /// Create the file manager and replace any existing one with it.
   ///
   /// \return The new file manager on success, or null on failure.
   FileManager *
   createFileManager(IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS = nullptr);
 
   /// Create the source manager and replace any existing one with it.

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

 #define LLVM_CLANG_FRONTEND_SARIFDIAGNOSTICPRINTER_H
 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/Sarif.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/StringRef.h"
 #include <memory>
+#include <optional>
+#include <variant>
 
 namespace clang {
 class DiagnosticOptions;
 class LangOptions;
 class SARIFDiagnostic;
 class SarifDocumentWriter;
 
 class SARIFDiagnosticPrinter : public DiagnosticConsumer {
 public:
   SARIFDiagnosticPrinter(raw_ostream &OS, DiagnosticOptions *Diags);
+
+  /// Constructs a SARIFDiagnosticPrinter so that it writes to a file mimicing
+  /// Clang's current output target. The diagnostics file target has the same
+  /// name suffixed with `.sarif`.
+  SARIFDiagnosticPrinter(StringRef TargetPath, DiagnosticOptions *Diags);
+
   ~SARIFDiagnosticPrinter() = default;
 
   SARIFDiagnosticPrinter &operator=(const SARIFDiagnosticPrinter &&) = delete;
   SARIFDiagnosticPrinter(SARIFDiagnosticPrinter &&) = delete;
   SARIFDiagnosticPrinter &operator=(const SARIFDiagnosticPrinter &) = delete;
   SARIFDiagnosticPrinter(const SARIFDiagnosticPrinter &) = delete;
 
   /// setPrefix - Set the diagnostic printer prefix string, which will be
public:
   }
 
   void BeginSourceFile(const LangOptions &LO, const Preprocessor *PP) override;
   void EndSourceFile() override;
   void HandleDiagnostic(DiagnosticsEngine::Level Level,
                         const Diagnostic &Info) override;
 
 private:
-  raw_ostream &OS;
+  std::optional<std::error_code> EC;
+  std::variant<raw_ostream *, std::unique_ptr<raw_ostream>> OS;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
 
   /// Handle to the currently active SARIF diagnostic emitter.
   std::unique_ptr<SARIFDiagnostic> SARIFDiag;
 
   /// A string to prefix to error messages.
   std::string Prefix;
 
   std::unique_ptr<SarifDocumentWriter> Writer;
+
+  raw_ostream &getOS() {
+    // Deliberately not using std::visit due to there being exactly two known
+    // types.
+    if (std::holds_alternative<raw_ostream *>(OS)) {
+      return *std::get<raw_ostream *>(OS);
+    } else {
+      return *std::get<std::unique_ptr<raw_ostream>>(OS);
+    }
+  }
 };
 
 } // end namespace clang
 
 #endif

clang/lib/Driver/ToolChains/Clang.cpp

static void RenderDiagnosticsOptions(const Driver &D, const ArgList &Args,
 
   if (const Arg *A =
           Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
     std::string Opt =
         std::string("-fdiagnostics-hotness-threshold=") + A->getValue();
     CmdArgs.push_back(Args.MakeArgString(Opt));
   }
 
-  if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
+  if (const Arg *Format =
+          Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
     CmdArgs.push_back("-fdiagnostics-format");
-    CmdArgs.push_back(A->getValue());
-    if (StringRef(A->getValue()) == "sarif" ||
-        StringRef(A->getValue()) == "SARIF")
+    CmdArgs.push_back(Format->getValue());
+    if (StringRef(Format->getValue()).starts_with("sarif"))
       D.Diag(diag::warn_drv_sarif_format_unstable);
+
+    const Arg *Path = Args.getLastArg(options::OPT_fdiagnostics_file_path_EQ);
+    if (StringRef(Format->getValue()).ends_with("-file")) {
+      if (Path != nullptr) {
+        CmdArgs.push_back("-fdiagnostics-file-path");
+        CmdArgs.push_back(Path->getValue());
+      } else if (const Arg *SyntaxOnly =
+                     Args.getLastArg(options::OPT_fsyntax_only))
+        D.Diag(diag::err_drv_diagnostics_format_file_fsyntax_only)
+            << Format->getValue();
+      else
+        D.Diag(diag::warn_drv_implicit_diagnostics_format_file)
+            << Format->getValue();
+    }
   }
 
   if (const Arg *A = Args.getLastArg(
           options::OPT_fdiagnostics_show_note_include_stack,
           options::OPT_fno_diagnostics_show_note_include_stack)) {
     const Option &O = A->getOption();
     if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
       CmdArgs.push_back("-fdiagnostics-show-note-include-stack");

clang/lib/Frontend/CompilerInstance.cpp

Diags.setClient(new ChainedDiagnosticConsumer(
         Diags.takeClient(), std::move(SerializedConsumer)));
   } else {
     Diags.setClient(new ChainedDiagnosticConsumer(
         Diags.getClient(), std::move(SerializedConsumer)));
   }
 }
 
 void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
-                                         bool ShouldOwnClient) {
-  Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
-                                  ShouldOwnClient, &getCodeGenOpts());
+                                         bool ShouldOwnClient,
+                                         StringRef Output) {
+  Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client, ShouldOwnClient,
+                                  &getCodeGenOpts(), Output);
 }
 
-IntrusiveRefCntPtr<DiagnosticsEngine>
-CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
-                                    DiagnosticConsumer *Client,
-                                    bool ShouldOwnClient,
-                                    const CodeGenOptions *CodeGenOpts) {
+IntrusiveRefCntPtr<DiagnosticsEngine> CompilerInstance::createDiagnostics(
+    DiagnosticOptions *Opts, DiagnosticConsumer *Client, bool ShouldOwnClient,
+    const CodeGenOptions *CodeGenOpts, StringRef OutputPath) {
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   IntrusiveRefCntPtr<DiagnosticsEngine>
       Diags(new DiagnosticsEngine(DiagID, Opts));
 
   // Create the diagnostic client for reporting errors or for
   // implementing -verify.
   if (Client) {
     Diags->setClient(Client, ShouldOwnClient);
-  } else if (Opts->getFormat() == DiagnosticOptions::SARIF) {
+  } else if (Opts->getFormat() == DiagnosticOptions::SARIFStderr) {
     Diags->setClient(new SARIFDiagnosticPrinter(llvm::errs(), Opts));
-  } else
+  } else if (Opts->getFormat() == DiagnosticOptions::SARIFFile) {
+    if (OutputPath.empty())
+      goto Default;
+    Diags->setClient(new SARIFDiagnosticPrinter(OutputPath, Opts));
+  } else {
+  Default:
     Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
+  }
 
   // Chain in -verify checker, if requested.
   if (Opts->VerifyDiagnostics)
     Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
 
   // Chain in -diagnostic-log-file dumper, if requested.
   if (!Opts->DiagnosticLogFile.empty())
     SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);

clang/lib/Frontend/FrontendAction.cpp

bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
   // Set up the file and source managers, if needed.
   if (!CI.hasFileManager()) {
     if (!CI.createFileManager()) {
       return false;
     }
   }
   if (!CI.hasSourceManager()) {
     CI.createSourceManager(CI.getFileManager());
-    if (CI.getDiagnosticOpts().getFormat() == DiagnosticOptions::SARIF) {
+    if (TextDiagnosticFormat Format = CI.getDiagnosticOpts().getFormat();
+        Format == DiagnosticOptions::SARIFStderr ||
+        Format == DiagnosticOptions::SARIFFile) {
       static_cast<SARIFDiagnosticPrinter *>(&CI.getDiagnosticClient())
           ->setSarifWriter(
               std::make_unique<SarifDocumentWriter>(CI.getSourceManager()));
     }
   }
 
   // Set up embedding for any specified files. Do this before we load any
   // source files, including the primary module map for the compilation.

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

 #include "clang/Frontend/DiagnosticRenderer.h"
 #include "clang/Frontend/SARIFDiagnostic.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+#include <memory>
 
 namespace clang {
 
 SARIFDiagnosticPrinter::SARIFDiagnosticPrinter(raw_ostream &OS,
                                                DiagnosticOptions *Diags)
-    : OS(OS), DiagOpts(Diags) {}
+    : OS(&OS), DiagOpts(Diags) {}
+
+static std::unique_ptr<llvm::raw_ostream>
+OpenDiagnosticFile(StringRef TargetPath, std::error_code &EC) {
+  assert(!TargetPath.empty());
+  return std::make_unique<llvm::raw_fd_ostream>(
+      std::string(TargetPath) + ".sarif", EC);
+}
+
+SARIFDiagnosticPrinter::SARIFDiagnosticPrinter(StringRef TargetPath,
+                                               DiagnosticOptions *Diags)
+    : EC(std::error_code()), OS(OpenDiagnosticFile(TargetPath, *EC)),
+      DiagOpts(Diags) {
+  if (*EC) {
+    assert(false and "not implemented yet: not even sure what to do");
+  }
+}
 
 void SARIFDiagnosticPrinter::BeginSourceFile(const LangOptions &LO,
                                              const Preprocessor *PP) {
   // Build the SARIFDiagnostic utility.
   assert(hasSarifWriter() && "Writer not set!");
   assert(!SARIFDiag && "SARIFDiagnostic already set.");
-  SARIFDiag = std::make_unique<SARIFDiagnostic>(OS, LO, &*DiagOpts, &*Writer);
+  SARIFDiag =
+      std::make_unique<SARIFDiagnostic>(getOS(), LO, &*DiagOpts, &*Writer);
   // Initialize the SARIF object.
   Writer->createRun("clang", Prefix);
 }
 
 void SARIFDiagnosticPrinter::EndSourceFile() {
   assert(SARIFDiag && "SARIFDiagnostic has not been set.");
   Writer->endRun();
   llvm::json::Value Value(Writer->createDocument());
-  OS << "\n" << Value << "\n\n";
-  OS.flush();
+  getOS() << '\n' << Value << '\n';
+  getOS().flush();
+  if (EC and *EC) {
+    llvm::errs() << "error: " << EC->message() << '\n';
+    llvm::errs() << "outputting to stderr as a backup\n";
+    llvm::errs() << Value << '\n';
+  }
   SARIFDiag.reset();
 }
 
 void SARIFDiagnosticPrinter::HandleDiagnostic(DiagnosticsEngine::Level Level,
                                               const Diagnostic &Info) {
   assert(SARIFDiag && "SARIFDiagnostic has not been set.");
   // Default implementation (Warnings/errors count). Keeps track of the
   // number of errors.

clang/lib/Frontend/TextDiagnostic.cpp

void TextDiagnostic::emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
   if (!DiagOpts->ShowLocation)
     return;
 
   if (DiagOpts->ShowColors)
     OS.changeColor(savedColor, true);
 
   emitFilename(PLoc.getFilename(), Loc.getManager());
   switch (DiagOpts->getFormat()) {
-  case DiagnosticOptions::SARIF:
+  case DiagnosticOptions::SARIFStderr:
+  case DiagnosticOptions::SARIFFile:
   case DiagnosticOptions::Clang:
     if (DiagOpts->ShowLine)
       OS << ':' << LineNo;
     break;
   case DiagnosticOptions::MSVC:  OS << '('  << LineNo; break;
   case DiagnosticOptions::Vi:    OS << " +" << LineNo; break;
   }
 
   if (DiagOpts->ShowColumn)
     // Compute the column number.
     if (unsigned ColNo = PLoc.getColumn()) {
       if (DiagOpts->getFormat() == DiagnosticOptions::MSVC) {
         OS << ',';
         // Visual Studio 2010 or earlier expects column number to be off by one
         if (LangOpts.MSCompatibilityVersion &&
             !LangOpts.isCompatibleWithMSVC(LangOptions::MSVC2012))
           ColNo--;
       } else
         OS << ':';
       OS << ColNo;
     }
   switch (DiagOpts->getFormat()) {
-  case DiagnosticOptions::SARIF:
+  case DiagnosticOptions::SARIFStderr:
+  case DiagnosticOptions::SARIFFile:
   case DiagnosticOptions::Clang:
   case DiagnosticOptions::Vi:    OS << ':';    break;
   case DiagnosticOptions::MSVC:
     // MSVC2013 and before print 'file(4) : error'. MSVC2015 gets rid of the
     // space and prints 'file(4): error'.
     OS << ')';
     if (LangOpts.MSCompatibilityVersion &&
         !LangOpts.isCompatibleWithMSVC(LangOptions::MSVC2015))

clang/lib/Tooling/CMakeLists.txt

add_clang_library(clangTooling
   ExpandResponseFilesCompilationDatabase.cpp
   FileMatchTrie.cpp
   FixIt.cpp
   GuessTargetAndModeCompilationDatabase.cpp
   InterpolatingCompilationDatabase.cpp
   JSONCompilationDatabase.cpp
   Refactoring.cpp
   RefactoringCallbacks.cpp
+  SarifLinker.cpp
   StandaloneExecution.cpp
   NodeIntrospection.cpp
   ${BINARY_INCLUDE_DIR}/NodeIntrospection.inc
   Tooling.cpp
 
   DEPENDS
   ClangDriverOptions
   omp_gen

clang/lib/Tooling/SarifLinker.cpp

+#include "clang/Basic/Sarif.h"
+#include "clang/Config/config.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Option/Option.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/Process.h"
+#include <cassert>
+#include <cstdlib>
+#include <fstream>
+#include <iterator>
+#include <string>
+#include <string_view>
+#include <system_error>
+
+namespace llvm::sarif_linker {
+[[noreturn]] void ReportErrorAndExit(llvm::errc error_code, StringRef Message) {
+  llvm::errs() << "sarif-ld: error: " << Message << '\n';
+  std::exit(static_cast<int>(error_code));
+}
+
+static json::Value ReadSarifDiagnostics(StringRef Path) {
+  std::ifstream in(Path.data());
+  if (!in) {
+    ReportErrorAndExit(llvm::errc::io_error, (Path + " not found").str());
+  }
+
+  in >> std::noskipws;
+  std::string data(std::istream_iterator<char>(in), {});
+  assert(!in);
+  if (!in.eof()) {
+    ReportErrorAndExit(llvm::errc::io_error, "Unable to read " + Path.str());
+  }
+
+  llvm::Expected<json::Value> value = json::parse(data);
+  if (!value) {
+    ReportErrorAndExit(llvm::errc::invalid_argument,
+                       "SARIF requires a valid JSON format");
+  }
+
+  // FIXME: we should eventually replace this with a proper SARIF validation
+  // algorithm. For now, we're just checking that a few fields are present
+  // (namely to ensure it "looks" like a SARIF file, and to check the fields
+  // we need are around).
+  json::Object *object = value->getAsObject();
+  if (object == nullptr) {
+    ReportErrorAndExit(llvm::errc::invalid_argument,
+                       "SARIF requires the top-level value to be an object");
+  }
+
+  if (object->getString("$schema") == std::nullopt) {
+    ReportErrorAndExit(llvm::errc::invalid_argument,
+                       "SARIF requires there to be a `$schema` string field");
+  }
+
+  if (object->getString("version") == std::nullopt) {
+    ReportErrorAndExit(llvm::errc::invalid_argument,
+                       "SARIF requires there to be a `version` string field");
+  }
+
+  if (object->getArray("runs") == nullptr) {
+    ReportErrorAndExit(llvm::errc::invalid_argument,
+                       "SARIF requires there to be a `runs` array field");
+  }
+
+  return *value;
+}
+
+template <class JsonValue> static auto &getRuns(JsonValue &value) {
+  return *value.getAsObject()->getArray("runs")->front().getAsObject();
+}
+
+static json::Value ReduceSarif(json::Value Init,
+                               ArrayRef<json::Value> SarifObjects) {
+  json::Object &FirstRuns = getRuns(Init);
+  json::Array &FirstArtifacts = *FirstRuns.getArray("artifacts");
+  json::Array &FirstResults = *FirstRuns.getArray("results");
+
+  for (const json::Value &Other : SarifObjects) {
+    const json::Object &OtherRuns = getRuns(Other);
+    const json::Array &Artifacts = *OtherRuns.getArray("artifacts");
+    FirstArtifacts.insert(FirstArtifacts.end(), Artifacts.begin(),
+                          Artifacts.end());
+
+    const json::Array &Results = *OtherRuns.getArray("results");
+    FirstResults.insert(FirstResults.end(), Results.begin(), Results.end());
+  }
+
+  return Init;
+}
+
+std::error_code LinkSarifDiagnostics(const opt::ArgStringList &InputPaths,
+                                     StringRef OutputPath) {
+  assert(InputPaths.size() > 0 && "There needs to be at least one Input path.");
+  std::vector<std::string> SarifDiagnosticPaths;
+  llvm::copy_if(InputPaths, std::back_inserter(SarifDiagnosticPaths),
+                [](StringRef File) { return File.ends_with(".o"); });
+  llvm::transform(SarifDiagnosticPaths, SarifDiagnosticPaths.begin(),
+                  [](const std::string &Temp) { return Temp + ".sarif"; });
+
+  std::vector<json::Value> JSONData;
+  llvm::transform(SarifDiagnosticPaths, std::back_inserter(JSONData),
+                  [](StringRef Path) {
+                    json::Value SarifDiagnostics = ReadSarifDiagnostics(Path);
+                    return SarifDiagnostics;
+                  });
+
+  json::Value Output = ReduceSarif(
+      std::move(JSONData[0]), ArrayRef<json::Value>(JSONData).drop_front());
+
+  std::error_code EC;
+  llvm::raw_fd_ostream Out(OutputPath.str() + ".sarif", EC);
+  if (EC) {
+    return EC;
+  }
+
+  Out << Output;
+  return EC;
+}
+} // namespace llvm::sarif_linker

clang/lib/Tooling/Tooling.cpp

std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs(
   for (auto &FilenameWithContent : VirtualMappedFiles) {
     InMemoryFileSystem->addFile(
         FilenameWithContent.first, 0,
         llvm::MemoryBuffer::getMemBuffer(FilenameWithContent.second));
   }
 
   if (!Invocation.run())
     return nullptr;
- 
   assert(ASTs.size() == 1);
   return std::move(ASTs[0]);
 }
 
 } // namespace tooling
 } // namespace clang

clang/test/Driver/fdiagnostics-format-sarif.cpp

-// RUN: %clang -fsyntax-only -fdiagnostics-format=sarif %s -### 2>&1 | FileCheck %s --check-prefix=WARN
+// RUN: %clang -fsyntax-only -fdiagnostics-format=sarif-stderr %s -### 2>&1 | FileCheck %s --check-prefix=WARN
+// RUN: %clang -fsyntax-only -fdiagnostics-format=sarif-file   %s -### 2>&1 | FileCheck %s --check-prefixes=WARN,ERROR
+// RUN: %clang -fsyntax-only -fdiagnostics-file-path=test      %s -### 2>&1 | FileCheck %s --check-prefixes=WARN2
 // WARN: warning: diagnostic formatting in SARIF mode is currently unstable [-Wsarif-format-unstable]
-
-// RUN: %clang -fsyntax-only -fdiagnostics-format=SARIF %s -### 2>&1 | FileCheck %s --check-prefix=WARN2
-// WARN2: warning: diagnostic formatting in SARIF mode is currently unstable [-Wsarif-format-unstable]
+// ERROR: error: '-fdiagnostics-file-path' must be set when combining '-fsyntax-only' with '-fdiagnostics-format=sarif-file'
+// WARN2: warning: argument unused during compilation: '-fdiagnostics-file-path=test' [-Wunused-command-line-argument]

clang/test/Frontend/sarif-diagnostics.cpp

 
 struct t1 { };
 void f1(t1 x, t1 y) {
     x + y;
 }
 
 #include "sarif-diagnostics.hpp"
 
-// RUN: %clang -fsyntax-only -Wall -Wextra -fdiagnostics-format=sarif %s > %t.txt 2>&1 || true
+// RUN: %clang -fsyntax-only -Wall -Wextra -fdiagnostics-format=sarif-stderr %s > %t.txt 2>&1 || true
 // RUN: FileCheck -dump-input=always %s --input-file=%t.txt --check-prefixes=STDERR,SARIF
 
+// RUN: %clang -fsyntax-only -Wall -Wextra -fdiagnostics-format=sarif-file -fdiagnostics-file-path=%t %s > %t.txt 2>&1 || true
+// RUN: FileCheck -dump-input=always --check-prefix=STDERR %s --input-file=%t.txt
+// RUN: FileCheck -dump-input=always --check-prefix=SARIF  %s --input-file=%t.sarif
+
+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: %clang -Wall -Wextra -fdiagnostics-format=sarif-file %s -o %t/sarif-output > %t.txt 2>&1 || true
+// RUN: FileCheck -dump-input=always --check-prefixes=STDERR,NOFILE %s --input-file=%t.txt
+// RUN: FileCheck -dump-input=always --check-prefix=SARIF           %s --input-file=%t/sarif-output.sarif
+
+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: %clang -Wall -Wextra -fdiagnostics-format=sarif-file %s %s -o %t/sarif-output > %t.txt 2>&1 || true
+// RUN: FileCheck -dump-input=always --check-prefixes=STDERR,NOFILE %s --input-file=%t.txt
+// RUN: FileCheck -dump-input=always --check-prefix=SARIF           %s --input-file=%t/sarif-output.sarif
+// RUN: FileCheck -dump-input=always --check-prefix=SARIF2          %s --input-file=%t/sarif-output.sarif
+
+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: %clang -Wall -Wextra -fdiagnostics-format=sarif-file -fdiagnostics-file-path=%t/diags %s -o %t/sarif-output > %t.txt 2>&1 || true
+// RUN: FileCheck -dump-input=always --check-prefix=STDERR %s --input-file=%t.txt
+// RUN: FileCheck -dump-input=always --check-prefix=SARIF  %s --input-file=%t/diags.sarif
+// RUN: grep -v "warning: '-fdiagnostics-file-path' should be set when using '-fdiagnostics-format=sarif-file'" %t.txt
+
 // STDERR: warning: diagnostic formatting in SARIF mode is currently unstable [-Wsarif-format-unstable]
+// NOFILE: warning: '-fdiagnostics-file-path' should be set when using '-fdiagnostics-format=sarif-file'
 // SARIF: {
 // SARIF:   "$schema":"https://docs.oasis-open.org/sarif/sarif/v2.1.0/cos02/schemas/sarif-schema-2.1.0.json",
 // SARIF:   "runs":[
 // SARIF:     {
 // SARIF:       "artifacts":[
 // SARIF:         {
 // SARIF:           "length":{{[0-9]+}},
 // SARIF:           "location":{

 // SARIF:               "id":"4657",
 // SARIF:               "name":""
 // SARIF:             }
 // SARIF:           ],
 // SARIF:           "version":"17.0.0"
 // SARIF:         }
 // SARIF:       }
 // SARIF:     }
+// SARIF2:    ,
+// SARIF2:    {
+// SARIF2:      "artifacts":[
+// SARIF2:        {
+// SARIF2:          "length":{{[0-9]+}},
+// SARIF2:          "location":{
+// SARIF2:            "index":0,
+// SARIF2:            "uri":{{"file://[^"]+/clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:          },
+// SARIF2:          "mimeType":"text/plain",
+// SARIF2:          "roles":[
+// SARIF2:            "resultFile"
+// SARIF2:          ]
+// SARIF2:        },
+// SARIF2:        {
+// SARIF2:          "length":{{[0-9]+}},
+// SARIF2:          "location":{
+// SARIF2:            "index":1,
+// SARIF2:            "uri":"file://{{[^"]+test/Frontend/sarif-diagnostics.hpp}}"
+// SARIF2:          },
+// SARIF2:          "mimeType":"text/plain",
+// SARIF2:          "roles":[
+// SARIF2:            "resultFile"
+// SARIF2:          ]
+// SARIF2:        }
+// SARIF2:      ],
+// SARIF2:      "columnKind":"unicodeCodePoints",
+// SARIF2:      "results":[
+// SARIF2:        {
+// SARIF2:          "level":"error",
+// SARIF2:          "locations":[
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":0,
+// SARIF2:                  "uri":{{"file://[^"]+/clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":1,
+// SARIF2:                  "startColumn":1,
+// SARIF2:                  "startLine":12
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            }
+// SARIF2:          ],
+// SARIF2:          "message":{
+// SARIF2:            "text":"'main' must return 'int'"
+// SARIF2:          },
+// SARIF2:          "ruleId":"3485",
+// SARIF2:          "ruleIndex":0
+// SARIF2:        },
+// SARIF2:        {
+// SARIF2:          "level":"error",
+// SARIF2:          "locations":[
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":0,
+// SARIF2:                  "uri":{{"file://[^"]+/clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":11,
+// SARIF2:                  "startColumn":11,
+// SARIF2:                  "startLine":13
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            }
+// SARIF2:          ],
+// SARIF2:          "message":{
+// SARIF2:            "text":"use of undeclared identifier 'hello'"
+// SARIF2:          },
+// SARIF2:          "ruleId":"4632",
+// SARIF2:          "ruleIndex":1
+// SARIF2:        },
+// SARIF2:        {
+// SARIF2:          "level":"error",
+// SARIF2:          "locations":[
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":0,
+// SARIF2:                  "uri":{{"file://[^"]+/clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":17,
+// SARIF2:                  "startColumn":17,
+// SARIF2:                  "startLine":15
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            }
+// SARIF2:          ],
+// SARIF2:          "message":{
+// SARIF2:            "text":"invalid digit 'a' in decimal constant"
+// SARIF2:          },
+// SARIF2:          "ruleId":"898",
+// SARIF2:          "ruleIndex":2
+// SARIF2:        },
+// SARIF2:        {
+// SARIF2:          "level":"warning",
+// SARIF2:          "locations":[
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":0,
+// SARIF2:                  "uri":{{"file://[^"]+clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":5,
+// SARIF2:                  "startColumn":5,
+// SARIF2:                  "startLine":19
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            }
+// SARIF2:          ],
+// SARIF2:          "message":{
+// SARIF2:            "text":"misleading indentation; statement is not part of the previous 'if'"
+// SARIF2:          },
+// SARIF2:          "ruleId":"1826",
+// SARIF2:          "ruleIndex":3
+// SARIF2:        },
+// SARIF2:        {
+// SARIF2:          "level":"note",
+// SARIF2:          "locations":[
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":0,
+// SARIF2:                  "uri":{{"file://[^"]+/clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":3,
+// SARIF2:                  "startColumn":3,
+// SARIF2:                  "startLine":17
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            }
+// SARIF2:          ],
+// SARIF2:          "message":{
+// SARIF2:            "text":"previous statement is here"
+// SARIF2:          },
+// SARIF2:          "ruleId":"1746",
+// SARIF2:          "ruleIndex":4
+// SARIF2:        },
+// SARIF2:        {
+// SARIF2:          "level":"warning",
+// SARIF2:          "locations":[
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":0,
+// SARIF2:                  "uri":{{"file://[^"]+clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":10,
+// SARIF2:                  "startColumn":10,
+// SARIF2:                  "startLine":18
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            }
+// SARIF2:          ],
+// SARIF2:          "message":{
+// SARIF2:            "text":"unused variable 'Yes'"
+// SARIF2:          },
+// SARIF2:          "ruleId":"6593",
+// SARIF2:          "ruleIndex":5
+// SARIF2:        },
+// SARIF2:        {
+// SARIF2:          "level":"error",
+// SARIF2:          "locations":[
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":0,
+// SARIF2:                  "uri":{{"file://[^"]+clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":12,
+// SARIF2:                  "startColumn":12,
+// SARIF2:                  "startLine":21
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            }
+// SARIF2:          ],
+// SARIF2:          "message":{
+// SARIF2:            "text":"use of undeclared identifier 'hi'"
+// SARIF2:          },
+// SARIF2:          "ruleId":"4632",
+// SARIF2:          "ruleIndex":6
+// SARIF2:        },
+// SARIF2:        {
+// SARIF2:          "level":"error",
+// SARIF2:          "locations":[
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":0,
+// SARIF2:                  "uri":{{"file://[^"]+/clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":1,
+// SARIF2:                  "startColumn":1,
+// SARIF2:                  "startLine":23
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            }
+// SARIF2:          ],
+// SARIF2:          "message":{
+// SARIF2:            "text":"extraneous closing brace ('}')"
+// SARIF2:          },
+// SARIF2:          "ruleId":"1400",
+// SARIF2:          "ruleIndex":7
+// SARIF2:        },
+// SARIF2:        {
+// SARIF2:          "level":"error",
+// SARIF2:          "locations":[
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":0,
+// SARIF2:                  "uri":{{"file://[^"]+/clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":6,
+// SARIF2:                  "endLine":27,
+// SARIF2:                  "startColumn":5,
+// SARIF2:                  "startLine":27
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            },
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":0,
+// SARIF2:                  "uri":{{"file://[^"]+/clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":10,
+// SARIF2:                  "endLine":27,
+// SARIF2:                  "startColumn":9,
+// SARIF2:                  "startLine":27
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            },
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":0,
+// SARIF2:                  "uri":{{"file://[^"]+/clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":7,
+// SARIF2:                  "startColumn":7,
+// SARIF2:                  "startLine":27
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            }
+// SARIF2:          ],
+// SARIF2:          "message":{
+// SARIF2:            "text":"invalid operands to binary expression ('t1' and 't1')"
+// SARIF2:          },
+// SARIF2:          "ruleId":"4567",
+// SARIF2:          "ruleIndex":8
+// SARIF2:        },
+// SARIF2:        {
+// SARIF2:          "level":"note",
+// SARIF2:          "locations":[
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":0,
+// SARIF2:                  "uri":{{"file://[^"]+/clang/test/Frontend/sarif-diagnostics.cpp"}}
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":10,
+// SARIF2:                  "startColumn":10,
+// SARIF2:                  "startLine":30
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            }
+// SARIF2:          ],
+// SARIF2:          "message":{
+// SARIF2:            "text":"in file included from {{[^"]+test/Frontend/sarif-diagnostics.cpp:30:}}\n"
+// SARIF2:          },
+// SARIF2:          "ruleId":"-1",
+// SARIF2:          "ruleIndex":9
+// SARIF2:        },
+// SARIF2:        {
+// SARIF2:          "level":"error",
+// SARIF2:          "locations":[
+// SARIF2:            {
+// SARIF2:              "physicalLocation":{
+// SARIF2:                "artifactLocation":{
+// SARIF2:                  "index":1,
+// SARIF2:                  "uri":"file:///{{[^"]+/test/Frontend/sarif-diagnostics.hpp}}"
+// SARIF2:                },
+// SARIF2:                "region":{
+// SARIF2:                  "endColumn":1,
+// SARIF2:                  "startColumn":1,
+// SARIF2:                  "startLine":1
+// SARIF2:                }
+// SARIF2:              }
+// SARIF2:            }
+// SARIF2:          ],
+// SARIF2:          "message":{
+// SARIF2:            "text":"unknown type name 'Test'"
+// SARIF2:          },
+// SARIF2:          "ruleId":"4657",
+// SARIF2:          "ruleIndex":10
+// SARIF2:        }
+// SARIF2:      ],
+// SARIF2:      "tool":{
+// SARIF2:        "driver":{
+// SARIF2:          "fullName":"",
+// SARIF2:          "informationUri":"https://clang.llvm.org/docs/UsersManual.html",
+// SARIF2:          "language":"en-US",
+// SARIF2:          "name":"clang",
+// SARIF2:          "rules":[
+// SARIF2:            {
+// SARIF2:              "defaultConfiguration":{
+// SARIF2:                "enabled":true,
+// SARIF2:                "level":"error",
+// SARIF2:                "rank":50
+// SARIF2:              },
+// SARIF2:              "fullDescription":{
+// SARIF2:                "text":""
+// SARIF2:              },
+// SARIF2:              "id":"3485",
+// SARIF2:              "name":""
+// SARIF2:            },
+// SARIF2:            {
+// SARIF2:              "defaultConfiguration":{
+// SARIF2:                "enabled":true,
+// SARIF2:                "level":"error",
+// SARIF2:                "rank":50
+// SARIF2:              },
+// SARIF2:              "fullDescription":{
+// SARIF2:                "text":""
+// SARIF2:              },
+// SARIF2:              "id":"4632",
+// SARIF2:              "name":""
+// SARIF2:            },
+// SARIF2:            {
+// SARIF2:              "defaultConfiguration":{
+// SARIF2:                "enabled":true,
+// SARIF2:                "level":"error",
+// SARIF2:                "rank":50
+// SARIF2:              },
+// SARIF2:              "fullDescription":{
+// SARIF2:                "text":""
+// SARIF2:              },
+// SARIF2:              "id":"898",
+// SARIF2:              "name":""
+// SARIF2:            },
+// SARIF2:            {
+// SARIF2:              "defaultConfiguration":{
+// SARIF2:                "enabled":true,
+// SARIF2:                "level":"warning",
+// SARIF2:                "rank":-1
+// SARIF2:              },
+// SARIF2:              "fullDescription":{
+// SARIF2:                "text":""
+// SARIF2:              },
+// SARIF2:              "id":"1826",
+// SARIF2:              "name":""
+// SARIF2:            },
+// SARIF2:            {
+// SARIF2:              "defaultConfiguration":{
+// SARIF2:                "enabled":true,
+// SARIF2:                "level":"note",
+// SARIF2:                "rank":-1
+// SARIF2:              },
+// SARIF2:              "fullDescription":{
+// SARIF2:                "text":""
+// SARIF2:              },
+// SARIF2:              "id":"1746",
+// SARIF2:              "name":""
+// SARIF2:            },
+// SARIF2:            {
+// SARIF2:              "defaultConfiguration":{
+// SARIF2:                "enabled":true,
+// SARIF2:                "level":"warning",
+// SARIF2:                "rank":-1
+// SARIF2:              },
+// SARIF2:              "fullDescription":{
+// SARIF2:                "text":""
+// SARIF2:              },
+// SARIF2:              "id":"6593",
+// SARIF2:              "name":""
+// SARIF2:            },
+// SARIF2:            {
+// SARIF2:              "defaultConfiguration":{
+// SARIF2:                "enabled":true,
+// SARIF2:                "level":"error",
+// SARIF2:                "rank":50
+// SARIF2:              },
+// SARIF2:              "fullDescription":{
+// SARIF2:                "text":""
+// SARIF2:              },
+// SARIF2:              "id":"4632",
+// SARIF2:              "name":""
+// SARIF2:            },
+// SARIF2:            {
+// SARIF2:              "defaultConfiguration":{
+// SARIF2:                "enabled":true,
+// SARIF2:                "level":"error",
+// SARIF2:                "rank":50
+// SARIF2:              },
+// SARIF2:              "fullDescription":{
+// SARIF2:                "text":""
+// SARIF2:              },
+// SARIF2:              "id":"1400",
+// SARIF2:              "name":""
+// SARIF2:            },
+// SARIF2:            {
+// SARIF2:              "defaultConfiguration":{
+// SARIF2:                "enabled":true,
+// SARIF2:                "level":"error",
+// SARIF2:                "rank":50
+// SARIF2:              },
+// SARIF2:              "fullDescription":{
+// SARIF2:                "text":""
+// SARIF2:              },
+// SARIF2:              "id":"4567",
+// SARIF2:              "name":""
+// SARIF2:            },
+// SARIF2:            {
+// SARIF2:              "defaultConfiguration":{
+// SARIF2:                "enabled":true,
+// SARIF2:                "level":"note",
+// SARIF2:                "rank":-1
+// SARIF2:              },
+// SARIF2:              "fullDescription":{
+// SARIF2:                "text":""
+// SARIF2:              },
+// SARIF2:              "id":"-1",
+// SARIF2:              "name":""
+// SARIF2:            },
+// SARIF2:            {
+// SARIF2:              "defaultConfiguration":{
+// SARIF2:                "enabled":true,
+// SARIF2:                "level":"error",
+// SARIF2:                "rank":50
+// SARIF2:              },
+// SARIF2:              "fullDescription":{
+// SARIF2:                "text":""
+// SARIF2:              },
+// SARIF2:              "id":"4657",
+// SARIF2:              "name":""
+// SARIF2:            }
+// SARIF2:          ],
+// SARIF2:          "version":"17.0.0"
+// SARIF2:        }
+// SARIF2:      }
+// SARIF2:    }
 // SARIF:   ],
 // SARIF:   "version":"2.1.0"
 // SARIF: }
 // STDERR: 2 warnings and 7 errors generated.

clang/tools/CMakeLists.txt

 # It also may be included by LLVM_EXTERNAL_CLANG_TOOLS_EXTRA_SOURCE_DIR.
 add_llvm_external_project(clang-tools-extra extra)
 
 # libclang may require clang-tidy in clang-tools-extra.
 add_clang_subdirectory(libclang)
 
 add_clang_subdirectory(amdgpu-arch)
 add_clang_subdirectory(nvptx-arch)
+add_clang_subdirectory(sarif-ld)

clang/tools/driver/CMakeLists.txt

 clang_target_link_libraries(clang
   PRIVATE
   clangBasic
   clangCodeGen
   clangDriver
   clangFrontend
   clangFrontendTool
   clangSerialization
+  clangTooling
   )
 
 if(WIN32 AND NOT CYGWIN)
   # Prevent versioning if the buildhost is targeting for Win32.
 else()
   set_target_properties(clang PROPERTIES VERSION ${CLANG_EXECUTABLE_VERSION})
 endif()
 

clang/tools/driver/cc1_main.cpp

int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
 
   // Infer the builtin include path if unspecified.
   if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
       Clang->getHeaderSearchOpts().ResourceDir.empty())
     Clang->getHeaderSearchOpts().ResourceDir =
       CompilerInvocation::GetResourcesPath(Argv0, MainAddr);
 
   // Create the actual diagnostics engine.
-  Clang->createDiagnostics();
+  auto DiagnosticsFilePathOption =
+      llvm::find_last(Argv, StringRef("-fdiagnostics-file-path"));
+  std::string DiagnosticsFilePath =
+      std::distance(DiagnosticsFilePathOption, Argv.end()) > 1
+          ? *std::next(DiagnosticsFilePathOption)
+          : Clang->getFrontendOpts().OutputFile;
+  Clang->createDiagnostics(nullptr, true, DiagnosticsFilePath);
   if (!Clang->hasDiagnostics())
     return 1;
 
   // Set an error handler, so that any LLVM backend diagnostics go through our
   // error handler.
   llvm::install_fatal_error_handler(LLVMErrorHandler,
                                   static_cast<void*>(&Clang->getDiagnostics()));
 

clang/tools/driver/driver.cpp

if (Tool == "-cc1gen-reproducer")
     return cc1gen_reproducer_main(ArrayRef(ArgV).slice(2), ArgV[0],
                                   GetExecutablePathVP, ToolContext);
   // Reject unknown tools.
   llvm::errs() << "error: unknown integrated tool '" << Tool << "'. "
                << "Valid tools include '-cc1' and '-cc1as'.\n";
   return 1;
 }
 
+namespace llvm::sarif_linker {
+[[noreturn]] void ReportErrorAndExit(llvm::errc error_code, StringRef Message);
+std::error_code LinkSarifDiagnostics(const opt::ArgStringList &InputPaths,
+                                     StringRef OutputPath);
+} // namespace llvm::sarif_linker
+
 int clang_main(int Argc, char **Argv, const llvm::ToolContext &ToolContext) {
   noteBottomOfStack();
   llvm::InitLLVM X(Argc, Argv);
   llvm::setBugReportMsg("PLEASE submit a bug report to " BUG_REPORT_URL
                         " and include the crash backtrace, preprocessed "
                         "source, and associated run script.\n");
   SmallVector<const char *, 256> Args(Argv, Argv + Argc);
 

 #ifdef _WIN32
   // Exit status should not be negative on Win32, unless abnormal termination.
   // Once abnormal termination was caught, negative status should not be
   // propagated.
   if (Res < 0)
     Res = 1;
 #endif
 
+  // Finally, we need to move any SARIF diagnostics into the build directory.
+  const DerivedArgList &ArgList = C->getArgs();
+  if (Arg *DF = ArgList.getLastArg(options::OPT_fdiagnostics_format_EQ);
+      DF && DF->containsValue("sarif-file") && !C->getTempFiles().empty()) {
+    Arg *o = ArgList.getLastArg(options::OPT_o);
+    const char *Out = o ? o->getValue(0) : TheDriver.getDefaultImageName();
+    if (auto EC =
+            llvm::sarif_linker::LinkSarifDiagnostics(C->getTempFiles(), Out)) {
+    }
+  }
+
   // If we have multiple failing commands, we return the result of the first
   // failing command.
   return Res;
 }

clang/tools/sarif-ld/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS support)
+
+add_clang_tool(
+  sarif-ld
+  SarifLinker.cpp
+)
+
+clang_target_link_libraries(
+  sarif-ld
+  PRIVATE clangTooling
+)
+
+install(
+  PROGRAMS sarif-ld
+  DESTINATION "${CMAKE_INSTALL_BINDIR}"
+  COMPONENT sarif-ld
+)

clang/tools/sarif-ld/SarifLinker.cpp

+#include "clang/Basic/Sarif.h"
+#include "clang/Config/config.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Option/Option.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/Process.h"
+#include <cassert>
+#include <cstdlib>
+#include <fstream>
+#include <iterator>
+#include <string>
+#include <string_view>
+#include <system_error>
+
+namespace json = llvm::json;
+namespace cl = llvm::cl;
+using llvm::ArrayRef, llvm::StringRef;
+
+static cl::opt<bool> Help("h", cl::desc("Alias for --help"), cl::Hidden);
+static cl::opt<std::string> Target("o", cl::init("<file>"),
+                                   cl::desc("Write output to <file>.sarif"));
+static cl::list<std::string> Files(cl::Positional, "files",
+                                   cl::desc("[<file> ...]"));
+
+static void PrintVersion(llvm::raw_ostream &OS) {
+  OS << clang::getClangToolFullVersion("sarif-ld") << '\n';
+}
+
+namespace {
+struct ParseArgsResult {
+  llvm::opt::ArgStringList Input;
+  std::string Output;
+};
+} // namespace
+
+static ParseArgsResult ParseArgs(int argc, char *argv[]) {
+  llvm::cl::ParseCommandLineOptions(
+      argc, argv,
+      "A tool that links separate SARIF files into a single SARIF file.");
+
+  if (Help) {
+    cl::PrintHelpMessage();
+    std::exit(0);
+  }
+
+  if (Files.empty()) {
+    llvm::errs() << argv[0] << ": error: no input files\n";
+    cl::PrintHelpMessage();
+    std::exit(1);
+  }
+
+  if (Target.empty()) {
+    llvm::errs() << argv[0] << ": error: no outpt file\n";
+    cl::PrintHelpMessage();
+    std::exit(2);
+  }
+
+  ParseArgsResult Result{llvm::opt::ArgStringList(), Target.getValue()};
+  llvm::transform(Files, std::back_inserter(Result.Input),
+                  [](StringRef File) { return File.data(); });
+  return Result;
+}
+
+namespace llvm::sarif_linker {
+[[noreturn]] void ReportErrorAndExit(llvm::errc error_code, StringRef Message);
+std::error_code LinkSarifDiagnostics(const opt::ArgStringList &InputPaths,
+                                     StringRef OutputPath);
+} // namespace llvm::sarif_linker
+
+int main(int argc, char *argv[]) {
+  llvm::InitLLVM X(argc, argv);
+  llvm::setBugReportMsg("PLEASE submit a bug report to " BUG_REPORT_URL
+                        " and include the crash backtrace, preprocessed "
+                        "source, and associated run script.\n");
+
+  if (llvm::sys::Process::FixupStandardFileDescriptors())
+    return 1;
+
+  llvm::cl::SetVersionPrinter(PrintVersion);
+  auto [Input, Output] = ParseArgs(argc, argv);
+
+  std::error_code EC = llvm::sarif_linker::LinkSarifDiagnostics(Input, Output);
+  if (EC)
+    llvm::sarif_linker::ReportErrorAndExit(static_cast<llvm::errc>(EC.value()),
+                                           EC.message());
+}

llvm/include/llvm/ADT/STLExtras.h

 }
 
 /// Provide wrappers to std::find which take ranges instead of having to pass
 /// begin/end explicitly.
 template <typename R, typename T> auto find(R &&Range, const T &Val) {
   return std::find(adl_begin(Range), adl_end(Range), Val);
 }
 
+/// std::ranges::find_last means that we don't need to work with
+/// reverse_iterators as often, and can also find the last matching element of a
+/// non-bidirectional range.
+template <typename I, typename T>
+auto find_last(I First, I Last, const T &Val) {
+  using iterator_category = typename std::iterator_traits<I>::iterator_category;
+  static_assert(std::is_base_of_v<std::forward_iterator_tag, iterator_category>,
+                "llvm::find_last requires forward iterators at minimum.");
+  if constexpr (std::is_base_of_v<std::bidirectional_iterator_tag,
+                                  iterator_category>) {
+    for (auto Current = Last; Current-- != First;)
+      if (*Current == Val)
+        return Current;
+
+    return Last;
+  } else {
+    auto Result = Last;
+    for (; First != Last; ++First)
+      if (*First == Val)
+        Result = First;
+    return Result;
+  }
+}
+
+template <typename R, typename T> auto find_last(R &&Range, const T &Val) {
+  return llvm::find_last(adl_begin(Range), adl_end(Range), Val);
+}
+
 /// Provide wrappers to std::find_if which take ranges instead of having to pass
 /// begin/end explicitly.
 template <typename R, typename UnaryPredicate>
 auto find_if(R &&Range, UnaryPredicate P) {
   return std::find_if(adl_begin(Range), adl_end(Range), P);
 }
 
 template <typename R, typename UnaryPredicate>