[diagnostics] Integrate clang -cc1as diagnostics into DiagnosticsEngine

[sanwou01]

Summary

Add initial support for printing assembly diagnostics using the
DiagnosticsEngine infrastructure. Add support for -w (no warnings) and
-Werror (warnings are errors) and print a summary with the number of
errors and warnings. -fcolor-diagnostics handling is implemented as
well.

This patch adds a subclass to FullSourceLoc, called UnifiedSourceLoc,
which can hold an llvm-style SourceLoc and SourceMgr. This class is
responsible for the translation from the clang::FullSourceLoc API to
llvm-style operations.

With these changes in place, it will be possible to convert inline
assembly diagnostics as well.

Missing is support for ranges and hints.

[olista01]

What advantages does this have over the current way of printing diagnostics? If this is just to get -w and -Werror working, would it not be easier to pass those through to the assembler, than to send all diagnostics back through clang? We already have some flags in MCTargetOptions that should be able to to the same things -w and -Werror do.

On the other hand, if this would enable other features, like -W options to promote/suppress categories of assembler warnings, than this might allow us to avoid duplicating a lot of clang's diagnostic system in the LLVM SourceMgr. Do you have any ideas for how this could be done?

[sanwou01]

Hi Oli,

Thanks for taking a look! You're right, -w and -Werror could be implemented by passing them as MCTargetOptions flags.

This patch is indeed intended to enable -W options to promote or silence (categories of) warnings. To enable that, the first step is to be able to associate a diagnostic with an identifier. Clang defines IDs (and their warning groups) in Diagnostic*Kinds.td. The IDs need to be available where a diagnostic is raised, so a table for LLVM diagnostics (or just the enum) needs to live on the LLVM side (but they'd share encoding space with the clang enum, e.g., the clang diag enum starts where the llvm diag enum ends). It is then a matter of plumbing this ID from the point where the diagnostic gets raised, into an SMDiagnostic, and into the DiagnosticsEngine on the clang side.

Once the infrastructure is in place, the calls to Report() and friends can be updated with IDs on a case by case basis.

Thanks,
Sanne

[olista01]

That all sounds sensible from an assembler perspective, especially the ability to gradually move diagnostics into categories rather than having one big change that touches every assembler diag. However, I've not done much work in clang, so it would be good to get someone more familiar with the clang diagnostics/driver side of things to have a look at this too.

[sanwou01]

Rebase on top of D31709 and D32159

[sanwou01]

Don't include the changes from D31709 and D32159 in this patch (oops).

include/clang/Basic/Diagnostic.h

 
 #include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
-#include "llvm/ADT/iterator_range.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/Support/SMLoc.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <list>
 #include <map>
 #include <memory>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
+namespace llvm {
+
+class SourceMgr;
+}
+
 namespace clang {
 
 class DeclContext;
 class DiagnosticBuilder;
 class DiagnosticConsumer;
 class IdentifierInfo;
 class LangOptions;
 class Preprocessor;
SourceManager &getSourceManager() const {
     return *SourceMgr;
   }
   void setSourceManager(SourceManager *SrcMgr) {
     assert(DiagStatesByLoc.empty() &&
            "Leftover diag state from a different SourceManager.");
     SourceMgr = SrcMgr;
   }
 
+  bool hasLLVMSourceManager() const { return CurDiagSM != nullptr; }
+  const llvm::SourceMgr *getLLVMSourceManager() const {
+    assert(CurDiagSM && "LLVMSourceManager not provided!");
+    return CurDiagSM;
+  }
+
   //===--------------------------------------------------------------------===//
   //  DiagnosticsEngine characterization methods, used by a client to customize
   //  how diagnostics are emitted.
   //
 
   /// \brief Copies the current DiagMappings and pushes the new copy
   /// onto the top of the stack.
   void pushMappings(SourceLocation Loc);
public:
   /// This actually returns an instance of DiagnosticBuilder which emits the
   /// diagnostics (through @c ProcessDiag) when it is destroyed.
   ///
   /// \param DiagID A member of the @c diag::kind enum.
   /// \param Loc Represents the source location associated with the diagnostic,
   /// which can be an invalid location if no position information is available.
   inline DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID);
   inline DiagnosticBuilder Report(unsigned DiagID);
+  inline DiagnosticBuilder Report(const llvm::SourceMgr *SM, llvm::SMLoc Loc,
+                                  unsigned DiagID);
 
   void Report(const StoredDiagnostic &storedDiag);
 
   /// \brief Determine whethere there is already a diagnostic in flight.
   bool isDiagnosticInFlight() const { return CurDiagID != ~0U; }
 
   /// \brief Set the "delayed" diagnostic that will be emitted once
   /// the current diagnostic completes.
public:
   ///
   /// \param Arg2 A string argument that will be provided to the
   /// diagnostic. A copy of this string will be stored in the
   /// DiagnosticsEngine object itself.
   void SetDelayedDiagnostic(unsigned DiagID, StringRef Arg1 = "",
                             StringRef Arg2 = "");
   
   /// \brief Clear out the current diagnostic.
-  void Clear() { CurDiagID = ~0U; }
+  void Clear() {
+    CurDiagID = ~0U;
+    CurDiagSMLoc = llvm::SMLoc();
+    CurDiagSM = nullptr;
+  }
 
   /// \brief Return the value associated with this diagnostic flag.
   StringRef getFlagValue() const { return FlagValue; }
 
 private:
   /// \brief Report the delayed diagnostic.
   void ReportDelayed();
 
private:
   /// \brief The location of the current diagnostic that is in flight.
   SourceLocation CurDiagLoc;
 
   /// \brief The ID of the current diagnostic that is in flight.
   ///
   /// This is set to ~0U when there is no diagnostic in flight.
   unsigned CurDiagID;
 
+  llvm::SMLoc CurDiagSMLoc = llvm::SMLoc();
+  const llvm::SourceMgr *CurDiagSM = nullptr;
+
   enum {
     /// \brief The maximum number of arguments we can hold.
     ///
     /// We currently only support up to 10 arguments (%0-%9).  A single
     /// diagnostic with more than that almost certainly has to be simplified
     /// anyway.
     MaxArguments = 10,
   };

 typedef std::pair<NullabilityKind, bool> DiagNullabilityKind;
 
 const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                     DiagNullabilityKind nullability);
 
 inline DiagnosticBuilder DiagnosticsEngine::Report(SourceLocation Loc,
                                                    unsigned DiagID) {
   assert(CurDiagID == ~0U && "Multiple diagnostics in flight at once!");
+  CurDiagSMLoc = llvm::SMLoc();
+  CurDiagSM = nullptr;
   CurDiagLoc = Loc;
   CurDiagID = DiagID;
   FlagValue.clear();
   return DiagnosticBuilder(this);
 }
 
 inline DiagnosticBuilder DiagnosticsEngine::Report(unsigned DiagID) {
   return Report(SourceLocation(), DiagID);
 }
 
+inline DiagnosticBuilder DiagnosticsEngine::Report(const llvm::SourceMgr *SM,
+                                                   llvm::SMLoc Loc,
+                                                   unsigned DiagID) {
+  auto DB = Report(DiagID);
+  CurDiagSM = SM;
+  CurDiagSMLoc = Loc;
+  return DB;
+}
+
 //===----------------------------------------------------------------------===//
 // Diagnostic
 //===----------------------------------------------------------------------===//
 
 /// A little helper class (which is basically a smart pointer that forwards
 /// info from DiagnosticsEngine) that allows clients to enquire about the
 /// currently in-flight diagnostic.
 class Diagnostic {
   const DiagnosticsEngine *DiagObj;
   StringRef StoredDiagMessage;
 
 public:
   explicit Diagnostic(const DiagnosticsEngine *DO) : DiagObj(DO) {}
   Diagnostic(const DiagnosticsEngine *DO, StringRef storedDiagMessage)
     : DiagObj(DO), StoredDiagMessage(storedDiagMessage) {}
 
   const DiagnosticsEngine *getDiags() const { return DiagObj; }
   unsigned getID() const { return DiagObj->CurDiagID; }
   const SourceLocation &getLocation() const { return DiagObj->CurDiagLoc; }
   bool hasSourceManager() const { return DiagObj->hasSourceManager(); }
   SourceManager &getSourceManager() const { return DiagObj->getSourceManager();}
 
+  llvm::SMLoc getLLVMLocation() const { return DiagObj->CurDiagSMLoc; }
+  bool hasLLVMSourceManager() const { return DiagObj->hasLLVMSourceManager(); }
+  const llvm::SourceMgr *getLLVMSourceManager() const {
+    return DiagObj->getLLVMSourceManager();
+  }
+
   unsigned getNumArgs() const { return DiagObj->NumDiagArgs; }
 
   /// \brief Return the kind of the specified index.
   ///
   /// Based on the kind of argument, the accessors below can be used to get
   /// the value.
   ///
   /// \pre Idx < getNumArgs()

include/clang/Driver/Options.h

 #ifndef LLVM_CLANG_DRIVER_OPTIONS_H
 #define LLVM_CLANG_DRIVER_OPTIONS_H
 
 #include <memory>
 
 namespace llvm {
 namespace opt {
 class OptTable;
+class ArgList;
 }
 }
 
 namespace clang {
+class DiagnosticOptions;
+class DiagnosticsEngine;
 namespace driver {
 
 namespace options {
 /// Flags specifically for clang options.  Must not overlap with
 /// llvm::opt::DriverFlag.
 enum ClangFlags {
   DriverOption = (1 << 4),
   LinkerInput = (1 << 5),

 #include "clang/Driver/Options.inc"
     LastOption
 #undef OPTION
   };
 }
 
 std::unique_ptr<llvm::opt::OptTable> createDriverOptTable();
 }
+
+/// \brief Fill out Opts based on the options given in Args.
+///
+/// Args must have been created from the OptTable returned by
+/// createCC1OptTable().
+///
+/// When errors are encountered, return false and, if Diags is non-null,
+/// report the error(s).
+bool ParseDiagnosticArgs(DiagnosticOptions &Opts,
+                         const llvm::opt::ArgList &Args,
+                         DiagnosticsEngine *Diags = nullptr,
+                         bool DefaultDiagColor = true,
+                         bool DefaultShowOpt = true);
 }
 
 #endif

include/clang/Driver/Options.td

def Wno_nonportable_cfstrings : Joined<["-"], "Wno-nonportable-cfstrings">, Group<W_Group>,
   Flags<[CC1Option]>;
 def Wnonportable_cfstrings : Joined<["-"], "Wnonportable-cfstrings">, Group<W_Group>,
   Flags<[CC1Option]>;
 def Wp_COMMA : CommaJoined<["-"], "Wp,">,
   HelpText<"Pass the comma separated arguments in <arg> to the preprocessor">,
   MetaVarName<"<arg>">, Group<Preprocessor_Group>;
 def Wwrite_strings : Flag<["-"], "Wwrite-strings">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
 def Wno_write_strings : Flag<["-"], "Wno-write-strings">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
-def W_Joined : Joined<["-"], "W">, Group<W_Group>, Flags<[CC1Option, CoreOption]>,
+def W_Joined : Joined<["-"], "W">, Group<W_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>,
   MetaVarName<"<warning>">, HelpText<"Enable the specified warning">;
 def Xanalyzer : Separate<["-"], "Xanalyzer">,
   HelpText<"Pass <arg> to the static analyzer">, MetaVarName<"<arg>">,
   Group<StaticAnalyzer_Group>;
 def Xarch__ : JoinedAndSeparate<["-"], "Xarch_">, Flags<[DriverOption]>;
 def Xassembler : Separate<["-"], "Xassembler">,
   HelpText<"Pass <arg> to the assembler">, MetaVarName<"<arg>">,
   Group<CompileOnly_Group>;

 def fborland_extensions : Flag<["-"], "fborland-extensions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Accept non-standard constructs supported by the Borland compiler">;
 def fbuiltin : Flag<["-"], "fbuiltin">, Group<f_Group>;
 def fbuiltin_module_map : Flag <["-"], "fbuiltin-module-map">, Group<f_Group>,
   Flags<[DriverOption]>, HelpText<"Load the clang builtins module map file.">;
 def fcaret_diagnostics : Flag<["-"], "fcaret-diagnostics">, Group<f_Group>;
 def fclasspath_EQ : Joined<["-"], "fclasspath=">, Group<f_Group>;
 def fcolor_diagnostics : Flag<["-"], "fcolor-diagnostics">, Group<f_Group>,
-  Flags<[CoreOption, CC1Option]>, HelpText<"Use colors in diagnostics">;
+  Flags<[CoreOption, CC1Option, CC1AsOption]>, HelpText<"Use colors in diagnostics">;
 def fdiagnostics_color : Flag<["-"], "fdiagnostics-color">, Group<f_Group>,
   Flags<[CoreOption, DriverOption]>;
 def fdiagnostics_color_EQ : Joined<["-"], "fdiagnostics-color=">, Group<f_Group>;
 def fansi_escape_codes : Flag<["-"], "fansi-escape-codes">, Group<f_Group>,
   Flags<[CoreOption, CC1Option]>, HelpText<"Use ANSI escape codes for diagnostics">;
 def fcomment_block_commands : CommaJoined<["-"], "fcomment-block-commands=">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Treat each comma separated argument in <arg> as a documentation comment block command">,
   MetaVarName<"<arg>">;

 def verify_debug_info : Flag<["--"], "verify-debug-info">, Flags<[DriverOption]>,
   HelpText<"Verify the binary representation of debug output">;
 def weak_l : Joined<["-"], "weak-l">, Flags<[LinkerInput]>;
 def weak__framework : Separate<["-"], "weak_framework">, Flags<[LinkerInput]>;
 def weak__library : Separate<["-"], "weak_library">, Flags<[LinkerInput]>;
 def weak__reference__mismatches : Separate<["-"], "weak_reference_mismatches">;
 def whatsloaded : Flag<["-"], "whatsloaded">;
 def whyload : Flag<["-"], "whyload">;
-def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">, Flags<[CC1Option]>;
+def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">, Flags<[CC1Option,CC1AsOption]>;
 def x : JoinedOrSeparate<["-"], "x">, Flags<[DriverOption,CC1Option]>,
   HelpText<"Treat subsequent input files as having type <language>">,
   MetaVarName<"<language>">;
 def y : Joined<["-"], "y">;
 
 def fintegrated_as : Flag<["-"], "fintegrated-as">, Flags<[DriverOption]>,
                      Group<f_Group>, HelpText<"Enable the integrated assembler">;
 def fno_integrated_as : Flag<["-"], "fno-integrated-as">,

include/clang/Frontend/CompilerInvocation.h

 namespace clang {
 class PreprocessorOptions;
 class HeaderSearchOptions;
 class TargetOptions;
 class LangOptions;
 class CompilerInvocation;
 class DiagnosticsEngine;
 
-/// \brief Fill out Opts based on the options given in Args.
-///
-/// Args must have been created from the OptTable returned by
-/// createCC1OptTable().
-///
-/// When errors are encountered, return false and, if Diags is non-null,
-/// report the error(s).
-bool ParseDiagnosticArgs(DiagnosticOptions &Opts, llvm::opt::ArgList &Args,
-                         DiagnosticsEngine *Diags = nullptr,
-                         bool DefaultDiagColor = true,
-                         bool DefaultShowOpt = true);
-
 class CompilerInvocationBase {
   void operator=(const CompilerInvocationBase &) = delete;
 
 public:
   /// Options controlling the language variant.
   std::shared_ptr<LangOptions> LangOpts;
 
   /// Options controlling the target.

include/clang/Frontend/DiagnosticRenderer.h

protected:
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
   
   /// \brief The location of the previous diagnostic if known.
   ///
   /// This will be invalid in cases where there is no (known) previous
   /// diagnostic location, or that location itself is invalid or comes from
   /// a different source manager than SM.
   SourceLocation LastLoc;
-  
+  /// \brief The location of the previous llvm diagnostic if known.
+  ///
+  /// This will be invalid in cases where there is no (known) previous
+  /// diagnostic location, or that location itself is invalid or comes from
+  /// a different source manager than LLVM SM.
+  llvm::SMLoc LastSMLoc;
+
   /// \brief The location of the last include whose stack was printed if known.
   ///
   /// Same restriction as LastLoc essentially, but tracking include stack
   /// root locations rather than diagnostic locations.
   SourceLocation LastIncludeLoc;
   
   /// \brief The level of the last diagnostic emitted.
   ///
   /// The level of the last diagnostic emitted. Used to detect level changes
   /// which change the amount of information displayed.
   DiagnosticsEngine::Level LastLevel;
 
   DiagnosticRenderer(const LangOptions &LangOpts,
                      DiagnosticOptions *DiagOpts);
   
   virtual ~DiagnosticRenderer();
   
   virtual void emitDiagnosticMessage(SourceLocation Loc, PresumedLoc PLoc,
                                      DiagnosticsEngine::Level Level,
                                      StringRef Message,
                                      ArrayRef<CharSourceRange> Ranges,
                                      const SourceManager *SM,
                                      DiagOrStoredDiag Info) = 0;
-  
+  virtual void emitDiagnosticMessage(llvm::SMLoc Loc,
+                                     DiagnosticsEngine::Level Level,
+                                     StringRef Message,
+                                     const llvm::SourceMgr *SM,
+                                     DiagOrStoredDiag Info) {}
   virtual void emitDiagnosticLoc(SourceLocation Loc, PresumedLoc PLoc,
                                  DiagnosticsEngine::Level Level,
                                  ArrayRef<CharSourceRange> Ranges,
                                  const SourceManager &SM) = 0;
 
+  virtual void emitDiagnosticLoc(llvm::SMLoc Loc,
+                                 DiagnosticsEngine::Level Level,
+                                 const llvm::SourceMgr *SM){};
+
   virtual void emitCodeContext(SourceLocation Loc,
                                DiagnosticsEngine::Level Level,
                                SmallVectorImpl<CharSourceRange>& Ranges,
                                ArrayRef<FixItHint> Hints,
                                const SourceManager &SM) = 0;
-  
+  virtual void emitCodeContext(llvm::SMLoc Loc, DiagnosticsEngine::Level Level,
+                               const llvm::SourceMgr *SM){};
   virtual void emitIncludeLocation(SourceLocation Loc, PresumedLoc PLoc,
                                    const SourceManager &SM) = 0;
   virtual void emitImportLocation(SourceLocation Loc, PresumedLoc PLoc,
                                   StringRef ModuleName,
                                   const SourceManager &SM) = 0;
   virtual void emitBuildingModuleLocation(SourceLocation Loc, PresumedLoc PLoc,
                                           StringRef ModuleName,
                                           const SourceManager &SM) = 0;
private:
   void emitIncludeStackRecursively(SourceLocation Loc, const SourceManager &SM);
   void emitImportStack(SourceLocation Loc, const SourceManager &SM);
   void emitImportStackRecursively(SourceLocation Loc, StringRef ModuleName,
                                   const SourceManager &SM);
   void emitModuleBuildStack(const SourceManager &SM);
   void emitCaret(SourceLocation Loc, DiagnosticsEngine::Level Level,
                  ArrayRef<CharSourceRange> Ranges, ArrayRef<FixItHint> Hints,
                  const SourceManager &SM);
+
+  void emitCaret(llvm::SMLoc Loc, DiagnosticsEngine::Level Level,
+                 const llvm::SourceMgr *SM);
   void emitSingleMacroExpansion(SourceLocation Loc,
                                 DiagnosticsEngine::Level Level,
                                 ArrayRef<CharSourceRange> Ranges,
                                 const SourceManager &SM);
   void emitMacroExpansions(SourceLocation Loc,
                            DiagnosticsEngine::Level Level,
                            ArrayRef<CharSourceRange> Ranges,
                            ArrayRef<FixItHint> Hints,
public:
   /// \param FixItHints The FixIt hints active for this diagnostic.
   /// \param SM The SourceManager; will be null if the diagnostic came from the
   ///        frontend, thus \p Loc will be invalid.
   void emitDiagnostic(SourceLocation Loc, DiagnosticsEngine::Level Level,
                       StringRef Message, ArrayRef<CharSourceRange> Ranges,
                       ArrayRef<FixItHint> FixItHints,
                       const SourceManager *SM,
                       DiagOrStoredDiag D = (Diagnostic *)nullptr);
+  void emitDiagnostic(llvm::SMLoc, DiagnosticsEngine::Level Level,
+                      StringRef Message, const llvm::SourceMgr *SM,
+                      DiagOrStoredDiag D = (Diagnostic *)nullptr);
 
   void emitStoredDiagnostic(StoredDiagnostic &Diag);
 };
   
 /// Subclass of DiagnosticRender that turns all subdiagostics into explicit
 /// notes.  It is up to subclasses to further define the behavior.
 class DiagnosticNoteRenderer : public DiagnosticRenderer {
 public:

include/clang/Frontend/TextDiagnostic.h

 
 protected:
   void emitDiagnosticMessage(SourceLocation Loc,PresumedLoc PLoc,
                              DiagnosticsEngine::Level Level,
                              StringRef Message,
                              ArrayRef<CharSourceRange> Ranges,
                              const SourceManager *SM,
                              DiagOrStoredDiag D) override;
+  void emitDiagnosticMessage(llvm::SMLoc Loc, DiagnosticsEngine::Level Level,
+                             StringRef Message, const llvm::SourceMgr *SM,
+                             DiagOrStoredDiag Info) override;
 
   void emitDiagnosticLoc(SourceLocation Loc, PresumedLoc PLoc,
                          DiagnosticsEngine::Level Level,
                          ArrayRef<CharSourceRange> Ranges,
                          const SourceManager &SM) override;
+  void emitDiagnosticLoc(llvm::SMLoc Loc, DiagnosticsEngine::Level Level,
+                         const llvm::SourceMgr *SM) override;
 
   void emitCodeContext(SourceLocation Loc,
                        DiagnosticsEngine::Level Level,
                        SmallVectorImpl<CharSourceRange>& Ranges,
                        ArrayRef<FixItHint> Hints,
                        const SourceManager &SM) override {
     emitSnippetAndCaret(Loc, Level, Ranges, Hints, SM);
   }
 
+  void emitCodeContext(llvm::SMLoc Loc, DiagnosticsEngine::Level Level,
+                       const llvm::SourceMgr *SM) override {
+    emitSnippetAndCaret(Loc, Level, SM);
+  }
+
   void emitIncludeLocation(SourceLocation Loc, PresumedLoc PLoc,
                            const SourceManager &SM) override;
 
   void emitImportLocation(SourceLocation Loc, PresumedLoc PLoc,
                           StringRef ModuleName,
                           const SourceManager &SM) override;
 
   void emitBuildingModuleLocation(SourceLocation Loc, PresumedLoc PLoc,
                                   StringRef ModuleName,
                                   const SourceManager &SM) override;
 
 private:
   void emitFilename(StringRef Filename, const SourceManager &SM);
-
+  void emitFilename(StringRef Filename, const llvm::SourceMgr *SM);
   void emitSnippetAndCaret(SourceLocation Loc, DiagnosticsEngine::Level Level,
                            SmallVectorImpl<CharSourceRange>& Ranges,
                            ArrayRef<FixItHint> Hints,
                            const SourceManager &SM);
+  void emitSnippetAndCaret(llvm::SMLoc Loc, DiagnosticsEngine::Level Level,
+                           const llvm::SourceMgr *SM);
 
   void emitSnippet(StringRef SourceLine);
 
   void emitParseableFixits(ArrayRef<FixItHint> Hints, const SourceManager &SM);
 };
 
 } // end namespace clang
 
 #endif

lib/Driver/DriverOptions.cpp

 //===--- DriverOptions.cpp - Driver Options Table -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
+#include "clang/Frontend/Utils.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
+#include "llvm/Support/Process.h"
 
 using namespace clang::driver;
 using namespace clang::driver::options;
 using namespace llvm::opt;
 
 #define PREFIX(NAME, VALUE) static const char *const NAME[] = VALUE;
 #include "clang/Driver/Options.inc"
 #undef PREFIX
DriverOptTable()
     : OptTable(InfoTable) {}
 };
 
 }
 
 std::unique_ptr<OptTable> clang::driver::createDriverOptTable() {
   return llvm::make_unique<DriverOptTable>();
 }
+
+namespace {
+using namespace clang;
+
+static void addDiagnosticArgs(const ArgList &Args, OptSpecifier Group,
+                              OptSpecifier GroupWithValue,
+                              std::vector<std::string> &Diagnostics) {
+  for (Arg *A : Args.filtered(Group)) {
+    if (A->getOption().getKind() == Option::FlagClass) {
+      // The argument is a pure flag (such as OPT_Wall or OPT_Wdeprecated). Add
+      // its name (minus the "W" or "R" at the beginning) to the warning list.
+      Diagnostics.push_back(A->getOption().getName().drop_front(1));
+    } else if (A->getOption().matches(GroupWithValue)) {
+      // This is -Wfoo= or -Rfoo=, where foo is the name of the diagnostic
+      // group.
+      Diagnostics.push_back(A->getOption().getName().drop_front(1).rtrim("=-"));
+    } else {
+      // Otherwise, add its value (for OPT_W_Joined and similar).
+      for (const char *Arg : A->getValues())
+        Diagnostics.emplace_back(Arg);
+    }
+  }
+}
+
+static bool parseDiagnosticLevelMask(StringRef FlagName,
+                                     const std::vector<std::string> &Levels,
+                                     DiagnosticsEngine *Diags,
+                                     DiagnosticLevelMask &M) {
+  bool Success = true;
+  for (const auto &Level : Levels) {
+    DiagnosticLevelMask const PM =
+        llvm::StringSwitch<DiagnosticLevelMask>(Level)
+            .Case("note", DiagnosticLevelMask::Note)
+            .Case("remark", DiagnosticLevelMask::Remark)
+            .Case("warning", DiagnosticLevelMask::Warning)
+            .Case("error", DiagnosticLevelMask::Error)
+            .Default(DiagnosticLevelMask::None);
+    if (PM == DiagnosticLevelMask::None) {
+      Success = false;
+      if (Diags)
+        Diags->Report(diag::err_drv_invalid_value) << FlagName << Level;
+    }
+    M = M | PM;
+  }
+  return Success;
+}
+
+static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor) {
+  // Color diagnostics default to auto ("on" if terminal supports) in the driver
+  // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
+  // Support both clang's -f[no-]color-diagnostics and gcc's
+  // -f[no-]diagnostics-colors[=never|always|auto].
+  enum {
+    Colors_On,
+    Colors_Off,
+    Colors_Auto
+  } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
+  for (Arg *A : Args) {
+    const Option &O = A->getOption();
+    if (O.matches(options::OPT_fcolor_diagnostics) ||
+        O.matches(options::OPT_fdiagnostics_color)) {
+      ShowColors = Colors_On;
+    } else if (O.matches(options::OPT_fno_color_diagnostics) ||
+               O.matches(options::OPT_fno_diagnostics_color)) {
+      ShowColors = Colors_Off;
+    } else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
+      StringRef Value(A->getValue());
+      if (Value == "always")
+        ShowColors = Colors_On;
+      else if (Value == "never")
+        ShowColors = Colors_Off;
+      else if (Value == "auto")
+        ShowColors = Colors_Auto;
+    }
+  }
+  return ShowColors == Colors_On ||
+         (ShowColors == Colors_Auto &&
+          llvm::sys::Process::StandardErrHasColors());
+}
+}
+
+bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts,
+                                const llvm::opt::ArgList &Args,
+                                DiagnosticsEngine *Diags, bool DefaultDiagColor,
+                                bool DefaultShowOpt) {
+  using namespace options;
+  bool Success = true;
+
+  Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
+  if (Arg *A =
+          Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
+    Opts.DiagnosticSerializationFile = A->getValue();
+  Opts.IgnoreWarnings = Args.hasArg(OPT_w);
+  Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
+  Opts.Pedantic = Args.hasArg(OPT_pedantic);
+  Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
+  Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
+  Opts.ShowColors = parseShowColorsArgs(Args, DefaultDiagColor);
+  Opts.ShowColumn = Args.hasFlag(OPT_fshow_column, OPT_fno_show_column,
+                                 /*Default=*/true);
+  Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
+  Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
+  Opts.AbsolutePath = Args.hasArg(OPT_fdiagnostics_absolute_paths);
+  Opts.ShowOptionNames =
+      Args.hasFlag(OPT_fdiagnostics_show_option,
+                   OPT_fno_diagnostics_show_option, DefaultShowOpt);
+
+  llvm::sys::Process::UseANSIEscapeCodes(Args.hasArg(OPT_fansi_escape_codes));
+
+  // Default behavior is to not to show note include stacks.
+  Opts.ShowNoteIncludeStack = false;
+  if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
+                               OPT_fno_diagnostics_show_note_include_stack))
+    if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
+      Opts.ShowNoteIncludeStack = true;
+
+  StringRef ShowOverloads = Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
+  if (ShowOverloads == "best")
+    Opts.setShowOverloads(Ovl_Best);
+  else if (ShowOverloads == "all")
+    Opts.setShowOverloads(Ovl_All);
+  else {
+    Success = false;
+    if (Diags)
+      Diags->Report(diag::err_drv_invalid_value)
+          << Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
+          << ShowOverloads;
+  }
+
+  StringRef ShowCategory =
+      Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
+  if (ShowCategory == "none")
+    Opts.ShowCategories = 0;
+  else if (ShowCategory == "id")
+    Opts.ShowCategories = 1;
+  else if (ShowCategory == "name")
+    Opts.ShowCategories = 2;
+  else {
+    Success = false;
+    if (Diags)
+      Diags->Report(diag::err_drv_invalid_value)
+          << Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
+          << ShowCategory;
+  }
+
+  StringRef Format = Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
+  if (Format == "clang")
+    Opts.setFormat(DiagnosticOptions::Clang);
+  else if (Format == "msvc")
+    Opts.setFormat(DiagnosticOptions::MSVC);
+  else if (Format == "msvc-fallback") {
+    Opts.setFormat(DiagnosticOptions::MSVC);
+    Opts.CLFallbackMode = true;
+  } else if (Format == "vi")
+    Opts.setFormat(DiagnosticOptions::Vi);
+  else {
+    Success = false;
+    if (Diags)
+      Diags->Report(diag::err_drv_invalid_value)
+          << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
+          << Format;
+  }
+
+  Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
+  Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
+  Opts.ShowPresumedLoc =
+      !Args.hasArg(OPT_fno_diagnostics_use_presumed_location);
+  Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
+  DiagnosticLevelMask DiagMask = DiagnosticLevelMask::None;
+  Success &= parseDiagnosticLevelMask(
+      "-verify-ignore-unexpected=",
+      Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), Diags, DiagMask);
+  if (Args.hasArg(OPT_verify_ignore_unexpected))
+    DiagMask = DiagnosticLevelMask::All;
+  Opts.setVerifyIgnoreUnexpected(DiagMask);
+  Opts.ElideType = !Args.hasArg(OPT_fno_elide_type);
+  Opts.ShowTemplateTree = Args.hasArg(OPT_fdiagnostics_show_template_tree);
+  Opts.ErrorLimit = getLastArgIntValue(Args, OPT_ferror_limit, 0, Diags);
+  Opts.MacroBacktraceLimit =
+      getLastArgIntValue(Args, OPT_fmacro_backtrace_limit,
+                         DiagnosticOptions::DefaultMacroBacktraceLimit, Diags);
+  Opts.TemplateBacktraceLimit = getLastArgIntValue(
+      Args, OPT_ftemplate_backtrace_limit,
+      DiagnosticOptions::DefaultTemplateBacktraceLimit, Diags);
+  Opts.ConstexprBacktraceLimit = getLastArgIntValue(
+      Args, OPT_fconstexpr_backtrace_limit,
+      DiagnosticOptions::DefaultConstexprBacktraceLimit, Diags);
+  Opts.SpellCheckingLimit =
+      getLastArgIntValue(Args, OPT_fspell_checking_limit,
+                         DiagnosticOptions::DefaultSpellCheckingLimit, Diags);
+  Opts.TabStop = getLastArgIntValue(Args, OPT_ftabstop,
+                                    DiagnosticOptions::DefaultTabStop, Diags);
+  if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
+    Opts.TabStop = DiagnosticOptions::DefaultTabStop;
+    if (Diags)
+      Diags->Report(diag::warn_ignoring_ftabstop_value)
+          << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
+  }
+  Opts.MessageLength = getLastArgIntValue(Args, OPT_fmessage_length, 0, Diags);
+  addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings);
+  addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks);
+
+  return Success;
+}

lib/Driver/ToolChains/Clang.cpp

 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/Version.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
 #include "clang/Driver/XRayArgs.h"
+#include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/YAMLParser.h"
void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
   ArgStringList CmdArgs;
 
   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
   const InputInfo &Input = Inputs[0];
 
   const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
   const std::string &TripleStr = Triple.getTriple();
 
-  // Don't warn about "clang -w -c foo.s"
-  Args.ClaimAllArgs(options::OPT_w);
-  // and "clang -emit-llvm -c foo.s"
+  // Don't warn about "clang -emit-llvm -c foo.s"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
 
   claimNoWarnArgs(Args);
 
   // Invoke ourselves in -cc1as mode.
   //
   // FIXME: Implement custom jobs for internal actions.
   CmdArgs.push_back("-cc1as");
case llvm::Triple::mips64el:
     break;
 
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     AddX86TargetArgs(Args, CmdArgs);
     break;
   }
 
-  // Consume all the warning flags. Usually this would be handled more
-  // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
-  // doesn't handle that so rather than warning about unused flags that are
-  // actually used, we'll lie by omission instead.
-  // FIXME: Stop lying and consume only the appropriate driver flags
-  Args.ClaimAllArgs(options::OPT_W_Group);
+  // Pass all warning flags to -cc1as.
+  Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
+  if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
+    CmdArgs.push_back("-pedantic");
+  Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
+  Args.AddLastArg(CmdArgs, options::OPT_w);
+
+  // Color diagnostics are parsed by the driver directly from argv
+  // and later re-parsed to construct this job; claim any possible
+  // color diagnostic here to avoid warn_drv_unused_argument and
+  // diagnose bad OPT_fdiagnostics_color_EQ values.
+  for (Arg *A : Args) {
+    const Option &O = A->getOption();
+    if (!O.matches(options::OPT_fcolor_diagnostics) &&
+        !O.matches(options::OPT_fdiagnostics_color) &&
+        !O.matches(options::OPT_fno_color_diagnostics) &&
+        !O.matches(options::OPT_fno_diagnostics_color) &&
+        !O.matches(options::OPT_fdiagnostics_color_EQ))
+      continue;
+    if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
+      StringRef Value(A->getValue());
+      if (Value != "always" && Value != "never" && Value != "auto")
+        getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
+            << ("-fdiagnostics-color=" + Value).str();
+    }
+    A->claim();
+  }
+  if (getToolChain().getDriver().getDiags().getDiagnosticOptions().ShowColors)
+    CmdArgs.push_back("-fcolor-diagnostics");
 
   CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
                                     getToolChain().getDriver());
 
   Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
 
   assert(Output.isFilename() && "Unexpected lipo output.");
   CmdArgs.push_back("-o");

lib/Frontend/CompilerInvocation.cpp

if (A->getOption().matches(options::OPT_O)) {
       case 'z':
         return 2;
       }
     }
   }
   return 0;
 }
 
-static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group,
-                              OptSpecifier GroupWithValue,
-                              std::vector<std::string> &Diagnostics) {
-  for (Arg *A : Args.filtered(Group)) {
-    if (A->getOption().getKind() == Option::FlagClass) {
-      // The argument is a pure flag (such as OPT_Wall or OPT_Wdeprecated). Add
-      // its name (minus the "W" or "R" at the beginning) to the warning list.
-      Diagnostics.push_back(A->getOption().getName().drop_front(1));
-    } else if (A->getOption().matches(GroupWithValue)) {
-      // This is -Wfoo= or -Rfoo=, where foo is the name of the diagnostic group.
-      Diagnostics.push_back(A->getOption().getName().drop_front(1).rtrim("=-"));
-    } else {
-      // Otherwise, add its value (for OPT_W_Joined and similar).
-      for (const char *Arg : A->getValues())
-        Diagnostics.emplace_back(Arg);
-    }
-  }
-}
-
 static void getAllNoBuiltinFuncValues(ArgList &Args,
                                       std::vector<std::string> &Funcs) {
   SmallVector<const char *, 8> Values;
   for (const auto &Arg : Args) {
     const Option &O = Arg->getOption();
     if (O.matches(options::OPT_fno_builtin_)) {
       const char *FuncName = Arg->getValue();
       if (Builtin::Context::isBuiltinFunc(FuncName))
GenerateOptimizationRemarkRegex(DiagnosticsEngine &Diags, ArgList &Args,
   if (!Pattern->isValid(RegexError)) {
     Diags.Report(diag::err_drv_optimization_remark_pattern)
         << RegexError << RpassArg->getAsString(Args);
     Pattern.reset();
   }
   return Pattern;
 }
 
-static bool parseDiagnosticLevelMask(StringRef FlagName,
-                                     const std::vector<std::string> &Levels,
-                                     DiagnosticsEngine *Diags,
-                                     DiagnosticLevelMask &M) {
-  bool Success = true;
-  for (const auto &Level : Levels) {
-    DiagnosticLevelMask const PM =
-      llvm::StringSwitch<DiagnosticLevelMask>(Level)
-        .Case("note",    DiagnosticLevelMask::Note)
-        .Case("remark",  DiagnosticLevelMask::Remark)
-        .Case("warning", DiagnosticLevelMask::Warning)
-        .Case("error",   DiagnosticLevelMask::Error)
-        .Default(DiagnosticLevelMask::None);
-    if (PM == DiagnosticLevelMask::None) {
-      Success = false;
-      if (Diags)
-        Diags->Report(diag::err_drv_invalid_value) << FlagName << Level;
-    }
-    M = M | PM;
-  }
-  return Success;
-}
 
 static void parseSanitizerKinds(StringRef FlagName,
                                 const std::vector<std::string> &Sanitizers,
                                 DiagnosticsEngine &Diags, SanitizerSet &S) {
   for (const auto &Sanitizer : Sanitizers) {
     SanitizerMask K = parseSanitizerValue(Sanitizer, /*AllowGroups=*/false);
     if (K == 0)
       Diags.Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
   // They won't be discovered by the regular preprocessor, so
   // we let make / ninja to know about this implicit dependency.
   Opts.ExtraDeps = Args.getAllArgValues(OPT_fdepfile_entry);
   auto ModuleFiles = Args.getAllArgValues(OPT_fmodule_file);
   Opts.ExtraDeps.insert(Opts.ExtraDeps.end(), ModuleFiles.begin(),
                         ModuleFiles.end());
 }
 
-static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor) {
-  // Color diagnostics default to auto ("on" if terminal supports) in the driver
-  // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
-  // Support both clang's -f[no-]color-diagnostics and gcc's
-  // -f[no-]diagnostics-colors[=never|always|auto].
-  enum {
-    Colors_On,
-    Colors_Off,
-    Colors_Auto
-  } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
-  for (Arg *A : Args) {
-    const Option &O = A->getOption();
-    if (O.matches(options::OPT_fcolor_diagnostics) ||
-        O.matches(options::OPT_fdiagnostics_color)) {
-      ShowColors = Colors_On;
-    } else if (O.matches(options::OPT_fno_color_diagnostics) ||
-               O.matches(options::OPT_fno_diagnostics_color)) {
-      ShowColors = Colors_Off;
-    } else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
-      StringRef Value(A->getValue());
-      if (Value == "always")
-        ShowColors = Colors_On;
-      else if (Value == "never")
-        ShowColors = Colors_Off;
-      else if (Value == "auto")
-        ShowColors = Colors_Auto;
-    }
-  }
-  return ShowColors == Colors_On ||
-         (ShowColors == Colors_Auto &&
-          llvm::sys::Process::StandardErrHasColors());
-}
-
-bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
-                                DiagnosticsEngine *Diags,
-                                bool DefaultDiagColor, bool DefaultShowOpt) {
-  using namespace options;
-  bool Success = true;
-
-  Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
-  if (Arg *A =
-          Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
-    Opts.DiagnosticSerializationFile = A->getValue();
-  Opts.IgnoreWarnings = Args.hasArg(OPT_w);
-  Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
-  Opts.Pedantic = Args.hasArg(OPT_pedantic);
-  Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
-  Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
-  Opts.ShowColors = parseShowColorsArgs(Args, DefaultDiagColor);
-  Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
-                                 OPT_fno_show_column,
-                                 /*Default=*/true);
-  Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
-  Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
-  Opts.AbsolutePath = Args.hasArg(OPT_fdiagnostics_absolute_paths);
-  Opts.ShowOptionNames =
-      Args.hasFlag(OPT_fdiagnostics_show_option,
-                   OPT_fno_diagnostics_show_option, DefaultShowOpt);
-
-  llvm::sys::Process::UseANSIEscapeCodes(Args.hasArg(OPT_fansi_escape_codes));
-
-  // Default behavior is to not to show note include stacks.
-  Opts.ShowNoteIncludeStack = false;
-  if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
-                               OPT_fno_diagnostics_show_note_include_stack))
-    if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
-      Opts.ShowNoteIncludeStack = true;
-
-  StringRef ShowOverloads =
-    Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
-  if (ShowOverloads == "best")
-    Opts.setShowOverloads(Ovl_Best);
-  else if (ShowOverloads == "all")
-    Opts.setShowOverloads(Ovl_All);
-  else {
-    Success = false;
-    if (Diags)
-      Diags->Report(diag::err_drv_invalid_value)
-      << Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
-      << ShowOverloads;
-  }
-
-  StringRef ShowCategory =
-    Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
-  if (ShowCategory == "none")
-    Opts.ShowCategories = 0;
-  else if (ShowCategory == "id")
-    Opts.ShowCategories = 1;
-  else if (ShowCategory == "name")
-    Opts.ShowCategories = 2;
-  else {
-    Success = false;
-    if (Diags)
-      Diags->Report(diag::err_drv_invalid_value)
-      << Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
-      << ShowCategory;
-  }
-
-  StringRef Format =
-    Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
-  if (Format == "clang")
-    Opts.setFormat(DiagnosticOptions::Clang);
-  else if (Format == "msvc")
-    Opts.setFormat(DiagnosticOptions::MSVC);
-  else if (Format == "msvc-fallback") {
-    Opts.setFormat(DiagnosticOptions::MSVC);
-    Opts.CLFallbackMode = true;
-  } else if (Format == "vi")
-    Opts.setFormat(DiagnosticOptions::Vi);
-  else {
-    Success = false;
-    if (Diags)
-      Diags->Report(diag::err_drv_invalid_value)
-      << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
-      << Format;
-  }
-
-  Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
-  Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
-  Opts.ShowPresumedLoc = !Args.hasArg(OPT_fno_diagnostics_use_presumed_location);
-  Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
-  DiagnosticLevelMask DiagMask = DiagnosticLevelMask::None;
-  Success &= parseDiagnosticLevelMask("-verify-ignore-unexpected=",
-    Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ),
-    Diags, DiagMask);
-  if (Args.hasArg(OPT_verify_ignore_unexpected))
-    DiagMask = DiagnosticLevelMask::All;
-  Opts.setVerifyIgnoreUnexpected(DiagMask);
-  Opts.ElideType = !Args.hasArg(OPT_fno_elide_type);
-  Opts.ShowTemplateTree = Args.hasArg(OPT_fdiagnostics_show_template_tree);
-  Opts.ErrorLimit = getLastArgIntValue(Args, OPT_ferror_limit, 0, Diags);
-  Opts.MacroBacktraceLimit =
-      getLastArgIntValue(Args, OPT_fmacro_backtrace_limit,
-                         DiagnosticOptions::DefaultMacroBacktraceLimit, Diags);
-  Opts.TemplateBacktraceLimit = getLastArgIntValue(
-      Args, OPT_ftemplate_backtrace_limit,
-      DiagnosticOptions::DefaultTemplateBacktraceLimit, Diags);
-  Opts.ConstexprBacktraceLimit = getLastArgIntValue(
-      Args, OPT_fconstexpr_backtrace_limit,
-      DiagnosticOptions::DefaultConstexprBacktraceLimit, Diags);
-  Opts.SpellCheckingLimit = getLastArgIntValue(
-      Args, OPT_fspell_checking_limit,
-      DiagnosticOptions::DefaultSpellCheckingLimit, Diags);
-  Opts.TabStop = getLastArgIntValue(Args, OPT_ftabstop,
-                                    DiagnosticOptions::DefaultTabStop, Diags);
-  if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
-    Opts.TabStop = DiagnosticOptions::DefaultTabStop;
-    if (Diags)
-      Diags->Report(diag::warn_ignoring_ftabstop_value)
-      << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
-  }
-  Opts.MessageLength = getLastArgIntValue(Args, OPT_fmessage_length, 0, Diags);
-  addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings);
-  addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks);
-
-  return Success;
-}
 
 static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
   Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
 }
 
 /// Parse the argument to the -ftest-module-file-extension
 /// command-line argument.
 ///

lib/Frontend/DiagnosticRenderer.cpp

void DiagnosticRenderer::emitDiagnostic(SourceLocation Loc,
   }
 
   LastLoc = Loc;
   LastLevel = Level;
 
   endDiagnostic(D, Level);
 }
 
+void DiagnosticRenderer::emitDiagnostic(llvm::SMLoc Loc,
+                                        DiagnosticsEngine::Level Level,
+                                        StringRef Message,
+                                        const llvm::SourceMgr *SM,
+                                        DiagOrStoredDiag D) {
+  assert(SM || !Loc.isValid());
+
+  beginDiagnostic(D, Level);
+
+  if (!Loc.isValid()) {
+    emitDiagnosticMessage(SourceLocation(), PresumedLoc(), Level, Message,
+                          ArrayRef<CharSourceRange>(), nullptr, D);
+  } else {
+    emitDiagnosticMessage(Loc, Level, Message, SM, D);
+    emitCaret(Loc, Level, SM);
+  }
+
+  LastSMLoc = Loc;
+  LastLevel = Level;
+
+  endDiagnostic(D, Level);
+}
 
 void DiagnosticRenderer::emitStoredDiagnostic(StoredDiagnostic &Diag) {
   emitDiagnostic(Diag.getLocation(), Diag.getLevel(), Diag.getMessage(),
                  Diag.getRanges(), Diag.getFixIts(),
                  Diag.getLocation().isValid() ? &Diag.getLocation().getManager()
                                               : nullptr,
                  &Diag);
 }
void DiagnosticRenderer::emitCaret(SourceLocation Loc,
                                    ArrayRef<CharSourceRange> Ranges,
                                    ArrayRef<FixItHint> Hints,
                                    const SourceManager &SM) {
   SmallVector<CharSourceRange, 4> SpellingRanges;
   mapDiagnosticRanges(Loc, Ranges, SpellingRanges, &SM);
   emitCodeContext(Loc, Level, SpellingRanges, Hints, SM);
 }
 
+void DiagnosticRenderer::emitCaret(llvm::SMLoc Loc,
+                                   DiagnosticsEngine::Level Level,
+                                   const llvm::SourceMgr *SM) {
+  emitCodeContext(Loc, Level, SM);
+}
+
 /// \brief A helper function for emitMacroExpansion to print the
 /// macro expansion message
 void DiagnosticRenderer::emitSingleMacroExpansion(
     SourceLocation Loc,
     DiagnosticsEngine::Level Level,
     ArrayRef<CharSourceRange> Ranges,
     const SourceManager &SM) {
   // Find the spelling location for the macro definition. We must use the

lib/Frontend/TextDiagnostic.cpp

TextDiagnostic::emitDiagnosticMessage(SourceLocation Loc,
   printDiagnosticLevel(OS, Level, DiagOpts->ShowColors,
                        DiagOpts->CLFallbackMode);
   printDiagnosticMessage(OS,
                          /*IsSupplemental*/ Level == DiagnosticsEngine::Note,
                          Message, OS.tell() - StartOfLocationInfo,
                          DiagOpts->MessageLength, DiagOpts->ShowColors);
 }
 
+void TextDiagnostic::emitDiagnosticMessage(llvm::SMLoc Loc,
+                                           DiagnosticsEngine::Level Level,
+                                           StringRef Message,
+                                           const llvm::SourceMgr *SM,
+                                           DiagOrStoredDiag D) {
+  uint64_t StartOfLocationInfo = OS.tell();
+
+  // Emit the location of this particular diagnostic.
+  if (Loc.isValid())
+    emitDiagnosticLoc(Loc, Level, SM);
+
+  if (DiagOpts->ShowColors)
+    OS.resetColor();
+
+  printDiagnosticLevel(OS, Level, DiagOpts->ShowColors,
+                       DiagOpts->CLFallbackMode);
+  printDiagnosticMessage(OS,
+                         /*IsSupplemental*/ Level == DiagnosticsEngine::Note,
+                         Message, OS.tell() - StartOfLocationInfo,
+                         DiagOpts->MessageLength, DiagOpts->ShowColors);
+}
+
 /*static*/ void
 TextDiagnostic::printDiagnosticLevel(raw_ostream &OS,
                                      DiagnosticsEngine::Level Level,
                                      bool ShowColors,
                                      bool CLFallbackMode) {
   if (ShowColors) {
     // Print diagnostic category in bold and color
     switch (Level) {
if (Dir) {
                               llvm::sys::path::filename(Filename));
       Filename = StringRef(AbsoluteFilename.data(), AbsoluteFilename.size());
     }
   }
 
   OS << Filename;
 }
 
+void TextDiagnostic::emitFilename(StringRef Filename, const llvm::SourceMgr *) {
+  // FIXME: Use the llvm::SourceMgr to support DiagOpts->AbsolutePath.
+
+  OS << Filename;
+}
+
+void TextDiagnostic::emitDiagnosticLoc(llvm::SMLoc Loc,
+                                       DiagnosticsEngine::Level Level,
+                                       const llvm::SourceMgr *SM) {
+  unsigned LineNo, ColNo;
+  std::tie(LineNo, ColNo) = SM->getLineAndColumn(Loc);
+
+  if (!DiagOpts->ShowLocation)
+    return;
+
+  if (DiagOpts->ShowColors)
+    OS.changeColor(savedColor, true);
+
+  unsigned CurBuf = SM->FindBufferContainingLoc(Loc);
+  assert(CurBuf && "Invalid or unspecified location!");
+
+  const llvm::MemoryBuffer *CurMB = SM->getMemoryBuffer(CurBuf);
+  emitFilename(CurMB->getBufferIdentifier(), SM);
+
+  switch (DiagOpts->getFormat()) {
+  case DiagnosticOptions::Clang:
+    OS << ':' << LineNo;
+    break;
+  case DiagnosticOptions::MSVC:
+    OS << '(' << LineNo;
+    break;
+  case DiagnosticOptions::Vi:
+    OS << " +" << LineNo;
+    break;
+  }
+
+  if (DiagOpts->ShowColumn)
+    // Compute the column number.
+    if (ColNo) {
+      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::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))
+      OS << ' ';
+    OS << ": ";
+    break;
+  }
+
+  OS << ' ';
+}
+
 /// \brief Print out the file/line/column information and include trace.
 ///
 /// This method handlen the emission of the diagnostic location information.
 /// This includes extracting as much location information as is present for
 /// the diagnostic and printing it, as well as any include stack or source
 /// ranges necessary.
 void TextDiagnostic::emitDiagnosticLoc(SourceLocation Loc, PresumedLoc PLoc,
                                        DiagnosticsEngine::Level Level,
for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
     }
   }
 
   expandTabs(FixItInsertionLine, DiagOpts->TabStop);
 
   return FixItInsertionLine;
 }
 
+void TextDiagnostic::emitSnippetAndCaret(llvm::SMLoc Loc,
+                                         DiagnosticsEngine::Level Level,
+                                         const llvm::SourceMgr *SM) {
+  assert(Loc.isValid() && "must have a valid source location here");
+
+  // If caret diagnostics are enabled and we have location, we want to
+  // emit the caret.  However, we only do this if the location moved
+  // from the last diagnostic, if the last diagnostic was a note that
+  // was part of a different warning or error diagnostic, or if the
+  // diagnostic has ranges.  We don't want to emit the same caret
+  // multiple times if one loc has multiple diagnostics.
+  if (!DiagOpts->ShowCarets)
+    return;
+  if (Loc == LastSMLoc /*&& Ranges.empty() && Hints.empty()*/ &&
+      (LastLevel != DiagnosticsEngine::Note || Level == LastLevel))
+    return;
+
+  unsigned BufID = SM->FindBufferContainingLoc(Loc);
+  const llvm::MemoryBuffer *Buf = SM->getMemoryBuffer(BufID);
+
+  if (!Buf)
+    return;
+
+  const char *BufEnd = Buf->getBufferEnd();
+
+  unsigned LineNo, ColNo;
+  std::tie(LineNo, ColNo) = SM->getLineAndColumn(Loc);
+
+  // Arbitrarily stop showing snippets when the line is too long.
+  static const size_t MaxLineLengthToPrint = 4096;
+  if (ColNo > MaxLineLengthToPrint)
+    return;
+
+  // Rewind from the current position to the start of the line.
+  const char *TokPtr = Loc.getPointer();
+  const char *LineStart = TokPtr - ColNo + 1; // Column # is 1-based.
+
+  // Compute the line end.  Scan forward from the error position to the end of
+  // the line.
+  const char *LineEnd = TokPtr;
+  while (*LineEnd != '\n' && *LineEnd != '\r' && LineEnd != BufEnd)
+    ++LineEnd;
+
+  // Arbitrarily stop showing snippets when the line is too long.
+  if (size_t(LineEnd - LineStart) > MaxLineLengthToPrint)
+    return;
+
+  // Trim trailing null-bytes.
+  StringRef Line(LineStart, LineEnd - LineStart);
+  while (Line.size() > ColNo && Line.back() == '\0')
+    Line = Line.drop_back();
+
+  // Copy the line of code into an std::string for ease of manipulation.
+  std::string SourceLine(Line.begin(), Line.end());
+
+  // Build the byte to column map.
+  const SourceColumnMap sourceColMap(SourceLine, DiagOpts->TabStop);
+
+  // Create a line for the caret that is filled with spaces that is the same
+  // number of columns as the line of source code.
+  std::string CaretLine(sourceColMap.columns(), ' ');
+
+  ColNo = sourceColMap.byteToContainingColumn(ColNo - 1);
+  if (CaretLine.size() < ColNo + 1)
+    CaretLine.resize(ColNo + 1, ' ');
+  CaretLine[ColNo] = '^';
+
+  // If we are in -fdiagnostics-print-source-range-info mode, we are trying
+  // to produce easily machine parsable output.  Add a space before the
+  // source line and the caret to make it trivial to tell the main diagnostic
+  // line from what the user is intended to see.
+  if (DiagOpts->ShowSourceRanges) {
+    SourceLine = ' ' + SourceLine;
+    CaretLine = ' ' + CaretLine;
+  }
+
+  // Finally, remove any blank spaces from the end of CaretLine.
+  while (CaretLine[CaretLine.size() - 1] == ' ')
+    CaretLine.erase(CaretLine.end() - 1);
+
+  // Emit what we have computed.
+  emitSnippet(SourceLine);
+
+  if (DiagOpts->ShowColors)
+    OS.changeColor(caretColor, true);
+  OS << CaretLine << '\n';
+  if (DiagOpts->ShowColors)
+    OS.resetColor();
+}
+
 /// \brief Emit a code snippet and caret line.
 ///
 /// This routine emits a single line's code snippet and caret line..
 ///
 /// \param Loc The location for the caret.
 /// \param Ranges The underlined ranges for this code snippet.
 /// \param Hints The FixIt hints active for this diagnostic.
 void TextDiagnostic::emitSnippetAndCaret(

lib/Frontend/TextDiagnosticPrinter.cpp

void TextDiagnosticPrinter::HandleDiagnostic(DiagnosticsEngine::Level Level,
 
   if (!Prefix.empty())
     OS << Prefix << ": ";
 
   // Use a dedicated, simpler path for diagnostics without a valid location.
   // This is important as if the location is missing, we may be emitting
   // diagnostics in a context that lacks language options, a source manager, or
   // other infrastructure necessary when emitting more rich diagnostics.
-  if (!Info.getLocation().isValid()) {
+  if (!Info.getLocation().isValid() && !Info.getLLVMLocation().isValid()) {
     TextDiagnostic::printDiagnosticLevel(OS, Level, DiagOpts->ShowColors,
                                          DiagOpts->CLFallbackMode);
     TextDiagnostic::printDiagnosticMessage(OS, Level, DiagMessageStream.str(),
                                            OS.tell() - StartOfLocationInfo,
                                            DiagOpts->MessageLength,
                                            DiagOpts->ShowColors);
     OS.flush();
     return;
   }
 
   // Assert that the rest of our infrastructure is setup properly.
   assert(DiagOpts && "Unexpected diagnostic without options set");
+  assert(TextDiag && "Unexpected diagnostic outside source file processing");
+
+  if (Info.getLocation().isValid()) {
     assert(Info.hasSourceManager() &&
            "Unexpected diagnostic with no source manager");
-  assert(TextDiag && "Unexpected diagnostic outside source file processing");
 
     TextDiag->emitDiagnostic(Info.getLocation(), Level, DiagMessageStream.str(),
-                           Info.getRanges(),
-                           Info.getFixItHints(),
+                             Info.getRanges(), Info.getFixItHints(),
                              &Info.getSourceManager());
 
     OS.flush();
+    return;
+  }
+
+  assert(Info.hasLLVMSourceManager() &&
+         "Unexpected diagnostic with no source manager");
+  TextDiag->emitDiagnostic(Info.getLLVMLocation(), Level,
+                           DiagMessageStream.str(),
+                           Info.getLLVMSourceManager());
+  OS.flush();
 }

tools/driver/cc1as_main.cpp

 //===-- cc1as_main.cpp - Clang Assembler  ---------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the entry point to the clang -cc1as functionality, which implements
 // the direct interface to the LLVM MC based assembler.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Basic/FileManager.h"
+#include "clang/Basic/FileSystemOptions.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/SourceManager.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"

 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 #include <system_error>
bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
   Opts.CompressDebugSections = Args.hasArg(OPT_compress_debug_sections);
   Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
   Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 2, Diags);
   Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
   Opts.DwarfDebugProducer = Args.getLastArgValue(OPT_dwarf_debug_producer);
   Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
   Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
 
+  ParseDiagnosticArgs(Diags.getDiagnosticOptions(), Args, &Diags, false, false);
+
   // Frontend Options
   if (Args.hasArg(OPT_INPUT)) {
     bool First = true;
     for (const Arg *A : Args.filtered(OPT_INPUT)) {
       if (First) {
         Opts.InputFile = A->getValue();
         First = false;
       } else {
if (EC) {
     Diags.Report(diag::err_fe_unable_to_open_output) << Opts.OutputPath
                                                      << EC.message();
     return nullptr;
   }
 
   return Out;
 }
 
+struct DiagsHandlerContext {
+  DiagnosticsEngine &Diags;
+  const SourceMgr *SrcMgr;
+};
+
+static void AssemblerDiagsHandler(const SMDiagnostic &D, void *Context) {
+  auto &Diags = *static_cast<DiagnosticsEngine *>(Context);
+  unsigned DiagID;
+  switch (D.getKind()) {
+  case llvm::SourceMgr::DK_Error:
+    DiagID = diag::err_fe_inline_asm;
+    break;
+  case llvm::SourceMgr::DK_Warning:
+    DiagID = diag::warn_fe_inline_asm;
+    break;
+  case llvm::SourceMgr::DK_Note:
+    DiagID = diag::note_fe_inline_asm;
+    break;
+  }
+
+  Diags.Report(D.getSourceMgr(), D.getLoc(), DiagID) << D.getMessage();
+}
+
 static bool ExecuteAssembler(AssemblerInvocation &Opts,
                              DiagnosticsEngine &Diags) {
   // Get the target specific parser.
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(Opts.Triple, Error);
   if (!TheTarget)
     return Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;
 
static bool ExecuteAssembler(AssemblerInvocation &Opts,
 
   // Tell SrcMgr about this buffer, which is what the parser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*Buffer), SMLoc());
 
   // Record the location of the include directories so that the lexer can find
   // it later.
   SrcMgr.setIncludeDirs(Opts.IncludePaths);
 
+  SrcMgr.setDiagHandler(AssemblerDiagsHandler, &Diags);
+
   std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(Opts.Triple));
   assert(MRI && "Unable to create target register info!");
 
   std::unique_ptr<MCAsmInfo> MAI(TheTarget->createMCAsmInfo(*MRI, Opts.Triple));
   assert(MAI && "Unable to create target asm info!");
 
   // Ensure MCAsmInfo initialization occurs before any use, otherwise sections
   // may be created with a combination of default and explicit settings.
int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllAsmParsers();
 
   // Construct our diagnostic client.
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   TextDiagnosticPrinter *DiagClient
     = new TextDiagnosticPrinter(errs(), &*DiagOpts);
-  DiagClient->setPrefix("clang -cc1as");
+  // DiagClient->setPrefix("clang -cc1as");
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
 
   // Set an error handler, so that any LLVM backend diagnostics go through our
   // error handler.
   ScopedFatalErrorHandler FatalErrorHandler
     (LLVMErrorHandler, static_cast<void*>(&Diags));
 
if (!Asm.LLVMArgs.empty()) {
     const char **Args = new const char*[NumArgs + 2];
     Args[0] = "clang (LLVM option parsing)";
     for (unsigned i = 0; i != NumArgs; ++i)
       Args[i + 1] = Asm.LLVMArgs[i].c_str();
     Args[NumArgs + 1] = nullptr;
     llvm::cl::ParseCommandLineOptions(NumArgs + 1, Args);
   }
 
+  ProcessWarningOptions(Diags, Diags.getDiagnosticOptions(), true);
+
+  LangOptions LangOpts;
+  DiagClient->BeginSourceFile(LangOpts, nullptr);
+
   // Execute the invocation, unless there were parsing errors.
   bool Failed = Diags.hasErrorOccurred() || ExecuteAssembler(Asm, Diags);
 
+  DiagClient->EndSourceFile();
+
+  // Notify the diagnostic client that all files were processed.
+  Diags.getClient()->finish();
+
+  if (Diags.getDiagnosticOptions().ShowCarets) {
+    // We can have multiple diagnostics sharing one diagnostic client.
+    // Get the total number of warnings/errors from the client.
+    unsigned NumWarnings = Diags.getClient()->getNumWarnings();
+    unsigned NumErrors = Diags.getClient()->getNumErrors();
+
+    if (NumWarnings)
+      errs() << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
+    if (NumWarnings && NumErrors)
+      errs() << " and ";
+    if (NumErrors)
+      errs() << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
+    if (NumWarnings || NumErrors)
+      errs() << " generated.\n";
+  }
+
   // If any timers were active but haven't been destroyed yet, print their
   // results now.
   TimerGroup::printAll(errs());
 
   return !!Failed;
 }