added passing -fdiagnostics-format option from clang driver to cc1as (PR36117)

[kbelochapka]

Summary

in order to facilitate uniform diagnostic message format between clang and llvm,
clang driver now passes the following options: -fdiagnostics-format, -fshow-column, -fms-compatibility-version to cc1as.

this fix consists of two parts, first one for llvm and the second part for clang.
this code review takes care of clang part, llvm part is here: https://reviews.llvm.org/D42677

include/clang/Driver/Options.td

def fdiagnostics_show_hotness : Flag<["-"], "fdiagnostics-show-hotness">, Group<f_Group>,
     Flags<[CC1Option]>, HelpText<"Enable profile hotness information in diagnostic line">;
 def fdiagnostics_hotness_threshold_EQ : Joined<["-"], "fdiagnostics-hotness-threshold=">,
     Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<number>">,
     HelpText<"Prevent optimization remarks from being output if they do not have at least this profile count">;
 def fdiagnostics_show_option : Flag<["-"], "fdiagnostics-show-option">, Group<f_Group>,
     Flags<[CC1Option]>, HelpText<"Print option name with mappable diagnostics">;
 def fdiagnostics_show_note_include_stack : Flag<["-"], "fdiagnostics-show-note-include-stack">,
     Group<f_Group>,  Flags<[CC1Option]>, HelpText<"Display include stacks for diagnostic notes">;
-def fdiagnostics_format_EQ : Joined<["-"], "fdiagnostics-format=">, Group<f_clang_Group>;
+def fdiagnostics_format_EQ : Joined<["-"], "fdiagnostics-format=">, Group<f_clang_Group>, Flags<[CC1Option, CC1AsOption]>;
 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">;
 def fdeclspec : Flag<["-"], "fdeclspec">, Group<f_clang_Group>,
   HelpText<"Allow __declspec as a keyword">, Flags<[CC1Option]>;
 def fdollars_in_identifiers : Flag<["-"], "fdollars-in-identifiers">, Group<f_Group>,
   HelpText<"Allow '$' in identifiers">, Flags<[CC1Option]>;

 def fms_compatibility : Flag<["-"], "fms-compatibility">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
   HelpText<"Enable full Microsoft Visual C++ compatibility">;
 def fms_volatile : Joined<["-"], "fms-volatile">, Group<f_Group>, Flags<[CC1Option]>;
 def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[DriverOption, CoreOption]>,
   HelpText<"Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))">;
 def fms_compatibility_version
     : Joined<["-"], "fms-compatibility-version=">,
       Group<f_Group>,
-      Flags<[ CC1Option, CoreOption ]>,
+      Flags<[ CC1Option, CoreOption, CC1AsOption ]>,
       HelpText<"Dot-separated value representing the Microsoft compiler "
                "version number to report in _MSC_VER (0 = don't define it "
                "(default))">;
 def fdelayed_template_parsing : Flag<["-"], "fdelayed-template-parsing">, Group<f_Group>,
   HelpText<"Parse templated function definitions at the end of the "
            "translation unit">,  Flags<[CC1Option, CoreOption]>;
 def fms_memptr_rep_EQ : Joined<["-"], "fms-memptr-rep=">, Group<f_Group>, Flags<[CC1Option]>;
 def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>,

 def fno_omit_frame_pointer : Flag<["-"], "fno-omit-frame-pointer">, Group<f_Group>;
 def fno_operator_names : Flag<["-"], "fno-operator-names">, Group<f_Group>,
   HelpText<"Do not treat C++ operator name keywords as synonyms for operators">,
   Flags<[CC1Option]>;
 def fno_pascal_strings : Flag<["-"], "fno-pascal-strings">, Group<f_Group>;
 def fno_rtti : Flag<["-"], "fno-rtti">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Disable generation of rtti information">;
 def fno_short_enums : Flag<["-"], "fno-short-enums">, Group<f_Group>;
-def fno_show_column : Flag<["-"], "fno-show-column">, Group<f_Group>, Flags<[CC1Option]>,
+def fno_show_column : Flag<["-"], "fno-show-column">, Group<f_Group>, Flags<[CC1Option, CC1AsOption]>,
   HelpText<"Do not include column number on diagnostics">;
 def fno_show_source_location : Flag<["-"], "fno-show-source-location">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Do not include source location information with diagnostics">;
 def fdiagnostics_absolute_paths : Flag<["-"], "fdiagnostics-absolute-paths">, Group<f_Group>,
   Flags<[CC1Option, CoreOption]>, HelpText<"Print absolute paths in diagnostics">;
 def fno_spell_checking : Flag<["-"], "fno-spell-checking">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Disable spell-checking">;
 def fno_stack_protector : Flag<["-"], "fno-stack-protector">, Group<f_Group>,

lib/Driver/ToolChains/Clang.cpp

for (const Arg *A :
     }
   }
   if (UseRelaxRelocations)
     CmdArgs.push_back("--mrelax-relocations");
   if (MipsTargetFeature != nullptr) {
     CmdArgs.push_back("-target-feature");
     CmdArgs.push_back(MipsTargetFeature);
   }
+
+  if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
+    CmdArgs.push_back(
+        Args.MakeArgString(Twine("-fdiagnostics-format=") + A->getValue()));
+  }
+
+  if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
+                    true))
+    CmdArgs.push_back("-fno-show-column");
+
+  VersionTuple MSVT = C.getDefaultToolChain().computeMSVCVersion(&D, Args);
+  if (!MSVT.empty())
+    CmdArgs.push_back(
+        Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
 }
 
 static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
                                        bool OFastEnabled, const ArgList &Args,
                                        ArgStringList &CmdArgs) {
   // Handle various floating point optimization flags, mapping them to the
   // appropriate LLVM code generation flags. This is complicated by several
   // "umbrella" flags, so we do this by stepping through the flags incrementally

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/VersionTuple.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"
struct AssemblerInvocation {
   /// @name Assembler Options
   /// @{
 
   unsigned RelaxAll : 1;
   unsigned NoExecStack : 1;
   unsigned FatalWarnings : 1;
   unsigned IncrementalLinkerCompatible : 1;
 
+  unsigned ShowColumn : 1;
   /// The name of the relocation model to use.
   std::string RelocationModel;
+  std::string DiagnosticsFormat;
+  SourceMgr::TextDiagnosticFormat DiagnosticFormat;
+  unsigned MsvcMajorVersion;
+  unsigned MsvcMinorVersion;
 
   /// @}
 
 public:
   AssemblerInvocation() {
     Triple = "";
     NoInitialTextSection = 0;
     InputFile = "-";
     OutputPath = "-";
     OutputType = FT_Asm;
     OutputAsmVariant = 0;
     ShowInst = 0;
     ShowEncoding = 0;
     RelaxAll = 0;
     NoExecStack = 0;
     FatalWarnings = 0;
     IncrementalLinkerCompatible = 0;
     DwarfVersion = 0;
+    DiagnosticFormat = SourceMgr::TextDiagnosticFormat::Clang;
+    MsvcMajorVersion = 13;
+    MsvcMinorVersion = 0;
   }
 
   static bool CreateFromArgs(AssemblerInvocation &Res,
                              ArrayRef<const char *> Argv,
                              DiagnosticsEngine &Diags);
 };
 
 }
bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
   Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
   Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
   Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
   Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
   Opts.IncrementalLinkerCompatible =
       Args.hasArg(OPT_mincremental_linker_compatible);
   Opts.SymbolDefs = Args.getAllArgValues(OPT_defsym);
 
+  if (const Arg *A = Args.getLastArg(OPT_fdiagnostics_format_EQ)) {
+    Opts.DiagnosticsFormat = A->getValue();
+  } else {
+    Opts.DiagnosticsFormat = "clang";
+  }
+
+  Opts.ShowColumn = Args.hasFlag(OPT_fshow_column, OPT_fno_show_column,
+                                 /*Default=*/true);
+
+  const Arg *MSCompatibilityVersion =
+      Args.getLastArg(options::OPT_fms_compatibility_version);
+
+  if (MSCompatibilityVersion) {
+    VersionTuple MSVT;
+    if (MSVT.tryParse(MSCompatibilityVersion->getValue())) {
+      Diags.Report(diag::err_drv_invalid_value)
+          << MSCompatibilityVersion->getAsString(Args)
+          << MSCompatibilityVersion->getValue();
+      Success = false;
+    } else {
+      Opts.MsvcMajorVersion = MSVT.getMajor();
+      Opts.MsvcMinorVersion = MSVT.getMinor().getValueOr<unsigned>(0);
+    }
+  }
+
   return Success;
 }
 
 static std::unique_ptr<raw_fd_ostream>
 getOutputStream(AssemblerInvocation &Opts, DiagnosticsEngine &Diags,
                 bool Binary) {
   if (Opts.OutputPath.empty())
     Opts.OutputPath = "-";
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);
 
+  if (Opts.DiagnosticsFormat == "vi") {
+    SrcMgr.DiagnosticFormat = SourceMgr::TextDiagnosticFormat::Vi;
+  } else if (Opts.DiagnosticsFormat == "msvc" ||
+             Opts.DiagnosticsFormat == "msvc-fallback") {
+    SrcMgr.DiagnosticFormat = SourceMgr::TextDiagnosticFormat::MSVC;
+  } else {
+    SrcMgr.DiagnosticFormat = SourceMgr::TextDiagnosticFormat::Clang;
+  }
+
+  SrcMgr.ShowColumn = (Opts.ShowColumn) ? true : false;
+
+  switch (Opts.MsvcMajorVersion) {
+  case 10:
+    SrcMgr.MsvcVersion = SourceMgr::MSVCVersion::MSVC40;
+    break;
+  case 11:
+    SrcMgr.MsvcVersion = SourceMgr::MSVCVersion::MSVC97;
+    break;
+  case 12:
+    SrcMgr.MsvcVersion = SourceMgr::MSVCVersion::MSVC60;
+    break;
+  case 13:
+    SrcMgr.MsvcVersion = (Opts.MsvcMinorVersion == 0)
+                             ? SourceMgr::MSVCVersion::MSVC2002
+                             : SourceMgr::MSVCVersion::MSVC2003;
+    break;
+  case 14:
+    SrcMgr.MsvcVersion = SourceMgr::MSVCVersion::MSVC2005;
+    break;
+  case 15:
+    SrcMgr.MsvcVersion = SourceMgr::MSVCVersion::MSVC2008;
+    break;
+  case 16:
+    SrcMgr.MsvcVersion = SourceMgr::MSVCVersion::MSVC2010;
+    break;
+  case 17:
+    SrcMgr.MsvcVersion = SourceMgr::MSVCVersion::MSVC2012;
+    break;
+  case 18:
+    SrcMgr.MsvcVersion = SourceMgr::MSVCVersion::MSVC2013;
+    break;
+  case 19:
+    SrcMgr.MsvcVersion = (Opts.MsvcMinorVersion == 0)
+                             ? SourceMgr::MSVCVersion::MSVC2015
+                             : SourceMgr::MSVCVersion::MSVC2017;
+    break;
+  }
+
   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.