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

34 files changed, 580 insertions, 580 deletions

diff --git a/contrib/libs/llvm12/include/llvm/MC/MCAsmBackend.h b/contrib/libs/llvm12/include/llvm/MC/MCAsmBackend.h
index 5b76d925af..791fb081a5 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCAsmBackend.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCAsmBackend.h
@@ -151,9 +151,9 @@ public:
   /// \param STI - The MCSubtargetInfo in effect when the instruction was
   /// encoded.
   virtual bool mayNeedRelaxation(const MCInst &Inst,
-                                 const MCSubtargetInfo &STI) const {
-    return false;
-  }
+                                 const MCSubtargetInfo &STI) const { 
+    return false; 
+  } 
 
   /// Target specific predicate for whether a given fixup requires the
   /// associated instruction to be relaxed.
@@ -184,10 +184,10 @@ public:
   ///
   virtual unsigned getMinimumNopSize() const { return 1; }
 
-  /// Returns the maximum size of a nop in bytes on this target.
-  ///
-  virtual unsigned getMaximumNopSize() const { return 0; }
-
+  /// Returns the maximum size of a nop in bytes on this target. 
+  /// 
+  virtual unsigned getMaximumNopSize() const { return 0; } 
+ 
   /// Write an (optimal) nop sequence of Count bytes to the given output. If the
   /// target cannot generate such a sequence, it should return an error.
   ///
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCAsmInfo.h b/contrib/libs/llvm12/include/llvm/MC/MCAsmInfo.h
index e4ee118ed2..638fa04638 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCAsmInfo.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCAsmInfo.h
@@ -61,15 +61,15 @@ enum LCOMMType { NoAlignment, ByteAlignment, Log2Alignment };
 /// This class is intended to be used as a base class for asm
 /// properties and features specific to the target.
 class MCAsmInfo {
-public:
-  /// Assembly character literal syntax types.
-  enum AsmCharLiteralSyntax {
-    ACLS_Unknown, /// Unknown; character literals not used by LLVM for this
-                  /// target.
-    ACLS_SingleQuotePrefix, /// The desired character is prefixed by a single
-                            /// quote, e.g., `'A`.
-  };
-
+public: 
+  /// Assembly character literal syntax types. 
+  enum AsmCharLiteralSyntax { 
+    ACLS_Unknown, /// Unknown; character literals not used by LLVM for this 
+                  /// target. 
+    ACLS_SingleQuotePrefix, /// The desired character is prefixed by a single 
+                            /// quote, e.g., `'A`. 
+  }; 
+ 
 protected:
   //===------------------------------------------------------------------===//
   // Properties to be set by the target writer, used to configure asm printer.
@@ -193,9 +193,9 @@ protected:
   /// alignment is supported.
   bool UseDotAlignForAlignment = false;
 
-  /// True if the target supports LEB128 directives.
-  bool HasLEB128Directives = true;
-
+  /// True if the target supports LEB128 directives. 
+  bool HasLEB128Directives = true; 
+ 
   //===--- Data Emission Directives -------------------------------------===//
 
   /// This should be set to the directive used to get some number of zero (and
@@ -219,16 +219,16 @@ protected:
   /// doesn't support this, it can be set to null.  Defaults to "\t.asciz\t"
   const char *AscizDirective;
 
-  /// This directive accepts a comma-separated list of bytes for emission as a
-  /// string of bytes.  For targets that do not support this, it shall be set to
-  /// null.  Defaults to null.
-  const char *ByteListDirective = nullptr;
-
-  /// Form used for character literals in the assembly syntax.  Useful for
-  /// producing strings as byte lists.  If a target does not use or support
-  /// this, it shall be set to ACLS_Unknown.  Defaults to ACLS_Unknown.
-  AsmCharLiteralSyntax CharacterLiteralSyntax = ACLS_Unknown;
-
+  /// This directive accepts a comma-separated list of bytes for emission as a 
+  /// string of bytes.  For targets that do not support this, it shall be set to 
+  /// null.  Defaults to null. 
+  const char *ByteListDirective = nullptr; 
+ 
+  /// Form used for character literals in the assembly syntax.  Useful for 
+  /// producing strings as byte lists.  If a target does not use or support 
+  /// this, it shall be set to ACLS_Unknown.  Defaults to ACLS_Unknown. 
+  AsmCharLiteralSyntax CharacterLiteralSyntax = ACLS_Unknown; 
+ 
   /// These directives are used to output some unit of integer data to the
   /// current section.  If a data directive is set to null, smaller data
   /// directives will be used to emit the large sizes.  Defaults to "\t.byte\t",
@@ -238,9 +238,9 @@ protected:
   const char *Data32bitsDirective;
   const char *Data64bitsDirective;
 
-  /// True if data directives support signed values
-  bool SupportsSignedData = true;
-
+  /// True if data directives support signed values 
+  bool SupportsSignedData = true; 
+ 
   /// If non-null, a directive that is used to emit a word which should be
   /// relocated as a 64-bit GP-relative offset, e.g. .gpdword on Mips.  Defaults
   /// to nullptr.
@@ -413,12 +413,12 @@ protected:
 
   //===--- Integrated Assembler Information ----------------------------===//
 
-  // Generated object files can use all ELF features supported by GNU ld of
-  // this binutils version and later. INT_MAX means all features can be used,
-  // regardless of GNU ld support. The default value is referenced by
-  // clang/Driver/Options.td.
-  std::pair<int, int> BinutilsVersion = {2, 26};
-
+  // Generated object files can use all ELF features supported by GNU ld of 
+  // this binutils version and later. INT_MAX means all features can be used, 
+  // regardless of GNU ld support. The default value is referenced by 
+  // clang/Driver/Options.td. 
+  std::pair<int, int> BinutilsVersion = {2, 26}; 
+ 
   /// Should we use the integrated assembler?
   /// The integrated assembler should be enabled by default (by the
   /// constructors) when failing to parse a valid piece of assembly (inline
@@ -474,7 +474,7 @@ public:
   const char *getData16bitsDirective() const { return Data16bitsDirective; }
   const char *getData32bitsDirective() const { return Data32bitsDirective; }
   const char *getData64bitsDirective() const { return Data64bitsDirective; }
-  bool supportsSignedData() const { return SupportsSignedData; }
+  bool supportsSignedData() const { return SupportsSignedData; } 
   const char *getGPRel64Directive() const { return GPRel64Directive; }
   const char *getGPRel32Directive() const { return GPRel32Directive; }
   const char *getDTPRel64Directive() const { return DTPRel64Directive; }
@@ -591,18 +591,18 @@ public:
     return UseDotAlignForAlignment;
   }
 
-  bool hasLEB128Directives() const { return HasLEB128Directives; }
-
+  bool hasLEB128Directives() const { return HasLEB128Directives; } 
+ 
   const char *getZeroDirective() const { return ZeroDirective; }
   bool doesZeroDirectiveSupportNonZeroValue() const {
     return ZeroDirectiveSupportsNonZeroValue;
   }
   const char *getAsciiDirective() const { return AsciiDirective; }
   const char *getAscizDirective() const { return AscizDirective; }
-  const char *getByteListDirective() const { return ByteListDirective; }
-  AsmCharLiteralSyntax characterLiteralSyntax() const {
-    return CharacterLiteralSyntax;
-  }
+  const char *getByteListDirective() const { return ByteListDirective; } 
+  AsmCharLiteralSyntax characterLiteralSyntax() const { 
+    return CharacterLiteralSyntax; 
+  } 
   bool getAlignmentIsInBytes() const { return AlignmentIsInBytes; }
   unsigned getTextAlignFillValue() const { return TextAlignFillValue; }
   const char *getGlobalDirective() const { return GlobalDirective; }
@@ -686,17 +686,17 @@ public:
     return InitialFrameState;
   }
 
-  void setBinutilsVersion(std::pair<int, int> Value) {
-    BinutilsVersion = Value;
-  }
-
+  void setBinutilsVersion(std::pair<int, int> Value) { 
+    BinutilsVersion = Value; 
+  } 
+ 
   /// Return true if assembly (inline or otherwise) should be parsed.
   bool useIntegratedAssembler() const { return UseIntegratedAssembler; }
 
-  bool binutilsIsAtLeast(int Major, int Minor) const {
-    return BinutilsVersion >= std::make_pair(Major, Minor);
-  }
-
+  bool binutilsIsAtLeast(int Major, int Minor) const { 
+    return BinutilsVersion >= std::make_pair(Major, Minor); 
+  } 
+ 
   /// Set whether assembly (inline or otherwise) should be parsed.
   virtual void setUseIntegratedAssembler(bool Value) {
     UseIntegratedAssembler = Value;
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCAsmMacro.h b/contrib/libs/llvm12/include/llvm/MC/MCAsmMacro.h
index 5e0ed50eba..a92109c677 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCAsmMacro.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCAsmMacro.h
@@ -150,16 +150,16 @@ struct MCAsmMacro {
   StringRef Name;
   StringRef Body;
   MCAsmMacroParameters Parameters;
-  std::vector<std::string> Locals;
-  bool IsFunction = false;
+  std::vector<std::string> Locals; 
+  bool IsFunction = false; 
 
 public:
   MCAsmMacro(StringRef N, StringRef B, MCAsmMacroParameters P)
       : Name(N), Body(B), Parameters(std::move(P)) {}
-  MCAsmMacro(StringRef N, StringRef B, MCAsmMacroParameters P,
-             std::vector<std::string> L, bool F)
-      : Name(N), Body(B), Parameters(std::move(P)), Locals(std::move(L)),
-        IsFunction(F) {}
+  MCAsmMacro(StringRef N, StringRef B, MCAsmMacroParameters P, 
+             std::vector<std::string> L, bool F) 
+      : Name(N), Body(B), Parameters(std::move(P)), Locals(std::move(L)), 
+        IsFunction(F) {} 
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const { dump(dbgs()); }
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCAssembler.h b/contrib/libs/llvm12/include/llvm/MC/MCAssembler.h
index 7f8dc1409c..dd3ae8df6c 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCAssembler.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCAssembler.h
@@ -209,7 +209,7 @@ private:
   bool relaxCVInlineLineTable(MCAsmLayout &Layout,
                               MCCVInlineLineTableFragment &DF);
   bool relaxCVDefRange(MCAsmLayout &Layout, MCCVDefRangeFragment &DF);
-  bool relaxPseudoProbeAddr(MCAsmLayout &Layout, MCPseudoProbeAddrFragment &DF);
+  bool relaxPseudoProbeAddr(MCAsmLayout &Layout, MCPseudoProbeAddrFragment &DF); 
 
   /// finishLayout - Finalize a layout, including fragment lowering.
   void finishLayout(MCAsmLayout &Layout);
@@ -218,12 +218,12 @@ private:
   handleFixup(const MCAsmLayout &Layout, MCFragment &F, const MCFixup &Fixup);
 
 public:
-  struct Symver {
-    StringRef Name;
-    const MCSymbol *Sym;
-    SMLoc Loc;
-  };
-  std::vector<Symver> Symvers;
+  struct Symver { 
+    StringRef Name; 
+    const MCSymbol *Sym; 
+    SMLoc Loc; 
+  }; 
+  std::vector<Symver> Symvers; 
 
   /// Construct a new assembler instance.
   //
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCContext.h b/contrib/libs/llvm12/include/llvm/MC/MCContext.h
index c8297d6088..52ceb23ff5 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCContext.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCContext.h
@@ -29,7 +29,7 @@
 #include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/MC/MCAsmMacro.h"
 #include "llvm/MC/MCDwarf.h"
-#include "llvm/MC/MCPseudoProbe.h"
+#include "llvm/MC/MCPseudoProbe.h" 
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/SectionKind.h"
@@ -105,7 +105,7 @@ namespace llvm {
     SpecificBumpPtrAllocator<MCSectionMachO> MachOAllocator;
     SpecificBumpPtrAllocator<MCSectionWasm> WasmAllocator;
     SpecificBumpPtrAllocator<MCSectionXCOFF> XCOFFAllocator;
-    SpecificBumpPtrAllocator<MCInst> MCInstAllocator;
+    SpecificBumpPtrAllocator<MCInst> MCInstAllocator; 
 
     /// Bindings of names to symbols.
     SymbolTable Symbols;
@@ -207,9 +207,9 @@ namespace llvm {
     /// The Compile Unit ID that we are currently processing.
     unsigned DwarfCompileUnitID = 0;
 
-    /// A collection of MCPseudoProbe in the current module
-    MCPseudoProbeTable PseudoProbeTable;
-
+    /// A collection of MCPseudoProbe in the current module 
+    MCPseudoProbeTable PseudoProbeTable; 
+ 
     // Sections are differentiated by the quadruple (section_name, group_name,
     // unique_id, link_to_symbol_name). Sections sharing the same quadruple are
     // combined into one section.
@@ -392,11 +392,11 @@ namespace llvm {
 
     /// @}
 
-    /// \name McInst Management
-
-    /// Create and return a new MC instruction.
-    MCInst *createMCInst();
-
+    /// \name McInst Management 
+ 
+    /// Create and return a new MC instruction. 
+    MCInst *createMCInst(); 
+ 
     /// \name Symbol Management
     /// @{
 
@@ -404,16 +404,16 @@ namespace llvm {
     /// unspecified name.
     MCSymbol *createLinkerPrivateTempSymbol();
 
-    /// Create a temporary symbol with a unique name. The name will be omitted
-    /// in the symbol table if UseNamesOnTempLabels is false (default except
-    /// MCAsmStreamer). The overload without Name uses an unspecified name.
-    MCSymbol *createTempSymbol();
-    MCSymbol *createTempSymbol(const Twine &Name, bool AlwaysAddSuffix = true);
+    /// Create a temporary symbol with a unique name. The name will be omitted 
+    /// in the symbol table if UseNamesOnTempLabels is false (default except 
+    /// MCAsmStreamer). The overload without Name uses an unspecified name. 
+    MCSymbol *createTempSymbol(); 
+    MCSymbol *createTempSymbol(const Twine &Name, bool AlwaysAddSuffix = true); 
 
-    /// Create a temporary symbol with a unique name whose name cannot be
-    /// omitted in the symbol table. This is rarely used.
-    MCSymbol *createNamedTempSymbol();
-    MCSymbol *createNamedTempSymbol(const Twine &Name);
+    /// Create a temporary symbol with a unique name whose name cannot be 
+    /// omitted in the symbol table. This is rarely used. 
+    MCSymbol *createNamedTempSymbol(); 
+    MCSymbol *createNamedTempSymbol(const Twine &Name); 
 
     /// Create the definition of a directional local symbol for numbered label
     /// (used for "1:" definitions).
@@ -579,8 +579,8 @@ namespace llvm {
 
     MCSectionXCOFF *getXCOFFSection(StringRef Section,
                                     XCOFF::StorageMappingClass MappingClass,
-                                    XCOFF::SymbolType CSectType, SectionKind K,
-                                    bool MultiSymbolsAllowed = false,
+                                    XCOFF::SymbolType CSectType, SectionKind K, 
+                                    bool MultiSymbolsAllowed = false, 
                                     const char *BeginSymName = nullptr);
 
     // Create and save a copy of STI and return a reference to the copy.
@@ -764,8 +764,8 @@ namespace llvm {
     }
 
     void undefineMacro(StringRef Name) { MacroMap.erase(Name); }
-
-    MCPseudoProbeTable &getMCPseudoProbeTable() { return PseudoProbeTable; }
+ 
+    MCPseudoProbeTable &getMCPseudoProbeTable() { return PseudoProbeTable; } 
   };
 
 } // end namespace llvm
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCDwarf.h b/contrib/libs/llvm12/include/llvm/MC/MCDwarf.h
index b5e8d14fb8..37652d9bef 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCDwarf.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCDwarf.h
@@ -32,7 +32,7 @@
 #include <cassert>
 #include <cstdint>
 #include <string>
-#include <tuple>
+#include <tuple> 
 #include <utility>
 #include <vector>
 
@@ -395,11 +395,11 @@ public:
                      int64_t LineDelta, uint64_t AddrDelta, raw_ostream &OS);
 
   /// Utility function to encode a Dwarf pair of LineDelta and AddrDeltas using
-  /// fixed length operands. Returns (Offset, Size, SetDelta).
-  static std::tuple<uint32_t, uint32_t, bool> fixedEncode(MCContext &Context,
-                                                          int64_t LineDelta,
-                                                          uint64_t AddrDelta,
-                                                          raw_ostream &OS);
+  /// fixed length operands. Returns (Offset, Size, SetDelta). 
+  static std::tuple<uint32_t, uint32_t, bool> fixedEncode(MCContext &Context, 
+                                                          int64_t LineDelta, 
+                                                          uint64_t AddrDelta, 
+                                                          raw_ostream &OS); 
 
   /// Utility function to emit the encoding to a streamer.
   static void Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCExpr.h b/contrib/libs/llvm12/include/llvm/MC/MCExpr.h
index cc395cdee3..32bdbefe02 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCExpr.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCExpr.h
@@ -231,7 +231,7 @@ public:
     VK_WEAKREF, // The link between the symbols in .weakref foo, bar
 
     VK_X86_ABS8,
-    VK_X86_PLTOFF,
+    VK_X86_PLTOFF, 
 
     VK_ARM_NONE,
     VK_ARM_GOT_PREL,
@@ -307,14 +307,14 @@ public:
     VK_PPC_GOT_TLSLD_HI,    // symbol@got@tlsld@h
     VK_PPC_GOT_TLSLD_HA,    // symbol@got@tlsld@ha
     VK_PPC_GOT_PCREL,       // symbol@got@pcrel
-    VK_PPC_GOT_TLSGD_PCREL, // symbol@got@tlsgd@pcrel
-    VK_PPC_GOT_TLSLD_PCREL, // symbol@got@tlsld@pcrel
-    VK_PPC_GOT_TPREL_PCREL, // symbol@got@tprel@pcrel
-    VK_PPC_TLS_PCREL,       // symbol@tls@pcrel
+    VK_PPC_GOT_TLSGD_PCREL, // symbol@got@tlsgd@pcrel 
+    VK_PPC_GOT_TLSLD_PCREL, // symbol@got@tlsld@pcrel 
+    VK_PPC_GOT_TPREL_PCREL, // symbol@got@tprel@pcrel 
+    VK_PPC_TLS_PCREL,       // symbol@tls@pcrel 
     VK_PPC_TLSLD,           // symbol@tlsld
     VK_PPC_LOCAL,           // symbol@local
     VK_PPC_NOTOC,           // symbol@notoc
-    VK_PPC_PCREL_OPT,       // .reloc expr, R_PPC64_PCREL_OPT, expr
+    VK_PPC_PCREL_OPT,       // .reloc expr, R_PPC64_PCREL_OPT, expr 
 
     VK_COFF_IMGREL32, // symbol@imgrel (image-relative)
 
@@ -329,9 +329,9 @@ public:
     VK_Hexagon_IE_GOT,
 
     VK_WASM_TYPEINDEX, // Reference to a symbol's type (signature)
-    VK_WASM_TLSREL,    // Memory address relative to __tls_base
-    VK_WASM_MBREL,     // Memory address relative to __memory_base
-    VK_WASM_TBREL,     // Table index relative to __table_base
+    VK_WASM_TLSREL,    // Memory address relative to __tls_base 
+    VK_WASM_MBREL,     // Memory address relative to __memory_base 
+    VK_WASM_TBREL,     // Table index relative to __table_base 
 
     VK_AMDGPU_GOTPCREL32_LO, // symbol@gotpcrel32@lo
     VK_AMDGPU_GOTPCREL32_HI, // symbol@gotpcrel32@hi
@@ -364,16 +364,16 @@ private:
   /// The symbol being referenced.
   const MCSymbol *Symbol;
 
-  // Subclass data stores VariantKind in bits 0..15 and HasSubsectionsViaSymbols
-  // in bit 16.
+  // Subclass data stores VariantKind in bits 0..15 and HasSubsectionsViaSymbols 
+  // in bit 16. 
   static const unsigned VariantKindBits = 16;
   static const unsigned VariantKindMask = (1 << VariantKindBits) - 1;
 
   // FIXME: Remove this bit.
-  static const unsigned HasSubsectionsViaSymbolsBit = 1 << VariantKindBits;
+  static const unsigned HasSubsectionsViaSymbolsBit = 1 << VariantKindBits; 
 
   static unsigned encodeSubclassData(VariantKind Kind,
-                                     bool HasSubsectionsViaSymbols) {
+                                     bool HasSubsectionsViaSymbols) { 
     return (unsigned)Kind |
            (HasSubsectionsViaSymbols ? HasSubsectionsViaSymbolsBit : 0);
   }
@@ -501,7 +501,7 @@ public:
     Mul,  ///< Multiplication.
     NE,   ///< Inequality comparison.
     Or,   ///< Bitwise or.
-    OrNot, ///< Bitwise or not.
+    OrNot, ///< Bitwise or not. 
     Shl,  ///< Shift left.
     AShr, ///< Arithmetic shift right.
     LShr, ///< Logical shift right.
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCFragment.h b/contrib/libs/llvm12/include/llvm/MC/MCFragment.h
index b6f7f628ff..a9bc653f87 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCFragment.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCFragment.h
@@ -44,7 +44,7 @@ public:
     FT_Data,
     FT_CompactEncodedInst,
     FT_Fill,
-    FT_Nops,
+    FT_Nops, 
     FT_Relaxable,
     FT_Org,
     FT_Dwarf,
@@ -54,7 +54,7 @@ public:
     FT_SymbolId,
     FT_CVInlineLines,
     FT_CVDefRange,
-    FT_PseudoProbe,
+    FT_PseudoProbe, 
     FT_Dummy
   };
 
@@ -72,10 +72,10 @@ private:
   /// The layout order of this fragment.
   unsigned LayoutOrder;
 
-  /// The subsection this fragment belongs to. This is 0 if the fragment is not
-  // in any subsection.
-  unsigned SubsectionNumber = 0;
-
+  /// The subsection this fragment belongs to. This is 0 if the fragment is not 
+  // in any subsection. 
+  unsigned SubsectionNumber = 0; 
+ 
   FragmentType Kind;
 
   /// Whether fragment is being laid out.
@@ -114,9 +114,9 @@ public:
   bool hasInstructions() const { return HasInstructions; }
 
   void dump() const;
-
-  void setSubsectionNumber(unsigned Value) { SubsectionNumber = Value; }
-  unsigned getSubsectionNumber() const { return SubsectionNumber; }
+ 
+  void setSubsectionNumber(unsigned Value) { SubsectionNumber = Value; } 
+  unsigned getSubsectionNumber() const { return SubsectionNumber; } 
 };
 
 class MCDummyFragment : public MCFragment {
@@ -155,7 +155,7 @@ public:
     case MCFragment::FT_Data:
     case MCFragment::FT_Dwarf:
     case MCFragment::FT_DwarfFrame:
-    case MCFragment::FT_PseudoProbe:
+    case MCFragment::FT_PseudoProbe: 
       return true;
     }
   }
@@ -367,31 +367,31 @@ public:
   }
 };
 
-class MCNopsFragment : public MCFragment {
-  /// The number of bytes to insert.
-  int64_t Size;
-  /// Maximum number of bytes allowed in each NOP instruction.
-  int64_t ControlledNopLength;
-
-  /// Source location of the directive that this fragment was created for.
-  SMLoc Loc;
-
-public:
-  MCNopsFragment(int64_t NumBytes, int64_t ControlledNopLength, SMLoc L,
-                 MCSection *Sec = nullptr)
-      : MCFragment(FT_Nops, false, Sec), Size(NumBytes),
-        ControlledNopLength(ControlledNopLength), Loc(L) {}
-
-  int64_t getNumBytes() const { return Size; }
-  int64_t getControlledNopLength() const { return ControlledNopLength; }
-
-  SMLoc getLoc() const { return Loc; }
-
-  static bool classof(const MCFragment *F) {
-    return F->getKind() == MCFragment::FT_Nops;
-  }
-};
-
+class MCNopsFragment : public MCFragment { 
+  /// The number of bytes to insert. 
+  int64_t Size; 
+  /// Maximum number of bytes allowed in each NOP instruction. 
+  int64_t ControlledNopLength; 
+ 
+  /// Source location of the directive that this fragment was created for. 
+  SMLoc Loc; 
+ 
+public: 
+  MCNopsFragment(int64_t NumBytes, int64_t ControlledNopLength, SMLoc L, 
+                 MCSection *Sec = nullptr) 
+      : MCFragment(FT_Nops, false, Sec), Size(NumBytes), 
+        ControlledNopLength(ControlledNopLength), Loc(L) {} 
+ 
+  int64_t getNumBytes() const { return Size; } 
+  int64_t getControlledNopLength() const { return ControlledNopLength; } 
+ 
+  SMLoc getLoc() const { return Loc; } 
+ 
+  static bool classof(const MCFragment *F) { 
+    return F->getKind() == MCFragment::FT_Nops; 
+  } 
+}; 
+ 
 class MCOrgFragment : public MCFragment {
   /// Value to use for filling bytes.
   int8_t Value;
@@ -600,23 +600,23 @@ public:
     return F->getKind() == MCFragment::FT_BoundaryAlign;
   }
 };
-
-class MCPseudoProbeAddrFragment : public MCEncodedFragmentWithFixups<8, 1> {
-  /// The expression for the difference of the two symbols that
-  /// make up the address delta between two .pseudoprobe directives.
-  const MCExpr *AddrDelta;
-
-public:
-  MCPseudoProbeAddrFragment(const MCExpr *AddrDelta, MCSection *Sec = nullptr)
-      : MCEncodedFragmentWithFixups<8, 1>(FT_PseudoProbe, false, Sec),
-        AddrDelta(AddrDelta) {}
-
-  const MCExpr &getAddrDelta() const { return *AddrDelta; }
-
-  static bool classof(const MCFragment *F) {
-    return F->getKind() == MCFragment::FT_PseudoProbe;
-  }
-};
+ 
+class MCPseudoProbeAddrFragment : public MCEncodedFragmentWithFixups<8, 1> { 
+  /// The expression for the difference of the two symbols that 
+  /// make up the address delta between two .pseudoprobe directives. 
+  const MCExpr *AddrDelta; 
+ 
+public: 
+  MCPseudoProbeAddrFragment(const MCExpr *AddrDelta, MCSection *Sec = nullptr) 
+      : MCEncodedFragmentWithFixups<8, 1>(FT_PseudoProbe, false, Sec), 
+        AddrDelta(AddrDelta) {} 
+ 
+  const MCExpr &getAddrDelta() const { return *AddrDelta; } 
+ 
+  static bool classof(const MCFragment *F) { 
+    return F->getKind() == MCFragment::FT_PseudoProbe; 
+  } 
+}; 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCFRAGMENT_H
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCInst.h b/contrib/libs/llvm12/include/llvm/MC/MCInst.h
index 14fcd3eaf6..7ac711071f 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCInst.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCInst.h
@@ -188,7 +188,7 @@ public:
   MCOperand &getOperand(unsigned i) { return Operands[i]; }
   unsigned getNumOperands() const { return Operands.size(); }
 
-  void addOperand(const MCOperand Op) { Operands.push_back(Op); }
+  void addOperand(const MCOperand Op) { Operands.push_back(Op); } 
 
   using iterator = SmallVectorImpl<MCOperand>::iterator;
   using const_iterator = SmallVectorImpl<MCOperand>::const_iterator;
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCInstPrinter.h b/contrib/libs/llvm12/include/llvm/MC/MCInstPrinter.h
index df6f54b26a..6d6d24f30f 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCInstPrinter.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCInstPrinter.h
@@ -25,7 +25,7 @@ class MCAsmInfo;
 class MCInst;
 class MCOperand;
 class MCInstrInfo;
-class MCInstrAnalysis;
+class MCInstrAnalysis; 
 class MCRegisterInfo;
 class MCSubtargetInfo;
 class raw_ostream;
@@ -56,7 +56,7 @@ protected:
   const MCAsmInfo &MAI;
   const MCInstrInfo &MII;
   const MCRegisterInfo &MRI;
-  const MCInstrAnalysis *MIA = nullptr;
+  const MCInstrAnalysis *MIA = nullptr; 
 
   /// True if we are printing marked up assembly.
   bool UseMarkup = false;
@@ -72,9 +72,9 @@ protected:
   /// (llvm-objdump -d).
   bool PrintBranchImmAsAddress = false;
 
-  /// If true, symbolize branch target and memory reference operands.
-  bool SymbolizeOperands = false;
-
+  /// If true, symbolize branch target and memory reference operands. 
+  bool SymbolizeOperands = false; 
+ 
   /// Utility function for printing annotations.
   void printAnnotation(raw_ostream &OS, StringRef Annot);
 
@@ -95,10 +95,10 @@ public:
   /// Specify a stream to emit comments to.
   void setCommentStream(raw_ostream &OS) { CommentStream = &OS; }
 
-  /// Returns a pair containing the mnemonic for \p MI and the number of bits
-  /// left for further processing by printInstruction (generated by tablegen).
-  virtual std::pair<const char *, uint64_t> getMnemonic(const MCInst *MI) = 0;
-
+  /// Returns a pair containing the mnemonic for \p MI and the number of bits 
+  /// left for further processing by printInstruction (generated by tablegen). 
+  virtual std::pair<const char *, uint64_t> getMnemonic(const MCInst *MI) = 0; 
+ 
   /// Print the specified MCInst to the specified raw_ostream.
   ///
   /// \p Address the address of current instruction on most targets, used to
@@ -131,9 +131,9 @@ public:
     PrintBranchImmAsAddress = Value;
   }
 
-  void setSymbolizeOperands(bool Value) { SymbolizeOperands = Value; }
-  void setMCInstrAnalysis(const MCInstrAnalysis *Value) { MIA = Value; }
-
+  void setSymbolizeOperands(bool Value) { SymbolizeOperands = Value; } 
+  void setMCInstrAnalysis(const MCInstrAnalysis *Value) { MIA = Value; } 
+ 
   /// Utility function to print immediates in decimal or hex.
   format_object<int64_t> formatImm(int64_t Value) const {
     return PrintImmHex ? formatHex(Value) : formatDec(Value);
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCInstrDesc.h b/contrib/libs/llvm12/include/llvm/MC/MCInstrDesc.h
index cb90a78f4e..db29717df0 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCInstrDesc.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCInstrDesc.h
@@ -34,22 +34,22 @@ class MCInst;
 //===----------------------------------------------------------------------===//
 
 namespace MCOI {
-/// Operand constraints. These are encoded in 16 bits with one of the
-/// low-order 3 bits specifying that a constraint is present and the
-/// corresponding high-order hex digit specifying the constraint value.
-/// This allows for a maximum of 3 constraints.
+/// Operand constraints. These are encoded in 16 bits with one of the 
+/// low-order 3 bits specifying that a constraint is present and the 
+/// corresponding high-order hex digit specifying the constraint value. 
+/// This allows for a maximum of 3 constraints. 
 enum OperandConstraint {
-  TIED_TO = 0,  // Must be allocated the same register as specified value.
-  EARLY_CLOBBER // If present, operand is an early clobber register.
+  TIED_TO = 0,  // Must be allocated the same register as specified value. 
+  EARLY_CLOBBER // If present, operand is an early clobber register. 
 };
 
-// Define a macro to produce each constraint value.
-#define MCOI_TIED_TO(op) \
-  ((1 << MCOI::TIED_TO) | ((op) << (4 + MCOI::TIED_TO * 4)))
-
-#define MCOI_EARLY_CLOBBER \
-  (1 << MCOI::EARLY_CLOBBER)
-
+// Define a macro to produce each constraint value. 
+#define MCOI_TIED_TO(op) \ 
+  ((1 << MCOI::TIED_TO) | ((op) << (4 + MCOI::TIED_TO * 4))) 
+ 
+#define MCOI_EARLY_CLOBBER \ 
+  (1 << MCOI::EARLY_CLOBBER) 
+ 
 /// These are flags set on operands, but should be considered
 /// private, all access should go through the MCOperandInfo accessors.
 /// See the accessors for a description of what these are.
@@ -102,9 +102,9 @@ public:
   /// Information about the type of the operand.
   uint8_t OperandType;
 
-  /// Operand constraints (see OperandConstraint enum).
-  uint16_t Constraints;
-
+  /// Operand constraints (see OperandConstraint enum). 
+  uint16_t Constraints; 
+ 
   /// Set if this operand is a pointer value and it requires a callback
   /// to look up its register class.
   bool isLookupPtrRegClass() const {
@@ -213,14 +213,14 @@ public:
   const MCPhysReg *ImplicitDefs; // Registers implicitly defined by this instr
   const MCOperandInfo *OpInfo;   // 'NumOperands' entries about operands
 
-  /// Returns the value of the specified operand constraint if
-  /// it is present. Returns -1 if it is not present.
+  /// Returns the value of the specified operand constraint if 
+  /// it is present. Returns -1 if it is not present. 
   int getOperandConstraint(unsigned OpNum,
                            MCOI::OperandConstraint Constraint) const {
     if (OpNum < NumOperands &&
         (OpInfo[OpNum].Constraints & (1 << Constraint))) {
-      unsigned ValuePos = 4 + Constraint * 4;
-      return (int)(OpInfo[OpNum].Constraints >> ValuePos) & 0x0f;
+      unsigned ValuePos = 4 + Constraint * 4; 
+      return (int)(OpInfo[OpNum].Constraints >> ValuePos) & 0x0f; 
     }
     return -1;
   }
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCMachObjectWriter.h b/contrib/libs/llvm12/include/llvm/MC/MCMachObjectWriter.h
index 8ffd972bb6..aaf5913e7a 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCMachObjectWriter.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCMachObjectWriter.h
@@ -121,7 +121,7 @@ class MachObjectWriter : public MCObjectWriter {
   /// \name Symbol Table Data
   /// @{
 
-  StringTableBuilder StringTable;
+  StringTableBuilder StringTable; 
   std::vector<MachSymbolData> LocalSymbolData;
   std::vector<MachSymbolData> ExternalSymbolData;
   std::vector<MachSymbolData> UndefinedSymbolData;
@@ -136,8 +136,8 @@ public:
   MachObjectWriter(std::unique_ptr<MCMachObjectTargetWriter> MOTW,
                    raw_pwrite_stream &OS, bool IsLittleEndian)
       : TargetObjectWriter(std::move(MOTW)),
-        StringTable(TargetObjectWriter->is64Bit() ? StringTableBuilder::MachO64
-                                                  : StringTableBuilder::MachO),
+        StringTable(TargetObjectWriter->is64Bit() ? StringTableBuilder::MachO64 
+                                                  : StringTableBuilder::MachO), 
         W(OS, IsLittleEndian ? support::little : support::big) {}
 
   support::endian::Writer W;
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCObjectFileInfo.h b/contrib/libs/llvm12/include/llvm/MC/MCObjectFileInfo.h
index 3e020bfd15..8bebe6adc7 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCObjectFileInfo.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCObjectFileInfo.h
@@ -181,10 +181,10 @@ protected:
   /// Section containing metadata on function stack sizes.
   MCSection *StackSizesSection = nullptr;
 
-  /// Section for pseudo probe information used by AutoFDO
-  MCSection *PseudoProbeSection = nullptr;
-  MCSection *PseudoProbeDescSection = nullptr;
-
+  /// Section for pseudo probe information used by AutoFDO 
+  MCSection *PseudoProbeSection = nullptr; 
+  MCSection *PseudoProbeDescSection = nullptr; 
+ 
   // ELF specific sections.
   MCSection *DataRelROSection = nullptr;
   MCSection *MergeableConst4Section = nullptr;
@@ -226,7 +226,7 @@ protected:
   MCSection *XDataSection = nullptr;
   MCSection *SXDataSection = nullptr;
   MCSection *GFIDsSection = nullptr;
-  MCSection *GIATsSection = nullptr;
+  MCSection *GIATsSection = nullptr; 
   MCSection *GLJMPSection = nullptr;
 
   // XCOFF specific sections
@@ -349,12 +349,12 @@ public:
 
   MCSection *getStackSizesSection(const MCSection &TextSec) const;
 
-  MCSection *getBBAddrMapSection(const MCSection &TextSec) const;
-
-  MCSection *getPseudoProbeSection(const MCSection *TextSec) const;
-
-  MCSection *getPseudoProbeDescSection(StringRef FuncName) const;
-
+  MCSection *getBBAddrMapSection(const MCSection &TextSec) const; 
+ 
+  MCSection *getPseudoProbeSection(const MCSection *TextSec) const; 
+ 
+  MCSection *getPseudoProbeDescSection(StringRef FuncName) const; 
+ 
   // ELF specific sections.
   MCSection *getDataRelROSection() const { return DataRelROSection; }
   const MCSection *getMergeableConst4Section() const {
@@ -413,13 +413,13 @@ public:
   MCSection *getXDataSection() const { return XDataSection; }
   MCSection *getSXDataSection() const { return SXDataSection; }
   MCSection *getGFIDsSection() const { return GFIDsSection; }
-  MCSection *getGIATsSection() const { return GIATsSection; }
+  MCSection *getGIATsSection() const { return GIATsSection; } 
   MCSection *getGLJMPSection() const { return GLJMPSection; }
 
   // XCOFF specific sections
   MCSection *getTOCBaseSection() const { return TOCBaseSection; }
 
-  MCSection *getEHFrameSection() const { return EHFrameSection; }
+  MCSection *getEHFrameSection() const { return EHFrameSection; } 
 
   enum Environment { IsMachO, IsELF, IsCOFF, IsWasm, IsXCOFF };
   Environment getObjectFileType() const { return Env; }
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCObjectStreamer.h b/contrib/libs/llvm12/include/llvm/MC/MCObjectStreamer.h
index f1e47eab00..5ec29c3498 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCObjectStreamer.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCObjectStreamer.h
@@ -186,8 +186,8 @@ public:
                 SMLoc Loc = SMLoc()) override;
   void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
                 SMLoc Loc = SMLoc()) override;
-  void emitNops(int64_t NumBytes, int64_t ControlledNopLength,
-                SMLoc Loc) override;
+  void emitNops(int64_t NumBytes, int64_t ControlledNopLength, 
+                SMLoc Loc) override; 
   void emitFileDirective(StringRef Filename) override;
 
   void emitAddrsig() override;
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCParser/AsmLexer.h b/contrib/libs/llvm12/include/llvm/MC/MCParser/AsmLexer.h
index 47d4149dd6..9a4bd2fb02 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCParser/AsmLexer.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCParser/AsmLexer.h
@@ -63,7 +63,7 @@ private:
   bool isAtStartOfComment(const char *Ptr);
   bool isAtStatementSeparator(const char *Ptr);
   int getNextChar();
-  int peekNextChar();
+  int peekNextChar(); 
   AsmToken ReturnError(const char *Loc, const std::string &Msg);
 
   AsmToken LexIdentifier();
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCParser/MCAsmLexer.h b/contrib/libs/llvm12/include/llvm/MC/MCParser/MCAsmLexer.h
index be14fd900d..9bd56e607a 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCParser/MCAsmLexer.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCParser/MCAsmLexer.h
@@ -56,11 +56,11 @@ protected: // Can only create subclasses.
   bool SkipSpace = true;
   bool AllowAtInIdentifier;
   bool IsAtStartOfStatement = true;
-  bool LexMasmHexFloats = false;
+  bool LexMasmHexFloats = false; 
   bool LexMasmIntegers = false;
-  bool LexMasmStrings = false;
-  bool UseMasmDefaultRadix = false;
-  unsigned DefaultRadix = 10;
+  bool LexMasmStrings = false; 
+  bool UseMasmDefaultRadix = false; 
+  unsigned DefaultRadix = 10; 
   AsmCommentConsumer *CommentConsumer = nullptr;
 
   MCAsmLexer();
@@ -158,23 +158,23 @@ public:
     this->CommentConsumer = CommentConsumer;
   }
 
-  /// Set whether to lex masm-style binary (e.g., 0b1101) and radix-specified
-  /// literals (e.g., 0ABCh [hex], 576t [decimal], 77o [octal], 1101y [binary]).
+  /// Set whether to lex masm-style binary (e.g., 0b1101) and radix-specified 
+  /// literals (e.g., 0ABCh [hex], 576t [decimal], 77o [octal], 1101y [binary]). 
   void setLexMasmIntegers(bool V) { LexMasmIntegers = V; }
-
-  /// Set whether to use masm-style default-radix integer literals. If disabled,
-  /// assume decimal unless prefixed (e.g., 0x2c [hex], 077 [octal]).
-  void useMasmDefaultRadix(bool V) { UseMasmDefaultRadix = V; }
-
-  unsigned getMasmDefaultRadix() const { return DefaultRadix; }
-  void setMasmDefaultRadix(unsigned Radix) { DefaultRadix = Radix; }
-
-  /// Set whether to lex masm-style hex float literals, such as 3f800000r.
-  void setLexMasmHexFloats(bool V) { LexMasmHexFloats = V; }
-
-  /// Set whether to lex masm-style string literals, such as 'Can''t find file'
-  /// and "This ""value"" not found".
-  void setLexMasmStrings(bool V) { LexMasmStrings = V; }
+ 
+  /// Set whether to use masm-style default-radix integer literals. If disabled, 
+  /// assume decimal unless prefixed (e.g., 0x2c [hex], 077 [octal]). 
+  void useMasmDefaultRadix(bool V) { UseMasmDefaultRadix = V; } 
+ 
+  unsigned getMasmDefaultRadix() const { return DefaultRadix; } 
+  void setMasmDefaultRadix(unsigned Radix) { DefaultRadix = Radix; } 
+ 
+  /// Set whether to lex masm-style hex float literals, such as 3f800000r. 
+  void setLexMasmHexFloats(bool V) { LexMasmHexFloats = V; } 
+ 
+  /// Set whether to lex masm-style string literals, such as 'Can''t find file' 
+  /// and "This ""value"" not found". 
+  void setLexMasmStrings(bool V) { LexMasmStrings = V; } 
 };
 
 } // end namespace llvm
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCParser/MCAsmParser.h b/contrib/libs/llvm12/include/llvm/MC/MCParser/MCAsmParser.h
index d8e1a5c9fa..2447aa9151 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCParser/MCAsmParser.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCParser/MCAsmParser.h
@@ -97,20 +97,20 @@ private:
   IdKind Kind;
 };
 
-// Generic type information for an assembly object.
-// All sizes measured in bytes.
-struct AsmTypeInfo {
-  StringRef Name;
-  unsigned Size = 0;
-  unsigned ElementSize = 0;
-  unsigned Length = 0;
-};
-
-struct AsmFieldInfo {
-  AsmTypeInfo Type;
-  unsigned Offset = 0;
-};
-
+// Generic type information for an assembly object. 
+// All sizes measured in bytes. 
+struct AsmTypeInfo { 
+  StringRef Name; 
+  unsigned Size = 0; 
+  unsigned ElementSize = 0; 
+  unsigned Length = 0; 
+}; 
+ 
+struct AsmFieldInfo { 
+  AsmTypeInfo Type; 
+  unsigned Offset = 0; 
+}; 
+ 
 /// Generic Sema callback for assembly parser.
 class MCAsmParserSemaCallback {
 public:
@@ -191,20 +191,20 @@ public:
 
   virtual bool isParsingMasm() const { return false; }
 
-  virtual bool defineMacro(StringRef Name, StringRef Value) { return true; }
-
-  virtual bool lookUpField(StringRef Name, AsmFieldInfo &Info) const {
-    return true;
-  }
-  virtual bool lookUpField(StringRef Base, StringRef Member,
-                           AsmFieldInfo &Info) const {
+  virtual bool defineMacro(StringRef Name, StringRef Value) { return true; } 
+ 
+  virtual bool lookUpField(StringRef Name, AsmFieldInfo &Info) const { 
     return true;
   }
-
-  virtual bool lookUpType(StringRef Name, AsmTypeInfo &Info) const {
+  virtual bool lookUpField(StringRef Base, StringRef Member, 
+                           AsmFieldInfo &Info) const { 
     return true;
   }
 
+  virtual bool lookUpType(StringRef Name, AsmTypeInfo &Info) const { 
+    return true; 
+  } 
+ 
   /// Parse MS-style inline assembly.
   virtual bool parseMSInlineAsm(
       void *AsmLoc, std::string &AsmString, unsigned &NumOutputs,
@@ -307,8 +307,8 @@ public:
   /// \param Res - The value of the expression. The result is undefined
   /// on error.
   /// \return - False on success.
-  virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
-                                AsmTypeInfo *TypeInfo) = 0;
+  virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc, 
+                                AsmTypeInfo *TypeInfo) = 0; 
 
   /// Parse an arbitrary expression, assuming that an initial '(' has
   /// already been consumed.
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCParser/MCTargetAsmParser.h b/contrib/libs/llvm12/include/llvm/MC/MCParser/MCTargetAsmParser.h
index 2241332057..fdaddca970 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCParser/MCTargetAsmParser.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCParser/MCTargetAsmParser.h
@@ -376,7 +376,7 @@ public:
 
   // Target-specific parsing of expression.
   virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
-    return getParser().parsePrimaryExpr(Res, EndLoc, nullptr);
+    return getParser().parsePrimaryExpr(Res, EndLoc, nullptr); 
   }
 
   virtual bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCPseudoProbe.h b/contrib/libs/llvm12/include/llvm/MC/MCPseudoProbe.h
index 8cc77d0e97..b3d8565696 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCPseudoProbe.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCPseudoProbe.h
@@ -1,189 +1,189 @@
-#pragma once
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
-//===- MCPseudoProbe.h - Pseudo probe encoding support ---------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains the declaration of the MCPseudoProbe to support the pseudo
-// probe encoding for AutoFDO. Pseudo probes together with their inline context
-// are encoded in a DFS recursive way in the .pseudoprobe sections. For each
-// .pseudoprobe section, the encoded binary data consist of a single or mutiple
-// function records each for one outlined function. A function record has the
-// following format :
-//
-// FUNCTION BODY (one for each outlined function present in the text section)
-//    GUID (uint64)
-//        GUID of the function
-//    NPROBES (ULEB128)
-//        Number of probes originating from this function.
-//    NUM_INLINED_FUNCTIONS (ULEB128)
-//        Number of callees inlined into this function, aka number of
-//        first-level inlinees
-//    PROBE RECORDS
-//        A list of NPROBES entries. Each entry contains:
-//          INDEX (ULEB128)
-//          TYPE (uint4)
-//            0 - block probe, 1 - indirect call, 2 - direct call
-//          ATTRIBUTE (uint3)
-//            reserved
-//          ADDRESS_TYPE (uint1)
-//            0 - code address, 1 - address delta
-//          CODE_ADDRESS (uint64 or ULEB128)
-//            code address or address delta, depending on ADDRESS_TYPE
-//    INLINED FUNCTION RECORDS
-//        A list of NUM_INLINED_FUNCTIONS entries describing each of the inlined
-//        callees.  Each record contains:
-//          INLINE SITE
-//            GUID of the inlinee (uint64)
-//            ID of the callsite probe (ULEB128)
-//          FUNCTION BODY
-//            A FUNCTION BODY entry describing the inlined function.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_MC_MCPSEUDOPROBE_H
-#define LLVM_MC_MCPSEUDOPROBE_H
-
-#include "llvm/ADT/MapVector.h"
-#include "llvm/MC/MCSection.h"
-#include <functional>
-#include <map>
-#include <vector>
-
-namespace llvm {
-
-class MCStreamer;
-class MCSymbol;
-class MCObjectStreamer;
-
-enum class MCPseudoProbeFlag {
-  // If set, indicates that the probe is encoded as an address delta
-  // instead of a real code address.
-  AddressDelta = 0x1,
-};
-
-/// Instances of this class represent a pseudo probe instance for a pseudo probe
-/// table entry, which is created during a machine instruction is assembled and
-/// uses an address from a temporary label created at the current address in the
-/// current section.
-class MCPseudoProbe {
-  MCSymbol *Label;
-  uint64_t Guid;
-  uint64_t Index;
-  uint8_t Type;
-  uint8_t Attributes;
-
-public:
-  MCPseudoProbe(MCSymbol *Label, uint64_t Guid, uint64_t Index, uint64_t Type,
-                uint64_t Attributes)
-      : Label(Label), Guid(Guid), Index(Index), Type(Type),
-        Attributes(Attributes) {
-    assert(Type <= 0xFF && "Probe type too big to encode, exceeding 2^8");
-    assert(Attributes <= 0xFF &&
-           "Probe attributes too big to encode, exceeding 2^16");
-  }
-
-  MCSymbol *getLabel() const { return Label; }
-
-  uint64_t getGuid() const { return Guid; }
-
-  uint64_t getIndex() const { return Index; }
-
-  uint8_t getType() const { return Type; }
-
-  uint8_t getAttributes() const { return Attributes; }
-
-  void emit(MCObjectStreamer *MCOS, const MCPseudoProbe *LastProbe) const;
-};
-
-// An inline frame has the form <Guid, ProbeID>
-using InlineSite = std::tuple<uint64_t, uint32_t>;
-using MCPseudoProbeInlineStack = SmallVector<InlineSite, 8>;
-
-// A Tri-tree based data structure to group probes by inline stack.
-// A tree is allocated for a standalone .text section. A fake
-// instance is created as the root of a tree.
-// A real instance of this class is created for each function, either an
-// unlined function that has code in .text section or an inlined function.
-class MCPseudoProbeInlineTree {
-  uint64_t Guid;
-  // Set of probes that come with the function.
-  std::vector<MCPseudoProbe> Probes;
-  // Use std::map for a deterministic output.
-  std::map<InlineSite, MCPseudoProbeInlineTree *> Inlinees;
-
-  // Root node has a GUID 0.
-  bool isRoot() { return Guid == 0; }
-  MCPseudoProbeInlineTree *getOrAddNode(InlineSite Site);
-
-public:
-  MCPseudoProbeInlineTree() = default;
-  MCPseudoProbeInlineTree(uint64_t Guid) : Guid(Guid) {}
-  ~MCPseudoProbeInlineTree();
-  void addPseudoProbe(const MCPseudoProbe &Probe,
-                      const MCPseudoProbeInlineStack &InlineStack);
-  void emit(MCObjectStreamer *MCOS, const MCPseudoProbe *&LastProbe);
-};
-
-/// Instances of this class represent the pseudo probes inserted into a compile
-/// unit.
-class MCPseudoProbeSection {
-public:
-  void addPseudoProbe(MCSection *Sec, const MCPseudoProbe &Probe,
-                      const MCPseudoProbeInlineStack &InlineStack) {
-    MCProbeDivisions[Sec].addPseudoProbe(Probe, InlineStack);
-  }
-
-  // TODO: Sort by getOrdinal to ensure a determinstic section order
-  using MCProbeDivisionMap = std::map<MCSection *, MCPseudoProbeInlineTree>;
-
-private:
-  // A collection of MCPseudoProbe for each text section. The MCPseudoProbes
-  // are grouped by GUID of the functions where they are from and will be
-  // encoded by groups. In the comdat scenario where a text section really only
-  // contains the code of a function solely, the probes associated with a comdat
-  // function are still grouped by GUIDs due to inlining that can bring probes
-  // from different functions into one function.
-  MCProbeDivisionMap MCProbeDivisions;
-
-public:
-  const MCProbeDivisionMap &getMCProbes() const { return MCProbeDivisions; }
-
-  bool empty() const { return MCProbeDivisions.empty(); }
-
-  void emit(MCObjectStreamer *MCOS);
-};
-
-class MCPseudoProbeTable {
-  // A collection of MCPseudoProbe in the current module grouped by text
-  // sections. MCPseudoProbes will be encoded into a corresponding
-  // .pseudoprobe section. With functions emitted as separate comdats,
-  // a text section really only contains the code of a function solely, and the
-  // probes associated with the text section will be emitted into a standalone
-  // .pseudoprobe section that shares the same comdat group with the function.
-  MCPseudoProbeSection MCProbeSections;
-
-public:
-  static void emit(MCObjectStreamer *MCOS);
-
-  MCPseudoProbeSection &getProbeSections() { return MCProbeSections; }
-
-#ifndef NDEBUG
-  static int DdgPrintIndent;
-#endif
-};
-} // end namespace llvm
-
-#endif // LLVM_MC_MCPSEUDOPROBE_H
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
+#pragma once 
+ 
+#ifdef __GNUC__ 
+#pragma GCC diagnostic push 
+#pragma GCC diagnostic ignored "-Wunused-parameter" 
+#endif 
+ 
+//===- MCPseudoProbe.h - Pseudo probe encoding support ---------*- C++ -*-===// 
+// 
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
+// See https://llvm.org/LICENSE.txt for license information. 
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
+// 
+//===----------------------------------------------------------------------===// 
+// 
+// This file contains the declaration of the MCPseudoProbe to support the pseudo 
+// probe encoding for AutoFDO. Pseudo probes together with their inline context 
+// are encoded in a DFS recursive way in the .pseudoprobe sections. For each 
+// .pseudoprobe section, the encoded binary data consist of a single or mutiple 
+// function records each for one outlined function. A function record has the 
+// following format : 
+// 
+// FUNCTION BODY (one for each outlined function present in the text section) 
+//    GUID (uint64) 
+//        GUID of the function 
+//    NPROBES (ULEB128) 
+//        Number of probes originating from this function. 
+//    NUM_INLINED_FUNCTIONS (ULEB128) 
+//        Number of callees inlined into this function, aka number of 
+//        first-level inlinees 
+//    PROBE RECORDS 
+//        A list of NPROBES entries. Each entry contains: 
+//          INDEX (ULEB128) 
+//          TYPE (uint4) 
+//            0 - block probe, 1 - indirect call, 2 - direct call 
+//          ATTRIBUTE (uint3) 
+//            reserved 
+//          ADDRESS_TYPE (uint1) 
+//            0 - code address, 1 - address delta 
+//          CODE_ADDRESS (uint64 or ULEB128) 
+//            code address or address delta, depending on ADDRESS_TYPE 
+//    INLINED FUNCTION RECORDS 
+//        A list of NUM_INLINED_FUNCTIONS entries describing each of the inlined 
+//        callees.  Each record contains: 
+//          INLINE SITE 
+//            GUID of the inlinee (uint64) 
+//            ID of the callsite probe (ULEB128) 
+//          FUNCTION BODY 
+//            A FUNCTION BODY entry describing the inlined function. 
+//===----------------------------------------------------------------------===// 
+ 
+#ifndef LLVM_MC_MCPSEUDOPROBE_H 
+#define LLVM_MC_MCPSEUDOPROBE_H 
+ 
+#include "llvm/ADT/MapVector.h" 
+#include "llvm/MC/MCSection.h" 
+#include <functional> 
+#include <map> 
+#include <vector> 
+ 
+namespace llvm { 
+ 
+class MCStreamer; 
+class MCSymbol; 
+class MCObjectStreamer; 
+ 
+enum class MCPseudoProbeFlag { 
+  // If set, indicates that the probe is encoded as an address delta 
+  // instead of a real code address. 
+  AddressDelta = 0x1, 
+}; 
+ 
+/// Instances of this class represent a pseudo probe instance for a pseudo probe 
+/// table entry, which is created during a machine instruction is assembled and 
+/// uses an address from a temporary label created at the current address in the 
+/// current section. 
+class MCPseudoProbe { 
+  MCSymbol *Label; 
+  uint64_t Guid; 
+  uint64_t Index; 
+  uint8_t Type; 
+  uint8_t Attributes; 
+ 
+public: 
+  MCPseudoProbe(MCSymbol *Label, uint64_t Guid, uint64_t Index, uint64_t Type, 
+                uint64_t Attributes) 
+      : Label(Label), Guid(Guid), Index(Index), Type(Type), 
+        Attributes(Attributes) { 
+    assert(Type <= 0xFF && "Probe type too big to encode, exceeding 2^8"); 
+    assert(Attributes <= 0xFF && 
+           "Probe attributes too big to encode, exceeding 2^16"); 
+  } 
+ 
+  MCSymbol *getLabel() const { return Label; } 
+ 
+  uint64_t getGuid() const { return Guid; } 
+ 
+  uint64_t getIndex() const { return Index; } 
+ 
+  uint8_t getType() const { return Type; } 
+ 
+  uint8_t getAttributes() const { return Attributes; } 
+ 
+  void emit(MCObjectStreamer *MCOS, const MCPseudoProbe *LastProbe) const; 
+}; 
+ 
+// An inline frame has the form <Guid, ProbeID> 
+using InlineSite = std::tuple<uint64_t, uint32_t>; 
+using MCPseudoProbeInlineStack = SmallVector<InlineSite, 8>; 
+ 
+// A Tri-tree based data structure to group probes by inline stack. 
+// A tree is allocated for a standalone .text section. A fake 
+// instance is created as the root of a tree. 
+// A real instance of this class is created for each function, either an 
+// unlined function that has code in .text section or an inlined function. 
+class MCPseudoProbeInlineTree { 
+  uint64_t Guid; 
+  // Set of probes that come with the function. 
+  std::vector<MCPseudoProbe> Probes; 
+  // Use std::map for a deterministic output. 
+  std::map<InlineSite, MCPseudoProbeInlineTree *> Inlinees; 
+ 
+  // Root node has a GUID 0. 
+  bool isRoot() { return Guid == 0; } 
+  MCPseudoProbeInlineTree *getOrAddNode(InlineSite Site); 
+ 
+public: 
+  MCPseudoProbeInlineTree() = default; 
+  MCPseudoProbeInlineTree(uint64_t Guid) : Guid(Guid) {} 
+  ~MCPseudoProbeInlineTree(); 
+  void addPseudoProbe(const MCPseudoProbe &Probe, 
+                      const MCPseudoProbeInlineStack &InlineStack); 
+  void emit(MCObjectStreamer *MCOS, const MCPseudoProbe *&LastProbe); 
+}; 
+ 
+/// Instances of this class represent the pseudo probes inserted into a compile 
+/// unit. 
+class MCPseudoProbeSection { 
+public: 
+  void addPseudoProbe(MCSection *Sec, const MCPseudoProbe &Probe, 
+                      const MCPseudoProbeInlineStack &InlineStack) { 
+    MCProbeDivisions[Sec].addPseudoProbe(Probe, InlineStack); 
+  } 
+ 
+  // TODO: Sort by getOrdinal to ensure a determinstic section order 
+  using MCProbeDivisionMap = std::map<MCSection *, MCPseudoProbeInlineTree>; 
+ 
+private: 
+  // A collection of MCPseudoProbe for each text section. The MCPseudoProbes 
+  // are grouped by GUID of the functions where they are from and will be 
+  // encoded by groups. In the comdat scenario where a text section really only 
+  // contains the code of a function solely, the probes associated with a comdat 
+  // function are still grouped by GUIDs due to inlining that can bring probes 
+  // from different functions into one function. 
+  MCProbeDivisionMap MCProbeDivisions; 
+ 
+public: 
+  const MCProbeDivisionMap &getMCProbes() const { return MCProbeDivisions; } 
+ 
+  bool empty() const { return MCProbeDivisions.empty(); } 
+ 
+  void emit(MCObjectStreamer *MCOS); 
+}; 
+ 
+class MCPseudoProbeTable { 
+  // A collection of MCPseudoProbe in the current module grouped by text 
+  // sections. MCPseudoProbes will be encoded into a corresponding 
+  // .pseudoprobe section. With functions emitted as separate comdats, 
+  // a text section really only contains the code of a function solely, and the 
+  // probes associated with the text section will be emitted into a standalone 
+  // .pseudoprobe section that shares the same comdat group with the function. 
+  MCPseudoProbeSection MCProbeSections; 
+ 
+public: 
+  static void emit(MCObjectStreamer *MCOS); 
+ 
+  MCPseudoProbeSection &getProbeSections() { return MCProbeSections; } 
+ 
+#ifndef NDEBUG 
+  static int DdgPrintIndent; 
+#endif 
+}; 
+} // end namespace llvm 
+ 
+#endif // LLVM_MC_MCPSEUDOPROBE_H 
+ 
+#ifdef __GNUC__ 
+#pragma GCC diagnostic pop 
+#endif 
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCRegister.h b/contrib/libs/llvm12/include/llvm/MC/MCRegister.h
index 2d9bd6ff08..92d36e2e87 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCRegister.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCRegister.h
@@ -27,7 +27,7 @@ using MCPhysReg = uint16_t;
 
 /// Wrapper class representing physical registers. Should be passed by value.
 class MCRegister {
-  friend hash_code hash_value(const MCRegister &);
+  friend hash_code hash_value(const MCRegister &); 
   unsigned Reg;
 
 public:
@@ -55,25 +55,25 @@ public:
   /// Register::isStackSlot() for the more information on them.
   ///
   static bool isStackSlot(unsigned Reg) {
-    return FirstStackSlot <= Reg && Reg < VirtualRegFlag;
+    return FirstStackSlot <= Reg && Reg < VirtualRegFlag; 
   }
 
   /// Return true if the specified register number is in
   /// the physical register namespace.
   static bool isPhysicalRegister(unsigned Reg) {
-    return FirstPhysicalReg <= Reg && Reg < FirstStackSlot;
+    return FirstPhysicalReg <= Reg && Reg < FirstStackSlot; 
   }
 
   constexpr operator unsigned() const {
     return Reg;
   }
 
-  /// Check the provided unsigned value is a valid MCRegister.
-  static MCRegister from(unsigned Val) {
-    assert(Val == NoRegister || isPhysicalRegister(Val));
-    return MCRegister(Val);
-  }
-
+  /// Check the provided unsigned value is a valid MCRegister. 
+  static MCRegister from(unsigned Val) { 
+    assert(Val == NoRegister || isPhysicalRegister(Val)); 
+    return MCRegister(Val); 
+  } 
+ 
   unsigned id() const {
     return Reg;
   }
@@ -113,10 +113,10 @@ template<> struct DenseMapInfo<MCRegister> {
   }
 };
 
-inline hash_code hash_value(const MCRegister &Reg) {
-  return hash_value(Reg.id());
-}
+inline hash_code hash_value(const MCRegister &Reg) { 
+  return hash_value(Reg.id()); 
 }
+} 
 
 #endif // ifndef LLVM_MC_REGISTER_H
 
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCRegisterInfo.h b/contrib/libs/llvm12/include/llvm/MC/MCRegisterInfo.h
index 4f6997edd6..8c53307820 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCRegisterInfo.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCRegisterInfo.h
@@ -682,7 +682,7 @@ public:
 
   MCRegUnitIterator(MCRegister Reg, const MCRegisterInfo *MCRI) {
     assert(Reg && "Null register has no regunits");
-    assert(MCRegister::isPhysicalRegister(Reg.id()));
+    assert(MCRegister::isPhysicalRegister(Reg.id())); 
     // Decode the RegUnits MCRegisterDesc field.
     unsigned RU = MCRI->get(Reg).RegUnits;
     unsigned Scale = RU & 15;
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCSchedule.h b/contrib/libs/llvm12/include/llvm/MC/MCSchedule.h
index efe15a2eff..fe04d31dd2 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCSchedule.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCSchedule.h
@@ -212,7 +212,7 @@ struct MCExtraProcessorInfo {
 /// subtargets can't be done. Nonetheless, the abstract model is
 /// useful. Futhermore, subtargets typically extend this model with processor
 /// specific resources to model any hardware features that can be exploited by
-/// scheduling heuristics and aren't sufficiently represented in the abstract.
+/// scheduling heuristics and aren't sufficiently represented in the abstract. 
 ///
 /// The abstract pipeline is built around the notion of an "issue point". This
 /// is merely a reference point for counting machine cycles. The physical
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCSectionXCOFF.h b/contrib/libs/llvm12/include/llvm/MC/MCSectionXCOFF.h
index 8382900211..9ced2fcb26 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCSectionXCOFF.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCSectionXCOFF.h
@@ -43,21 +43,21 @@ class MCSectionXCOFF final : public MCSection {
   XCOFF::SymbolType Type;
   MCSymbolXCOFF *const QualName;
   StringRef SymbolTableName;
-  bool MultiSymbolsAllowed;
+  bool MultiSymbolsAllowed; 
   static constexpr unsigned DefaultAlignVal = 4;
 
   MCSectionXCOFF(StringRef Name, XCOFF::StorageMappingClass SMC,
-                 XCOFF::SymbolType ST, SectionKind K, MCSymbolXCOFF *QualName,
-                 MCSymbol *Begin, StringRef SymbolTableName,
-                 bool MultiSymbolsAllowed)
+                 XCOFF::SymbolType ST, SectionKind K, MCSymbolXCOFF *QualName, 
+                 MCSymbol *Begin, StringRef SymbolTableName, 
+                 bool MultiSymbolsAllowed) 
       : MCSection(SV_XCOFF, Name, K, Begin), MappingClass(SMC), Type(ST),
-        QualName(QualName), SymbolTableName(SymbolTableName),
-        MultiSymbolsAllowed(MultiSymbolsAllowed) {
+        QualName(QualName), SymbolTableName(SymbolTableName), 
+        MultiSymbolsAllowed(MultiSymbolsAllowed) { 
     assert((ST == XCOFF::XTY_SD || ST == XCOFF::XTY_CM || ST == XCOFF::XTY_ER) &&
            "Invalid or unhandled type for csect.");
     assert(QualName != nullptr && "QualName is needed.");
     QualName->setRepresentedCsect(this);
-    QualName->setStorageClass(XCOFF::C_HIDEXT);
+    QualName->setStorageClass(XCOFF::C_HIDEXT); 
     // A csect is 4 byte aligned by default, except for undefined symbol csects.
     if (Type != XCOFF::XTY_ER)
       setAlignment(Align(DefaultAlignVal));
@@ -73,9 +73,9 @@ public:
   }
 
   XCOFF::StorageMappingClass getMappingClass() const { return MappingClass; }
-  XCOFF::StorageClass getStorageClass() const {
-    return QualName->getStorageClass();
-  }
+  XCOFF::StorageClass getStorageClass() const { 
+    return QualName->getStorageClass(); 
+  } 
   XCOFF::SymbolType getCSectType() const { return Type; }
   MCSymbolXCOFF *getQualNameSymbol() const { return QualName; }
 
@@ -85,7 +85,7 @@ public:
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
   StringRef getSymbolTableName() const { return SymbolTableName; }
-  bool isMultiSymbolsAllowed() const { return MultiSymbolsAllowed; }
+  bool isMultiSymbolsAllowed() const { return MultiSymbolsAllowed; } 
 };
 
 } // end namespace llvm
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCStreamer.h b/contrib/libs/llvm12/include/llvm/MC/MCStreamer.h
index 4802d6cb35..4bc2f50c04 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCStreamer.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCStreamer.h
@@ -20,7 +20,7 @@
 #ifndef LLVM_MC_MCSTREAMER_H
 #define LLVM_MC_MCSTREAMER_H
 
-#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/APInt.h" 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
@@ -28,7 +28,7 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCLinkerOptimizationHint.h"
-#include "llvm/MC/MCPseudoProbe.h"
+#include "llvm/MC/MCPseudoProbe.h" 
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCWinEH.h"
 #include "llvm/Support/Error.h"
@@ -214,7 +214,7 @@ class MCStreamer {
   std::vector<std::unique_ptr<WinEH::FrameInfo>> WinFrameInfos;
 
   WinEH::FrameInfo *CurrentWinFrameInfo;
-  size_t CurrentProcWinFrameInfoStartIndex;
+  size_t CurrentProcWinFrameInfoStartIndex; 
 
   /// Tracks an index to represent the order a symbol was emitted in.
   /// Zero means we did not emit that symbol.
@@ -224,10 +224,10 @@ class MCStreamer {
   /// PushSection.
   SmallVector<std::pair<MCSectionSubPair, MCSectionSubPair>, 4> SectionStack;
 
-  /// Pointer to the parser's SMLoc if available. This is used to provide
-  /// locations for diagnostics.
-  const SMLoc *StartTokLocPtr = nullptr;
-
+  /// Pointer to the parser's SMLoc if available. This is used to provide 
+  /// locations for diagnostics. 
+  const SMLoc *StartTokLocPtr = nullptr; 
+ 
   /// The next unique ID to use when creating a WinCFI-related section (.pdata
   /// or .xdata). This ID ensures that we have a one-to-one mapping from
   /// code section to unwind info section, which MSVC's incremental linker
@@ -253,8 +253,8 @@ protected:
     return CurrentWinFrameInfo;
   }
 
-  virtual void EmitWindowsUnwindTables(WinEH::FrameInfo *Frame);
-
+  virtual void EmitWindowsUnwindTables(WinEH::FrameInfo *Frame); 
+ 
   virtual void EmitWindowsUnwindTables();
 
   virtual void emitRawTextImpl(StringRef String);
@@ -274,11 +274,11 @@ public:
     TargetStreamer.reset(TS);
   }
 
-  void setStartTokLocPtr(const SMLoc *Loc) { StartTokLocPtr = Loc; }
-  SMLoc getStartTokLoc() const {
-    return StartTokLocPtr ? *StartTokLocPtr : SMLoc();
-  }
-
+  void setStartTokLocPtr(const SMLoc *Loc) { StartTokLocPtr = Loc; } 
+  SMLoc getStartTokLoc() const { 
+    return StartTokLocPtr ? *StartTokLocPtr : SMLoc(); 
+  } 
+ 
   /// State management
   ///
   virtual void reset();
@@ -463,10 +463,10 @@ public:
   /// so we can sort on them later.
   void AssignFragment(MCSymbol *Symbol, MCFragment *Fragment);
 
-  /// Returns the mnemonic for \p MI, if the streamer has access to a
-  /// instruction printer and returns an empty string otherwise.
-  virtual StringRef getMnemonic(MCInst &MI) { return ""; }
-
+  /// Returns the mnemonic for \p MI, if the streamer has access to a 
+  /// instruction printer and returns an empty string otherwise. 
+  virtual StringRef getMnemonic(MCInst &MI) { return ""; } 
+ 
   /// Emit a label for \p Symbol into the current section.
   ///
   /// This corresponds to an assembler statement such as:
@@ -698,7 +698,7 @@ public:
   /// Special case of EmitValue that avoids the client having
   /// to pass in a MCExpr for constant integers.
   virtual void emitIntValue(uint64_t Value, unsigned Size);
-  virtual void emitIntValue(APInt Value);
+  virtual void emitIntValue(APInt Value); 
 
   /// Special case of EmitValue that avoids the client having to pass
   /// in a MCExpr for constant integers & prints in Hex format for certain
@@ -803,9 +803,9 @@ public:
   virtual void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
                         SMLoc Loc = SMLoc());
 
-  virtual void emitNops(int64_t NumBytes, int64_t ControlledNopLength,
-                        SMLoc Loc);
-
+  virtual void emitNops(int64_t NumBytes, int64_t ControlledNopLength, 
+                        SMLoc Loc); 
+ 
   /// Emit NumBytes worth of zeros.
   /// This function properly handles data in virtual sections.
   void emitZeros(uint64_t NumBytes);
@@ -1057,11 +1057,11 @@ public:
   /// Emit the given \p Instruction into the current section.
   virtual void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
 
-  /// Emit the a pseudo probe into the current section.
-  virtual void emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type,
-                               uint64_t Attr,
-                               const MCPseudoProbeInlineStack &InlineStack);
-
+  /// Emit the a pseudo probe into the current section. 
+  virtual void emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type, 
+                               uint64_t Attr, 
+                               const MCPseudoProbeInlineStack &InlineStack); 
+ 
   /// Set the bundle alignment mode from now on in the section.
   /// The argument is the power of 2 to which the alignment is set. The
   /// value 0 means turn the bundle alignment off.
@@ -1084,7 +1084,7 @@ public:
   /// Streamer specific finalization.
   virtual void finishImpl();
   /// Finish emission of machine code.
-  void Finish(SMLoc EndLoc = SMLoc());
+  void Finish(SMLoc EndLoc = SMLoc()); 
 
   virtual bool mayHaveInstructions(MCSection &Sec) const { return true; }
 };
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCSubtargetInfo.h b/contrib/libs/llvm12/include/llvm/MC/MCSubtargetInfo.h
index b197f603bd..f6d9137599 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCSubtargetInfo.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCSubtargetInfo.h
@@ -61,7 +61,7 @@ struct SubtargetFeatureKV {
 struct SubtargetSubTypeKV {
   const char *Key;                      ///< K-V key string
   FeatureBitArray Implies;              ///< K-V bit mask
-  FeatureBitArray TuneImplies;          ///< K-V bit mask
+  FeatureBitArray TuneImplies;          ///< K-V bit mask 
   const MCSchedModel *SchedModel;
 
   /// Compare routine for std::lower_bound
@@ -82,7 +82,7 @@ struct SubtargetSubTypeKV {
 class MCSubtargetInfo {
   Triple TargetTriple;
   std::string CPU; // CPU being targeted.
-  std::string TuneCPU; // CPU being tuned for.
+  std::string TuneCPU; // CPU being tuned for. 
   ArrayRef<SubtargetFeatureKV> ProcFeatures;  // Processor feature list
   ArrayRef<SubtargetSubTypeKV> ProcDesc;  // Processor descriptions
 
@@ -99,8 +99,8 @@ class MCSubtargetInfo {
 
 public:
   MCSubtargetInfo(const MCSubtargetInfo &) = default;
-  MCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef TuneCPU,
-                  StringRef FS, ArrayRef<SubtargetFeatureKV> PF,
+  MCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef TuneCPU, 
+                  StringRef FS, ArrayRef<SubtargetFeatureKV> PF, 
                   ArrayRef<SubtargetSubTypeKV> PD,
                   const MCWriteProcResEntry *WPR, const MCWriteLatencyEntry *WL,
                   const MCReadAdvanceEntry *RA, const InstrStage *IS,
@@ -112,7 +112,7 @@ public:
 
   const Triple &getTargetTriple() const { return TargetTriple; }
   StringRef getCPU() const { return CPU; }
-  StringRef getTuneCPU() const { return TuneCPU; }
+  StringRef getTuneCPU() const { return TuneCPU; } 
 
   const FeatureBitset& getFeatureBits() const { return FeatureBits; }
   void setFeatureBits(const FeatureBitset &FeatureBits_) {
@@ -128,12 +128,12 @@ protected:
   ///
   /// FIXME: Find a way to stick this in the constructor, since it should only
   /// be called during initialization.
-  void InitMCProcessorInfo(StringRef CPU, StringRef TuneCPU, StringRef FS);
+  void InitMCProcessorInfo(StringRef CPU, StringRef TuneCPU, StringRef FS); 
 
 public:
-  /// Set the features to the default for the given CPU and TuneCPU, with ano
-  /// appended feature string.
-  void setDefaultFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS);
+  /// Set the features to the default for the given CPU and TuneCPU, with ano 
+  /// appended feature string. 
+  void setDefaultFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS); 
 
   /// Toggle a feature and return the re-computed feature bits.
   /// This version does not change the implied bits.
@@ -220,16 +220,16 @@ public:
   void initInstrItins(InstrItineraryData &InstrItins) const;
 
   /// Resolve a variant scheduling class for the given MCInst and CPU.
-  virtual unsigned resolveVariantSchedClass(unsigned SchedClass,
-                                            const MCInst *MI,
-                                            const MCInstrInfo *MCII,
-                                            unsigned CPUID) const {
+  virtual unsigned resolveVariantSchedClass(unsigned SchedClass, 
+                                            const MCInst *MI, 
+                                            const MCInstrInfo *MCII, 
+                                            unsigned CPUID) const { 
     return 0;
   }
 
   /// Check whether the CPU string is valid.
   bool isCPUStringValid(StringRef CPU) const {
-    auto Found = llvm::lower_bound(ProcDesc, CPU);
+    auto Found = llvm::lower_bound(ProcDesc, CPU); 
     return Found != ProcDesc.end() && StringRef(Found->Key) == CPU;
   }
 
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCSymbol.h b/contrib/libs/llvm12/include/llvm/MC/MCSymbol.h
index e87e24c0a9..739267eea0 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCSymbol.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCSymbol.h
@@ -23,7 +23,7 @@
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCExpr.h" 
 #include "llvm/MC/MCFragment.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
@@ -101,8 +101,8 @@ protected:
 
   mutable unsigned IsRegistered : 1;
 
-  /// True if this symbol is visible outside this translation unit. Note: ELF
-  /// uses binding instead of this bit.
+  /// True if this symbol is visible outside this translation unit. Note: ELF 
+  /// uses binding instead of this bit. 
   mutable unsigned IsExternal : 1;
 
   /// This symbol is private extern.
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCSymbolWasm.h b/contrib/libs/llvm12/include/llvm/MC/MCSymbolWasm.h
index 9f84b82191..6812b57334 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCSymbolWasm.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCSymbolWasm.h
@@ -32,7 +32,7 @@ class MCSymbolWasm : public MCSymbol {
   Optional<StringRef> ExportName;
   wasm::WasmSignature *Signature = nullptr;
   Optional<wasm::WasmGlobalType> GlobalType;
-  Optional<wasm::ValType> TableType;
+  Optional<wasm::ValType> TableType; 
   Optional<wasm::WasmEventType> EventType;
 
   /// An expression describing how to calculate the size of a symbol. If a
@@ -50,7 +50,7 @@ public:
   bool isFunction() const { return Type == wasm::WASM_SYMBOL_TYPE_FUNCTION; }
   bool isData() const { return Type == wasm::WASM_SYMBOL_TYPE_DATA; }
   bool isGlobal() const { return Type == wasm::WASM_SYMBOL_TYPE_GLOBAL; }
-  bool isTable() const { return Type == wasm::WASM_SYMBOL_TYPE_TABLE; }
+  bool isTable() const { return Type == wasm::WASM_SYMBOL_TYPE_TABLE; } 
   bool isSection() const { return Type == wasm::WASM_SYMBOL_TYPE_SECTION; }
   bool isEvent() const { return Type == wasm::WASM_SYMBOL_TYPE_EVENT; }
   wasm::WasmSymbolType getType() const { return Type; }
@@ -103,15 +103,15 @@ public:
   StringRef getExportName() const { return ExportName.getValue(); }
   void setExportName(StringRef Name) { ExportName = Name; }
 
-  bool isFunctionTable() const {
-    return isTable() && hasTableType() &&
-           getTableType() == wasm::ValType::FUNCREF;
-  }
-  void setFunctionTable() {
-    setType(wasm::WASM_SYMBOL_TYPE_TABLE);
-    setTableType(wasm::ValType::FUNCREF);
-  }
-
+  bool isFunctionTable() const { 
+    return isTable() && hasTableType() && 
+           getTableType() == wasm::ValType::FUNCREF; 
+  } 
+  void setFunctionTable() { 
+    setType(wasm::WASM_SYMBOL_TYPE_TABLE); 
+    setTableType(wasm::ValType::FUNCREF); 
+  } 
+ 
   void setUsedInGOT() const { IsUsedInGOT = true; }
   bool isUsedInGOT() const { return IsUsedInGOT; }
 
@@ -127,13 +127,13 @@ public:
   }
   void setGlobalType(wasm::WasmGlobalType GT) { GlobalType = GT; }
 
-  bool hasTableType() const { return TableType.hasValue(); }
-  wasm::ValType getTableType() const {
-    assert(hasTableType());
-    return TableType.getValue();
-  }
-  void setTableType(wasm::ValType TT) { TableType = TT; }
-
+  bool hasTableType() const { return TableType.hasValue(); } 
+  wasm::ValType getTableType() const { 
+    assert(hasTableType()); 
+    return TableType.getValue(); 
+  } 
+  void setTableType(wasm::ValType TT) { TableType = TT; } 
+ 
   const wasm::WasmEventType &getEventType() const {
     assert(EventType.hasValue());
     return EventType.getValue();
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCTargetOptions.h b/contrib/libs/llvm12/include/llvm/MC/MCTargetOptions.h
index fb097bf912..a9999d727f 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCTargetOptions.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCTargetOptions.h
@@ -29,7 +29,7 @@ enum class ExceptionHandling {
   ARM,      ///< ARM EHABI
   WinEH,    ///< Windows Exception Handling
   Wasm,     ///< WebAssembly Exception Handling
-  AIX,      ///< AIX Exception Handling
+  AIX,      ///< AIX Exception Handling 
 };
 
 enum class DebugCompressionType {
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCWasmObjectWriter.h b/contrib/libs/llvm12/include/llvm/MC/MCWasmObjectWriter.h
index 112bb19b93..9c91c37b59 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCWasmObjectWriter.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCWasmObjectWriter.h
@@ -59,10 +59,10 @@ std::unique_ptr<MCObjectWriter>
 createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
                        raw_pwrite_stream &OS);
 
-std::unique_ptr<MCObjectWriter>
-createWasmDwoObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
-                          raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS);
-
+std::unique_ptr<MCObjectWriter> 
+createWasmDwoObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW, 
+                          raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS); 
+ 
 } // namespace llvm
 
 #endif
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCWin64EH.h b/contrib/libs/llvm12/include/llvm/MC/MCWin64EH.h
index a7993d8304..8abc939974 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCWin64EH.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCWin64EH.h
@@ -60,15 +60,15 @@ struct Instruction {
 class UnwindEmitter : public WinEH::UnwindEmitter {
 public:
   void Emit(MCStreamer &Streamer) const override;
-  void EmitUnwindInfo(MCStreamer &Streamer, WinEH::FrameInfo *FI,
-                      bool HandlerData) const override;
+  void EmitUnwindInfo(MCStreamer &Streamer, WinEH::FrameInfo *FI, 
+                      bool HandlerData) const override; 
 };
 
 class ARM64UnwindEmitter : public WinEH::UnwindEmitter {
 public:
   void Emit(MCStreamer &Streamer) const override;
-  void EmitUnwindInfo(MCStreamer &Streamer, WinEH::FrameInfo *FI,
-                      bool HandlerData) const override;
+  void EmitUnwindInfo(MCStreamer &Streamer, WinEH::FrameInfo *FI, 
+                      bool HandlerData) const override; 
 };
 
 }
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCWinCOFFStreamer.h b/contrib/libs/llvm12/include/llvm/MC/MCWinCOFFStreamer.h
index 8fb135c08e..a3e4bd74a2 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCWinCOFFStreamer.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCWinCOFFStreamer.h
@@ -65,7 +65,7 @@ public:
                         unsigned ByteAlignment) override;
   void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                              unsigned ByteAlignment) override;
-  void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
+  void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override; 
   void emitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                     unsigned ByteAlignment, SMLoc Loc = SMLoc()) override;
   void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
diff --git a/contrib/libs/llvm12/include/llvm/MC/MCWinEH.h b/contrib/libs/llvm12/include/llvm/MC/MCWinEH.h
index 2143a40baa..9ebb76d3d4 100644
--- a/contrib/libs/llvm12/include/llvm/MC/MCWinEH.h
+++ b/contrib/libs/llvm12/include/llvm/MC/MCWinEH.h
@@ -33,14 +33,14 @@ struct Instruction {
 
   Instruction(unsigned Op, MCSymbol *L, unsigned Reg, unsigned Off)
     : Label(L), Offset(Off), Register(Reg), Operation(Op) {}
-
-  bool operator==(const Instruction &I) const {
-    // Check whether two instructions refer to the same operation
-    // applied at a different spot (i.e. pointing at a different label).
-    return Offset == I.Offset && Register == I.Register &&
-           Operation == I.Operation;
-  }
-  bool operator!=(const Instruction &I) const { return !(*this == I); }
+ 
+  bool operator==(const Instruction &I) const { 
+    // Check whether two instructions refer to the same operation 
+    // applied at a different spot (i.e. pointing at a different label). 
+    return Offset == I.Offset && Register == I.Register && 
+           Operation == I.Operation; 
+  } 
+  bool operator!=(const Instruction &I) const { return !(*this == I); } 
 };
 
 struct FrameInfo {
@@ -51,12 +51,12 @@ struct FrameInfo {
   const MCSymbol *Function = nullptr;
   const MCSymbol *PrologEnd = nullptr;
   const MCSymbol *Symbol = nullptr;
-  MCSection *TextSection = nullptr;
-  uint32_t PackedInfo = 0;
+  MCSection *TextSection = nullptr; 
+  uint32_t PackedInfo = 0; 
 
   bool HandlesUnwind = false;
   bool HandlesExceptions = false;
-  bool EmitAttempted = false;
+  bool EmitAttempted = false; 
 
   int LastFrameInst = -1;
   const FrameInfo *ChainedParent = nullptr;
@@ -70,15 +70,15 @@ struct FrameInfo {
             const FrameInfo *ChainedParent)
       : Begin(BeginFuncEHLabel), Function(Function),
         ChainedParent(ChainedParent) {}
-
-  bool empty() const {
-    if (!Instructions.empty())
-      return false;
-    for (const auto &E : EpilogMap)
-      if (!E.second.empty())
-        return false;
-    return true;
-  }
+ 
+  bool empty() const { 
+    if (!Instructions.empty()) 
+      return false; 
+    for (const auto &E : EpilogMap) 
+      if (!E.second.empty()) 
+        return false; 
+    return true; 
+  } 
 };
 
 class UnwindEmitter {
@@ -87,8 +87,8 @@ public:
 
   /// This emits the unwind info sections (.pdata and .xdata in PE/COFF).
   virtual void Emit(MCStreamer &Streamer) const = 0;
-  virtual void EmitUnwindInfo(MCStreamer &Streamer, FrameInfo *FI,
-                              bool HandlerData) const = 0;
+  virtual void EmitUnwindInfo(MCStreamer &Streamer, FrameInfo *FI, 
+                              bool HandlerData) const = 0; 
 };
 }
 }
diff --git a/contrib/libs/llvm12/include/llvm/MC/StringTableBuilder.h b/contrib/libs/llvm12/include/llvm/MC/StringTableBuilder.h
index f731b06153..6512654052 100644
--- a/contrib/libs/llvm12/include/llvm/MC/StringTableBuilder.h
+++ b/contrib/libs/llvm12/include/llvm/MC/StringTableBuilder.h
@@ -29,17 +29,17 @@ class raw_ostream;
 /// Utility for building string tables with deduplicated suffixes.
 class StringTableBuilder {
 public:
-  enum Kind {
-    ELF,
-    WinCOFF,
-    MachO,
-    MachO64,
-    MachOLinked,
-    MachO64Linked,
-    RAW,
-    DWARF,
-    XCOFF
-  };
+  enum Kind { 
+    ELF, 
+    WinCOFF, 
+    MachO, 
+    MachO64, 
+    MachOLinked, 
+    MachO64Linked, 
+    RAW, 
+    DWARF, 
+    XCOFF 
+  }; 
 
 private:
   DenseMap<CachedHashStringRef, size_t> StringIndexMap;
diff --git a/contrib/libs/llvm12/include/llvm/MC/SubtargetFeature.h b/contrib/libs/llvm12/include/llvm/MC/SubtargetFeature.h
index 2d534b7bbf..2f5202860e 100644
--- a/contrib/libs/llvm12/include/llvm/MC/SubtargetFeature.h
+++ b/contrib/libs/llvm12/include/llvm/MC/SubtargetFeature.h
@@ -37,7 +37,7 @@ namespace llvm {
 class raw_ostream;
 class Triple;
 
-const unsigned MAX_SUBTARGET_WORDS = 4;
+const unsigned MAX_SUBTARGET_WORDS = 4; 
 const unsigned MAX_SUBTARGET_FEATURES = MAX_SUBTARGET_WORDS * 64;
 
 /// Container class for subtarget features.