Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 1 of 2.

3 files changed, 345 insertions, 345 deletions

diff --git a/contrib/libs/llvm12/tools/llvm-ml/Opts.td b/contrib/libs/llvm12/tools/llvm-ml/Opts.td
index 4c2757b057..4e4766484d 100644
--- a/contrib/libs/llvm12/tools/llvm-ml/Opts.td
+++ b/contrib/libs/llvm12/tools/llvm-ml/Opts.td
@@ -1,110 +1,110 @@
-include "llvm/Option/OptParser.td"
-
-// For LLVM-specific options, we prefer a two-dash prefix, but accept one for
-// compatibility with llvm-mc. For clear separation from ML.EXE compatible
-// options, slash is not accepted.
-class LLVMFlag<string name> : Flag<["--", "-"], name>;
-class LLVMJoined<string name> : Joined<["--", "-"], name>;
-class LLVMJoinedOrSeparate<string name> : JoinedOrSeparate<["--", "-"], name>;
-class LLVMSeparate<string name> : Separate<["--", "-"], name>;
-
-def ml_Group : OptionGroup<"<ml options>">,
-               HelpText<"ML.EXE COMPATIBILITY OPTIONS">;
-class MLFlag<string name> : Flag<["/", "-"], name>, Group<ml_Group>;
-class MLJoined<string name> : Joined<["/", "-"], name>, Group<ml_Group>;
-class MLJoinedOrSeparate<string name> : JoinedOrSeparate<["/", "-"], name>,
-                                        Group<ml_Group>;
-class MLSeparate<string name> : Separate<["/", "-"], name>, Group<ml_Group>;
-
-def unsupported_Group : OptionGroup<"unsupported">, Flags<[HelpHidden]>,
-                        HelpText<"UNSUPPORTED ML.EXE COMPATIBILITY OPTIONS">;
-class UnsupportedFlag<string name> : Flag<["/", "-"], name>,
-                                     Group<unsupported_Group>;
-class UnsupportedJoined<string name> : Joined<["/", "-"], name>,
-                                       Group<unsupported_Group>;
-class UnsupportedJoinedOrSeparate<string name> :
-        JoinedOrSeparate<["/", "-"], name>, Group<unsupported_Group>;
-class UnsupportedSeparate<string name> : Separate<["/", "-"], name>,
-                                         Group<unsupported_Group>;
-
-def help : MLFlag<"?">,
-           HelpText<"Display available options">;
-def help_long : MLFlag<"help">, Alias<help>;
-def assemble_only : MLFlag<"c">, HelpText<"Assemble only; do not link">;
-def define : MLJoinedOrSeparate<"D">, MetaVarName<"<macro>=<value>">,
-             HelpText<"Define <macro> to <value> (or blank if <value> "
-                      "omitted)">;
-def output_file : MLJoinedOrSeparate<"Fo">, HelpText<"Names the output file">;
-def include_path : MLJoinedOrSeparate<"I">,
-                   HelpText<"Sets path for include files">;
-def safeseh : MLFlag<"safeseh">,
-              HelpText<"Mark resulting object files as either containing no "
-                       "exception handlers or containing exception handlers "
-                       "that are all declared with .SAFESEH. Only available in "
-                       "32-bit.">;
-def assembly_file : MLJoinedOrSeparate<"Ta">,
-                    HelpText<"Assemble source file with name not ending with "
-                             "the .asm extension">;
-
-def bitness : LLVMJoined<"m">, Values<"32,64">,
-              HelpText<"Target platform (x86 or x86-64)">;
-def as_lex : LLVMFlag<"as-lex">,
-             HelpText<"Lex tokens from a .asm file without assembling">;
-def filetype : LLVMJoined<"filetype=">, Values<"obj,s,null">,
-               HelpText<"Emit a file with the given type">;
-def output_att_asm : LLVMFlag<"output-att-asm">,
-                     HelpText<"Use ATT syntax for output assembly">;
-def show_encoding : LLVMFlag<"show-encoding">,
-                    HelpText<"Show instruction encodings in output assembly">;
-def show_inst : LLVMFlag<"show-inst">,
-                HelpText<"Show internal instruction representation in output "
-                         "assembly">;
-def show_inst_operands : LLVMFlag<"show-inst-operands">,
-                         HelpText<"Show instructions operands as parsed">;
-def print_imm_hex : LLVMFlag<"print-imm-hex">,
-                    HelpText<"Prefer hex format for immediate values in output "
-                             "assembly">;
-def preserve_comments : LLVMFlag<"preserve-comments">,
-                        HelpText<"Preserve comments in output assembly">;
-def save_temp_labels : LLVMFlag<"save-temp-labels">,
-                       HelpText<"Don't discard temporary labels">;
-
-def tiny_model_support : UnsupportedFlag<"AT">, HelpText<"">;
-def alternate_linker : UnsupportedJoined<"Bl">, HelpText<"">;
-def coff_object_file : UnsupportedFlag<"coff">, HelpText<"">;
-def preserve_identifier_case : UnsupportedFlag<"Cp">, HelpText<"">;
-def uppercase_identifiers : UnsupportedFlag<"Cu">, HelpText<"">;
-def preserve_extern_case : UnsupportedFlag<"Cx">, HelpText<"">;
-def output_preprocessed : UnsupportedFlag<"EP">, HelpText<"">;
-def errorreport : UnsupportedJoined<"ERRORREPORT">, HelpText<"">;
-def stacksize : UnsupportedSeparate<"F">, HelpText<"">;
-def executable_file : UnsupportedSeparate<"Fe">, HelpText<"">;
-def code_listing_file : UnsupportedJoined<"FI">, HelpText<"">;
-def linker_map_file : UnsupportedJoined<"Fm">, HelpText<"">;
-def fp_emulator_fixups : UnsupportedFlag<"FPi">, HelpText<"">;
-def source_browser_file : UnsupportedJoined<"Fr">, HelpText<"">;
-def extended_source_browser_file : UnsupportedJoined<"FR">, HelpText<"">;
-def pascal_conventions : UnsupportedFlag<"Gc">, HelpText<"">;
-def c_conventions : UnsupportedFlag<"Gd">, HelpText<"">;
-def stdcall_conventions : UnsupportedFlag<"GZ">, HelpText<"">;
-def extern_name_limit : UnsupportedSeparate<"H">, HelpText<"">;
-def nologo : UnsupportedFlag<"nologo">, HelpText<"">;
-def omf_object_file : UnsupportedFlag<"omf">, HelpText<"">;
-def full_listing : UnsupportedFlag<"Sa">, HelpText<"">;
-def first_pass_listing : UnsupportedFlag<"Sf">, HelpText<"">;
-def listing_width : UnsupportedSeparate<"SI">, HelpText<"">;
-def listing_without_symbols : UnsupportedFlag<"Sn">, HelpText<"">;
-def listing_page_length : UnsupportedSeparate<"Sp">, HelpText<"">;
-def listing_subtitle : UnsupportedSeparate<"Ss">, HelpText<"">;
-def listing_title : UnsupportedSeparate<"St">, HelpText<"">;
-def listing_false_conditionals : UnsupportedFlag<"Sx">, HelpText<"">;
-def extra_warnings : UnsupportedFlag<"w">, HelpText<"">;
-def warning_level : UnsupportedJoined<"W">, HelpText<"">;
-def error_on_warning : UnsupportedFlag<"WX">, HelpText<"">;
-def ignore_include_envvar : UnsupportedFlag<"X">, HelpText<"">;
-def line_number_info : UnsupportedFlag<"Zd">, HelpText<"">;
-def export_all_symbols : UnsupportedFlag<"Zf">, HelpText<"">;
-def codeview_info : UnsupportedFlag<"Zi">, HelpText<"">;
-def enable_m510_option : UnsupportedFlag<"Zm">, HelpText<"">;
-def structure_packing : UnsupportedJoined<"Zp">, HelpText<"">;
-def parse_only : UnsupportedFlag<"Zs">, HelpText<"">;
+include "llvm/Option/OptParser.td" 
+ 
+// For LLVM-specific options, we prefer a two-dash prefix, but accept one for 
+// compatibility with llvm-mc. For clear separation from ML.EXE compatible 
+// options, slash is not accepted. 
+class LLVMFlag<string name> : Flag<["--", "-"], name>; 
+class LLVMJoined<string name> : Joined<["--", "-"], name>; 
+class LLVMJoinedOrSeparate<string name> : JoinedOrSeparate<["--", "-"], name>; 
+class LLVMSeparate<string name> : Separate<["--", "-"], name>; 
+ 
+def ml_Group : OptionGroup<"<ml options>">, 
+               HelpText<"ML.EXE COMPATIBILITY OPTIONS">; 
+class MLFlag<string name> : Flag<["/", "-"], name>, Group<ml_Group>; 
+class MLJoined<string name> : Joined<["/", "-"], name>, Group<ml_Group>; 
+class MLJoinedOrSeparate<string name> : JoinedOrSeparate<["/", "-"], name>, 
+                                        Group<ml_Group>; 
+class MLSeparate<string name> : Separate<["/", "-"], name>, Group<ml_Group>; 
+ 
+def unsupported_Group : OptionGroup<"unsupported">, Flags<[HelpHidden]>, 
+                        HelpText<"UNSUPPORTED ML.EXE COMPATIBILITY OPTIONS">; 
+class UnsupportedFlag<string name> : Flag<["/", "-"], name>, 
+                                     Group<unsupported_Group>; 
+class UnsupportedJoined<string name> : Joined<["/", "-"], name>, 
+                                       Group<unsupported_Group>; 
+class UnsupportedJoinedOrSeparate<string name> : 
+        JoinedOrSeparate<["/", "-"], name>, Group<unsupported_Group>; 
+class UnsupportedSeparate<string name> : Separate<["/", "-"], name>, 
+                                         Group<unsupported_Group>; 
+ 
+def help : MLFlag<"?">, 
+           HelpText<"Display available options">; 
+def help_long : MLFlag<"help">, Alias<help>; 
+def assemble_only : MLFlag<"c">, HelpText<"Assemble only; do not link">; 
+def define : MLJoinedOrSeparate<"D">, MetaVarName<"<macro>=<value>">, 
+             HelpText<"Define <macro> to <value> (or blank if <value> " 
+                      "omitted)">; 
+def output_file : MLJoinedOrSeparate<"Fo">, HelpText<"Names the output file">; 
+def include_path : MLJoinedOrSeparate<"I">, 
+                   HelpText<"Sets path for include files">; 
+def safeseh : MLFlag<"safeseh">, 
+              HelpText<"Mark resulting object files as either containing no " 
+                       "exception handlers or containing exception handlers " 
+                       "that are all declared with .SAFESEH. Only available in " 
+                       "32-bit.">; 
+def assembly_file : MLJoinedOrSeparate<"Ta">, 
+                    HelpText<"Assemble source file with name not ending with " 
+                             "the .asm extension">; 
+ 
+def bitness : LLVMJoined<"m">, Values<"32,64">, 
+              HelpText<"Target platform (x86 or x86-64)">; 
+def as_lex : LLVMFlag<"as-lex">, 
+             HelpText<"Lex tokens from a .asm file without assembling">; 
+def filetype : LLVMJoined<"filetype=">, Values<"obj,s,null">, 
+               HelpText<"Emit a file with the given type">; 
+def output_att_asm : LLVMFlag<"output-att-asm">, 
+                     HelpText<"Use ATT syntax for output assembly">; 
+def show_encoding : LLVMFlag<"show-encoding">, 
+                    HelpText<"Show instruction encodings in output assembly">; 
+def show_inst : LLVMFlag<"show-inst">, 
+                HelpText<"Show internal instruction representation in output " 
+                         "assembly">; 
+def show_inst_operands : LLVMFlag<"show-inst-operands">, 
+                         HelpText<"Show instructions operands as parsed">; 
+def print_imm_hex : LLVMFlag<"print-imm-hex">, 
+                    HelpText<"Prefer hex format for immediate values in output " 
+                             "assembly">; 
+def preserve_comments : LLVMFlag<"preserve-comments">, 
+                        HelpText<"Preserve comments in output assembly">; 
+def save_temp_labels : LLVMFlag<"save-temp-labels">, 
+                       HelpText<"Don't discard temporary labels">; 
+ 
+def tiny_model_support : UnsupportedFlag<"AT">, HelpText<"">; 
+def alternate_linker : UnsupportedJoined<"Bl">, HelpText<"">; 
+def coff_object_file : UnsupportedFlag<"coff">, HelpText<"">; 
+def preserve_identifier_case : UnsupportedFlag<"Cp">, HelpText<"">; 
+def uppercase_identifiers : UnsupportedFlag<"Cu">, HelpText<"">; 
+def preserve_extern_case : UnsupportedFlag<"Cx">, HelpText<"">; 
+def output_preprocessed : UnsupportedFlag<"EP">, HelpText<"">; 
+def errorreport : UnsupportedJoined<"ERRORREPORT">, HelpText<"">; 
+def stacksize : UnsupportedSeparate<"F">, HelpText<"">; 
+def executable_file : UnsupportedSeparate<"Fe">, HelpText<"">; 
+def code_listing_file : UnsupportedJoined<"FI">, HelpText<"">; 
+def linker_map_file : UnsupportedJoined<"Fm">, HelpText<"">; 
+def fp_emulator_fixups : UnsupportedFlag<"FPi">, HelpText<"">; 
+def source_browser_file : UnsupportedJoined<"Fr">, HelpText<"">; 
+def extended_source_browser_file : UnsupportedJoined<"FR">, HelpText<"">; 
+def pascal_conventions : UnsupportedFlag<"Gc">, HelpText<"">; 
+def c_conventions : UnsupportedFlag<"Gd">, HelpText<"">; 
+def stdcall_conventions : UnsupportedFlag<"GZ">, HelpText<"">; 
+def extern_name_limit : UnsupportedSeparate<"H">, HelpText<"">; 
+def nologo : UnsupportedFlag<"nologo">, HelpText<"">; 
+def omf_object_file : UnsupportedFlag<"omf">, HelpText<"">; 
+def full_listing : UnsupportedFlag<"Sa">, HelpText<"">; 
+def first_pass_listing : UnsupportedFlag<"Sf">, HelpText<"">; 
+def listing_width : UnsupportedSeparate<"SI">, HelpText<"">; 
+def listing_without_symbols : UnsupportedFlag<"Sn">, HelpText<"">; 
+def listing_page_length : UnsupportedSeparate<"Sp">, HelpText<"">; 
+def listing_subtitle : UnsupportedSeparate<"Ss">, HelpText<"">; 
+def listing_title : UnsupportedSeparate<"St">, HelpText<"">; 
+def listing_false_conditionals : UnsupportedFlag<"Sx">, HelpText<"">; 
+def extra_warnings : UnsupportedFlag<"w">, HelpText<"">; 
+def warning_level : UnsupportedJoined<"W">, HelpText<"">; 
+def error_on_warning : UnsupportedFlag<"WX">, HelpText<"">; 
+def ignore_include_envvar : UnsupportedFlag<"X">, HelpText<"">; 
+def line_number_info : UnsupportedFlag<"Zd">, HelpText<"">; 
+def export_all_symbols : UnsupportedFlag<"Zf">, HelpText<"">; 
+def codeview_info : UnsupportedFlag<"Zi">, HelpText<"">; 
+def enable_m510_option : UnsupportedFlag<"Zm">, HelpText<"">; 
+def structure_packing : UnsupportedJoined<"Zp">, HelpText<"">; 
+def parse_only : UnsupportedFlag<"Zs">, HelpText<"">; 
diff --git a/contrib/libs/llvm12/tools/llvm-ml/llvm-ml.cpp b/contrib/libs/llvm12/tools/llvm-ml/llvm-ml.cpp
index 1733dcd472..5c21d0bb40 100644
--- a/contrib/libs/llvm12/tools/llvm-ml/llvm-ml.cpp
+++ b/contrib/libs/llvm12/tools/llvm-ml/llvm-ml.cpp
@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/StringSwitch.h" 
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
@@ -25,17 +25,17 @@
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptionsCommandFlags.h"
-#include "llvm/Option/Arg.h"
-#include "llvm/Option/ArgList.h"
-#include "llvm/Option/Option.h"
+#include "llvm/Option/Arg.h" 
+#include "llvm/Option/ArgList.h" 
+#include "llvm/Option/Option.h" 
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileUtilities.h"
-#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/FormatVariadic.h" 
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/Path.h"
+#include "llvm/Support/Path.h" 
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
@@ -43,55 +43,55 @@
 #include "llvm/Support/WithColor.h"
 
 using namespace llvm;
-using namespace llvm::opt;
+using namespace llvm::opt; 
 
-namespace {
+namespace { 
 
-enum ID {
-  OPT_INVALID = 0, // This is not an option ID.
-#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
-               HELPTEXT, METAVAR, VALUES)                                      \
-  OPT_##ID,
-#include "Opts.inc"
-#undef OPTION
+enum ID { 
+  OPT_INVALID = 0, // This is not an option ID. 
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \ 
+               HELPTEXT, METAVAR, VALUES)                                      \ 
+  OPT_##ID, 
+#include "Opts.inc" 
+#undef OPTION 
 };
 
-#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
-#include "Opts.inc"
-#undef PREFIX
-
-static const opt::OptTable::Info InfoTable[] = {
-#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
-               HELPTEXT, METAVAR, VALUES)                                      \
-  {                                                                            \
-      PREFIX,      NAME,      HELPTEXT,                                        \
-      METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
-      PARAM,       FLAGS,     OPT_##GROUP,                                     \
-      OPT_##ALIAS, ALIASARGS, VALUES},
-#include "Opts.inc"
-#undef OPTION
+#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE; 
+#include "Opts.inc" 
+#undef PREFIX 
+
+static const opt::OptTable::Info InfoTable[] = { 
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \ 
+               HELPTEXT, METAVAR, VALUES)                                      \ 
+  {                                                                            \ 
+      PREFIX,      NAME,      HELPTEXT,                                        \ 
+      METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \ 
+      PARAM,       FLAGS,     OPT_##GROUP,                                     \ 
+      OPT_##ALIAS, ALIASARGS, VALUES}, 
+#include "Opts.inc" 
+#undef OPTION 
 };
 
-class MLOptTable : public opt::OptTable {
-public:
-  MLOptTable() : OptTable(InfoTable, /*IgnoreCase=*/false) {}
+class MLOptTable : public opt::OptTable { 
+public: 
+  MLOptTable() : OptTable(InfoTable, /*IgnoreCase=*/false) {} 
 };
-} // namespace
+} // namespace 
 
-static Triple GetTriple(StringRef ProgName, opt::InputArgList &Args) {
+static Triple GetTriple(StringRef ProgName, opt::InputArgList &Args) { 
   // Figure out the target triple.
-  StringRef DefaultBitness = "32";
-  SmallString<255> Program = ProgName;
-  sys::path::replace_extension(Program, "");
-  if (Program.endswith("ml64"))
-    DefaultBitness = "64";
-
-  StringRef TripleName =
-      StringSwitch<StringRef>(Args.getLastArgValue(OPT_bitness, DefaultBitness))
-          .Case("32", "i386-pc-windows")
-          .Case("64", "x86_64-pc-windows")
-          .Default("");
-  return Triple(Triple::normalize(TripleName));
+  StringRef DefaultBitness = "32"; 
+  SmallString<255> Program = ProgName; 
+  sys::path::replace_extension(Program, ""); 
+  if (Program.endswith("ml64")) 
+    DefaultBitness = "64"; 
+
+  StringRef TripleName = 
+      StringSwitch<StringRef>(Args.getLastArgValue(OPT_bitness, DefaultBitness)) 
+          .Case("32", "i386-pc-windows") 
+          .Case("64", "x86_64-pc-windows") 
+          .Default(""); 
+  return Triple(Triple::normalize(TripleName)); 
 }
 
 static std::unique_ptr<ToolOutputFile> GetOutputStream(StringRef Path) {
@@ -108,10 +108,10 @@ static std::unique_ptr<ToolOutputFile> GetOutputStream(StringRef Path) {
 static int AsLexInput(SourceMgr &SrcMgr, MCAsmInfo &MAI, raw_ostream &OS) {
   AsmLexer Lexer(MAI);
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(SrcMgr.getMainFileID())->getBuffer());
-  Lexer.setLexMasmIntegers(true);
-  Lexer.useMasmDefaultRadix(true);
-  Lexer.setLexMasmHexFloats(true);
-  Lexer.setLexMasmStrings(true);
+  Lexer.setLexMasmIntegers(true); 
+  Lexer.useMasmDefaultRadix(true); 
+  Lexer.setLexMasmHexFloats(true); 
+  Lexer.setLexMasmStrings(true); 
 
   bool Error = false;
   while (Lexer.Lex().isNot(AsmToken::Eof)) {
@@ -124,13 +124,13 @@ static int AsLexInput(SourceMgr &SrcMgr, MCAsmInfo &MAI, raw_ostream &OS) {
   return Error;
 }
 
-static int AssembleInput(StringRef ProgName, const Target *TheTarget,
+static int AssembleInput(StringRef ProgName, const Target *TheTarget, 
                          SourceMgr &SrcMgr, MCContext &Ctx, MCStreamer &Str,
                          MCAsmInfo &MAI, MCSubtargetInfo &STI,
-                         MCInstrInfo &MCII, MCTargetOptions &MCOptions,
-                         const opt::ArgList &InputArgs) {
+                         MCInstrInfo &MCII, MCTargetOptions &MCOptions, 
+                         const opt::ArgList &InputArgs) { 
   std::unique_ptr<MCAsmParser> Parser(
-      createMCMasmParser(SrcMgr, Ctx, Str, MAI, 0));
+      createMCMasmParser(SrcMgr, Ctx, Str, MAI, 0)); 
   std::unique_ptr<MCTargetAsmParser> TAP(
       TheTarget->createMCAsmParser(STI, *Parser, MCII, MCOptions));
 
@@ -140,32 +140,32 @@ static int AssembleInput(StringRef ProgName, const Target *TheTarget,
     return 1;
   }
 
-  Parser->setShowParsedOperands(InputArgs.hasArg(OPT_show_inst_operands));
+  Parser->setShowParsedOperands(InputArgs.hasArg(OPT_show_inst_operands)); 
   Parser->setTargetParser(*TAP);
   Parser->getLexer().setLexMasmIntegers(true);
-  Parser->getLexer().useMasmDefaultRadix(true);
-  Parser->getLexer().setLexMasmHexFloats(true);
-  Parser->getLexer().setLexMasmStrings(true);
-
-  auto Defines = InputArgs.getAllArgValues(OPT_define);
-  for (StringRef Define : Defines) {
-    const auto NameValue = Define.split('=');
-    StringRef Name = NameValue.first, Value = NameValue.second;
-    if (Parser->defineMacro(Name, Value)) {
-      WithColor::error(errs(), ProgName)
-          << "can't define macro '" << Name << "' = '" << Value << "'\n";
-      return 1;
-    }
-  }
-
+  Parser->getLexer().useMasmDefaultRadix(true); 
+  Parser->getLexer().setLexMasmHexFloats(true); 
+  Parser->getLexer().setLexMasmStrings(true); 
+
+  auto Defines = InputArgs.getAllArgValues(OPT_define); 
+  for (StringRef Define : Defines) { 
+    const auto NameValue = Define.split('='); 
+    StringRef Name = NameValue.first, Value = NameValue.second; 
+    if (Parser->defineMacro(Name, Value)) { 
+      WithColor::error(errs(), ProgName) 
+          << "can't define macro '" << Name << "' = '" << Value << "'\n"; 
+      return 1; 
+    } 
+  } 
+ 
   int Res = Parser->Run(/*NoInitialTextSection=*/true);
 
   return Res;
 }
 
-int main(int Argc, char **Argv) {
-  InitLLVM X(Argc, Argv);
-  StringRef ProgName = sys::path::filename(Argv[0]);
+int main(int Argc, char **Argv) { 
+  InitLLVM X(Argc, Argv); 
+  StringRef ProgName = sys::path::filename(Argv[0]); 
 
   // Initialize targets and assembly printers/parsers.
   llvm::InitializeAllTargetInfos();
@@ -173,81 +173,81 @@ int main(int Argc, char **Argv) {
   llvm::InitializeAllAsmParsers();
   llvm::InitializeAllDisassemblers();
 
-  MLOptTable T;
-  unsigned MissingArgIndex, MissingArgCount;
-  ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc - 1);
-  opt::InputArgList InputArgs =
-      T.ParseArgs(ArgsArr, MissingArgIndex, MissingArgCount);
-
-  std::string InputFilename;
-  for (auto *Arg : InputArgs.filtered(OPT_INPUT)) {
-    std::string ArgString = Arg->getAsString(InputArgs);
-    if (ArgString == "-" || StringRef(ArgString).endswith(".asm")) {
-      if (!InputFilename.empty()) {
-        WithColor::warning(errs(), ProgName)
-            << "does not support multiple assembly files in one command; "
-            << "ignoring '" << InputFilename << "'\n";
-      }
-      InputFilename = ArgString;
-    } else {
-      std::string Diag;
-      raw_string_ostream OS(Diag);
-      OS << "invalid option '" << ArgString << "'";
-
-      std::string Nearest;
-      if (T.findNearest(ArgString, Nearest) < 2)
-        OS << ", did you mean '" << Nearest << "'?";
-
-      WithColor::error(errs(), ProgName) << OS.str() << '\n';
-      exit(1);
-    }
-  }
-  for (auto *Arg : InputArgs.filtered(OPT_assembly_file)) {
-    if (!InputFilename.empty()) {
-      WithColor::warning(errs(), ProgName)
-          << "does not support multiple assembly files in one command; "
-          << "ignoring '" << InputFilename << "'\n";
-    }
-    InputFilename = Arg->getAsString(InputArgs);
-  }
-
-  for (auto *Arg : InputArgs.filtered(OPT_unsupported_Group)) {
-    WithColor::warning(errs(), ProgName)
-        << "ignoring unsupported '" << Arg->getOption().getName()
-        << "' option\n";
-  }
-
-  if (InputArgs.hasArg(OPT_help)) {
-    std::string Usage = llvm::formatv("{0} [ /options ] file", ProgName).str();
-    T.PrintHelp(outs(), Usage.c_str(), "LLVM MASM Assembler",
-                /*ShowHidden=*/false);
-    return 0;
-  } else if (InputFilename.empty()) {
-    outs() << "USAGE: " << ProgName << " [ /options ] file\n"
-           << "Run \"" << ProgName << " /?\" or \"" << ProgName
-           << " /help\" for more info.\n";
-    return 0;
-  }
-
-  MCTargetOptions MCOptions;
+  MLOptTable T; 
+  unsigned MissingArgIndex, MissingArgCount; 
+  ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc - 1); 
+  opt::InputArgList InputArgs = 
+      T.ParseArgs(ArgsArr, MissingArgIndex, MissingArgCount); 
+
+  std::string InputFilename; 
+  for (auto *Arg : InputArgs.filtered(OPT_INPUT)) { 
+    std::string ArgString = Arg->getAsString(InputArgs); 
+    if (ArgString == "-" || StringRef(ArgString).endswith(".asm")) { 
+      if (!InputFilename.empty()) { 
+        WithColor::warning(errs(), ProgName) 
+            << "does not support multiple assembly files in one command; " 
+            << "ignoring '" << InputFilename << "'\n"; 
+      } 
+      InputFilename = ArgString; 
+    } else { 
+      std::string Diag; 
+      raw_string_ostream OS(Diag); 
+      OS << "invalid option '" << ArgString << "'"; 
+ 
+      std::string Nearest; 
+      if (T.findNearest(ArgString, Nearest) < 2) 
+        OS << ", did you mean '" << Nearest << "'?"; 
+ 
+      WithColor::error(errs(), ProgName) << OS.str() << '\n'; 
+      exit(1); 
+    } 
+  } 
+  for (auto *Arg : InputArgs.filtered(OPT_assembly_file)) { 
+    if (!InputFilename.empty()) { 
+      WithColor::warning(errs(), ProgName) 
+          << "does not support multiple assembly files in one command; " 
+          << "ignoring '" << InputFilename << "'\n"; 
+    } 
+    InputFilename = Arg->getAsString(InputArgs); 
+  } 
+ 
+  for (auto *Arg : InputArgs.filtered(OPT_unsupported_Group)) { 
+    WithColor::warning(errs(), ProgName) 
+        << "ignoring unsupported '" << Arg->getOption().getName() 
+        << "' option\n"; 
+  } 
+ 
+  if (InputArgs.hasArg(OPT_help)) { 
+    std::string Usage = llvm::formatv("{0} [ /options ] file", ProgName).str(); 
+    T.PrintHelp(outs(), Usage.c_str(), "LLVM MASM Assembler", 
+                /*ShowHidden=*/false); 
+    return 0; 
+  } else if (InputFilename.empty()) { 
+    outs() << "USAGE: " << ProgName << " [ /options ] file\n" 
+           << "Run \"" << ProgName << " /?\" or \"" << ProgName 
+           << " /help\" for more info.\n"; 
+    return 0; 
+  } 
+ 
+  MCTargetOptions MCOptions; 
   MCOptions.AssemblyLanguage = "masm";
 
-  Triple TheTriple = GetTriple(ProgName, InputArgs);
-  std::string Error;
-  const Target *TheTarget = TargetRegistry::lookupTarget("", TheTriple, Error);
-  if (!TheTarget) {
-    WithColor::error(errs(), ProgName) << Error;
+  Triple TheTriple = GetTriple(ProgName, InputArgs); 
+  std::string Error; 
+  const Target *TheTarget = TargetRegistry::lookupTarget("", TheTriple, Error); 
+  if (!TheTarget) { 
+    WithColor::error(errs(), ProgName) << Error; 
     return 1;
-  }
-  const std::string &TripleName = TheTriple.getTriple();
-
-  bool SafeSEH = InputArgs.hasArg(OPT_safeseh);
-  if (SafeSEH && !(TheTriple.isArch32Bit() && TheTriple.isX86())) {
-    WithColor::warning()
-        << "/safeseh applies only to 32-bit X86 platforms; ignoring.\n";
-    SafeSEH = false;
-  }
-
+  } 
+  const std::string &TripleName = TheTriple.getTriple(); 
+
+  bool SafeSEH = InputArgs.hasArg(OPT_safeseh); 
+  if (SafeSEH && !(TheTriple.isArch32Bit() && TheTriple.isX86())) { 
+    WithColor::warning() 
+        << "/safeseh applies only to 32-bit X86 platforms; ignoring.\n"; 
+    SafeSEH = false; 
+  } 
+ 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
       MemoryBuffer::getFileOrSTDIN(InputFilename);
   if (std::error_code EC = BufferPtr.getError()) {
@@ -263,7 +263,7 @@ int main(int Argc, char **Argv) {
 
   // Record the location of the include directories so that the lexer can find
   // it later.
-  SrcMgr.setIncludeDirs(InputArgs.getAllArgValues(OPT_include_path));
+  SrcMgr.setIncludeDirs(InputArgs.getAllArgValues(OPT_include_path)); 
 
   std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
   assert(MRI && "Unable to create target register info!");
@@ -272,7 +272,7 @@ int main(int Argc, char **Argv) {
       TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
   assert(MAI && "Unable to create target asm info!");
 
-  MAI->setPreserveAsmComments(InputArgs.hasArg(OPT_preserve_comments));
+  MAI->setPreserveAsmComments(InputArgs.hasArg(OPT_preserve_comments)); 
 
   // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
   // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
@@ -281,25 +281,25 @@ int main(int Argc, char **Argv) {
   MOFI.InitMCObjectFileInfo(TheTriple, /*PIC=*/false, Ctx,
                             /*LargeCodeModel=*/true);
 
-  if (InputArgs.hasArg(OPT_save_temp_labels))
+  if (InputArgs.hasArg(OPT_save_temp_labels)) 
     Ctx.setAllowTemporaryLabels(false);
 
-  // Set compilation information.
-  SmallString<128> CWD;
-  if (!sys::fs::current_path(CWD))
-    Ctx.setCompilationDir(CWD);
-  Ctx.setMainFileName(InputFilename);
-
-  StringRef FileType = InputArgs.getLastArgValue(OPT_filetype, "obj");
-  SmallString<255> DefaultOutputFilename;
-  if (InputArgs.hasArg(OPT_as_lex)) {
-    DefaultOutputFilename = "-";
+  // Set compilation information. 
+  SmallString<128> CWD; 
+  if (!sys::fs::current_path(CWD)) 
+    Ctx.setCompilationDir(CWD); 
+  Ctx.setMainFileName(InputFilename); 
+ 
+  StringRef FileType = InputArgs.getLastArgValue(OPT_filetype, "obj"); 
+  SmallString<255> DefaultOutputFilename; 
+  if (InputArgs.hasArg(OPT_as_lex)) { 
+    DefaultOutputFilename = "-"; 
   } else {
-    DefaultOutputFilename = InputFilename;
-    sys::path::replace_extension(DefaultOutputFilename, FileType);
+    DefaultOutputFilename = InputFilename; 
+    sys::path::replace_extension(DefaultOutputFilename, FileType); 
   }
-  const StringRef OutputFilename =
-      InputArgs.getLastArgValue(OPT_output_file, DefaultOutputFilename);
+  const StringRef OutputFilename = 
+      InputArgs.getLastArgValue(OPT_output_file, DefaultOutputFilename); 
   std::unique_ptr<ToolOutputFile> Out = GetOutputStream(OutputFilename);
   if (!Out)
     return 1;
@@ -309,19 +309,19 @@ int main(int Argc, char **Argv) {
   std::unique_ptr<MCStreamer> Str;
 
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
-  assert(MCII && "Unable to create instruction info!");
-
+  assert(MCII && "Unable to create instruction info!"); 
+ 
   std::unique_ptr<MCSubtargetInfo> STI(TheTarget->createMCSubtargetInfo(
       TripleName, /*CPU=*/"", /*Features=*/""));
-  assert(STI && "Unable to create subtarget info!");
+  assert(STI && "Unable to create subtarget info!"); 
 
   MCInstPrinter *IP = nullptr;
-  if (FileType == "s") {
-    const bool OutputATTAsm = InputArgs.hasArg(OPT_output_att_asm);
+  if (FileType == "s") { 
+    const bool OutputATTAsm = InputArgs.hasArg(OPT_output_att_asm); 
     const unsigned OutputAsmVariant = OutputATTAsm ? 0U   // ATT dialect
                                                    : 1U;  // Intel dialect
-    IP = TheTarget->createMCInstPrinter(TheTriple, OutputAsmVariant, *MAI,
-                                        *MCII, *MRI);
+    IP = TheTarget->createMCInstPrinter(TheTriple, OutputAsmVariant, *MAI, 
+                                        *MCII, *MRI); 
 
     if (!IP) {
       WithColor::error()
@@ -332,24 +332,24 @@ int main(int Argc, char **Argv) {
     }
 
     // Set the display preference for hex vs. decimal immediates.
-    IP->setPrintImmHex(InputArgs.hasArg(OPT_print_imm_hex));
+    IP->setPrintImmHex(InputArgs.hasArg(OPT_print_imm_hex)); 
 
     // Set up the AsmStreamer.
     std::unique_ptr<MCCodeEmitter> CE;
-    if (InputArgs.hasArg(OPT_show_encoding))
+    if (InputArgs.hasArg(OPT_show_encoding)) 
       CE.reset(TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx));
 
     std::unique_ptr<MCAsmBackend> MAB(
         TheTarget->createMCAsmBackend(*STI, *MRI, MCOptions));
     auto FOut = std::make_unique<formatted_raw_ostream>(*OS);
-    Str.reset(TheTarget->createAsmStreamer(
-        Ctx, std::move(FOut), /*asmverbose*/ true,
-        /*useDwarfDirectory*/ true, IP, std::move(CE), std::move(MAB),
-        InputArgs.hasArg(OPT_show_inst)));
+    Str.reset(TheTarget->createAsmStreamer( 
+        Ctx, std::move(FOut), /*asmverbose*/ true, 
+        /*useDwarfDirectory*/ true, IP, std::move(CE), std::move(MAB), 
+        InputArgs.hasArg(OPT_show_inst))); 
 
-  } else if (FileType == "null") {
+  } else if (FileType == "null") { 
     Str.reset(TheTarget->createNullStreamer(Ctx));
-  } else if (FileType == "obj") {
+  } else if (FileType == "obj") { 
     if (!Out->os().supportsSeeking()) {
       BOS = std::make_unique<buffer_ostream>(Out->os());
       OS = BOS.get();
@@ -362,37 +362,37 @@ int main(int Argc, char **Argv) {
         MAB->createObjectWriter(*OS), std::unique_ptr<MCCodeEmitter>(CE), *STI,
         MCOptions.MCRelaxAll, MCOptions.MCIncrementalLinkerCompatible,
         /*DWARFMustBeAtTheEnd*/ false));
-  } else {
-    llvm_unreachable("Invalid file type!");
-  }
-
-  if (TheTriple.isOSBinFormatCOFF()) {
-    // Emit an absolute @feat.00 symbol. This is a features bitfield read by
-    // link.exe.
-    int64_t Feat00Flags = 0x2;
-    if (SafeSEH) {
-      // According to the PE-COFF spec, the LSB of this value marks the object
-      // for "registered SEH".  This means that all SEH handler entry points
-      // must be registered in .sxdata.  Use of any unregistered handlers will
-      // cause the process to terminate immediately.
-      Feat00Flags |= 0x1;
-    }
-    MCSymbol *Feat00Sym = Ctx.getOrCreateSymbol("@feat.00");
-    Feat00Sym->setRedefinable(true);
-    Str->emitSymbolAttribute(Feat00Sym, MCSA_Global);
-    Str->emitAssignment(Feat00Sym, MCConstantExpr::create(Feat00Flags, Ctx));
+  } else { 
+    llvm_unreachable("Invalid file type!"); 
   }
 
+  if (TheTriple.isOSBinFormatCOFF()) { 
+    // Emit an absolute @feat.00 symbol. This is a features bitfield read by 
+    // link.exe. 
+    int64_t Feat00Flags = 0x2; 
+    if (SafeSEH) { 
+      // According to the PE-COFF spec, the LSB of this value marks the object 
+      // for "registered SEH".  This means that all SEH handler entry points 
+      // must be registered in .sxdata.  Use of any unregistered handlers will 
+      // cause the process to terminate immediately. 
+      Feat00Flags |= 0x1; 
+    } 
+    MCSymbol *Feat00Sym = Ctx.getOrCreateSymbol("@feat.00"); 
+    Feat00Sym->setRedefinable(true); 
+    Str->emitSymbolAttribute(Feat00Sym, MCSA_Global); 
+    Str->emitAssignment(Feat00Sym, MCConstantExpr::create(Feat00Flags, Ctx)); 
+  } 
+ 
   // Use Assembler information for parsing.
   Str->setUseAssemblerInfoForParsing(true);
 
   int Res = 1;
-  if (InputArgs.hasArg(OPT_as_lex)) {
-    // -as-lex; Lex only, and output a stream of tokens
+  if (InputArgs.hasArg(OPT_as_lex)) { 
+    // -as-lex; Lex only, and output a stream of tokens 
     Res = AsLexInput(SrcMgr, *MAI, Out->os());
-  } else {
+  } else { 
     Res = AssembleInput(ProgName, TheTarget, SrcMgr, Ctx, *Str, *MAI, *STI,
-                        *MCII, MCOptions, InputArgs);
+                        *MCII, MCOptions, InputArgs); 
   }
 
   // Keep output if no errors.
diff --git a/contrib/libs/llvm12/tools/llvm-ml/ya.make b/contrib/libs/llvm12/tools/llvm-ml/ya.make
index 5371cfd851..7816f1d57b 100644
--- a/contrib/libs/llvm12/tools/llvm-ml/ya.make
+++ b/contrib/libs/llvm12/tools/llvm-ml/ya.make
@@ -12,44 +12,44 @@ LICENSE(Apache-2.0 WITH LLVM-exception)
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
 PEERDIR(
-    contrib/libs/llvm12
-    contrib/libs/llvm12/include
-    contrib/libs/llvm12/lib/BinaryFormat
-    contrib/libs/llvm12/lib/Demangle
-    contrib/libs/llvm12/lib/MC
-    contrib/libs/llvm12/lib/MC/MCDisassembler
-    contrib/libs/llvm12/lib/MC/MCParser
-    contrib/libs/llvm12/lib/Option
-    contrib/libs/llvm12/lib/Support
-    contrib/libs/llvm12/lib/Target/AArch64/AsmParser
-    contrib/libs/llvm12/lib/Target/AArch64/Disassembler
-    contrib/libs/llvm12/lib/Target/AArch64/MCTargetDesc
-    contrib/libs/llvm12/lib/Target/AArch64/TargetInfo
-    contrib/libs/llvm12/lib/Target/AArch64/Utils
-    contrib/libs/llvm12/lib/Target/ARM/AsmParser
-    contrib/libs/llvm12/lib/Target/ARM/Disassembler
-    contrib/libs/llvm12/lib/Target/ARM/MCTargetDesc
-    contrib/libs/llvm12/lib/Target/ARM/TargetInfo
-    contrib/libs/llvm12/lib/Target/ARM/Utils
-    contrib/libs/llvm12/lib/Target/BPF/AsmParser
-    contrib/libs/llvm12/lib/Target/BPF/Disassembler
-    contrib/libs/llvm12/lib/Target/BPF/MCTargetDesc
-    contrib/libs/llvm12/lib/Target/BPF/TargetInfo
-    contrib/libs/llvm12/lib/Target/NVPTX/MCTargetDesc
-    contrib/libs/llvm12/lib/Target/NVPTX/TargetInfo
-    contrib/libs/llvm12/lib/Target/PowerPC/AsmParser
-    contrib/libs/llvm12/lib/Target/PowerPC/Disassembler
-    contrib/libs/llvm12/lib/Target/PowerPC/MCTargetDesc
-    contrib/libs/llvm12/lib/Target/PowerPC/TargetInfo
-    contrib/libs/llvm12/lib/Target/X86/AsmParser
-    contrib/libs/llvm12/lib/Target/X86/Disassembler
-    contrib/libs/llvm12/lib/Target/X86/MCTargetDesc
-    contrib/libs/llvm12/lib/Target/X86/TargetInfo
+    contrib/libs/llvm12 
+    contrib/libs/llvm12/include 
+    contrib/libs/llvm12/lib/BinaryFormat 
+    contrib/libs/llvm12/lib/Demangle 
+    contrib/libs/llvm12/lib/MC 
+    contrib/libs/llvm12/lib/MC/MCDisassembler 
+    contrib/libs/llvm12/lib/MC/MCParser 
+    contrib/libs/llvm12/lib/Option 
+    contrib/libs/llvm12/lib/Support 
+    contrib/libs/llvm12/lib/Target/AArch64/AsmParser 
+    contrib/libs/llvm12/lib/Target/AArch64/Disassembler 
+    contrib/libs/llvm12/lib/Target/AArch64/MCTargetDesc 
+    contrib/libs/llvm12/lib/Target/AArch64/TargetInfo 
+    contrib/libs/llvm12/lib/Target/AArch64/Utils 
+    contrib/libs/llvm12/lib/Target/ARM/AsmParser 
+    contrib/libs/llvm12/lib/Target/ARM/Disassembler 
+    contrib/libs/llvm12/lib/Target/ARM/MCTargetDesc 
+    contrib/libs/llvm12/lib/Target/ARM/TargetInfo 
+    contrib/libs/llvm12/lib/Target/ARM/Utils 
+    contrib/libs/llvm12/lib/Target/BPF/AsmParser 
+    contrib/libs/llvm12/lib/Target/BPF/Disassembler 
+    contrib/libs/llvm12/lib/Target/BPF/MCTargetDesc 
+    contrib/libs/llvm12/lib/Target/BPF/TargetInfo 
+    contrib/libs/llvm12/lib/Target/NVPTX/MCTargetDesc 
+    contrib/libs/llvm12/lib/Target/NVPTX/TargetInfo 
+    contrib/libs/llvm12/lib/Target/PowerPC/AsmParser 
+    contrib/libs/llvm12/lib/Target/PowerPC/Disassembler 
+    contrib/libs/llvm12/lib/Target/PowerPC/MCTargetDesc 
+    contrib/libs/llvm12/lib/Target/PowerPC/TargetInfo 
+    contrib/libs/llvm12/lib/Target/X86/AsmParser 
+    contrib/libs/llvm12/lib/Target/X86/Disassembler 
+    contrib/libs/llvm12/lib/Target/X86/MCTargetDesc 
+    contrib/libs/llvm12/lib/Target/X86/TargetInfo 
 )
 
 ADDINCL(
-    ${ARCADIA_BUILD_ROOT}/contrib/libs/llvm12/tools/llvm-ml
-    contrib/libs/llvm12/tools/llvm-ml
+    ${ARCADIA_BUILD_ROOT}/contrib/libs/llvm12/tools/llvm-ml 
+    contrib/libs/llvm12/tools/llvm-ml 
 )
 
 NO_COMPILER_WARNINGS()