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

42 files changed, 3679 insertions, 3679 deletions

diff --git a/contrib/libs/llvm12/lib/MC/ELFObjectWriter.cpp b/contrib/libs/llvm12/lib/MC/ELFObjectWriter.cpp
index 43a9121893..2d810ffd35 100644
--- a/contrib/libs/llvm12/lib/MC/ELFObjectWriter.cpp
+++ b/contrib/libs/llvm12/lib/MC/ELFObjectWriter.cpp
@@ -464,7 +464,7 @@ void ELFWriter::writeHeader(const MCAssembler &Asm) {
 
 uint64_t ELFWriter::SymbolValue(const MCSymbol &Sym,
                                 const MCAsmLayout &Layout) {
-  if (Sym.isCommon()) 
+  if (Sym.isCommon())
     return Sym.getCommonAlignment();
 
   uint64_t Res;
@@ -1024,13 +1024,13 @@ void ELFWriter::writeSection(const SectionIndexMapTy &SectionIndexMap,
   }
 
   if (Section.getFlags() & ELF::SHF_LINK_ORDER) {
-    // If the value in the associated metadata is not a definition, Sym will be 
-    // undefined. Represent this with sh_link=0. 
+    // If the value in the associated metadata is not a definition, Sym will be
+    // undefined. Represent this with sh_link=0.
     const MCSymbol *Sym = Section.getLinkedToSymbol();
-    if (Sym && Sym->isInSection()) { 
-      const MCSectionELF *Sec = cast<MCSectionELF>(&Sym->getSection()); 
-      sh_link = SectionIndexMap.lookup(Sec); 
-    } 
+    if (Sym && Sym->isInSection()) {
+      const MCSectionELF *Sec = cast<MCSectionELF>(&Sym->getSection());
+      sh_link = SectionIndexMap.lookup(Sec);
+    }
   }
 
   WriteSecHdrEntry(StrTabBuilder.getOffset(Section.getName()),
@@ -1258,9 +1258,9 @@ void ELFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
                                                const MCAsmLayout &Layout) {
   // The presence of symbol versions causes undefined symbols and
   // versions declared with @@@ to be renamed.
-  for (const MCAssembler::Symver &S : Asm.Symvers) { 
-    StringRef AliasName = S.Name; 
-    const auto &Symbol = cast<MCSymbolELF>(*S.Sym); 
+  for (const MCAssembler::Symver &S : Asm.Symvers) {
+    StringRef AliasName = S.Name;
+    const auto &Symbol = cast<MCSymbolELF>(*S.Sym);
     size_t Pos = AliasName.find('@');
     assert(Pos != StringRef::npos);
 
@@ -1279,7 +1279,7 @@ void ELFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
     // Aliases defined with .symvar copy the binding from the symbol they alias.
     // This is the first place we are able to copy this information.
     Alias->setBinding(Symbol.getBinding());
-    Alias->setVisibility(Symbol.getVisibility()); 
+    Alias->setVisibility(Symbol.getVisibility());
     Alias->setOther(Symbol.getOther());
 
     if (!Symbol.isUndefined() && !Rest.startswith("@@@"))
@@ -1287,14 +1287,14 @@ void ELFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
 
     if (Symbol.isUndefined() && Rest.startswith("@@") &&
         !Rest.startswith("@@@")) {
-      Asm.getContext().reportError(S.Loc, "default version symbol " + 
-                                              AliasName + " must be defined"); 
+      Asm.getContext().reportError(S.Loc, "default version symbol " +
+                                              AliasName + " must be defined");
       continue;
     }
 
     if (Renames.count(&Symbol) && Renames[&Symbol] != Alias) {
-      Asm.getContext().reportError(S.Loc, Twine("multiple versions for ") + 
-                                              Symbol.getName()); 
+      Asm.getContext().reportError(S.Loc, Twine("multiple versions for ") +
+                                              Symbol.getName());
       continue;
     }
 
@@ -1392,22 +1392,22 @@ bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
       if (C != 0)
         return true;
 
-      // gold<2.34 incorrectly ignored the addend for R_386_GOTOFF (9) 
-      // (http://sourceware.org/PR16794). 
-      if (TargetObjectWriter->getEMachine() == ELF::EM_386 && 
-          Type == ELF::R_386_GOTOFF) 
+      // gold<2.34 incorrectly ignored the addend for R_386_GOTOFF (9)
+      // (http://sourceware.org/PR16794).
+      if (TargetObjectWriter->getEMachine() == ELF::EM_386 &&
+          Type == ELF::R_386_GOTOFF)
+        return true;
+
+      // ld.lld handles R_MIPS_HI16/R_MIPS_LO16 separately, not as a whole, so
+      // it doesn't know that an R_MIPS_HI16 with implicit addend 1 and an
+      // R_MIPS_LO16 with implicit addend -32768 represents 32768, which is in
+      // range of a MergeInputSection. We could introduce a new RelExpr member
+      // (like R_RISCV_PC_INDIRECT for R_RISCV_PCREL_HI20 / R_RISCV_PCREL_LO12)
+      // but the complexity is unnecessary given that GNU as keeps the original
+      // symbol for this case as well.
+      if (TargetObjectWriter->getEMachine() == ELF::EM_MIPS &&
+          !hasRelocationAddend())
         return true;
- 
-      // ld.lld handles R_MIPS_HI16/R_MIPS_LO16 separately, not as a whole, so 
-      // it doesn't know that an R_MIPS_HI16 with implicit addend 1 and an 
-      // R_MIPS_LO16 with implicit addend -32768 represents 32768, which is in 
-      // range of a MergeInputSection. We could introduce a new RelExpr member 
-      // (like R_RISCV_PC_INDIRECT for R_RISCV_PCREL_HI20 / R_RISCV_PCREL_LO12) 
-      // but the complexity is unnecessary given that GNU as keeps the original 
-      // symbol for this case as well. 
-      if (TargetObjectWriter->getEMachine() == ELF::EM_MIPS && 
-          !hasRelocationAddend()) 
-        return true; 
     }
 
     // Most TLS relocations use a got, so they need the symbol. Even those that
diff --git a/contrib/libs/llvm12/lib/MC/MCAsmBackend.cpp b/contrib/libs/llvm12/lib/MC/MCAsmBackend.cpp
index 2c4ab96363..0d32e71c2d 100644
--- a/contrib/libs/llvm12/lib/MC/MCAsmBackend.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCAsmBackend.cpp
@@ -54,17 +54,17 @@ std::unique_ptr<MCObjectWriter>
 MCAsmBackend::createDwoObjectWriter(raw_pwrite_stream &OS,
                                     raw_pwrite_stream &DwoOS) const {
   auto TW = createObjectTargetWriter();
-  switch (TW->getFormat()) { 
-  case Triple::ELF: 
-    return createELFDwoObjectWriter( 
-        cast<MCELFObjectTargetWriter>(std::move(TW)), OS, DwoOS, 
-        Endian == support::little); 
-  case Triple::Wasm: 
-    return createWasmDwoObjectWriter( 
-        cast<MCWasmObjectTargetWriter>(std::move(TW)), OS, DwoOS); 
-  default: 
-    report_fatal_error("dwo only supported with ELF and Wasm"); 
-  } 
+  switch (TW->getFormat()) {
+  case Triple::ELF:
+    return createELFDwoObjectWriter(
+        cast<MCELFObjectTargetWriter>(std::move(TW)), OS, DwoOS,
+        Endian == support::little);
+  case Triple::Wasm:
+    return createWasmDwoObjectWriter(
+        cast<MCWasmObjectTargetWriter>(std::move(TW)), OS, DwoOS);
+  default:
+    report_fatal_error("dwo only supported with ELF and Wasm");
+  }
 }
 
 Optional<MCFixupKind> MCAsmBackend::getFixupKind(StringRef Name) const {
diff --git a/contrib/libs/llvm12/lib/MC/MCAsmInfo.cpp b/contrib/libs/llvm12/lib/MC/MCAsmInfo.cpp
index 0ed9b1ec26..620d3e7cff 100644
--- a/contrib/libs/llvm12/lib/MC/MCAsmInfo.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCAsmInfo.cpp
@@ -28,12 +28,12 @@ static cl::opt<DefaultOnOff> DwarfExtendedLoc(
                clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")),
     cl::init(Default));
 
-cl::opt<cl::boolOrDefault> UseLEB128Directives( 
-    "use-leb128-directives", cl::Hidden, 
-    cl::desc( 
-        "Disable the usage of LEB128 directives, and generate .byte instead."), 
-    cl::init(cl::BOU_UNSET)); 
- 
+cl::opt<cl::boolOrDefault> UseLEB128Directives(
+    "use-leb128-directives", cl::Hidden,
+    cl::desc(
+        "Disable the usage of LEB128 directives, and generate .byte instead."),
+    cl::init(cl::BOU_UNSET));
+
 MCAsmInfo::MCAsmInfo() {
   SeparatorString = ";";
   CommentString = "#";
@@ -57,8 +57,8 @@ MCAsmInfo::MCAsmInfo() {
   WeakDirective = "\t.weak\t";
   if (DwarfExtendedLoc != Default)
     SupportsExtendedDwarfLocDirective = DwarfExtendedLoc == Enable;
-  if (UseLEB128Directives != cl::BOU_UNSET) 
-    HasLEB128Directives = UseLEB128Directives == cl::BOU_TRUE; 
+  if (UseLEB128Directives != cl::BOU_UNSET)
+    HasLEB128Directives = UseLEB128Directives == cl::BOU_TRUE;
 
   // FIXME: Clang's logic should be synced with the logic used to initialize
   //        this member and the two implementations should be merged.
@@ -109,7 +109,7 @@ MCAsmInfo::getExprForFDESymbol(const MCSymbol *Sym,
 }
 
 bool MCAsmInfo::isAcceptableChar(char C) const {
-  return isAlnum(C) || C == '_' || C == '$' || C == '.' || C == '@'; 
+  return isAlnum(C) || C == '_' || C == '$' || C == '.' || C == '@';
 }
 
 bool MCAsmInfo::isValidUnquotedName(StringRef Name) const {
diff --git a/contrib/libs/llvm12/lib/MC/MCAsmInfoXCOFF.cpp b/contrib/libs/llvm12/lib/MC/MCAsmInfoXCOFF.cpp
index 5674478681..2f8bc6a49b 100644
--- a/contrib/libs/llvm12/lib/MC/MCAsmInfoXCOFF.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCAsmInfoXCOFF.cpp
@@ -8,12 +8,12 @@
 
 #include "llvm/MC/MCAsmInfoXCOFF.h"
 #include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/CommandLine.h" 
+#include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
-extern cl::opt<cl::boolOrDefault> UseLEB128Directives; 
- 
+extern cl::opt<cl::boolOrDefault> UseLEB128Directives;
+
 void MCAsmInfoXCOFF::anchor() {}
 
 MCAsmInfoXCOFF::MCAsmInfoXCOFF() {
@@ -23,14 +23,14 @@ MCAsmInfoXCOFF::MCAsmInfoXCOFF() {
   PrivateLabelPrefix = "L..";
   SupportsQuotedNames = false;
   UseDotAlignForAlignment = true;
-  if (UseLEB128Directives == cl::BOU_UNSET) 
-    HasLEB128Directives = false; 
+  if (UseLEB128Directives == cl::BOU_UNSET)
+    HasLEB128Directives = false;
   ZeroDirective = "\t.space\t";
   ZeroDirectiveSupportsNonZeroValue = false;
   AsciiDirective = nullptr; // not supported
   AscizDirective = nullptr; // not supported
-  ByteListDirective = "\t.byte\t"; 
-  CharacterLiteralSyntax = ACLS_SingleQuotePrefix; 
+  ByteListDirective = "\t.byte\t";
+  CharacterLiteralSyntax = ACLS_SingleQuotePrefix;
 
   // Use .vbyte for data definition to avoid directives that apply an implicit
   // alignment.
@@ -42,8 +42,8 @@ MCAsmInfoXCOFF::MCAsmInfoXCOFF() {
   HasDotTypeDotSizeDirective = false;
   UseIntegratedAssembler = false;
   NeedsFunctionDescriptors = true;
- 
-  ExceptionsType = ExceptionHandling::AIX; 
+
+  ExceptionsType = ExceptionHandling::AIX;
 }
 
 bool MCAsmInfoXCOFF::isAcceptableChar(char C) const {
diff --git a/contrib/libs/llvm12/lib/MC/MCAsmMacro.cpp b/contrib/libs/llvm12/lib/MC/MCAsmMacro.cpp
index fe30787b4a..bc95f98f29 100644
--- a/contrib/libs/llvm12/lib/MC/MCAsmMacro.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCAsmMacro.cpp
@@ -38,11 +38,11 @@ void MCAsmMacro::dump(raw_ostream &OS) const {
     OS << "    ";
     P.dump();
   }
-  if (!Locals.empty()) { 
-    OS << "  Locals:\n"; 
-    for (StringRef L : Locals) 
-      OS << "    " << L << '\n'; 
-  } 
+  if (!Locals.empty()) {
+    OS << "  Locals:\n";
+    for (StringRef L : Locals)
+      OS << "    " << L << '\n';
+  }
   OS << "  (BEGIN BODY)" << Body << "(END BODY)\n";
 }
 #endif
diff --git a/contrib/libs/llvm12/lib/MC/MCAsmStreamer.cpp b/contrib/libs/llvm12/lib/MC/MCAsmStreamer.cpp
index cd89aa8557..10d72553fe 100644
--- a/contrib/libs/llvm12/lib/MC/MCAsmStreamer.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCAsmStreamer.cpp
@@ -24,7 +24,7 @@
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
-#include "llvm/MC/MCPseudoProbe.h" 
+#include "llvm/MC/MCPseudoProbe.h"
 #include "llvm/MC/MCRegister.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionMachO.h"
@@ -145,11 +145,11 @@ public:
                               const MCSymbol *Aliasee) override;
 
   void emitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) override;
- 
-  StringRef getMnemonic(MCInst &MI) override { 
-    return InstPrinter->getMnemonic(&MI).first; 
-  } 
- 
+
+  StringRef getMnemonic(MCInst &MI) override {
+    return InstPrinter->getMnemonic(&MI).first;
+  }
+
   void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
 
   void emitAssemblerFlag(MCAssemblerFlag Flag) override;
@@ -351,10 +351,10 @@ public:
 
   void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
 
-  void emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type, 
-                       uint64_t Attr, 
-                       const MCPseudoProbeInlineStack &InlineStack) override; 
- 
+  void emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type,
+                       uint64_t Attr,
+                       const MCPseudoProbeInlineStack &InlineStack) override;
+
   void emitBundleAlignMode(unsigned AlignPow2) override;
   void emitBundleLock(bool AlignToEnd) override;
   void emitBundleUnlock() override;
@@ -590,7 +590,7 @@ static const char *getPlatformName(MachO::PlatformType Type) {
   case MachO::PLATFORM_IOSSIMULATOR:     return "iossimulator";
   case MachO::PLATFORM_TVOSSIMULATOR:    return "tvossimulator";
   case MachO::PLATFORM_WATCHOSSIMULATOR: return "watchossimulator";
-  case MachO::PLATFORM_DRIVERKIT:        return "driverkit"; 
+  case MachO::PLATFORM_DRIVERKIT:        return "driverkit";
   }
   llvm_unreachable("Invalid Mach-O platform type");
 }
@@ -807,12 +807,12 @@ void MCAsmStreamer::emitXCOFFLocalCommonSymbol(MCSymbol *LabelSym,
   OS << ',' << Log2_32(ByteAlignment);
 
   EmitEOL();
- 
-  // Print symbol's rename (original name contains invalid character(s)) if 
-  // there is one. 
-  MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(CsectSym); 
-  if (XSym->hasRename()) 
-    emitXCOFFRenameDirective(XSym, XSym->getSymbolTableName()); 
+
+  // Print symbol's rename (original name contains invalid character(s)) if
+  // there is one.
+  MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(CsectSym);
+  if (XSym->hasRename())
+    emitXCOFFRenameDirective(XSym, XSym->getSymbolTableName());
 }
 
 void MCAsmStreamer::emitXCOFFSymbolLinkageWithVisibility(
@@ -851,12 +851,12 @@ void MCAsmStreamer::emitXCOFFSymbolLinkageWithVisibility(
     report_fatal_error("unexpected value for Visibility type");
   }
   EmitEOL();
- 
-  // Print symbol's rename (original name contains invalid character(s)) if 
-  // there is one. 
-  if (cast<MCSymbolXCOFF>(Symbol)->hasRename()) 
-    emitXCOFFRenameDirective(Symbol, 
-                             cast<MCSymbolXCOFF>(Symbol)->getSymbolTableName()); 
+
+  // Print symbol's rename (original name contains invalid character(s)) if
+  // there is one.
+  if (cast<MCSymbolXCOFF>(Symbol)->hasRename())
+    emitXCOFFRenameDirective(Symbol,
+                             cast<MCSymbolXCOFF>(Symbol)->getSymbolTableName());
 }
 
 void MCAsmStreamer::emitXCOFFRenameDirective(const MCSymbol *Name,
@@ -897,13 +897,13 @@ void MCAsmStreamer::emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
       OS << ',' << Log2_32(ByteAlignment);
   }
   EmitEOL();
- 
-  // Print symbol's rename (original name contains invalid character(s)) if 
-  // there is one. 
-  MCSymbolXCOFF *XSym = dyn_cast<MCSymbolXCOFF>(Symbol); 
-  if (XSym && XSym->hasRename()) 
-    emitXCOFFRenameDirective(XSym, XSym->getSymbolTableName()); 
- 
+
+  // Print symbol's rename (original name contains invalid character(s)) if
+  // there is one.
+  MCSymbolXCOFF *XSym = dyn_cast<MCSymbolXCOFF>(Symbol);
+  if (XSym && XSym->hasRename())
+    emitXCOFFRenameDirective(XSym, XSym->getSymbolTableName());
+
 }
 
 void MCAsmStreamer::emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
@@ -981,47 +981,47 @@ void MCAsmStreamer::emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
 
 static inline char toOctal(int X) { return (X&7)+'0'; }
 
-static void PrintByteList(StringRef Data, raw_ostream &OS, 
-                          MCAsmInfo::AsmCharLiteralSyntax ACLS) { 
-  assert(!Data.empty() && "Cannot generate an empty list."); 
-  const auto printCharacterInOctal = [&OS](unsigned char C) { 
-    OS << '0'; 
-    OS << toOctal(C >> 6); 
-    OS << toOctal(C >> 3); 
-    OS << toOctal(C >> 0); 
-  }; 
-  const auto printOneCharacterFor = [printCharacterInOctal]( 
-                                        auto printOnePrintingCharacter) { 
-    return [printCharacterInOctal, printOnePrintingCharacter](unsigned char C) { 
-      if (isPrint(C)) { 
-        printOnePrintingCharacter(static_cast<char>(C)); 
-        return; 
-      } 
-      printCharacterInOctal(C); 
-    }; 
-  }; 
-  const auto printCharacterList = [Data, &OS](const auto &printOneCharacter) { 
-    const auto BeginPtr = Data.begin(), EndPtr = Data.end(); 
-    for (const unsigned char C : make_range(BeginPtr, EndPtr - 1)) { 
-      printOneCharacter(C); 
-      OS << ','; 
-    } 
-    printOneCharacter(*(EndPtr - 1)); 
-  }; 
-  switch (ACLS) { 
-  case MCAsmInfo::ACLS_Unknown: 
-    printCharacterList(printCharacterInOctal); 
-    return; 
-  case MCAsmInfo::ACLS_SingleQuotePrefix: 
-    printCharacterList(printOneCharacterFor([&OS](char C) { 
-      const char AsmCharLitBuf[2] = {'\'', C}; 
-      OS << StringRef(AsmCharLitBuf, sizeof(AsmCharLitBuf)); 
-    })); 
-    return; 
-  } 
-  llvm_unreachable("Invalid AsmCharLiteralSyntax value!"); 
-} 
- 
+static void PrintByteList(StringRef Data, raw_ostream &OS,
+                          MCAsmInfo::AsmCharLiteralSyntax ACLS) {
+  assert(!Data.empty() && "Cannot generate an empty list.");
+  const auto printCharacterInOctal = [&OS](unsigned char C) {
+    OS << '0';
+    OS << toOctal(C >> 6);
+    OS << toOctal(C >> 3);
+    OS << toOctal(C >> 0);
+  };
+  const auto printOneCharacterFor = [printCharacterInOctal](
+                                        auto printOnePrintingCharacter) {
+    return [printCharacterInOctal, printOnePrintingCharacter](unsigned char C) {
+      if (isPrint(C)) {
+        printOnePrintingCharacter(static_cast<char>(C));
+        return;
+      }
+      printCharacterInOctal(C);
+    };
+  };
+  const auto printCharacterList = [Data, &OS](const auto &printOneCharacter) {
+    const auto BeginPtr = Data.begin(), EndPtr = Data.end();
+    for (const unsigned char C : make_range(BeginPtr, EndPtr - 1)) {
+      printOneCharacter(C);
+      OS << ',';
+    }
+    printOneCharacter(*(EndPtr - 1));
+  };
+  switch (ACLS) {
+  case MCAsmInfo::ACLS_Unknown:
+    printCharacterList(printCharacterInOctal);
+    return;
+  case MCAsmInfo::ACLS_SingleQuotePrefix:
+    printCharacterList(printOneCharacterFor([&OS](char C) {
+      const char AsmCharLitBuf[2] = {'\'', C};
+      OS << StringRef(AsmCharLitBuf, sizeof(AsmCharLitBuf));
+    }));
+    return;
+  }
+  llvm_unreachable("Invalid AsmCharLiteralSyntax value!");
+}
+
 static void PrintQuotedString(StringRef Data, raw_ostream &OS) {
   OS << '"';
 
@@ -1060,42 +1060,42 @@ void MCAsmStreamer::emitBytes(StringRef Data) {
          "Cannot emit contents before setting section!");
   if (Data.empty()) return;
 
-  const auto emitAsString = [this](StringRef Data) { 
-    // If the data ends with 0 and the target supports .asciz, use it, otherwise 
-    // use .ascii or a byte-list directive 
-    if (MAI->getAscizDirective() && Data.back() == 0) { 
-      OS << MAI->getAscizDirective(); 
-      Data = Data.substr(0, Data.size() - 1); 
-    } else if (LLVM_LIKELY(MAI->getAsciiDirective())) { 
-      OS << MAI->getAsciiDirective(); 
-    } else if (MAI->getByteListDirective()) { 
-      OS << MAI->getByteListDirective(); 
-      PrintByteList(Data, OS, MAI->characterLiteralSyntax()); 
-      EmitEOL(); 
-      return true; 
+  const auto emitAsString = [this](StringRef Data) {
+    // If the data ends with 0 and the target supports .asciz, use it, otherwise
+    // use .ascii or a byte-list directive
+    if (MAI->getAscizDirective() && Data.back() == 0) {
+      OS << MAI->getAscizDirective();
+      Data = Data.substr(0, Data.size() - 1);
+    } else if (LLVM_LIKELY(MAI->getAsciiDirective())) {
+      OS << MAI->getAsciiDirective();
+    } else if (MAI->getByteListDirective()) {
+      OS << MAI->getByteListDirective();
+      PrintByteList(Data, OS, MAI->characterLiteralSyntax());
+      EmitEOL();
+      return true;
     } else {
-      return false; 
+      return false;
     }
- 
-    PrintQuotedString(Data, OS); 
-    EmitEOL(); 
-    return true; 
-  }; 
- 
-  if (Data.size() != 1 && emitAsString(Data)) 
+
+    PrintQuotedString(Data, OS);
+    EmitEOL();
+    return true;
+  };
+
+  if (Data.size() != 1 && emitAsString(Data))
     return;
 
-  // Only single byte is provided or no ascii, asciz, or byte-list directives 
-  // are applicable. Emit as vector of individual 8bits data elements. 
-  if (MCTargetStreamer *TS = getTargetStreamer()) { 
-    TS->emitRawBytes(Data); 
-    return; 
+  // Only single byte is provided or no ascii, asciz, or byte-list directives
+  // are applicable. Emit as vector of individual 8bits data elements.
+  if (MCTargetStreamer *TS = getTargetStreamer()) {
+    TS->emitRawBytes(Data);
+    return;
+  }
+  const char *Directive = MAI->getData8bitsDirective();
+  for (const unsigned char C : Data.bytes()) {
+    OS << Directive << (unsigned)C;
+    EmitEOL();
   }
-  const char *Directive = MAI->getData8bitsDirective(); 
-  for (const unsigned char C : Data.bytes()) { 
-    OS << Directive << (unsigned)C; 
-    EmitEOL(); 
-  } 
 }
 
 void MCAsmStreamer::emitBinaryData(StringRef Data) {
@@ -1883,10 +1883,10 @@ void MCAsmStreamer::EmitWinCFIEndProc(SMLoc Loc) {
 }
 
 void MCAsmStreamer::EmitWinCFIFuncletOrFuncEnd(SMLoc Loc) {
-  MCStreamer::EmitWinCFIFuncletOrFuncEnd(Loc); 
- 
-  OS << "\t.seh_endfunclet"; 
-  EmitEOL(); 
+  MCStreamer::EmitWinCFIFuncletOrFuncEnd(Loc);
+
+  OS << "\t.seh_endfunclet";
+  EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFIStartChained(SMLoc Loc) {
@@ -2127,18 +2127,18 @@ void MCAsmStreamer::emitInstruction(const MCInst &Inst,
   EmitEOL();
 }
 
-void MCAsmStreamer::emitPseudoProbe( 
-    uint64_t Guid, uint64_t Index, uint64_t Type, uint64_t Attr, 
-    const MCPseudoProbeInlineStack &InlineStack) { 
-  OS << "\t.pseudoprobe\t" << Guid << " " << Index << " " << Type << " " 
-     << Attr; 
-  // Emit inline stack like 
-  //  @ GUIDmain:3 @ GUIDCaller:1 @ GUIDDirectCaller:11 
-  for (const auto &Site : InlineStack) 
-    OS << " @ " << std::get<0>(Site) << ":" << std::get<1>(Site); 
-  EmitEOL(); 
-} 
- 
+void MCAsmStreamer::emitPseudoProbe(
+    uint64_t Guid, uint64_t Index, uint64_t Type, uint64_t Attr,
+    const MCPseudoProbeInlineStack &InlineStack) {
+  OS << "\t.pseudoprobe\t" << Guid << " " << Index << " " << Type << " "
+     << Attr;
+  // Emit inline stack like
+  //  @ GUIDmain:3 @ GUIDCaller:1 @ GUIDDirectCaller:11
+  for (const auto &Site : InlineStack)
+    OS << " @ " << std::get<0>(Site) << ":" << std::get<1>(Site);
+  EmitEOL();
+}
+
 void MCAsmStreamer::emitBundleAlignMode(unsigned AlignPow2) {
   OS << "\t.bundle_align_mode " << AlignPow2;
   EmitEOL();
diff --git a/contrib/libs/llvm12/lib/MC/MCAssembler.cpp b/contrib/libs/llvm12/lib/MC/MCAssembler.cpp
index 6531b3f752..ce296d7faa 100644
--- a/contrib/libs/llvm12/lib/MC/MCAssembler.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCAssembler.cpp
@@ -62,8 +62,8 @@ STATISTIC(EmittedAlignFragments,
           "Number of emitted assembler fragments - align");
 STATISTIC(EmittedFillFragments,
           "Number of emitted assembler fragments - fill");
-STATISTIC(EmittedNopsFragments, "Number of emitted assembler fragments - nops"); 
-STATISTIC(EmittedOrgFragments, "Number of emitted assembler fragments - org"); 
+STATISTIC(EmittedNopsFragments, "Number of emitted assembler fragments - nops");
+STATISTIC(EmittedOrgFragments, "Number of emitted assembler fragments - org");
 STATISTIC(evaluateFixup, "Number of evaluated fixups");
 STATISTIC(FragmentLayouts, "Number of fragment layouts");
 STATISTIC(ObjectBytes, "Number of emitted object file bytes");
@@ -312,9 +312,9 @@ uint64_t MCAssembler::computeFragmentSize(const MCAsmLayout &Layout,
     return Size;
   }
 
-  case MCFragment::FT_Nops: 
-    return cast<MCNopsFragment>(F).getNumBytes(); 
- 
+  case MCFragment::FT_Nops:
+    return cast<MCNopsFragment>(F).getNumBytes();
+
   case MCFragment::FT_LEB:
     return cast<MCLEBFragment>(F).getContents().size();
 
@@ -383,8 +383,8 @@ uint64_t MCAssembler::computeFragmentSize(const MCAsmLayout &Layout,
     return cast<MCCVInlineLineTableFragment>(F).getContents().size();
   case MCFragment::FT_CVDefRange:
     return cast<MCCVDefRangeFragment>(F).getContents().size();
-  case MCFragment::FT_PseudoProbe: 
-    return cast<MCPseudoProbeAddrFragment>(F).getContents().size(); 
+  case MCFragment::FT_PseudoProbe:
+    return cast<MCPseudoProbeAddrFragment>(F).getContents().size();
   case MCFragment::FT_Dummy:
     llvm_unreachable("Should not have been added");
   }
@@ -618,45 +618,45 @@ static void writeFragment(raw_ostream &OS, const MCAssembler &Asm,
     break;
   }
 
-  case MCFragment::FT_Nops: { 
-    ++stats::EmittedNopsFragments; 
-    const MCNopsFragment &NF = cast<MCNopsFragment>(F); 
-    int64_t NumBytes = NF.getNumBytes(); 
-    int64_t ControlledNopLength = NF.getControlledNopLength(); 
-    int64_t MaximumNopLength = Asm.getBackend().getMaximumNopSize(); 
- 
-    assert(NumBytes > 0 && "Expected positive NOPs fragment size"); 
-    assert(ControlledNopLength >= 0 && "Expected non-negative NOP size"); 
- 
-    if (ControlledNopLength > MaximumNopLength) { 
-      Asm.getContext().reportError(NF.getLoc(), 
-                                   "illegal NOP size " + 
-                                       std::to_string(ControlledNopLength) + 
-                                       ". (expected within [0, " + 
-                                       std::to_string(MaximumNopLength) + "])"); 
-      // Clamp the NOP length as reportError does not stop the execution 
-      // immediately. 
-      ControlledNopLength = MaximumNopLength; 
-    } 
- 
-    // Use maximum value if the size of each NOP is not specified 
-    if (!ControlledNopLength) 
-      ControlledNopLength = MaximumNopLength; 
- 
-    while (NumBytes) { 
-      uint64_t NumBytesToEmit = 
-          (uint64_t)std::min(NumBytes, ControlledNopLength); 
-      assert(NumBytesToEmit && "try to emit empty NOP instruction"); 
-      if (!Asm.getBackend().writeNopData(OS, NumBytesToEmit)) { 
-        report_fatal_error("unable to write nop sequence of the remaining " + 
-                           Twine(NumBytesToEmit) + " bytes"); 
-        break; 
-      } 
-      NumBytes -= NumBytesToEmit; 
-    } 
-    break; 
-  } 
- 
+  case MCFragment::FT_Nops: {
+    ++stats::EmittedNopsFragments;
+    const MCNopsFragment &NF = cast<MCNopsFragment>(F);
+    int64_t NumBytes = NF.getNumBytes();
+    int64_t ControlledNopLength = NF.getControlledNopLength();
+    int64_t MaximumNopLength = Asm.getBackend().getMaximumNopSize();
+
+    assert(NumBytes > 0 && "Expected positive NOPs fragment size");
+    assert(ControlledNopLength >= 0 && "Expected non-negative NOP size");
+
+    if (ControlledNopLength > MaximumNopLength) {
+      Asm.getContext().reportError(NF.getLoc(),
+                                   "illegal NOP size " +
+                                       std::to_string(ControlledNopLength) +
+                                       ". (expected within [0, " +
+                                       std::to_string(MaximumNopLength) + "])");
+      // Clamp the NOP length as reportError does not stop the execution
+      // immediately.
+      ControlledNopLength = MaximumNopLength;
+    }
+
+    // Use maximum value if the size of each NOP is not specified
+    if (!ControlledNopLength)
+      ControlledNopLength = MaximumNopLength;
+
+    while (NumBytes) {
+      uint64_t NumBytesToEmit =
+          (uint64_t)std::min(NumBytes, ControlledNopLength);
+      assert(NumBytesToEmit && "try to emit empty NOP instruction");
+      if (!Asm.getBackend().writeNopData(OS, NumBytesToEmit)) {
+        report_fatal_error("unable to write nop sequence of the remaining " +
+                           Twine(NumBytesToEmit) + " bytes");
+        break;
+      }
+      NumBytes -= NumBytesToEmit;
+    }
+    break;
+  }
+
   case MCFragment::FT_LEB: {
     const MCLEBFragment &LF = cast<MCLEBFragment>(F);
     OS << LF.getContents();
@@ -706,11 +706,11 @@ static void writeFragment(raw_ostream &OS, const MCAssembler &Asm,
     OS << DRF.getContents();
     break;
   }
-  case MCFragment::FT_PseudoProbe: { 
-    const MCPseudoProbeAddrFragment &PF = cast<MCPseudoProbeAddrFragment>(F); 
-    OS << PF.getContents(); 
-    break; 
-  } 
+  case MCFragment::FT_PseudoProbe: {
+    const MCPseudoProbeAddrFragment &PF = cast<MCPseudoProbeAddrFragment>(F);
+    OS << PF.getContents();
+    break;
+  }
   case MCFragment::FT_Dummy:
     llvm_unreachable("Should not have been added");
   }
@@ -761,8 +761,8 @@ void MCAssembler::writeSectionData(raw_ostream &OS, const MCSection *Sec,
         assert((cast<MCFillFragment>(F).getValue() == 0) &&
                "Invalid fill in virtual section!");
         break;
-      case MCFragment::FT_Org: 
-        break; 
+      case MCFragment::FT_Org:
+        break;
       }
     }
 
@@ -775,8 +775,8 @@ void MCAssembler::writeSectionData(raw_ostream &OS, const MCSection *Sec,
   for (const MCFragment &F : *Sec)
     writeFragment(OS, *this, Layout, F);
 
-  assert(getContext().hadError() || 
-         OS.tell() - Start == Layout.getSectionAddressSize(Sec)); 
+  assert(getContext().hadError() ||
+         OS.tell() - Start == Layout.getSectionAddressSize(Sec));
 }
 
 std::tuple<MCValue, uint64_t, bool>
@@ -922,13 +922,13 @@ void MCAssembler::layout(MCAsmLayout &Layout) {
         Contents = DF.getContents();
         break;
       }
-      case MCFragment::FT_PseudoProbe: { 
-        MCPseudoProbeAddrFragment &PF = cast<MCPseudoProbeAddrFragment>(Frag); 
-        Fixups = PF.getFixups(); 
-        Contents = PF.getContents(); 
-        break; 
+      case MCFragment::FT_PseudoProbe: {
+        MCPseudoProbeAddrFragment &PF = cast<MCPseudoProbeAddrFragment>(Frag);
+        Fixups = PF.getFixups();
+        Contents = PF.getContents();
+        break;
+      }
       }
-      } 
       for (const MCFixup &Fixup : Fixups) {
         uint64_t FixedValue;
         bool IsResolved;
@@ -1119,9 +1119,9 @@ bool MCAssembler::relaxDwarfLineAddr(MCAsmLayout &Layout,
   } else {
     uint32_t Offset;
     uint32_t Size;
-    bool SetDelta; 
-    std::tie(Offset, Size, SetDelta) = 
-        MCDwarfLineAddr::fixedEncode(Context, LineDelta, AddrDelta, OSE); 
+    bool SetDelta;
+    std::tie(Offset, Size, SetDelta) =
+        MCDwarfLineAddr::fixedEncode(Context, LineDelta, AddrDelta, OSE);
     // Add Fixups for address delta or new address.
     const MCExpr *FixupExpr;
     if (SetDelta) {
@@ -1182,27 +1182,27 @@ bool MCAssembler::relaxCVDefRange(MCAsmLayout &Layout,
   return OldSize != F.getContents().size();
 }
 
-bool MCAssembler::relaxPseudoProbeAddr(MCAsmLayout &Layout, 
-                                       MCPseudoProbeAddrFragment &PF) { 
-  uint64_t OldSize = PF.getContents().size(); 
-  int64_t AddrDelta; 
-  bool Abs = PF.getAddrDelta().evaluateKnownAbsolute(AddrDelta, Layout); 
-  assert(Abs && "We created a pseudo probe with an invalid expression"); 
-  (void)Abs; 
-  SmallVectorImpl<char> &Data = PF.getContents(); 
-  Data.clear(); 
-  raw_svector_ostream OSE(Data); 
-  PF.getFixups().clear(); 
- 
-  // Relocations should not be needed in general except on RISC-V which we are 
-  // not targeted for now. 
-  assert(!getBackend().requiresDiffExpressionRelocations() && 
-         "cannot relax relocations"); 
-  // AddrDelta is a signed integer 
-  encodeSLEB128(AddrDelta, OSE, OldSize); 
-  return OldSize != Data.size(); 
-} 
- 
+bool MCAssembler::relaxPseudoProbeAddr(MCAsmLayout &Layout,
+                                       MCPseudoProbeAddrFragment &PF) {
+  uint64_t OldSize = PF.getContents().size();
+  int64_t AddrDelta;
+  bool Abs = PF.getAddrDelta().evaluateKnownAbsolute(AddrDelta, Layout);
+  assert(Abs && "We created a pseudo probe with an invalid expression");
+  (void)Abs;
+  SmallVectorImpl<char> &Data = PF.getContents();
+  Data.clear();
+  raw_svector_ostream OSE(Data);
+  PF.getFixups().clear();
+
+  // Relocations should not be needed in general except on RISC-V which we are
+  // not targeted for now.
+  assert(!getBackend().requiresDiffExpressionRelocations() &&
+         "cannot relax relocations");
+  // AddrDelta is a signed integer
+  encodeSLEB128(AddrDelta, OSE, OldSize);
+  return OldSize != Data.size();
+}
+
 bool MCAssembler::relaxFragment(MCAsmLayout &Layout, MCFragment &F) {
   switch(F.getKind()) {
   default:
@@ -1224,8 +1224,8 @@ bool MCAssembler::relaxFragment(MCAsmLayout &Layout, MCFragment &F) {
     return relaxCVInlineLineTable(Layout, cast<MCCVInlineLineTableFragment>(F));
   case MCFragment::FT_CVDefRange:
     return relaxCVDefRange(Layout, cast<MCCVDefRangeFragment>(F));
-  case MCFragment::FT_PseudoProbe: 
-    return relaxPseudoProbeAddr(Layout, cast<MCPseudoProbeAddrFragment>(F)); 
+  case MCFragment::FT_PseudoProbe:
+    return relaxPseudoProbeAddr(Layout, cast<MCPseudoProbeAddrFragment>(F));
   }
 }
 
diff --git a/contrib/libs/llvm12/lib/MC/MCCodeView.cpp b/contrib/libs/llvm12/lib/MC/MCCodeView.cpp
index 3515a69471..3da1a9c3e3 100644
--- a/contrib/libs/llvm12/lib/MC/MCCodeView.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCCodeView.cpp
@@ -563,7 +563,7 @@ void CodeViewContext::encodeInlineLineTable(MCAsmLayout &Layout,
     int LineDelta = CurSourceLoc.Line - LastSourceLoc.Line;
     unsigned EncodedLineDelta = encodeSignedNumber(LineDelta);
     unsigned CodeDelta = computeLabelDiff(Layout, LastLabel, Loc.getLabel());
-    if (EncodedLineDelta < 0x8 && CodeDelta <= 0xf) { 
+    if (EncodedLineDelta < 0x8 && CodeDelta <= 0xf) {
       // The ChangeCodeOffsetAndLineOffset combination opcode is used when the
       // encoded line delta uses 3 or fewer set bits and the code offset fits
       // in one nibble.
diff --git a/contrib/libs/llvm12/lib/MC/MCContext.cpp b/contrib/libs/llvm12/lib/MC/MCContext.cpp
index 5a5858c9c9..9dab8a6c09 100644
--- a/contrib/libs/llvm12/lib/MC/MCContext.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCContext.cpp
@@ -90,7 +90,7 @@ void MCContext::reset() {
   ELFAllocator.DestroyAll();
   MachOAllocator.DestroyAll();
   XCOFFAllocator.DestroyAll();
-  MCInstAllocator.DestroyAll(); 
+  MCInstAllocator.DestroyAll();
 
   MCSubtargetAllocator.DestroyAll();
   InlineAsmUsedLabelNames.clear();
@@ -128,14 +128,14 @@ void MCContext::reset() {
 }
 
 //===----------------------------------------------------------------------===//
-// MCInst Management 
-//===----------------------------------------------------------------------===// 
- 
-MCInst *MCContext::createMCInst() { 
-  return new (MCInstAllocator.Allocate()) MCInst; 
-} 
- 
-//===----------------------------------------------------------------------===// 
+// MCInst Management
+//===----------------------------------------------------------------------===//
+
+MCInst *MCContext::createMCInst() {
+  return new (MCInstAllocator.Allocate()) MCInst;
+}
+
+//===----------------------------------------------------------------------===//
 // Symbol Manipulation
 //===----------------------------------------------------------------------===//
 
@@ -232,28 +232,28 @@ MCSymbol *MCContext::createSymbol(StringRef Name, bool AlwaysAddSuffix,
   llvm_unreachable("Infinite loop");
 }
 
-MCSymbol *MCContext::createTempSymbol(const Twine &Name, bool AlwaysAddSuffix) { 
+MCSymbol *MCContext::createTempSymbol(const Twine &Name, bool AlwaysAddSuffix) {
+  SmallString<128> NameSV;
+  raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name;
+  return createSymbol(NameSV, AlwaysAddSuffix, true);
+}
+
+MCSymbol *MCContext::createNamedTempSymbol(const Twine &Name) {
   SmallString<128> NameSV;
   raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name;
-  return createSymbol(NameSV, AlwaysAddSuffix, true); 
+  return createSymbol(NameSV, true, false);
 }
 
-MCSymbol *MCContext::createNamedTempSymbol(const Twine &Name) { 
-  SmallString<128> NameSV; 
-  raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name; 
-  return createSymbol(NameSV, true, false); 
-} 
- 
 MCSymbol *MCContext::createLinkerPrivateTempSymbol() {
   SmallString<128> NameSV;
   raw_svector_ostream(NameSV) << MAI->getLinkerPrivateGlobalPrefix() << "tmp";
   return createSymbol(NameSV, true, false);
 }
 
-MCSymbol *MCContext::createTempSymbol() { return createTempSymbol("tmp"); } 
- 
-MCSymbol *MCContext::createNamedTempSymbol() { 
-  return createNamedTempSymbol("tmp"); 
+MCSymbol *MCContext::createTempSymbol() { return createTempSymbol("tmp"); }
+
+MCSymbol *MCContext::createNamedTempSymbol() {
+  return createNamedTempSymbol("tmp");
 }
 
 unsigned MCContext::NextInstance(unsigned LocalLabelVal) {
@@ -274,7 +274,7 @@ MCSymbol *MCContext::getOrCreateDirectionalLocalSymbol(unsigned LocalLabelVal,
                                                        unsigned Instance) {
   MCSymbol *&Sym = LocalSymbols[std::make_pair(LocalLabelVal, Instance)];
   if (!Sym)
-    Sym = createNamedTempSymbol(); 
+    Sym = createNamedTempSymbol();
   return Sym;
 }
 
@@ -651,7 +651,7 @@ MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind Kind,
 
   StringRef CachedName = Entry.first.SectionName;
 
-  MCSymbol *Begin = createSymbol(CachedName, true, false); 
+  MCSymbol *Begin = createSymbol(CachedName, true, false);
   cast<MCSymbolWasm>(Begin)->setType(wasm::WASM_SYMBOL_TYPE_SECTION);
 
   MCSectionWasm *Result = new (WasmAllocator.Allocate())
@@ -666,22 +666,22 @@ MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind Kind,
   return Result;
 }
 
-MCSectionXCOFF * 
-MCContext::getXCOFFSection(StringRef Section, XCOFF::StorageMappingClass SMC, 
-                           XCOFF::SymbolType Type, SectionKind Kind, 
-                           bool MultiSymbolsAllowed, const char *BeginSymName) { 
+MCSectionXCOFF *
+MCContext::getXCOFFSection(StringRef Section, XCOFF::StorageMappingClass SMC,
+                           XCOFF::SymbolType Type, SectionKind Kind,
+                           bool MultiSymbolsAllowed, const char *BeginSymName) {
   // Do the lookup. If we have a hit, return it.
   auto IterBool = XCOFFUniquingMap.insert(
       std::make_pair(XCOFFSectionKey{Section.str(), SMC}, nullptr));
   auto &Entry = *IterBool.first;
-  if (!IterBool.second) { 
-    MCSectionXCOFF *ExistedEntry = Entry.second; 
-    if (ExistedEntry->isMultiSymbolsAllowed() != MultiSymbolsAllowed) 
-      report_fatal_error("section's multiply symbols policy does not match"); 
-
-    return ExistedEntry; 
-  } 
- 
+  if (!IterBool.second) {
+    MCSectionXCOFF *ExistedEntry = Entry.second;
+    if (ExistedEntry->isMultiSymbolsAllowed() != MultiSymbolsAllowed)
+      report_fatal_error("section's multiply symbols policy does not match");
+
+    return ExistedEntry;
+  }
+
   // Otherwise, return a new section.
   StringRef CachedName = Entry.first.SectionName;
   MCSymbolXCOFF *QualName = cast<MCSymbolXCOFF>(getOrCreateSymbol(
@@ -694,8 +694,8 @@ MCContext::getXCOFFSection(StringRef Section, XCOFF::StorageMappingClass SMC,
   // QualName->getUnqualifiedName() and CachedName are the same except when
   // CachedName contains invalid character(s) such as '$' for an XCOFF symbol.
   MCSectionXCOFF *Result = new (XCOFFAllocator.Allocate())
-      MCSectionXCOFF(QualName->getUnqualifiedName(), SMC, Type, Kind, QualName, 
-                     Begin, CachedName, MultiSymbolsAllowed); 
+      MCSectionXCOFF(QualName->getUnqualifiedName(), SMC, Type, Kind, QualName,
+                     Begin, CachedName, MultiSymbolsAllowed);
   Entry.second = Result;
 
   auto *F = new MCDataFragment();
@@ -832,13 +832,13 @@ void MCContext::reportError(SMLoc Loc, const Twine &Msg) {
 
   // If we have a source manager use it. Otherwise, try using the inline source
   // manager.
-  // If that fails, construct a temporary SourceMgr. 
+  // If that fails, construct a temporary SourceMgr.
   if (SrcMgr)
     SrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg);
   else if (InlineSrcMgr)
     InlineSrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg);
   else
-    SourceMgr().PrintMessage(Loc, SourceMgr::DK_Error, Msg); 
+    SourceMgr().PrintMessage(Loc, SourceMgr::DK_Error, Msg);
 }
 
 void MCContext::reportWarning(SMLoc Loc, const Twine &Msg) {
diff --git a/contrib/libs/llvm12/lib/MC/MCDisassembler/ya.make b/contrib/libs/llvm12/lib/MC/MCDisassembler/ya.make
index 1f6d2c8654..160728d237 100644
--- a/contrib/libs/llvm12/lib/MC/MCDisassembler/ya.make
+++ b/contrib/libs/llvm12/lib/MC/MCDisassembler/ya.make
@@ -12,9 +12,9 @@ LICENSE(Apache-2.0 WITH LLVM-exception)
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
 PEERDIR(
-    contrib/libs/llvm12 
-    contrib/libs/llvm12/lib/MC 
-    contrib/libs/llvm12/lib/Support 
+    contrib/libs/llvm12
+    contrib/libs/llvm12/lib/MC
+    contrib/libs/llvm12/lib/Support
 )
 
 ADDINCL(
diff --git a/contrib/libs/llvm12/lib/MC/MCDwarf.cpp b/contrib/libs/llvm12/lib/MC/MCDwarf.cpp
index fe0c0d6bd4..f86d4266a1 100644
--- a/contrib/libs/llvm12/lib/MC/MCDwarf.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCDwarf.cpp
@@ -46,8 +46,8 @@
 using namespace llvm;
 
 MCSymbol *mcdwarf::emitListsTableHeaderStart(MCStreamer &S) {
-  MCSymbol *Start = S.getContext().createTempSymbol("debug_list_header_start"); 
-  MCSymbol *End = S.getContext().createTempSymbol("debug_list_header_end"); 
+  MCSymbol *Start = S.getContext().createTempSymbol("debug_list_header_start");
+  MCSymbol *End = S.getContext().createTempSymbol("debug_list_header_end");
   auto DwarfFormat = S.getContext().getDwarfFormat();
   if (DwarfFormat == dwarf::DWARF64) {
     S.AddComment("DWARF64 mark");
@@ -766,10 +766,10 @@ void MCDwarfLineAddr::Encode(MCContext &Context, MCDwarfLineTableParams Params,
   }
 }
 
-std::tuple<uint32_t, uint32_t, bool> 
-MCDwarfLineAddr::fixedEncode(MCContext &Context, int64_t LineDelta, 
-                             uint64_t AddrDelta, raw_ostream &OS) { 
-  uint32_t Offset, Size; 
+std::tuple<uint32_t, uint32_t, bool>
+MCDwarfLineAddr::fixedEncode(MCContext &Context, int64_t LineDelta,
+                             uint64_t AddrDelta, raw_ostream &OS) {
+  uint32_t Offset, Size;
   if (LineDelta != INT64_MAX) {
     OS << char(dwarf::DW_LNS_advance_line);
     encodeSLEB128(LineDelta, OS);
@@ -789,15 +789,15 @@ MCDwarfLineAddr::fixedEncode(MCContext &Context, int64_t LineDelta,
     encodeULEB128(1 + AddrSize, OS);
     OS << char(dwarf::DW_LNE_set_address);
     // Generate fixup for the address.
-    Offset = OS.tell(); 
-    Size = AddrSize; 
+    Offset = OS.tell();
+    Size = AddrSize;
     SetDelta = false;
     OS.write_zeros(AddrSize);
   } else {
     OS << char(dwarf::DW_LNS_fixed_advance_pc);
     // Generate fixup for 2-bytes address delta.
-    Offset = OS.tell(); 
-    Size = 2; 
+    Offset = OS.tell();
+    Size = 2;
     SetDelta = true;
     OS << char(0);
     OS << char(0);
@@ -811,7 +811,7 @@ MCDwarfLineAddr::fixedEncode(MCContext &Context, int64_t LineDelta,
     OS << char(dwarf::DW_LNS_copy);
   }
 
-  return std::make_tuple(Offset, Size, SetDelta); 
+  return std::make_tuple(Offset, Size, SetDelta);
 }
 
 // Utility function to write a tuple for .debug_abbrev.
@@ -1137,7 +1137,7 @@ static MCSymbol *emitGenDwarfRanges(MCStreamer *MCOS) {
     MCSymbol *EndSymbol = mcdwarf::emitListsTableHeaderStart(*MCOS);
     MCOS->AddComment("Offset entry count");
     MCOS->emitInt32(0);
-    RangesSymbol = context.createTempSymbol("debug_rnglist0_start"); 
+    RangesSymbol = context.createTempSymbol("debug_rnglist0_start");
     MCOS->emitLabel(RangesSymbol);
     for (MCSection *Sec : Sections) {
       const MCSymbol *StartSymbol = Sec->getBeginSymbol();
@@ -1154,7 +1154,7 @@ static MCSymbol *emitGenDwarfRanges(MCStreamer *MCOS) {
     MCOS->emitLabel(EndSymbol);
   } else {
     MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRangesSection());
-    RangesSymbol = context.createTempSymbol("debug_ranges_start"); 
+    RangesSymbol = context.createTempSymbol("debug_ranges_start");
     MCOS->emitLabel(RangesSymbol);
     for (MCSection *Sec : Sections) {
       const MCSymbol *StartSymbol = Sec->getBeginSymbol();
diff --git a/contrib/libs/llvm12/lib/MC/MCELFStreamer.cpp b/contrib/libs/llvm12/lib/MC/MCELFStreamer.cpp
index b2ead90bf8..db45aef7d5 100644
--- a/contrib/libs/llvm12/lib/MC/MCELFStreamer.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCELFStreamer.cpp
@@ -224,31 +224,31 @@ bool MCELFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
     break;
 
   case MCSA_Global:
-    // For `.weak x; .global x`, GNU as sets the binding to STB_WEAK while we 
-    // traditionally set the binding to STB_GLOBAL. This is error-prone, so we 
-    // error on such cases. Note, we also disallow changed binding from .local. 
-    if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_GLOBAL) 
-      getContext().reportError(getStartTokLoc(), 
-                               Symbol->getName() + 
-                                   " changed binding to STB_GLOBAL"); 
+    // For `.weak x; .global x`, GNU as sets the binding to STB_WEAK while we
+    // traditionally set the binding to STB_GLOBAL. This is error-prone, so we
+    // error on such cases. Note, we also disallow changed binding from .local.
+    if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_GLOBAL)
+      getContext().reportError(getStartTokLoc(),
+                               Symbol->getName() +
+                                   " changed binding to STB_GLOBAL");
     Symbol->setBinding(ELF::STB_GLOBAL);
     break;
 
   case MCSA_WeakReference:
   case MCSA_Weak:
-    // For `.global x; .weak x`, both MC and GNU as set the binding to STB_WEAK. 
-    // We emit a warning for now but may switch to an error in the future. 
-    if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_WEAK) 
-      getContext().reportWarning( 
-          getStartTokLoc(), Symbol->getName() + " changed binding to STB_WEAK"); 
+    // For `.global x; .weak x`, both MC and GNU as set the binding to STB_WEAK.
+    // We emit a warning for now but may switch to an error in the future.
+    if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_WEAK)
+      getContext().reportWarning(
+          getStartTokLoc(), Symbol->getName() + " changed binding to STB_WEAK");
     Symbol->setBinding(ELF::STB_WEAK);
     break;
 
   case MCSA_Local:
-    if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_LOCAL) 
-      getContext().reportError(getStartTokLoc(), 
-                               Symbol->getName() + 
-                                   " changed binding to STB_LOCAL"); 
+    if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_LOCAL)
+      getContext().reportError(getStartTokLoc(),
+                               Symbol->getName() +
+                                   " changed binding to STB_LOCAL");
     Symbol->setBinding(ELF::STB_LOCAL);
     break;
 
@@ -304,7 +304,7 @@ void MCELFStreamer::emitCommonSymbol(MCSymbol *S, uint64_t Size,
   auto *Symbol = cast<MCSymbolELF>(S);
   getAssembler().registerSymbol(*Symbol);
 
-  if (!Symbol->isBindingSet()) 
+  if (!Symbol->isBindingSet())
     Symbol->setBinding(ELF::STB_GLOBAL);
 
   Symbol->setType(ELF::STT_OBJECT);
@@ -336,8 +336,8 @@ void MCELFStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
 
 void MCELFStreamer::emitELFSymverDirective(StringRef AliasName,
                                            const MCSymbol *Aliasee) {
-  getAssembler().Symvers.push_back( 
-      MCAssembler::Symver{AliasName, Aliasee, getStartTokLoc()}); 
+  getAssembler().Symvers.push_back(
+      MCAssembler::Symver{AliasName, Aliasee, getStartTokLoc()});
 }
 
 void MCELFStreamer::emitLocalCommonSymbol(MCSymbol *S, uint64_t Size,
@@ -443,18 +443,18 @@ void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
     case MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO:
     case MCSymbolRefExpr::VK_PPC_GOT_TPREL_HI:
     case MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA:
-    case MCSymbolRefExpr::VK_PPC_GOT_TPREL_PCREL: 
+    case MCSymbolRefExpr::VK_PPC_GOT_TPREL_PCREL:
     case MCSymbolRefExpr::VK_PPC_GOT_DTPREL:
     case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_LO:
     case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HI:
     case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HA:
     case MCSymbolRefExpr::VK_PPC_TLS:
-    case MCSymbolRefExpr::VK_PPC_TLS_PCREL: 
+    case MCSymbolRefExpr::VK_PPC_TLS_PCREL:
     case MCSymbolRefExpr::VK_PPC_GOT_TLSGD:
     case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO:
     case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HI:
     case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA:
-    case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_PCREL: 
+    case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_PCREL:
     case MCSymbolRefExpr::VK_PPC_TLSGD:
     case MCSymbolRefExpr::VK_PPC_GOT_TLSLD:
     case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO:
@@ -492,7 +492,7 @@ void MCELFStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE) {
   // Not a temporary, referece it as a weak undefined.
   bool Created;
   getAssembler().registerSymbol(*S, &Created);
-  if (Created) 
+  if (Created)
     cast<MCSymbolELF>(S)->setBinding(ELF::STB_WEAK);
 }
 
diff --git a/contrib/libs/llvm12/lib/MC/MCExpr.cpp b/contrib/libs/llvm12/lib/MC/MCExpr.cpp
index 39a9853b75..3b123a46d9 100644
--- a/contrib/libs/llvm12/lib/MC/MCExpr.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCExpr.cpp
@@ -47,8 +47,8 @@ void MCExpr::print(raw_ostream &OS, const MCAsmInfo *MAI, bool InParens) const {
     auto Value = cast<MCConstantExpr>(*this).getValue();
     auto PrintInHex = cast<MCConstantExpr>(*this).useHexFormat();
     auto SizeInBytes = cast<MCConstantExpr>(*this).getSizeInBytes();
-    if (Value < 0 && MAI && !MAI->supportsSignedData()) 
-      PrintInHex = true; 
+    if (Value < 0 && MAI && !MAI->supportsSignedData())
+      PrintInHex = true;
     if (PrintInHex)
       switch (SizeInBytes) {
       default:
@@ -85,13 +85,13 @@ void MCExpr::print(raw_ostream &OS, const MCAsmInfo *MAI, bool InParens) const {
     } else
       Sym.print(OS, MAI);
 
-    const MCSymbolRefExpr::VariantKind Kind = SRE.getKind(); 
-    if (Kind != MCSymbolRefExpr::VK_None) { 
-      if (MAI && MAI->useParensForSymbolVariant()) // ARM 
-        OS << '(' << MCSymbolRefExpr::getVariantKindName(Kind) << ')'; 
-      else 
-        OS << '@' << MCSymbolRefExpr::getVariantKindName(Kind); 
-    } 
+    const MCSymbolRefExpr::VariantKind Kind = SRE.getKind();
+    if (Kind != MCSymbolRefExpr::VK_None) {
+      if (MAI && MAI->useParensForSymbolVariant()) // ARM
+        OS << '(' << MCSymbolRefExpr::getVariantKindName(Kind) << ')';
+      else
+        OS << '@' << MCSymbolRefExpr::getVariantKindName(Kind);
+    }
 
     return;
   }
@@ -150,7 +150,7 @@ void MCExpr::print(raw_ostream &OS, const MCAsmInfo *MAI, bool InParens) const {
     case MCBinaryExpr::Mul:  OS <<  '*'; break;
     case MCBinaryExpr::NE:   OS << "!="; break;
     case MCBinaryExpr::Or:   OS <<  '|'; break;
-    case MCBinaryExpr::OrNot: OS << '!'; break; 
+    case MCBinaryExpr::OrNot: OS << '!'; break;
     case MCBinaryExpr::Shl:  OS << "<<"; break;
     case MCBinaryExpr::Sub:  OS <<  '-'; break;
     case MCBinaryExpr::Xor:  OS <<  '^'; break;
@@ -202,7 +202,7 @@ const MCConstantExpr *MCConstantExpr::create(int64_t Value, MCContext &Ctx,
 MCSymbolRefExpr::MCSymbolRefExpr(const MCSymbol *Symbol, VariantKind Kind,
                                  const MCAsmInfo *MAI, SMLoc Loc)
     : MCExpr(MCExpr::SymbolRef, Loc,
-             encodeSubclassData(Kind, MAI->hasSubsectionsViaSymbols())), 
+             encodeSubclassData(Kind, MAI->hasSubsectionsViaSymbols())),
       Symbol(Symbol) {
   assert(Symbol);
 }
@@ -253,7 +253,7 @@ StringRef MCSymbolRefExpr::getVariantKindName(VariantKind Kind) {
   case VK_SIZE: return "SIZE";
   case VK_WEAKREF: return "WEAKREF";
   case VK_X86_ABS8: return "ABS8";
-  case VK_X86_PLTOFF: return "PLTOFF"; 
+  case VK_X86_PLTOFF: return "PLTOFF";
   case VK_ARM_NONE: return "none";
   case VK_ARM_GOT_PREL: return "GOT_PREL";
   case VK_ARM_TARGET1: return "target1";
@@ -327,18 +327,18 @@ StringRef MCSymbolRefExpr::getVariantKindName(VariantKind Kind) {
   case VK_PPC_GOT_TLSLD_HA: return "got@tlsld@ha";
   case VK_PPC_GOT_PCREL:
     return "got@pcrel";
-  case VK_PPC_GOT_TLSGD_PCREL: 
-    return "got@tlsgd@pcrel"; 
-  case VK_PPC_GOT_TLSLD_PCREL: 
-    return "got@tlsld@pcrel"; 
-  case VK_PPC_GOT_TPREL_PCREL: 
-    return "got@tprel@pcrel"; 
-  case VK_PPC_TLS_PCREL: 
-    return "tls@pcrel"; 
+  case VK_PPC_GOT_TLSGD_PCREL:
+    return "got@tlsgd@pcrel";
+  case VK_PPC_GOT_TLSLD_PCREL:
+    return "got@tlsld@pcrel";
+  case VK_PPC_GOT_TPREL_PCREL:
+    return "got@tprel@pcrel";
+  case VK_PPC_TLS_PCREL:
+    return "tls@pcrel";
   case VK_PPC_TLSLD: return "tlsld";
   case VK_PPC_LOCAL: return "local";
   case VK_PPC_NOTOC: return "notoc";
-  case VK_PPC_PCREL_OPT: return "<<invalid>>"; 
+  case VK_PPC_PCREL_OPT: return "<<invalid>>";
   case VK_COFF_IMGREL32: return "IMGREL";
   case VK_Hexagon_LO16: return "LO16";
   case VK_Hexagon_HI16: return "HI16";
@@ -351,7 +351,7 @@ StringRef MCSymbolRefExpr::getVariantKindName(VariantKind Kind) {
   case VK_Hexagon_IE_GOT: return "IEGOT";
   case VK_WASM_TYPEINDEX: return "TYPEINDEX";
   case VK_WASM_MBREL: return "MBREL";
-  case VK_WASM_TLSREL: return "TLSREL"; 
+  case VK_WASM_TLSREL: return "TLSREL";
   case VK_WASM_TBREL: return "TBREL";
   case VK_AMDGPU_GOTPCREL32_LO: return "gotpcrel32@lo";
   case VK_AMDGPU_GOTPCREL32_HI: return "gotpcrel32@hi";
@@ -411,7 +411,7 @@ MCSymbolRefExpr::getVariantKindForName(StringRef Name) {
     .Case("secrel32", VK_SECREL)
     .Case("size", VK_SIZE)
     .Case("abs8", VK_X86_ABS8)
-    .Case("pltoff", VK_X86_PLTOFF) 
+    .Case("pltoff", VK_X86_PLTOFF)
     .Case("l", VK_PPC_LO)
     .Case("h", VK_PPC_HI)
     .Case("ha", VK_PPC_HA)
@@ -469,10 +469,10 @@ MCSymbolRefExpr::getVariantKindForName(StringRef Name) {
     .Case("got@tlsld@h", VK_PPC_GOT_TLSLD_HI)
     .Case("got@tlsld@ha", VK_PPC_GOT_TLSLD_HA)
     .Case("got@pcrel", VK_PPC_GOT_PCREL)
-    .Case("got@tlsgd@pcrel", VK_PPC_GOT_TLSGD_PCREL) 
-    .Case("got@tlsld@pcrel", VK_PPC_GOT_TLSLD_PCREL) 
-    .Case("got@tprel@pcrel", VK_PPC_GOT_TPREL_PCREL) 
-    .Case("tls@pcrel", VK_PPC_TLS_PCREL) 
+    .Case("got@tlsgd@pcrel", VK_PPC_GOT_TLSGD_PCREL)
+    .Case("got@tlsld@pcrel", VK_PPC_GOT_TLSLD_PCREL)
+    .Case("got@tprel@pcrel", VK_PPC_GOT_TPREL_PCREL)
+    .Case("tls@pcrel", VK_PPC_TLS_PCREL)
     .Case("notoc", VK_PPC_NOTOC)
     .Case("gdgot", VK_Hexagon_GD_GOT)
     .Case("gdplt", VK_Hexagon_GD_PLT)
@@ -493,7 +493,7 @@ MCSymbolRefExpr::getVariantKindForName(StringRef Name) {
     .Case("typeindex", VK_WASM_TYPEINDEX)
     .Case("tbrel", VK_WASM_TBREL)
     .Case("mbrel", VK_WASM_MBREL)
-    .Case("tlsrel", VK_WASM_TLSREL) 
+    .Case("tlsrel", VK_WASM_TLSREL)
     .Case("gotpcrel32@lo", VK_AMDGPU_GOTPCREL32_LO)
     .Case("gotpcrel32@hi", VK_AMDGPU_GOTPCREL32_HI)
     .Case("rel32@lo", VK_AMDGPU_REL32_LO)
@@ -592,7 +592,7 @@ static void AttemptToFoldSymbolOffsetDifference(
   if (!Asm->getWriter().isSymbolRefDifferenceFullyResolved(*Asm, A, B, InSet))
     return;
 
-  auto FinalizeFolding = [&]() { 
+  auto FinalizeFolding = [&]() {
     // Pointers to Thumb symbols need to have their low-bit set to allow
     // for interworking.
     if (Asm->isThumbFunc(&SA))
@@ -606,16 +606,16 @@ static void AttemptToFoldSymbolOffsetDifference(
     // Clear the symbol expr pointers to indicate we have folded these
     // operands.
     A = B = nullptr;
-  }; 
- 
-  const MCFragment *FA = SA.getFragment(); 
-  const MCFragment *FB = SB.getFragment(); 
-  // If both symbols are in the same fragment, return the difference of their 
-  // offsets 
-  if (FA == FB && !SA.isVariable() && !SA.isUnset() && !SB.isVariable() && 
-      !SB.isUnset()) { 
-    Addend += SA.getOffset() - SB.getOffset(); 
-    return FinalizeFolding(); 
+  };
+
+  const MCFragment *FA = SA.getFragment();
+  const MCFragment *FB = SB.getFragment();
+  // If both symbols are in the same fragment, return the difference of their
+  // offsets
+  if (FA == FB && !SA.isVariable() && !SA.isUnset() && !SB.isVariable() &&
+      !SB.isUnset()) {
+    Addend += SA.getOffset() - SB.getOffset();
+    return FinalizeFolding();
   }
 
   const MCSection &SecA = *FA->getParent();
@@ -624,46 +624,46 @@ static void AttemptToFoldSymbolOffsetDifference(
   if ((&SecA != &SecB) && !Addrs)
     return;
 
-  if (Layout) { 
-    // One of the symbol involved is part of a fragment being laid out. Quit now 
-    // to avoid a self loop. 
-    if (!Layout->canGetFragmentOffset(FA) || !Layout->canGetFragmentOffset(FB)) 
-      return; 
-
-    // Eagerly evaluate when layout is finalized. 
-    Addend += Layout->getSymbolOffset(A->getSymbol()) - 
-              Layout->getSymbolOffset(B->getSymbol()); 
-    if (Addrs && (&SecA != &SecB)) 
-      Addend += (Addrs->lookup(&SecA) - Addrs->lookup(&SecB)); 
-
-    FinalizeFolding(); 
-  } else { 
-    // When layout is not finalized, our ability to resolve differences between 
-    // symbols is limited to specific cases where the fragments between two 
-    // symbols (including the fragments the symbols are defined in) are 
-    // fixed-size fragments so the difference can be calculated. For example, 
-    // this is important when the Subtarget is changed and a new MCDataFragment 
-    // is created in the case of foo: instr; .arch_extension ext; instr .if . - 
-    // foo. 
-    if (SA.isVariable() || SA.isUnset() || SB.isVariable() || SB.isUnset() || 
-        FA->getKind() != MCFragment::FT_Data || 
-        FB->getKind() != MCFragment::FT_Data || 
-        FA->getSubsectionNumber() != FB->getSubsectionNumber()) 
-      return; 
-    // Try to find a constant displacement from FA to FB, add the displacement 
-    // between the offset in FA of SA and the offset in FB of SB. 
-    int64_t Displacement = SA.getOffset() - SB.getOffset(); 
-    for (auto FI = FB->getIterator(), FE = SecA.end(); FI != FE; ++FI) { 
-      if (&*FI == FA) { 
-        Addend += Displacement; 
-        return FinalizeFolding(); 
-      } 
-
-      if (FI->getKind() != MCFragment::FT_Data) 
-        return; 
-      Displacement += cast<MCDataFragment>(FI)->getContents().size(); 
-    } 
-  } 
+  if (Layout) {
+    // One of the symbol involved is part of a fragment being laid out. Quit now
+    // to avoid a self loop.
+    if (!Layout->canGetFragmentOffset(FA) || !Layout->canGetFragmentOffset(FB))
+      return;
+
+    // Eagerly evaluate when layout is finalized.
+    Addend += Layout->getSymbolOffset(A->getSymbol()) -
+              Layout->getSymbolOffset(B->getSymbol());
+    if (Addrs && (&SecA != &SecB))
+      Addend += (Addrs->lookup(&SecA) - Addrs->lookup(&SecB));
+
+    FinalizeFolding();
+  } else {
+    // When layout is not finalized, our ability to resolve differences between
+    // symbols is limited to specific cases where the fragments between two
+    // symbols (including the fragments the symbols are defined in) are
+    // fixed-size fragments so the difference can be calculated. For example,
+    // this is important when the Subtarget is changed and a new MCDataFragment
+    // is created in the case of foo: instr; .arch_extension ext; instr .if . -
+    // foo.
+    if (SA.isVariable() || SA.isUnset() || SB.isVariable() || SB.isUnset() ||
+        FA->getKind() != MCFragment::FT_Data ||
+        FB->getKind() != MCFragment::FT_Data ||
+        FA->getSubsectionNumber() != FB->getSubsectionNumber())
+      return;
+    // Try to find a constant displacement from FA to FB, add the displacement
+    // between the offset in FA of SA and the offset in FB of SB.
+    int64_t Displacement = SA.getOffset() - SB.getOffset();
+    for (auto FI = FB->getIterator(), FE = SecA.end(); FI != FE; ++FI) {
+      if (&*FI == FA) {
+        Addend += Displacement;
+        return FinalizeFolding();
+      }
+
+      if (FI->getKind() != MCFragment::FT_Data)
+        return;
+      Displacement += cast<MCDataFragment>(FI)->getContents().size();
+    }
+  }
 }
 
 static bool canFold(const MCAssembler *Asm, const MCSymbolRefExpr *A,
@@ -804,30 +804,30 @@ bool MCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
   case SymbolRef: {
     const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(this);
     const MCSymbol &Sym = SRE->getSymbol();
-    const auto Kind = SRE->getKind(); 
+    const auto Kind = SRE->getKind();
 
     // Evaluate recursively if this is a variable.
-    if (Sym.isVariable() && (Kind == MCSymbolRefExpr::VK_None || Layout) && 
+    if (Sym.isVariable() && (Kind == MCSymbolRefExpr::VK_None || Layout) &&
         canExpand(Sym, InSet)) {
       bool IsMachO = SRE->hasSubsectionsViaSymbols();
       if (Sym.getVariableValue()->evaluateAsRelocatableImpl(
               Res, Asm, Layout, Fixup, Addrs, InSet || IsMachO)) {
-        if (Kind != MCSymbolRefExpr::VK_None) { 
-          if (Res.isAbsolute()) { 
-            Res = MCValue::get(SRE, nullptr, 0); 
-            return true; 
-          } 
-          // If the reference has a variant kind, we can only handle expressions 
-          // which evaluate exactly to a single unadorned symbol. Attach the 
-          // original VariantKind to SymA of the result. 
-          if (Res.getRefKind() != MCSymbolRefExpr::VK_None || !Res.getSymA() || 
-              Res.getSymB() || Res.getConstant()) 
-            return false; 
-          Res = 
-              MCValue::get(MCSymbolRefExpr::create(&Res.getSymA()->getSymbol(), 
-                                                   Kind, Asm->getContext()), 
-                           Res.getSymB(), Res.getConstant(), Res.getRefKind()); 
-        } 
+        if (Kind != MCSymbolRefExpr::VK_None) {
+          if (Res.isAbsolute()) {
+            Res = MCValue::get(SRE, nullptr, 0);
+            return true;
+          }
+          // If the reference has a variant kind, we can only handle expressions
+          // which evaluate exactly to a single unadorned symbol. Attach the
+          // original VariantKind to SymA of the result.
+          if (Res.getRefKind() != MCSymbolRefExpr::VK_None || !Res.getSymA() ||
+              Res.getSymB() || Res.getConstant())
+            return false;
+          Res =
+              MCValue::get(MCSymbolRefExpr::create(&Res.getSymA()->getSymbol(),
+                                                   Kind, Asm->getContext()),
+                           Res.getSymB(), Res.getConstant(), Res.getRefKind());
+        }
         if (!IsMachO)
           return true;
 
@@ -968,7 +968,7 @@ bool MCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
     case MCBinaryExpr::Mul:  Result = LHS * RHS; break;
     case MCBinaryExpr::NE:   Result = LHS != RHS; break;
     case MCBinaryExpr::Or:   Result = LHS | RHS; break;
-    case MCBinaryExpr::OrNot: Result = LHS | ~RHS; break; 
+    case MCBinaryExpr::OrNot: Result = LHS | ~RHS; break;
     case MCBinaryExpr::Shl:  Result = uint64_t(LHS) << uint64_t(RHS); break;
     case MCBinaryExpr::Sub:  Result = LHS - RHS; break;
     case MCBinaryExpr::Xor:  Result = LHS ^ RHS; break;
diff --git a/contrib/libs/llvm12/lib/MC/MCFragment.cpp b/contrib/libs/llvm12/lib/MC/MCFragment.cpp
index ca90696064..0f8543f510 100644
--- a/contrib/libs/llvm12/lib/MC/MCFragment.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCFragment.cpp
@@ -279,9 +279,9 @@ void MCFragment::destroy() {
     case FT_Fill:
       delete cast<MCFillFragment>(this);
       return;
-    case FT_Nops: 
-      delete cast<MCNopsFragment>(this); 
-      return; 
+    case FT_Nops:
+      delete cast<MCNopsFragment>(this);
+      return;
     case FT_Relaxable:
       delete cast<MCRelaxableFragment>(this);
       return;
@@ -309,9 +309,9 @@ void MCFragment::destroy() {
     case FT_CVDefRange:
       delete cast<MCCVDefRangeFragment>(this);
       return;
-    case FT_PseudoProbe: 
-      delete cast<MCPseudoProbeAddrFragment>(this); 
-      return; 
+    case FT_PseudoProbe:
+      delete cast<MCPseudoProbeAddrFragment>(this);
+      return;
     case FT_Dummy:
       delete cast<MCDummyFragment>(this);
       return;
@@ -342,9 +342,9 @@ LLVM_DUMP_METHOD void MCFragment::dump() const {
   case MCFragment::FT_CompactEncodedInst:
     OS << "MCCompactEncodedInstFragment"; break;
   case MCFragment::FT_Fill:  OS << "MCFillFragment"; break;
-  case MCFragment::FT_Nops: 
-    OS << "MCFNopsFragment"; 
-    break; 
+  case MCFragment::FT_Nops:
+    OS << "MCFNopsFragment";
+    break;
   case MCFragment::FT_Relaxable:  OS << "MCRelaxableFragment"; break;
   case MCFragment::FT_Org:   OS << "MCOrgFragment"; break;
   case MCFragment::FT_Dwarf: OS << "MCDwarfFragment"; break;
@@ -354,9 +354,9 @@ LLVM_DUMP_METHOD void MCFragment::dump() const {
   case MCFragment::FT_SymbolId:    OS << "MCSymbolIdFragment"; break;
   case MCFragment::FT_CVInlineLines: OS << "MCCVInlineLineTableFragment"; break;
   case MCFragment::FT_CVDefRange: OS << "MCCVDefRangeTableFragment"; break;
-  case MCFragment::FT_PseudoProbe: 
-    OS << "MCPseudoProbe"; 
-    break; 
+  case MCFragment::FT_PseudoProbe:
+    OS << "MCPseudoProbe";
+    break;
   case MCFragment::FT_Dummy: OS << "MCDummyFragment"; break;
   }
 
@@ -420,12 +420,12 @@ LLVM_DUMP_METHOD void MCFragment::dump() const {
        << " NumValues:" << FF->getNumValues();
     break;
   }
-  case MCFragment::FT_Nops: { 
-    const auto *NF = cast<MCNopsFragment>(this); 
-    OS << " NumBytes:" << NF->getNumBytes() 
-       << " ControlledNopLength:" << NF->getControlledNopLength(); 
-    break; 
-  } 
+  case MCFragment::FT_Nops: {
+    const auto *NF = cast<MCNopsFragment>(this);
+    OS << " NumBytes:" << NF->getNumBytes()
+       << " ControlledNopLength:" << NF->getControlledNopLength();
+    break;
+  }
   case MCFragment::FT_Relaxable:  {
     const auto *F = cast<MCRelaxableFragment>(this);
     OS << "\n       ";
@@ -490,12 +490,12 @@ LLVM_DUMP_METHOD void MCFragment::dump() const {
     }
     break;
   }
-  case MCFragment::FT_PseudoProbe: { 
-    const auto *OF = cast<MCPseudoProbeAddrFragment>(this); 
-    OS << "\n       "; 
-    OS << " AddrDelta:" << OF->getAddrDelta(); 
-    break; 
-  } 
+  case MCFragment::FT_PseudoProbe: {
+    const auto *OF = cast<MCPseudoProbeAddrFragment>(this);
+    OS << "\n       ";
+    OS << " AddrDelta:" << OF->getAddrDelta();
+    break;
+  }
   case MCFragment::FT_Dummy:
     break;
   }
diff --git a/contrib/libs/llvm12/lib/MC/MCObjectFileInfo.cpp b/contrib/libs/llvm12/lib/MC/MCObjectFileInfo.cpp
index 23761956ca..398de873fe 100644
--- a/contrib/libs/llvm12/lib/MC/MCObjectFileInfo.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCObjectFileInfo.cpp
@@ -497,10 +497,10 @@ void MCObjectFileInfo::initELFMCObjectFileInfo(const Triple &T, bool Large) {
       Ctx->getELFSection(".eh_frame", EHSectionType, EHSectionFlags);
 
   StackSizesSection = Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, 0);
- 
-  PseudoProbeSection = Ctx->getELFSection(".pseudo_probe", DebugSecType, 0); 
-  PseudoProbeDescSection = 
-      Ctx->getELFSection(".pseudo_probe_desc", DebugSecType, 0); 
+
+  PseudoProbeSection = Ctx->getELFSection(".pseudo_probe", DebugSecType, 0);
+  PseudoProbeDescSection =
+      Ctx->getELFSection(".pseudo_probe_desc", DebugSecType, 0);
 }
 
 void MCObjectFileInfo::initCOFFMCObjectFileInfo(const Triple &T) {
@@ -758,11 +758,11 @@ void MCObjectFileInfo::initCOFFMCObjectFileInfo(const Triple &T) {
                                          COFF::IMAGE_SCN_MEM_READ,
                                      SectionKind::getMetadata());
 
-  GIATsSection = Ctx->getCOFFSection(".giats$y", 
-                                     COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 
-                                         COFF::IMAGE_SCN_MEM_READ, 
-                                     SectionKind::getMetadata()); 
- 
+  GIATsSection = Ctx->getCOFFSection(".giats$y",
+                                     COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
+                                         COFF::IMAGE_SCN_MEM_READ,
+                                     SectionKind::getMetadata());
+
   GLJMPSection = Ctx->getCOFFSection(".gljmp$y",
                                      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
                                          COFF::IMAGE_SCN_MEM_READ,
@@ -807,10 +807,10 @@ void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
   DwarfFrameSection = Ctx->getWasmSection(".debug_frame", SectionKind::getMetadata());
   DwarfPubNamesSection = Ctx->getWasmSection(".debug_pubnames", SectionKind::getMetadata());
   DwarfPubTypesSection = Ctx->getWasmSection(".debug_pubtypes", SectionKind::getMetadata());
-  DwarfGnuPubNamesSection = 
-      Ctx->getWasmSection(".debug_gnu_pubnames", SectionKind::getMetadata()); 
-  DwarfGnuPubTypesSection = 
-      Ctx->getWasmSection(".debug_gnu_pubtypes", SectionKind::getMetadata()); 
+  DwarfGnuPubNamesSection =
+      Ctx->getWasmSection(".debug_gnu_pubnames", SectionKind::getMetadata());
+  DwarfGnuPubTypesSection =
+      Ctx->getWasmSection(".debug_gnu_pubtypes", SectionKind::getMetadata());
 
   DwarfDebugNamesSection =
       Ctx->getWasmSection(".debug_names", SectionKind::getMetadata());
@@ -823,37 +823,37 @@ void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
   DwarfLoclistsSection =
       Ctx->getWasmSection(".debug_loclists", SectionKind::getMetadata());
 
-  // Fission Sections 
-  DwarfInfoDWOSection = 
-      Ctx->getWasmSection(".debug_info.dwo", SectionKind::getMetadata()); 
-  DwarfTypesDWOSection = 
-      Ctx->getWasmSection(".debug_types.dwo", SectionKind::getMetadata()); 
-  DwarfAbbrevDWOSection = 
-      Ctx->getWasmSection(".debug_abbrev.dwo", SectionKind::getMetadata()); 
-  DwarfStrDWOSection = 
-      Ctx->getWasmSection(".debug_str.dwo", SectionKind::getMetadata()); 
-  DwarfLineDWOSection = 
-      Ctx->getWasmSection(".debug_line.dwo", SectionKind::getMetadata()); 
-  DwarfLocDWOSection = 
-      Ctx->getWasmSection(".debug_loc.dwo", SectionKind::getMetadata()); 
-  DwarfStrOffDWOSection = 
-      Ctx->getWasmSection(".debug_str_offsets.dwo", SectionKind::getMetadata()); 
-  DwarfRnglistsDWOSection = 
-      Ctx->getWasmSection(".debug_rnglists.dwo", SectionKind::getMetadata()); 
-  DwarfMacinfoDWOSection = 
-      Ctx->getWasmSection(".debug_macinfo.dwo", SectionKind::getMetadata()); 
-  DwarfMacroDWOSection = 
-      Ctx->getWasmSection(".debug_macro.dwo", SectionKind::getMetadata()); 
- 
-  DwarfLoclistsDWOSection = 
-      Ctx->getWasmSection(".debug_loclists.dwo", SectionKind::getMetadata()); 
- 
-  // DWP Sections 
-  DwarfCUIndexSection = 
-      Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata(), 0); 
-  DwarfTUIndexSection = 
-      Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata(), 0); 
- 
+  // Fission Sections
+  DwarfInfoDWOSection =
+      Ctx->getWasmSection(".debug_info.dwo", SectionKind::getMetadata());
+  DwarfTypesDWOSection =
+      Ctx->getWasmSection(".debug_types.dwo", SectionKind::getMetadata());
+  DwarfAbbrevDWOSection =
+      Ctx->getWasmSection(".debug_abbrev.dwo", SectionKind::getMetadata());
+  DwarfStrDWOSection =
+      Ctx->getWasmSection(".debug_str.dwo", SectionKind::getMetadata());
+  DwarfLineDWOSection =
+      Ctx->getWasmSection(".debug_line.dwo", SectionKind::getMetadata());
+  DwarfLocDWOSection =
+      Ctx->getWasmSection(".debug_loc.dwo", SectionKind::getMetadata());
+  DwarfStrOffDWOSection =
+      Ctx->getWasmSection(".debug_str_offsets.dwo", SectionKind::getMetadata());
+  DwarfRnglistsDWOSection =
+      Ctx->getWasmSection(".debug_rnglists.dwo", SectionKind::getMetadata());
+  DwarfMacinfoDWOSection =
+      Ctx->getWasmSection(".debug_macinfo.dwo", SectionKind::getMetadata());
+  DwarfMacroDWOSection =
+      Ctx->getWasmSection(".debug_macro.dwo", SectionKind::getMetadata());
+
+  DwarfLoclistsDWOSection =
+      Ctx->getWasmSection(".debug_loclists.dwo", SectionKind::getMetadata());
+
+  // DWP Sections
+  DwarfCUIndexSection =
+      Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata(), 0);
+  DwarfTUIndexSection =
+      Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata(), 0);
+
   // Wasm use data section for LSDA.
   // TODO Consider putting each function's exception table in a separate
   // section, as in -function-sections, to facilitate lld's --gc-section.
@@ -870,31 +870,31 @@ void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
   // csect for program code.
   TextSection = Ctx->getXCOFFSection(
       ".text", XCOFF::StorageMappingClass::XMC_PR, XCOFF::XTY_SD,
-      SectionKind::getText(), /* MultiSymbolsAllowed*/ true); 
+      SectionKind::getText(), /* MultiSymbolsAllowed*/ true);
 
   DataSection = Ctx->getXCOFFSection(
       ".data", XCOFF::StorageMappingClass::XMC_RW, XCOFF::XTY_SD,
-      SectionKind::getData(), /* MultiSymbolsAllowed*/ true); 
+      SectionKind::getData(), /* MultiSymbolsAllowed*/ true);
 
   ReadOnlySection = Ctx->getXCOFFSection(
       ".rodata", XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD,
-      SectionKind::getReadOnly(), /* MultiSymbolsAllowed*/ true); 
+      SectionKind::getReadOnly(), /* MultiSymbolsAllowed*/ true);
 
-  TOCBaseSection = 
-      Ctx->getXCOFFSection("TOC", XCOFF::StorageMappingClass::XMC_TC0, 
-                           XCOFF::XTY_SD, SectionKind::getData()); 
+  TOCBaseSection =
+      Ctx->getXCOFFSection("TOC", XCOFF::StorageMappingClass::XMC_TC0,
+                           XCOFF::XTY_SD, SectionKind::getData());
 
   // The TOC-base always has 0 size, but 4 byte alignment.
   TOCBaseSection->setAlignment(Align(4));
 
-  LSDASection = Ctx->getXCOFFSection(".gcc_except_table", 
-                                     XCOFF::StorageMappingClass::XMC_RO, 
-                                     XCOFF::XTY_SD, SectionKind::getReadOnly()); 
- 
-  CompactUnwindSection = 
-      Ctx->getXCOFFSection(".eh_info_table", XCOFF::StorageMappingClass::XMC_RW, 
-                           XCOFF::XTY_SD, SectionKind::getData()); 
- 
+  LSDASection = Ctx->getXCOFFSection(".gcc_except_table",
+                                     XCOFF::StorageMappingClass::XMC_RO,
+                                     XCOFF::XTY_SD, SectionKind::getReadOnly());
+
+  CompactUnwindSection =
+      Ctx->getXCOFFSection(".eh_info_table", XCOFF::StorageMappingClass::XMC_RW,
+                           XCOFF::XTY_SD, SectionKind::getData());
+
   // DWARF sections for XCOFF are not csects. They are special STYP_DWARF
   // sections, and the individual DWARF sections are distinguished by their
   // section subtype.
@@ -958,9 +958,9 @@ void MCObjectFileInfo::InitMCObjectFileInfo(const Triple &TheTriple, bool PIC,
     Env = IsWasm;
     initWasmMCObjectFileInfo(TT);
     break;
-  case Triple::GOFF: 
-    report_fatal_error("Cannot initialize MC for GOFF object file format"); 
-    break; 
+  case Triple::GOFF:
+    report_fatal_error("Cannot initialize MC for GOFF object file format");
+    break;
   case Triple::XCOFF:
     Env = IsXCOFF;
     initXCOFFMCObjectFileInfo(TT);
@@ -977,12 +977,12 @@ MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name,
   case Triple::ELF:
     return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, ELF::SHF_GROUP, 0,
                               utostr(Hash));
-  case Triple::Wasm: 
-    return Ctx->getWasmSection(Name, SectionKind::getMetadata(), utostr(Hash), 
-                               MCContext::GenericSectionID); 
+  case Triple::Wasm:
+    return Ctx->getWasmSection(Name, SectionKind::getMetadata(), utostr(Hash),
+                               MCContext::GenericSectionID);
   case Triple::MachO:
   case Triple::COFF:
-  case Triple::GOFF: 
+  case Triple::GOFF:
   case Triple::XCOFF:
   case Triple::UnknownObjectFormat:
     report_fatal_error("Cannot get DWARF comdat section for this object file "
@@ -1006,64 +1006,64 @@ MCObjectFileInfo::getStackSizesSection(const MCSection &TextSec) const {
   }
 
   return Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, Flags, 0,
-                            GroupName, ElfSec.getUniqueID(), 
+                            GroupName, ElfSec.getUniqueID(),
+                            cast<MCSymbolELF>(TextSec.getBeginSymbol()));
+}
+
+MCSection *
+MCObjectFileInfo::getBBAddrMapSection(const MCSection &TextSec) const {
+  if (Env != IsELF)
+    return nullptr;
+
+  const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
+  unsigned Flags = ELF::SHF_LINK_ORDER;
+  StringRef GroupName;
+  if (const MCSymbol *Group = ElfSec.getGroup()) {
+    GroupName = Group->getName();
+    Flags |= ELF::SHF_GROUP;
+  }
+
+  // Use the text section's begin symbol and unique ID to create a separate
+  // .llvm_bb_addr_map section associated with every unique text section.
+  return Ctx->getELFSection(".llvm_bb_addr_map", ELF::SHT_LLVM_BB_ADDR_MAP,
+                            Flags, 0, GroupName, ElfSec.getUniqueID(),
                             cast<MCSymbolELF>(TextSec.getBeginSymbol()));
 }
- 
-MCSection * 
-MCObjectFileInfo::getBBAddrMapSection(const MCSection &TextSec) const { 
-  if (Env != IsELF) 
-    return nullptr; 
- 
-  const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec); 
-  unsigned Flags = ELF::SHF_LINK_ORDER; 
-  StringRef GroupName; 
-  if (const MCSymbol *Group = ElfSec.getGroup()) { 
-    GroupName = Group->getName(); 
-    Flags |= ELF::SHF_GROUP; 
-  } 
- 
-  // Use the text section's begin symbol and unique ID to create a separate 
-  // .llvm_bb_addr_map section associated with every unique text section. 
-  return Ctx->getELFSection(".llvm_bb_addr_map", ELF::SHT_LLVM_BB_ADDR_MAP, 
-                            Flags, 0, GroupName, ElfSec.getUniqueID(), 
-                            cast<MCSymbolELF>(TextSec.getBeginSymbol())); 
-} 
- 
-MCSection * 
-MCObjectFileInfo::getPseudoProbeSection(const MCSection *TextSec) const { 
-  if (Env == IsELF) { 
-    const auto *ElfSec = static_cast<const MCSectionELF *>(TextSec); 
-    // Create a separate section for probes that comes with a comdat function. 
-    if (const MCSymbol *Group = ElfSec->getGroup()) { 
-      auto *S = static_cast<MCSectionELF *>(PseudoProbeSection); 
-      auto Flags = S->getFlags() | ELF::SHF_GROUP; 
-      return Ctx->getELFSection(S->getName(), S->getType(), Flags, 
-                                S->getEntrySize(), Group->getName()); 
-    } 
-  } 
-  return PseudoProbeSection; 
-} 
- 
-MCSection * 
-MCObjectFileInfo::getPseudoProbeDescSection(StringRef FuncName) const { 
-  if (Env == IsELF) { 
-    // Create a separate comdat group for each function's descriptor in order 
-    // for the linker to deduplicate. The duplication, must be from different 
-    // tranlation unit, can come from: 
-    //  1. Inline functions defined in header files; 
-    //  2. ThinLTO imported funcions; 
-    //  3. Weak-linkage definitions. 
-    // Use a concatenation of the section name and the function name as the 
-    // group name so that descriptor-only groups won't be folded with groups of 
-    // code. 
-    if (TT.supportsCOMDAT() && !FuncName.empty()) { 
-      auto *S = static_cast<MCSectionELF *>(PseudoProbeDescSection); 
-      auto Flags = S->getFlags() | ELF::SHF_GROUP; 
-      return Ctx->getELFSection(S->getName(), S->getType(), Flags, 
-                                S->getEntrySize(), 
-                                S->getName() + "_" + FuncName); 
-    } 
-  } 
-  return PseudoProbeDescSection; 
-} 
+
+MCSection *
+MCObjectFileInfo::getPseudoProbeSection(const MCSection *TextSec) const {
+  if (Env == IsELF) {
+    const auto *ElfSec = static_cast<const MCSectionELF *>(TextSec);
+    // Create a separate section for probes that comes with a comdat function.
+    if (const MCSymbol *Group = ElfSec->getGroup()) {
+      auto *S = static_cast<MCSectionELF *>(PseudoProbeSection);
+      auto Flags = S->getFlags() | ELF::SHF_GROUP;
+      return Ctx->getELFSection(S->getName(), S->getType(), Flags,
+                                S->getEntrySize(), Group->getName());
+    }
+  }
+  return PseudoProbeSection;
+}
+
+MCSection *
+MCObjectFileInfo::getPseudoProbeDescSection(StringRef FuncName) const {
+  if (Env == IsELF) {
+    // Create a separate comdat group for each function's descriptor in order
+    // for the linker to deduplicate. The duplication, must be from different
+    // tranlation unit, can come from:
+    //  1. Inline functions defined in header files;
+    //  2. ThinLTO imported funcions;
+    //  3. Weak-linkage definitions.
+    // Use a concatenation of the section name and the function name as the
+    // group name so that descriptor-only groups won't be folded with groups of
+    // code.
+    if (TT.supportsCOMDAT() && !FuncName.empty()) {
+      auto *S = static_cast<MCSectionELF *>(PseudoProbeDescSection);
+      auto Flags = S->getFlags() | ELF::SHF_GROUP;
+      return Ctx->getELFSection(S->getName(), S->getType(), Flags,
+                                S->getEntrySize(),
+                                S->getName() + "_" + FuncName);
+    }
+  }
+  return PseudoProbeDescSection;
+}
diff --git a/contrib/libs/llvm12/lib/MC/MCObjectStreamer.cpp b/contrib/libs/llvm12/lib/MC/MCObjectStreamer.cpp
index 10cbc00bc5..1c23d31f87 100644
--- a/contrib/libs/llvm12/lib/MC/MCObjectStreamer.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCObjectStreamer.cpp
@@ -248,7 +248,7 @@ void MCObjectStreamer::emitValueImpl(const MCExpr *Value, unsigned Size,
 }
 
 MCSymbol *MCObjectStreamer::emitCFILabel() {
-  MCSymbol *Label = getContext().createTempSymbol("cfi"); 
+  MCSymbol *Label = getContext().createTempSymbol("cfi");
   emitLabel(Label);
   return Label;
 }
@@ -665,68 +665,68 @@ void MCObjectStreamer::emitGPRel64Value(const MCExpr *Value) {
   DF->getContents().resize(DF->getContents().size() + 8, 0);
 }
 
-static Optional<std::pair<bool, std::string>> 
-getOffsetAndDataFragment(const MCSymbol &Symbol, uint32_t &RelocOffset, 
-                         MCDataFragment *&DF) { 
-  if (Symbol.isVariable()) { 
-    const MCExpr *SymbolExpr = Symbol.getVariableValue(); 
-    MCValue OffsetVal; 
-    if(!SymbolExpr->evaluateAsRelocatable(OffsetVal, nullptr, nullptr)) 
-      return std::make_pair(false, 
-                            std::string("symbol in .reloc offset is not " 
-                                        "relocatable")); 
-    if (OffsetVal.isAbsolute()) { 
-      RelocOffset = OffsetVal.getConstant(); 
-      MCFragment *Fragment = Symbol.getFragment(); 
-      // FIXME Support symbols with no DF. For example: 
-      // .reloc .data, ENUM_VALUE, <some expr> 
-      if (!Fragment || Fragment->getKind() != MCFragment::FT_Data) 
-        return std::make_pair(false, 
-                              std::string("symbol in offset has no data " 
-                                          "fragment")); 
-      DF = cast<MCDataFragment>(Fragment); 
-      return None; 
-    } 
- 
-    if (OffsetVal.getSymB()) 
-      return std::make_pair(false, 
-                            std::string(".reloc symbol offset is not " 
-                                        "representable")); 
- 
-    const MCSymbolRefExpr &SRE = cast<MCSymbolRefExpr>(*OffsetVal.getSymA()); 
-    if (!SRE.getSymbol().isDefined()) 
-      return std::make_pair(false, 
-                            std::string("symbol used in the .reloc offset is " 
-                                        "not defined")); 
- 
-    if (SRE.getSymbol().isVariable()) 
-      return std::make_pair(false, 
-                            std::string("symbol used in the .reloc offset is " 
-                                        "variable")); 
- 
-    MCFragment *Fragment = SRE.getSymbol().getFragment(); 
-    // FIXME Support symbols with no DF. For example: 
-    // .reloc .data, ENUM_VALUE, <some expr> 
-    if (!Fragment || Fragment->getKind() != MCFragment::FT_Data) 
-      return std::make_pair(false, 
-                            std::string("symbol in offset has no data " 
-                                        "fragment")); 
-    RelocOffset = SRE.getSymbol().getOffset() + OffsetVal.getConstant(); 
-    DF = cast<MCDataFragment>(Fragment); 
-  } else { 
-    RelocOffset = Symbol.getOffset(); 
-    MCFragment *Fragment = Symbol.getFragment(); 
-    // FIXME Support symbols with no DF. For example: 
-    // .reloc .data, ENUM_VALUE, <some expr> 
-    if (!Fragment || Fragment->getKind() != MCFragment::FT_Data) 
-      return std::make_pair(false, 
-                            std::string("symbol in offset has no data " 
-                                        "fragment")); 
-    DF = cast<MCDataFragment>(Fragment); 
-  } 
-  return None; 
-} 
- 
+static Optional<std::pair<bool, std::string>>
+getOffsetAndDataFragment(const MCSymbol &Symbol, uint32_t &RelocOffset,
+                         MCDataFragment *&DF) {
+  if (Symbol.isVariable()) {
+    const MCExpr *SymbolExpr = Symbol.getVariableValue();
+    MCValue OffsetVal;
+    if(!SymbolExpr->evaluateAsRelocatable(OffsetVal, nullptr, nullptr))
+      return std::make_pair(false,
+                            std::string("symbol in .reloc offset is not "
+                                        "relocatable"));
+    if (OffsetVal.isAbsolute()) {
+      RelocOffset = OffsetVal.getConstant();
+      MCFragment *Fragment = Symbol.getFragment();
+      // FIXME Support symbols with no DF. For example:
+      // .reloc .data, ENUM_VALUE, <some expr>
+      if (!Fragment || Fragment->getKind() != MCFragment::FT_Data)
+        return std::make_pair(false,
+                              std::string("symbol in offset has no data "
+                                          "fragment"));
+      DF = cast<MCDataFragment>(Fragment);
+      return None;
+    }
+
+    if (OffsetVal.getSymB())
+      return std::make_pair(false,
+                            std::string(".reloc symbol offset is not "
+                                        "representable"));
+
+    const MCSymbolRefExpr &SRE = cast<MCSymbolRefExpr>(*OffsetVal.getSymA());
+    if (!SRE.getSymbol().isDefined())
+      return std::make_pair(false,
+                            std::string("symbol used in the .reloc offset is "
+                                        "not defined"));
+
+    if (SRE.getSymbol().isVariable())
+      return std::make_pair(false,
+                            std::string("symbol used in the .reloc offset is "
+                                        "variable"));
+
+    MCFragment *Fragment = SRE.getSymbol().getFragment();
+    // FIXME Support symbols with no DF. For example:
+    // .reloc .data, ENUM_VALUE, <some expr>
+    if (!Fragment || Fragment->getKind() != MCFragment::FT_Data)
+      return std::make_pair(false,
+                            std::string("symbol in offset has no data "
+                                        "fragment"));
+    RelocOffset = SRE.getSymbol().getOffset() + OffsetVal.getConstant();
+    DF = cast<MCDataFragment>(Fragment);
+  } else {
+    RelocOffset = Symbol.getOffset();
+    MCFragment *Fragment = Symbol.getFragment();
+    // FIXME Support symbols with no DF. For example:
+    // .reloc .data, ENUM_VALUE, <some expr>
+    if (!Fragment || Fragment->getKind() != MCFragment::FT_Data)
+      return std::make_pair(false,
+                            std::string("symbol in offset has no data "
+                                        "fragment"));
+    DF = cast<MCDataFragment>(Fragment);
+  }
+  return None;
+}
+
 Optional<std::pair<bool, std::string>>
 MCObjectStreamer::emitRelocDirective(const MCExpr &Offset, StringRef Name,
                                      const MCExpr *Expr, SMLoc Loc,
@@ -760,17 +760,17 @@ MCObjectStreamer::emitRelocDirective(const MCExpr &Offset, StringRef Name,
                           std::string(".reloc offset is not representable"));
 
   const MCSymbolRefExpr &SRE = cast<MCSymbolRefExpr>(*OffsetVal.getSymA());
-  const MCSymbol &Symbol = SRE.getSymbol(); 
-  if (Symbol.isDefined()) { 
-    uint32_t SymbolOffset = 0; 
-    Optional<std::pair<bool, std::string>> Error; 
-    Error = getOffsetAndDataFragment(Symbol, SymbolOffset, DF); 
- 
-    if (Error != None) 
-      return Error; 
- 
+  const MCSymbol &Symbol = SRE.getSymbol();
+  if (Symbol.isDefined()) {
+    uint32_t SymbolOffset = 0;
+    Optional<std::pair<bool, std::string>> Error;
+    Error = getOffsetAndDataFragment(Symbol, SymbolOffset, DF);
+
+    if (Error != None)
+      return Error;
+
     DF->getFixups().push_back(
-        MCFixup::create(SymbolOffset + OffsetVal.getConstant(), 
+        MCFixup::create(SymbolOffset + OffsetVal.getConstant(),
                         Expr, Kind, Loc));
     return None;
   }
@@ -819,16 +819,16 @@ void MCObjectStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
   insert(new MCFillFragment(Expr, Size, NumValues, Loc));
 }
 
-void MCObjectStreamer::emitNops(int64_t NumBytes, int64_t ControlledNopLength, 
-                                SMLoc Loc) { 
-  // Emit an NOP fragment. 
-  MCDataFragment *DF = getOrCreateDataFragment(); 
-  flushPendingLabels(DF, DF->getContents().size()); 
- 
-  assert(getCurrentSectionOnly() && "need a section"); 
-  insert(new MCNopsFragment(NumBytes, ControlledNopLength, Loc)); 
-} 
- 
+void MCObjectStreamer::emitNops(int64_t NumBytes, int64_t ControlledNopLength,
+                                SMLoc Loc) {
+  // Emit an NOP fragment.
+  MCDataFragment *DF = getOrCreateDataFragment();
+  flushPendingLabels(DF, DF->getContents().size());
+
+  assert(getCurrentSectionOnly() && "need a section");
+  insert(new MCNopsFragment(NumBytes, ControlledNopLength, Loc));
+}
+
 void MCObjectStreamer::emitFileDirective(StringRef Filename) {
   getAssembler().addFileName(Filename);
 }
@@ -852,9 +852,9 @@ void MCObjectStreamer::finishImpl() {
   // Dump out the dwarf file & directory tables and line tables.
   MCDwarfLineTable::Emit(this, getAssembler().getDWARFLinetableParams());
 
-  // Emit pseudo probes for the current module. 
-  MCPseudoProbeTable::emit(this); 
- 
+  // Emit pseudo probes for the current module.
+  MCPseudoProbeTable::emit(this);
+
   // Update any remaining pending labels with empty data fragments.
   flushPendingLabels();
 
diff --git a/contrib/libs/llvm12/lib/MC/MCParser/AsmLexer.cpp b/contrib/libs/llvm12/lib/MC/MCParser/AsmLexer.cpp
index 43c36f8eab..1fa22ab000 100644
--- a/contrib/libs/llvm12/lib/MC/MCParser/AsmLexer.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCParser/AsmLexer.cpp
@@ -18,7 +18,7 @@
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCParser/MCAsmLexer.h"
-#include "llvm/Support/Compiler.h" 
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include <cassert>
@@ -64,12 +64,12 @@ int AsmLexer::getNextChar() {
   return (unsigned char)*CurPtr++;
 }
 
-int AsmLexer::peekNextChar() { 
-  if (CurPtr == CurBuf.end()) 
-    return EOF; 
-  return (unsigned char)*CurPtr; 
-} 
- 
+int AsmLexer::peekNextChar() {
+  if (CurPtr == CurBuf.end())
+    return EOF;
+  return (unsigned char)*CurPtr;
+}
+
 /// The leading integral digit sequence and dot should have already been
 /// consumed, some or all of the fractional digit sequence *can* have been
 /// consumed.
@@ -278,34 +278,34 @@ static unsigned doHexLookAhead(const char *&CurPtr, unsigned DefaultRadix,
   return DefaultRadix;
 }
 
-static const char *findLastDigit(const char *CurPtr, unsigned DefaultRadix) { 
-  while (hexDigitValue(*CurPtr) < DefaultRadix) { 
-    ++CurPtr; 
-  } 
-  return CurPtr; 
-} 
- 
-static AsmToken intToken(StringRef Ref, APInt &Value) { 
+static const char *findLastDigit(const char *CurPtr, unsigned DefaultRadix) {
+  while (hexDigitValue(*CurPtr) < DefaultRadix) {
+    ++CurPtr;
+  }
+  return CurPtr;
+}
+
+static AsmToken intToken(StringRef Ref, APInt &Value) {
   if (Value.isIntN(64))
     return AsmToken(AsmToken::Integer, Ref, Value);
   return AsmToken(AsmToken::BigNum, Ref, Value);
 }
 
-static std::string radixName(unsigned Radix) { 
-  switch (Radix) { 
-  case 2: 
-    return "binary"; 
-  case 8: 
-    return "octal"; 
-  case 10: 
-    return "decimal"; 
-  case 16: 
-    return "hexadecimal"; 
-  default: 
-    return "base-" + std::to_string(Radix); 
-  } 
-} 
- 
+static std::string radixName(unsigned Radix) {
+  switch (Radix) {
+  case 2:
+    return "binary";
+  case 8:
+    return "octal";
+  case 10:
+    return "decimal";
+  case 16:
+    return "hexadecimal";
+  default:
+    return "base-" + std::to_string(Radix);
+  }
+}
+
 /// LexDigit: First character is [0-9].
 ///   Local Label: [0-9][:]
 ///   Forward/Backward Label: [0-9][fb]
@@ -314,113 +314,113 @@ static std::string radixName(unsigned Radix) {
 ///   Hex integer: 0x[0-9a-fA-F]+ or [0x]?[0-9][0-9a-fA-F]*[hH]
 ///   Decimal integer: [1-9][0-9]*
 AsmToken AsmLexer::LexDigit() {
-  // MASM-flavor binary integer: [01]+[yY] (if DefaultRadix < 16, [bByY]) 
-  // MASM-flavor octal integer: [0-7]+[oOqQ] 
-  // MASM-flavor decimal integer: [0-9]+[tT] (if DefaultRadix < 16, [dDtT]) 
+  // MASM-flavor binary integer: [01]+[yY] (if DefaultRadix < 16, [bByY])
+  // MASM-flavor octal integer: [0-7]+[oOqQ]
+  // MASM-flavor decimal integer: [0-9]+[tT] (if DefaultRadix < 16, [dDtT])
   // MASM-flavor hexadecimal integer: [0-9][0-9a-fA-F]*[hH]
   if (LexMasmIntegers && isdigit(CurPtr[-1])) {
-    const char *FirstNonBinary = 
-        (CurPtr[-1] != '0' && CurPtr[-1] != '1') ? CurPtr - 1 : nullptr; 
-    const char *FirstNonDecimal = 
-        (CurPtr[-1] < '0' || CurPtr[-1] > '9') ? CurPtr - 1 : nullptr; 
+    const char *FirstNonBinary =
+        (CurPtr[-1] != '0' && CurPtr[-1] != '1') ? CurPtr - 1 : nullptr;
+    const char *FirstNonDecimal =
+        (CurPtr[-1] < '0' || CurPtr[-1] > '9') ? CurPtr - 1 : nullptr;
     const char *OldCurPtr = CurPtr;
     while (isHexDigit(*CurPtr)) {
-      switch (*CurPtr) { 
-      default: 
-        if (!FirstNonDecimal) { 
-          FirstNonDecimal = CurPtr; 
-        } 
-        LLVM_FALLTHROUGH; 
-      case '9': 
-      case '8': 
-      case '7': 
-      case '6': 
-      case '5': 
-      case '4': 
-      case '3': 
-      case '2': 
-        if (!FirstNonBinary) { 
-          FirstNonBinary = CurPtr; 
-        } 
-        break; 
-      case '1': 
-      case '0': 
-        break; 
-      } 
+      switch (*CurPtr) {
+      default:
+        if (!FirstNonDecimal) {
+          FirstNonDecimal = CurPtr;
+        }
+        LLVM_FALLTHROUGH;
+      case '9':
+      case '8':
+      case '7':
+      case '6':
+      case '5':
+      case '4':
+      case '3':
+      case '2':
+        if (!FirstNonBinary) {
+          FirstNonBinary = CurPtr;
+        }
+        break;
+      case '1':
+      case '0':
+        break;
+      }
       ++CurPtr;
     }
-    if (*CurPtr == '.') { 
-      // MASM float literals (other than hex floats) always contain a ".", and 
-      // are always written in decimal. 
-      ++CurPtr; 
-      return LexFloatLiteral(); 
-    } 
-
-    if (LexMasmHexFloats && (*CurPtr == 'r' || *CurPtr == 'R')) { 
-      ++CurPtr; 
-      return AsmToken(AsmToken::Real, StringRef(TokStart, CurPtr - TokStart)); 
-    } 
- 
+    if (*CurPtr == '.') {
+      // MASM float literals (other than hex floats) always contain a ".", and
+      // are always written in decimal.
+      ++CurPtr;
+      return LexFloatLiteral();
+    }
+
+    if (LexMasmHexFloats && (*CurPtr == 'r' || *CurPtr == 'R')) {
+      ++CurPtr;
+      return AsmToken(AsmToken::Real, StringRef(TokStart, CurPtr - TokStart));
+    }
+
     unsigned Radix = 0;
     if (*CurPtr == 'h' || *CurPtr == 'H') {
       // hexadecimal number
       ++CurPtr;
       Radix = 16;
-    } else if (*CurPtr == 't' || *CurPtr == 'T') { 
-      // decimal number 
-      ++CurPtr; 
-      Radix = 10; 
-    } else if (*CurPtr == 'o' || *CurPtr == 'O' || *CurPtr == 'q' || 
-               *CurPtr == 'Q') { 
-      // octal number 
-      ++CurPtr; 
-      Radix = 8; 
-    } else if (*CurPtr == 'y' || *CurPtr == 'Y') { 
-      // binary number 
-      ++CurPtr; 
-      Radix = 2; 
-    } else if (FirstNonDecimal && FirstNonDecimal + 1 == CurPtr && 
-               DefaultRadix < 14 && 
-               (*FirstNonDecimal == 'd' || *FirstNonDecimal == 'D')) { 
-      Radix = 10; 
+    } else if (*CurPtr == 't' || *CurPtr == 'T') {
+      // decimal number
+      ++CurPtr;
+      Radix = 10;
+    } else if (*CurPtr == 'o' || *CurPtr == 'O' || *CurPtr == 'q' ||
+               *CurPtr == 'Q') {
+      // octal number
+      ++CurPtr;
+      Radix = 8;
+    } else if (*CurPtr == 'y' || *CurPtr == 'Y') {
+      // binary number
+      ++CurPtr;
+      Radix = 2;
+    } else if (FirstNonDecimal && FirstNonDecimal + 1 == CurPtr &&
+               DefaultRadix < 14 &&
+               (*FirstNonDecimal == 'd' || *FirstNonDecimal == 'D')) {
+      Radix = 10;
     } else if (FirstNonBinary && FirstNonBinary + 1 == CurPtr &&
-               DefaultRadix < 12 && 
-               (*FirstNonBinary == 'b' || *FirstNonBinary == 'B')) { 
+               DefaultRadix < 12 &&
+               (*FirstNonBinary == 'b' || *FirstNonBinary == 'B')) {
       Radix = 2;
-    } 
+    }
 
-    if (Radix) { 
+    if (Radix) {
       StringRef Result(TokStart, CurPtr - TokStart);
       APInt Value(128, 0, true);
 
       if (Result.drop_back().getAsInteger(Radix, Value))
-        return ReturnError(TokStart, "invalid " + radixName(Radix) + " number"); 
+        return ReturnError(TokStart, "invalid " + radixName(Radix) + " number");
 
       // MSVC accepts and ignores type suffices on integer literals.
       SkipIgnoredIntegerSuffix(CurPtr);
 
       return intToken(Result, Value);
-    } 
+    }
 
-    // default-radix integers, or floating point numbers, fall through 
+    // default-radix integers, or floating point numbers, fall through
     CurPtr = OldCurPtr;
   }
 
-  // MASM default-radix integers: [0-9a-fA-F]+ 
-  // (All other integer literals have a radix specifier.) 
-  if (LexMasmIntegers && UseMasmDefaultRadix) { 
-    CurPtr = findLastDigit(CurPtr, 16); 
-    StringRef Result(TokStart, CurPtr - TokStart); 
- 
-    APInt Value(128, 0, true); 
-    if (Result.getAsInteger(DefaultRadix, Value)) { 
-      return ReturnError(TokStart, 
-                         "invalid " + radixName(DefaultRadix) + " number"); 
-    } 
- 
-    return intToken(Result, Value); 
-  } 
- 
+  // MASM default-radix integers: [0-9a-fA-F]+
+  // (All other integer literals have a radix specifier.)
+  if (LexMasmIntegers && UseMasmDefaultRadix) {
+    CurPtr = findLastDigit(CurPtr, 16);
+    StringRef Result(TokStart, CurPtr - TokStart);
+
+    APInt Value(128, 0, true);
+    if (Result.getAsInteger(DefaultRadix, Value)) {
+      return ReturnError(TokStart,
+                         "invalid " + radixName(DefaultRadix) + " number");
+    }
+
+    return intToken(Result, Value);
+  }
+
   // Decimal integer: [1-9][0-9]*
   if (CurPtr[-1] != '0' || CurPtr[0] == '.') {
     unsigned Radix = doHexLookAhead(CurPtr, 10, LexMasmIntegers);
@@ -435,9 +435,9 @@ AsmToken AsmLexer::LexDigit() {
     StringRef Result(TokStart, CurPtr - TokStart);
 
     APInt Value(128, 0, true);
-    if (Result.getAsInteger(Radix, Value)) { 
-      return ReturnError(TokStart, "invalid " + radixName(Radix) + " number"); 
-    } 
+    if (Result.getAsInteger(Radix, Value)) {
+      return ReturnError(TokStart, "invalid " + radixName(Radix) + " number");
+    }
 
     // The darwin/x86 (and x86-64) assembler accepts and ignores type
     // suffices on integer literals.
@@ -510,7 +510,7 @@ AsmToken AsmLexer::LexDigit() {
   unsigned Radix = doHexLookAhead(CurPtr, 8, LexMasmIntegers);
   StringRef Result(TokStart, CurPtr - TokStart);
   if (Result.getAsInteger(Radix, Value))
-    return ReturnError(TokStart, "invalid " + radixName(Radix) + " number"); 
+    return ReturnError(TokStart, "invalid " + radixName(Radix) + " number");
 
   // Consume the [hH].
   if (Radix == 16)
@@ -527,24 +527,24 @@ AsmToken AsmLexer::LexDigit() {
 AsmToken AsmLexer::LexSingleQuote() {
   int CurChar = getNextChar();
 
-  if (LexMasmStrings) { 
-    while (CurChar != EOF) { 
-      if (CurChar != '\'') { 
-        CurChar = getNextChar(); 
-      } else if (peekNextChar() == '\'') { 
-        // In MASM single-quote strings, doubled single-quotes mean an escaped 
-        // single quote, so should be lexed in. 
-        getNextChar(); 
-        CurChar = getNextChar(); 
-      } else { 
-        break; 
-      } 
-    } 
-    if (CurChar == EOF) 
-      return ReturnError(TokStart, "unterminated string constant"); 
-    return AsmToken(AsmToken::String, StringRef(TokStart, CurPtr - TokStart)); 
-  } 
- 
+  if (LexMasmStrings) {
+    while (CurChar != EOF) {
+      if (CurChar != '\'') {
+        CurChar = getNextChar();
+      } else if (peekNextChar() == '\'') {
+        // In MASM single-quote strings, doubled single-quotes mean an escaped
+        // single quote, so should be lexed in.
+        getNextChar();
+        CurChar = getNextChar();
+      } else {
+        break;
+      }
+    }
+    if (CurChar == EOF)
+      return ReturnError(TokStart, "unterminated string constant");
+    return AsmToken(AsmToken::String, StringRef(TokStart, CurPtr - TokStart));
+  }
+
   if (CurChar == '\\')
     CurChar = getNextChar();
 
@@ -579,24 +579,24 @@ AsmToken AsmLexer::LexSingleQuote() {
 /// LexQuote: String: "..."
 AsmToken AsmLexer::LexQuote() {
   int CurChar = getNextChar();
-  if (LexMasmStrings) { 
-    while (CurChar != EOF) { 
-      if (CurChar != '"') { 
-        CurChar = getNextChar(); 
-      } else if (peekNextChar() == '"') { 
-        // In MASM double-quoted strings, doubled double-quotes mean an escaped 
-        // double quote, so should be lexed in. 
-        getNextChar(); 
-        CurChar = getNextChar(); 
-      } else { 
-        break; 
-      } 
-    } 
-    if (CurChar == EOF) 
-      return ReturnError(TokStart, "unterminated string constant"); 
-    return AsmToken(AsmToken::String, StringRef(TokStart, CurPtr - TokStart)); 
-  } 
- 
+  if (LexMasmStrings) {
+    while (CurChar != EOF) {
+      if (CurChar != '"') {
+        CurChar = getNextChar();
+      } else if (peekNextChar() == '"') {
+        // In MASM double-quoted strings, doubled double-quotes mean an escaped
+        // double quote, so should be lexed in.
+        getNextChar();
+        CurChar = getNextChar();
+      } else {
+        break;
+      }
+    }
+    if (CurChar == EOF)
+      return ReturnError(TokStart, "unterminated string constant");
+    return AsmToken(AsmToken::String, StringRef(TokStart, CurPtr - TokStart));
+  }
+
   // TODO: does gas allow multiline string constants?
   while (CurChar != '"') {
     if (CurChar == '\\') {
@@ -715,7 +715,7 @@ AsmToken AsmLexer::LexToken() {
   if (CurChar == EOF && !IsAtStartOfStatement && EndStatementAtEOF) {
     IsAtStartOfLine = true;
     IsAtStartOfStatement = true;
-    return AsmToken(AsmToken::EndOfStatement, StringRef(TokStart, 0)); 
+    return AsmToken(AsmToken::EndOfStatement, StringRef(TokStart, 0));
   }
   IsAtStartOfLine = false;
   bool OldIsAtStartOfStatement = IsAtStartOfStatement;
diff --git a/contrib/libs/llvm12/lib/MC/MCParser/AsmParser.cpp b/contrib/libs/llvm12/lib/MC/MCParser/AsmParser.cpp
index 32ae3b1122..c5ff241ead 100644
--- a/contrib/libs/llvm12/lib/MC/MCParser/AsmParser.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCParser/AsmParser.cpp
@@ -126,7 +126,7 @@ private:
   SourceMgr::DiagHandlerTy SavedDiagHandler;
   void *SavedDiagContext;
   std::unique_ptr<MCAsmParserExtension> PlatformParser;
-  SMLoc StartTokLoc; 
+  SMLoc StartTokLoc;
 
   /// This is the current buffer index we're lexing from as managed by the
   /// SourceMgr object.
@@ -245,8 +245,8 @@ public:
 
   bool parseExpression(const MCExpr *&Res);
   bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
-  bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc, 
-                        AsmTypeInfo *TypeInfo) override; 
+  bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
+                        AsmTypeInfo *TypeInfo) override;
   bool parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
   bool parseParenExprOfDepth(unsigned ParenDepth, const MCExpr *&Res,
                              SMLoc &EndLoc) override;
@@ -515,7 +515,7 @@ private:
     DK_PRINT,
     DK_ADDRSIG,
     DK_ADDRSIG_SYM,
-    DK_PSEUDO_PROBE, 
+    DK_PSEUDO_PROBE,
     DK_END
   };
 
@@ -679,9 +679,9 @@ private:
   // .print <double-quotes-string>
   bool parseDirectivePrint(SMLoc DirectiveLoc);
 
-  // .pseudoprobe 
-  bool parseDirectivePseudoProbe(); 
- 
+  // .pseudoprobe
+  bool parseDirectivePseudoProbe();
+
   // Directives to support address-significance tables.
   bool parseDirectiveAddrsig();
   bool parseDirectiveAddrsigSym();
@@ -714,8 +714,8 @@ AsmParser::AsmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
   // Set our own handler which calls the saved handler.
   SrcMgr.setDiagHandler(DiagHandler, this);
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
-  // Make MCStreamer aware of the StartTokLoc for locations in diagnostics. 
-  Out.setStartTokLocPtr(&StartTokLoc); 
+  // Make MCStreamer aware of the StartTokLoc for locations in diagnostics.
+  Out.setStartTokLocPtr(&StartTokLoc);
 
   // Initialize the platform / file format parser.
   switch (Ctx.getObjectFileInfo()->getObjectFileType()) {
@@ -749,8 +749,8 @@ AsmParser::~AsmParser() {
   assert((HadError || ActiveMacros.empty()) &&
          "Unexpected active macro instantiation!");
 
-  // Remove MCStreamer's reference to the parser SMLoc. 
-  Out.setStartTokLocPtr(nullptr); 
+  // Remove MCStreamer's reference to the parser SMLoc.
+  Out.setStartTokLocPtr(nullptr);
   // Restore the saved diagnostics handler and context for use during
   // finalization.
   SrcMgr.setDiagHandler(SavedDiagHandler, SavedDiagContext);
@@ -998,7 +998,7 @@ bool AsmParser::Run(bool NoInitialTextSection, bool NoFinalize) {
   // Finalize the output stream if there are no errors and if the client wants
   // us to.
   if (!HadError && !NoFinalize)
-    Out.Finish(Lexer.getLoc()); 
+    Out.Finish(Lexer.getLoc());
 
   return HadError || getContext().hadError();
 }
@@ -1078,8 +1078,8 @@ bool AsmParser::parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc) {
 ///  primaryexpr ::= number
 ///  primaryexpr ::= '.'
 ///  primaryexpr ::= ~,+,- primaryexpr
-bool AsmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc, 
-                                 AsmTypeInfo *TypeInfo) { 
+bool AsmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
+                                 AsmTypeInfo *TypeInfo) {
   SMLoc FirstTokenLoc = getLexer().getLoc();
   AsmToken::TokenKind FirstTokenKind = Lexer.getKind();
   switch (FirstTokenKind) {
@@ -1090,7 +1090,7 @@ bool AsmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
     return true;
   case AsmToken::Exclaim:
     Lex(); // Eat the operator.
-    if (parsePrimaryExpr(Res, EndLoc, TypeInfo)) 
+    if (parsePrimaryExpr(Res, EndLoc, TypeInfo))
       return true;
     Res = MCUnaryExpr::createLNot(Res, getContext(), FirstTokenLoc);
     return false;
@@ -1249,19 +1249,19 @@ bool AsmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
     return parseBracketExpr(Res, EndLoc);
   case AsmToken::Minus:
     Lex(); // Eat the operator.
-    if (parsePrimaryExpr(Res, EndLoc, TypeInfo)) 
+    if (parsePrimaryExpr(Res, EndLoc, TypeInfo))
       return true;
     Res = MCUnaryExpr::createMinus(Res, getContext(), FirstTokenLoc);
     return false;
   case AsmToken::Plus:
     Lex(); // Eat the operator.
-    if (parsePrimaryExpr(Res, EndLoc, TypeInfo)) 
+    if (parsePrimaryExpr(Res, EndLoc, TypeInfo))
       return true;
     Res = MCUnaryExpr::createPlus(Res, getContext(), FirstTokenLoc);
     return false;
   case AsmToken::Tilde:
     Lex(); // Eat the operator.
-    if (parsePrimaryExpr(Res, EndLoc, TypeInfo)) 
+    if (parsePrimaryExpr(Res, EndLoc, TypeInfo))
       return true;
     Res = MCUnaryExpr::createNot(Res, getContext(), FirstTokenLoc);
     return false;
@@ -1568,8 +1568,8 @@ static unsigned getDarwinBinOpPrecedence(AsmToken::TokenKind K,
   }
 }
 
-static unsigned getGNUBinOpPrecedence(const MCAsmInfo &MAI, 
-                                      AsmToken::TokenKind K, 
+static unsigned getGNUBinOpPrecedence(const MCAsmInfo &MAI,
+                                      AsmToken::TokenKind K,
                                       MCBinaryExpr::Opcode &Kind,
                                       bool ShouldUseLogicalShr) {
   switch (K) {
@@ -1613,18 +1613,18 @@ static unsigned getGNUBinOpPrecedence(const MCAsmInfo &MAI,
     Kind = MCBinaryExpr::Sub;
     return 4;
 
-  // High Intermediate Precedence: |, !, &, ^ 
+  // High Intermediate Precedence: |, !, &, ^
   //
   case AsmToken::Pipe:
     Kind = MCBinaryExpr::Or;
     return 5;
-  case AsmToken::Exclaim: 
-    // Hack to support ARM compatible aliases (implied 'sp' operand in 'srs*' 
-    // instructions like 'srsda #31!') and not parse ! as an infix operator. 
-    if (MAI.getCommentString() == "@") 
-      return 0; 
-    Kind = MCBinaryExpr::OrNot; 
-    return 5; 
+  case AsmToken::Exclaim:
+    // Hack to support ARM compatible aliases (implied 'sp' operand in 'srs*'
+    // instructions like 'srsda #31!') and not parse ! as an infix operator.
+    if (MAI.getCommentString() == "@")
+      return 0;
+    Kind = MCBinaryExpr::OrNot;
+    return 5;
   case AsmToken::Caret:
     Kind = MCBinaryExpr::Xor;
     return 5;
@@ -1655,7 +1655,7 @@ unsigned AsmParser::getBinOpPrecedence(AsmToken::TokenKind K,
                                        MCBinaryExpr::Opcode &Kind) {
   bool ShouldUseLogicalShr = MAI.shouldUseLogicalShr();
   return IsDarwin ? getDarwinBinOpPrecedence(K, Kind, ShouldUseLogicalShr)
-                  : getGNUBinOpPrecedence(MAI, K, Kind, ShouldUseLogicalShr); 
+                  : getGNUBinOpPrecedence(MAI, K, Kind, ShouldUseLogicalShr);
 }
 
 /// Parse all binary operators with precedence >= 'Precedence'.
@@ -1714,7 +1714,7 @@ bool AsmParser::parseStatement(ParseStatementInfo &Info,
   SMLoc IDLoc = ID.getLoc();
   StringRef IDVal;
   int64_t LocalLabelVal = -1;
-  StartTokLoc = ID.getLoc(); 
+  StartTokLoc = ID.getLoc();
   if (Lexer.is(AsmToken::HashDirective))
     return parseCppHashLineFilenameComment(IDLoc,
                                            !isInsideMacroInstantiation());
@@ -2206,8 +2206,8 @@ bool AsmParser::parseStatement(ParseStatementInfo &Info,
       return parseDirectiveAddrsig();
     case DK_ADDRSIG_SYM:
       return parseDirectiveAddrsigSym();
-    case DK_PSEUDO_PROBE: 
-      return parseDirectivePseudoProbe(); 
+    case DK_PSEUDO_PROBE:
+      return parseDirectivePseudoProbe();
     }
 
     return Error(IDLoc, "unknown directive");
@@ -3008,20 +3008,20 @@ bool AsmParser::parseAngleBracketString(std::string &Data) {
 }
 
 /// parseDirectiveAscii:
-//    ::= .ascii [ "string"+ ( , "string"+ )* ] 
-///   ::= ( .asciz | .string ) [ "string" ( , "string" )* ] 
+//    ::= .ascii [ "string"+ ( , "string"+ )* ]
+///   ::= ( .asciz | .string ) [ "string" ( , "string" )* ]
 bool AsmParser::parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated) {
   auto parseOp = [&]() -> bool {
     std::string Data;
-    if (checkForValidSection()) 
+    if (checkForValidSection())
       return true;
-    // Only support spaces as separators for .ascii directive for now. See the 
-    // discusssion at https://reviews.llvm.org/D91460 for more details. 
-    do { 
-      if (parseEscapedString(Data)) 
-        return true; 
-      getStreamer().emitBytes(Data); 
-    } while (!ZeroTerminated && getTok().is(AsmToken::String)); 
+    // Only support spaces as separators for .ascii directive for now. See the
+    // discusssion at https://reviews.llvm.org/D91460 for more details.
+    do {
+      if (parseEscapedString(Data))
+        return true;
+      getStreamer().emitBytes(Data);
+    } while (!ZeroTerminated && getTok().is(AsmToken::String));
     if (ZeroTerminated)
       getStreamer().emitBytes(StringRef("\0", 1));
     return false;
@@ -3349,8 +3349,8 @@ bool AsmParser::parseDirectiveAlign(bool IsPow2, unsigned ValueSize) {
       Alignment = 1;
     if (!isPowerOf2_64(Alignment))
       ReturnVal |= Error(AlignmentLoc, "alignment must be a power of 2");
-    if (!isUInt<32>(Alignment)) 
-      ReturnVal |= Error(AlignmentLoc, "alignment must be smaller than 2**32"); 
+    if (!isUInt<32>(Alignment))
+      ReturnVal |= Error(AlignmentLoc, "alignment must be smaller than 2**32");
   }
 
   // Diagnose non-sensical max bytes to align.
@@ -4092,9 +4092,9 @@ bool AsmParser::parseDirectiveCFISections() {
       Debug = true;
   }
 
-  if (parseToken(AsmToken::EndOfStatement)) 
-    return addErrorSuffix(" in '.cfi_sections' directive"); 
- 
+  if (parseToken(AsmToken::EndOfStatement))
+    return addErrorSuffix(" in '.cfi_sections' directive");
+
   getStreamer().emitCFISections(EH, Debug);
   return false;
 }
@@ -4122,8 +4122,8 @@ bool AsmParser::parseDirectiveCFIStartProc() {
 /// parseDirectiveCFIEndProc
 /// ::= .cfi_endproc
 bool AsmParser::parseDirectiveCFIEndProc() {
-  if (parseToken(AsmToken::EndOfStatement)) 
-    return addErrorSuffix(" in '.cfi_endproc' directive"); 
+  if (parseToken(AsmToken::EndOfStatement))
+    return addErrorSuffix(" in '.cfi_endproc' directive");
   getStreamer().emitCFIEndProc();
   return false;
 }
@@ -5535,7 +5535,7 @@ void AsmParser::initializeDirectiveKindMap() {
   DirectiveKindMap[".print"] = DK_PRINT;
   DirectiveKindMap[".addrsig"] = DK_ADDRSIG;
   DirectiveKindMap[".addrsig_sym"] = DK_ADDRSIG_SYM;
-  DirectiveKindMap[".pseudoprobe"] = DK_PSEUDO_PROBE; 
+  DirectiveKindMap[".pseudoprobe"] = DK_PSEUDO_PROBE;
 }
 
 MCAsmMacro *AsmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
@@ -5791,69 +5791,69 @@ bool AsmParser::parseDirectiveAddrsigSym() {
   return false;
 }
 
-bool AsmParser::parseDirectivePseudoProbe() { 
-  int64_t Guid; 
-  int64_t Index; 
-  int64_t Type; 
-  int64_t Attr; 
- 
-  if (getLexer().is(AsmToken::Integer)) { 
-    if (parseIntToken(Guid, "unexpected token in '.pseudoprobe' directive")) 
-      return true; 
-  } 
- 
-  if (getLexer().is(AsmToken::Integer)) { 
-    if (parseIntToken(Index, "unexpected token in '.pseudoprobe' directive")) 
-      return true; 
-  } 
- 
-  if (getLexer().is(AsmToken::Integer)) { 
-    if (parseIntToken(Type, "unexpected token in '.pseudoprobe' directive")) 
-      return true; 
-  } 
- 
-  if (getLexer().is(AsmToken::Integer)) { 
-    if (parseIntToken(Attr, "unexpected token in '.pseudoprobe' directive")) 
-      return true; 
-  } 
- 
-  // Parse inline stack like @ GUID:11:12 @ GUID:1:11 @ GUID:3:21 
-  MCPseudoProbeInlineStack InlineStack; 
- 
-  while (getLexer().is(AsmToken::At)) { 
-    // eat @ 
-    Lex(); 
- 
-    int64_t CallerGuid = 0; 
-    if (getLexer().is(AsmToken::Integer)) { 
-      if (parseIntToken(CallerGuid, 
-                        "unexpected token in '.pseudoprobe' directive")) 
-        return true; 
-    } 
- 
-    // eat colon 
-    if (getLexer().is(AsmToken::Colon)) 
-      Lex(); 
- 
-    int64_t CallerProbeId = 0; 
-    if (getLexer().is(AsmToken::Integer)) { 
-      if (parseIntToken(CallerProbeId, 
-                        "unexpected token in '.pseudoprobe' directive")) 
-        return true; 
-    } 
- 
-    InlineSite Site(CallerGuid, CallerProbeId); 
-    InlineStack.push_back(Site); 
-  } 
- 
-  if (parseToken(AsmToken::EndOfStatement, 
-                 "unexpected token in '.pseudoprobe' directive")) 
-    return true; 
- 
-  getStreamer().emitPseudoProbe(Guid, Index, Type, Attr, InlineStack); 
-  return false; 
-} 
- 
+bool AsmParser::parseDirectivePseudoProbe() {
+  int64_t Guid;
+  int64_t Index;
+  int64_t Type;
+  int64_t Attr;
+
+  if (getLexer().is(AsmToken::Integer)) {
+    if (parseIntToken(Guid, "unexpected token in '.pseudoprobe' directive"))
+      return true;
+  }
+
+  if (getLexer().is(AsmToken::Integer)) {
+    if (parseIntToken(Index, "unexpected token in '.pseudoprobe' directive"))
+      return true;
+  }
+
+  if (getLexer().is(AsmToken::Integer)) {
+    if (parseIntToken(Type, "unexpected token in '.pseudoprobe' directive"))
+      return true;
+  }
+
+  if (getLexer().is(AsmToken::Integer)) {
+    if (parseIntToken(Attr, "unexpected token in '.pseudoprobe' directive"))
+      return true;
+  }
+
+  // Parse inline stack like @ GUID:11:12 @ GUID:1:11 @ GUID:3:21
+  MCPseudoProbeInlineStack InlineStack;
+
+  while (getLexer().is(AsmToken::At)) {
+    // eat @
+    Lex();
+
+    int64_t CallerGuid = 0;
+    if (getLexer().is(AsmToken::Integer)) {
+      if (parseIntToken(CallerGuid,
+                        "unexpected token in '.pseudoprobe' directive"))
+        return true;
+    }
+
+    // eat colon
+    if (getLexer().is(AsmToken::Colon))
+      Lex();
+
+    int64_t CallerProbeId = 0;
+    if (getLexer().is(AsmToken::Integer)) {
+      if (parseIntToken(CallerProbeId,
+                        "unexpected token in '.pseudoprobe' directive"))
+        return true;
+    }
+
+    InlineSite Site(CallerGuid, CallerProbeId);
+    InlineStack.push_back(Site);
+  }
+
+  if (parseToken(AsmToken::EndOfStatement,
+                 "unexpected token in '.pseudoprobe' directive"))
+    return true;
+
+  getStreamer().emitPseudoProbe(Guid, Index, Type, Attr, InlineStack);
+  return false;
+}
+
 // We are comparing pointers, but the pointers are relative to a single string.
 // Thus, this should always be deterministic.
 static int rewritesSort(const AsmRewrite *AsmRewriteA,
@@ -5975,7 +5975,7 @@ bool AsmParser::parseMSInlineAsm(
     // Consider implicit defs to be clobbers.  Think of cpuid and push.
     ArrayRef<MCPhysReg> ImpDefs(Desc.getImplicitDefs(),
                                 Desc.getNumImplicitDefs());
-    llvm::append_range(ClobberRegs, ImpDefs); 
+    llvm::append_range(ClobberRegs, ImpDefs);
   }
 
   // Set the number of Outputs and Inputs.
diff --git a/contrib/libs/llvm12/lib/MC/MCParser/COFFAsmParser.cpp b/contrib/libs/llvm12/lib/MC/MCParser/COFFAsmParser.cpp
index d823afa49c..3ac6a88341 100644
--- a/contrib/libs/llvm12/lib/MC/MCParser/COFFAsmParser.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCParser/COFFAsmParser.cpp
@@ -77,8 +77,8 @@ class COFFAsmParser : public MCAsmParserExtension {
                                                                    ".seh_proc");
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndProc>(
                                                                 ".seh_endproc");
-    addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndFuncletOrFunc>( 
-                                                                ".seh_endfunclet"); 
+    addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndFuncletOrFunc>(
+                                                                ".seh_endfunclet");
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveStartChained>(
                                                            ".seh_startchained");
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndChained>(
@@ -133,7 +133,7 @@ class COFFAsmParser : public MCAsmParserExtension {
   // Win64 EH directives.
   bool ParseSEHDirectiveStartProc(StringRef, SMLoc);
   bool ParseSEHDirectiveEndProc(StringRef, SMLoc);
-  bool ParseSEHDirectiveEndFuncletOrFunc(StringRef, SMLoc); 
+  bool ParseSEHDirectiveEndFuncletOrFunc(StringRef, SMLoc);
   bool ParseSEHDirectiveStartChained(StringRef, SMLoc);
   bool ParseSEHDirectiveEndChained(StringRef, SMLoc);
   bool ParseSEHDirectiveHandler(StringRef, SMLoc);
@@ -631,12 +631,12 @@ bool COFFAsmParser::ParseSEHDirectiveEndProc(StringRef, SMLoc Loc) {
   return false;
 }
 
-bool COFFAsmParser::ParseSEHDirectiveEndFuncletOrFunc(StringRef, SMLoc Loc) { 
-  Lex(); 
-  getStreamer().EmitWinCFIFuncletOrFuncEnd(Loc); 
-  return false; 
-} 
- 
+bool COFFAsmParser::ParseSEHDirectiveEndFuncletOrFunc(StringRef, SMLoc Loc) {
+  Lex();
+  getStreamer().EmitWinCFIFuncletOrFuncEnd(Loc);
+  return false;
+}
+
 bool COFFAsmParser::ParseSEHDirectiveStartChained(StringRef, SMLoc Loc) {
   Lex();
   getStreamer().EmitWinCFIStartChained(Loc);
diff --git a/contrib/libs/llvm12/lib/MC/MCParser/COFFMasmParser.cpp b/contrib/libs/llvm12/lib/MC/MCParser/COFFMasmParser.cpp
index 89b44bf6ba..95128cf7d1 100644
--- a/contrib/libs/llvm12/lib/MC/MCParser/COFFMasmParser.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCParser/COFFMasmParser.cpp
@@ -20,7 +20,7 @@
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCStreamer.h"
-#include "llvm/MC/MCSymbolCOFF.h" 
+#include "llvm/MC/MCSymbolCOFF.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/SMLoc.h"
 #include <cassert>
@@ -53,11 +53,11 @@ class COFFMasmParser : public MCAsmParserExtension {
   bool ParseDirectiveSegmentEnd(StringRef, SMLoc);
   bool ParseDirectiveIncludelib(StringRef, SMLoc);
 
-  bool ParseDirectiveAlias(StringRef, SMLoc); 
- 
-  bool ParseSEHDirectiveAllocStack(StringRef, SMLoc); 
-  bool ParseSEHDirectiveEndProlog(StringRef, SMLoc); 
- 
+  bool ParseDirectiveAlias(StringRef, SMLoc);
+
+  bool ParseSEHDirectiveAllocStack(StringRef, SMLoc);
+  bool ParseSEHDirectiveEndProlog(StringRef, SMLoc);
+
   bool IgnoreDirective(StringRef, SMLoc) {
     while (!getLexer().is(AsmToken::EndOfStatement)) {
       Lex();
@@ -70,10 +70,10 @@ class COFFMasmParser : public MCAsmParserExtension {
     MCAsmParserExtension::Initialize(Parser);
 
     // x64 directives
-    addDirectiveHandler<&COFFMasmParser::ParseSEHDirectiveAllocStack>( 
-        ".allocstack"); 
-    addDirectiveHandler<&COFFMasmParser::ParseSEHDirectiveEndProlog>( 
-        ".endprolog"); 
+    addDirectiveHandler<&COFFMasmParser::ParseSEHDirectiveAllocStack>(
+        ".allocstack");
+    addDirectiveHandler<&COFFMasmParser::ParseSEHDirectiveEndProlog>(
+        ".endprolog");
 
     // Code label directives
     // label
@@ -95,10 +95,10 @@ class COFFMasmParser : public MCAsmParserExtension {
     // Data allocation directives
     // align
     // even
-    // mmword 
+    // mmword
     // tbyte
-    // xmmword 
-    // ymmword 
+    // xmmword
+    // ymmword
 
     // Listing control directives
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".cref");
@@ -120,7 +120,7 @@ class COFFMasmParser : public MCAsmParserExtension {
     // goto
 
     // Miscellaneous directives
-    addDirectiveHandler<&COFFMasmParser::ParseDirectiveAlias>("alias"); 
+    addDirectiveHandler<&COFFMasmParser::ParseDirectiveAlias>("alias");
     // assume
     // .fpo
     addDirectiveHandler<&COFFMasmParser::ParseDirectiveIncludelib>(
@@ -136,7 +136,7 @@ class COFFMasmParser : public MCAsmParserExtension {
     addDirectiveHandler<&COFFMasmParser::ParseDirectiveProc>("proc");
     // proto
 
-    // Processor directives; all ignored 
+    // Processor directives; all ignored
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".386");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".386P");
     addDirectiveHandler<&COFFMasmParser::IgnoreDirective>(".387");
@@ -212,7 +212,7 @@ class COFFMasmParser : public MCAsmParserExtension {
   }
 
   StringRef CurrentProcedure;
-  bool CurrentProcedureFramed; 
+  bool CurrentProcedureFramed;
 
 public:
   COFFMasmParser() = default;
@@ -332,23 +332,23 @@ bool COFFMasmParser::ParseDirectiveProc(StringRef Directive, SMLoc Loc) {
       nextLoc = getTok().getLoc();
     }
   }
-  MCSymbolCOFF *Sym = cast<MCSymbolCOFF>(getContext().getOrCreateSymbol(Label)); 
-
-  // Define symbol as simple external function 
-  Sym->setExternal(true); 
-  Sym->setType(COFF::IMAGE_SYM_DTYPE_FUNCTION << COFF::SCT_COMPLEX_TYPE_SHIFT); 
-
-  bool Framed = false; 
-  if (getLexer().is(AsmToken::Identifier) && 
-      getTok().getString().equals_lower("frame")) { 
-    Lex(); 
-    Framed = true; 
-    getStreamer().EmitWinCFIStartProc(Sym, Loc); 
-  } 
+  MCSymbolCOFF *Sym = cast<MCSymbolCOFF>(getContext().getOrCreateSymbol(Label));
+
+  // Define symbol as simple external function
+  Sym->setExternal(true);
+  Sym->setType(COFF::IMAGE_SYM_DTYPE_FUNCTION << COFF::SCT_COMPLEX_TYPE_SHIFT);
+
+  bool Framed = false;
+  if (getLexer().is(AsmToken::Identifier) &&
+      getTok().getString().equals_lower("frame")) {
+    Lex();
+    Framed = true;
+    getStreamer().EmitWinCFIStartProc(Sym, Loc);
+  }
   getStreamer().emitLabel(Sym, Loc);
- 
+
   CurrentProcedure = Label;
-  CurrentProcedureFramed = Framed; 
+  CurrentProcedureFramed = Framed;
   return false;
 }
 bool COFFMasmParser::ParseDirectiveEndProc(StringRef Directive, SMLoc Loc) {
@@ -362,52 +362,52 @@ bool COFFMasmParser::ParseDirectiveEndProc(StringRef Directive, SMLoc Loc) {
   else if (CurrentProcedure != Label)
     return Error(LabelLoc, "endp does not match current procedure '" +
                                CurrentProcedure + "'");
- 
-  if (CurrentProcedureFramed) { 
-    getStreamer().EmitWinCFIEndProc(Loc); 
-  } 
-  CurrentProcedure = ""; 
-  CurrentProcedureFramed = false; 
+
+  if (CurrentProcedureFramed) {
+    getStreamer().EmitWinCFIEndProc(Loc);
+  }
+  CurrentProcedure = "";
+  CurrentProcedureFramed = false;
+  return false;
+}
+
+bool COFFMasmParser::ParseDirectiveAlias(StringRef Directive, SMLoc Loc) {
+  std::string AliasName, ActualName;
+  if (getTok().isNot(AsmToken::Less) ||
+      getParser().parseAngleBracketString(AliasName))
+    return Error(getTok().getLoc(), "expected <aliasName>");
+  if (getParser().parseToken(AsmToken::Equal))
+    return addErrorSuffix(" in " + Directive + " directive");
+  if (getTok().isNot(AsmToken::Less) ||
+      getParser().parseAngleBracketString(ActualName))
+    return Error(getTok().getLoc(), "expected <actualName>");
+
+  MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName);
+  MCSymbol *Actual = getContext().getOrCreateSymbol(ActualName);
+
+  getStreamer().emitWeakReference(Alias, Actual);
+
+  return false;
+}
+
+bool COFFMasmParser::ParseSEHDirectiveAllocStack(StringRef Directive,
+                                                 SMLoc Loc) {
+  int64_t Size;
+  SMLoc SizeLoc = getTok().getLoc();
+  if (getParser().parseAbsoluteExpression(Size))
+    return Error(SizeLoc, "expected integer size");
+  if (Size % 8 != 0)
+    return Error(SizeLoc, "stack size must be a multiple of 8");
+  getStreamer().EmitWinCFIAllocStack(static_cast<unsigned>(Size), Loc);
+  return false;
+}
+
+bool COFFMasmParser::ParseSEHDirectiveEndProlog(StringRef Directive,
+                                                SMLoc Loc) {
+  getStreamer().EmitWinCFIEndProlog(Loc);
   return false;
 }
 
-bool COFFMasmParser::ParseDirectiveAlias(StringRef Directive, SMLoc Loc) { 
-  std::string AliasName, ActualName; 
-  if (getTok().isNot(AsmToken::Less) || 
-      getParser().parseAngleBracketString(AliasName)) 
-    return Error(getTok().getLoc(), "expected <aliasName>"); 
-  if (getParser().parseToken(AsmToken::Equal)) 
-    return addErrorSuffix(" in " + Directive + " directive"); 
-  if (getTok().isNot(AsmToken::Less) || 
-      getParser().parseAngleBracketString(ActualName)) 
-    return Error(getTok().getLoc(), "expected <actualName>"); 
- 
-  MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName); 
-  MCSymbol *Actual = getContext().getOrCreateSymbol(ActualName); 
- 
-  getStreamer().emitWeakReference(Alias, Actual); 
- 
-  return false; 
-} 
- 
-bool COFFMasmParser::ParseSEHDirectiveAllocStack(StringRef Directive, 
-                                                 SMLoc Loc) { 
-  int64_t Size; 
-  SMLoc SizeLoc = getTok().getLoc(); 
-  if (getParser().parseAbsoluteExpression(Size)) 
-    return Error(SizeLoc, "expected integer size"); 
-  if (Size % 8 != 0) 
-    return Error(SizeLoc, "stack size must be a multiple of 8"); 
-  getStreamer().EmitWinCFIAllocStack(static_cast<unsigned>(Size), Loc); 
-  return false; 
-} 
- 
-bool COFFMasmParser::ParseSEHDirectiveEndProlog(StringRef Directive, 
-                                                SMLoc Loc) { 
-  getStreamer().EmitWinCFIEndProlog(Loc); 
-  return false; 
-} 
- 
 namespace llvm {
 
 MCAsmParserExtension *createCOFFMasmParser() { return new COFFMasmParser; }
diff --git a/contrib/libs/llvm12/lib/MC/MCParser/DarwinAsmParser.cpp b/contrib/libs/llvm12/lib/MC/MCParser/DarwinAsmParser.cpp
index 0d0067f99d..9264834512 100644
--- a/contrib/libs/llvm12/lib/MC/MCParser/DarwinAsmParser.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCParser/DarwinAsmParser.cpp
@@ -1152,7 +1152,7 @@ static Triple::OSType getOSTypeFromPlatform(MachO::PlatformType Type) {
   case MachO::PLATFORM_IOSSIMULATOR:     /* silence warning */ break;
   case MachO::PLATFORM_TVOSSIMULATOR:    /* silence warning */ break;
   case MachO::PLATFORM_WATCHOSSIMULATOR: /* silence warning */ break;
-  case MachO::PLATFORM_DRIVERKIT:        /* silence warning */ break; 
+  case MachO::PLATFORM_DRIVERKIT:        /* silence warning */ break;
   }
   llvm_unreachable("Invalid mach-o platform type");
 }
diff --git a/contrib/libs/llvm12/lib/MC/MCParser/ELFAsmParser.cpp b/contrib/libs/llvm12/lib/MC/MCParser/ELFAsmParser.cpp
index b270ac543d..65ac1d6b5b 100644
--- a/contrib/libs/llvm12/lib/MC/MCParser/ELFAsmParser.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCParser/ELFAsmParser.cpp
@@ -450,14 +450,14 @@ bool ELFAsmParser::parseLinkedToSym(MCSymbolELF *&LinkedToSym) {
   Lex();
   StringRef Name;
   SMLoc StartLoc = L.getLoc();
-  if (getParser().parseIdentifier(Name)) { 
-    if (getParser().getTok().getString() == "0") { 
-      getParser().Lex(); 
-      LinkedToSym = nullptr; 
-      return false; 
-    } 
+  if (getParser().parseIdentifier(Name)) {
+    if (getParser().getTok().getString() == "0") {
+      getParser().Lex();
+      LinkedToSym = nullptr;
+      return false;
+    }
     return TokError("invalid linked-to symbol");
-  } 
+  }
   LinkedToSym = dyn_cast_or_null<MCSymbolELF>(getContext().lookupSymbol(Name));
   if (!LinkedToSym || !LinkedToSym->isInSection())
     return Error(StartLoc, "linked-to symbol is not in a section: " + Name);
@@ -626,8 +626,8 @@ EndStmt:
       Type = ELF::SHT_LLVM_DEPENDENT_LIBRARIES;
     else if (TypeName == "llvm_sympart")
       Type = ELF::SHT_LLVM_SYMPART;
-    else if (TypeName == "llvm_bb_addr_map") 
-      Type = ELF::SHT_LLVM_BB_ADDR_MAP; 
+    else if (TypeName == "llvm_bb_addr_map")
+      Type = ELF::SHT_LLVM_BB_ADDR_MAP;
     else if (TypeName.getAsInteger(0, Type))
       return TokError("unknown section type");
   }
@@ -662,9 +662,9 @@ EndStmt:
     Error(loc, "changed section entsize for " + SectionName +
                    ", expected: " + Twine(Section->getEntrySize()));
 
-  if (getContext().getGenDwarfForAssembly() && 
-      (Section->getFlags() & ELF::SHF_ALLOC) && 
-      (Section->getFlags() & ELF::SHF_EXECINSTR)) { 
+  if (getContext().getGenDwarfForAssembly() &&
+      (Section->getFlags() & ELF::SHF_ALLOC) &&
+      (Section->getFlags() & ELF::SHF_EXECINSTR)) {
     bool InsertResult = getContext().addGenDwarfSection(Section);
     if (InsertResult) {
       if (getContext().getDwarfVersion() <= 2)
diff --git a/contrib/libs/llvm12/lib/MC/MCParser/MasmParser.cpp b/contrib/libs/llvm12/lib/MC/MCParser/MasmParser.cpp
index 7ec0c16abe..4957ee7a03 100644
--- a/contrib/libs/llvm12/lib/MC/MCParser/MasmParser.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCParser/MasmParser.cpp
@@ -14,14 +14,14 @@
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
-#include "llvm/ADT/Optional.h" 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringSwitch.h" 
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
@@ -52,7 +52,7 @@
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/Format.h" 
+#include "llvm/Support/Format.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
@@ -108,9 +108,9 @@ struct ParseStatementInfo {
   /// Was there an error parsing the inline assembly?
   bool ParseError = false;
 
-  /// The value associated with a macro exit. 
-  Optional<std::string> ExitValue; 
- 
+  /// The value associated with a macro exit.
+  Optional<std::string> ExitValue;
+
   SmallVectorImpl<AsmRewrite> *AsmRewrites = nullptr;
 
   ParseStatementInfo() = delete;
@@ -128,14 +128,14 @@ struct FieldInfo;
 struct StructInfo {
   StringRef Name;
   bool IsUnion = false;
-  unsigned Alignment = 0; 
-  unsigned Size = 0; 
-  unsigned AlignmentSize = 0; 
+  unsigned Alignment = 0;
+  unsigned Size = 0;
+  unsigned AlignmentSize = 0;
   std::vector<FieldInfo> Fields;
   StringMap<size_t> FieldsByName;
 
-  FieldInfo &addField(StringRef FieldName, FieldType FT, 
-                      unsigned FieldAlignmentSize); 
+  FieldInfo &addField(StringRef FieldName, FieldType FT,
+                      unsigned FieldAlignmentSize);
 
   StructInfo() = default;
 
@@ -325,32 +325,32 @@ struct FieldInfo {
   size_t Offset = 0;
 
   // Total size of the field (= LengthOf * Type).
-  unsigned SizeOf = 0; 
+  unsigned SizeOf = 0;
 
   // Number of elements in the field (1 if scalar, >1 if an array).
-  unsigned LengthOf = 0; 
+  unsigned LengthOf = 0;
 
   // Size of a single entry in this field, in bytes ("type" in MASM standards).
-  unsigned Type = 0; 
+  unsigned Type = 0;
 
   FieldInitializer Contents;
 
   FieldInfo(FieldType FT) : Contents(FT) {}
 };
 
-FieldInfo &StructInfo::addField(StringRef FieldName, FieldType FT, 
-                                unsigned FieldAlignmentSize) { 
+FieldInfo &StructInfo::addField(StringRef FieldName, FieldType FT,
+                                unsigned FieldAlignmentSize) {
   if (!FieldName.empty())
-    FieldsByName[FieldName.lower()] = Fields.size(); 
+    FieldsByName[FieldName.lower()] = Fields.size();
   Fields.emplace_back(FT);
   FieldInfo &Field = Fields.back();
   if (IsUnion) {
     Field.Offset = 0;
   } else {
-    Size = llvm::alignTo(Size, std::min(Alignment, FieldAlignmentSize)); 
+    Size = llvm::alignTo(Size, std::min(Alignment, FieldAlignmentSize));
     Field.Offset = Size;
   }
-  AlignmentSize = std::max(AlignmentSize, FieldAlignmentSize); 
+  AlignmentSize = std::max(AlignmentSize, FieldAlignmentSize);
   return Field;
 }
 
@@ -371,7 +371,7 @@ private:
   /// This is the current buffer index we're lexing from as managed by the
   /// SourceMgr object.
   unsigned CurBuffer;
-  std::vector<bool> EndStatementAtEOFStack; 
+  std::vector<bool> EndStatementAtEOFStack;
 
   AsmCond TheCondState;
   std::vector<AsmCond> TheCondStack;
@@ -397,8 +397,8 @@ private:
   /// Maps struct tags to struct definitions.
   StringMap<StructInfo> Structs;
 
-  /// Maps data location names to types. 
-  StringMap<AsmTypeInfo> KnownType; 
+  /// Maps data location names to types.
+  StringMap<AsmTypeInfo> KnownType;
 
   /// Stack of active macro instantiations.
   std::vector<MacroInstantiation*> ActiveMacros;
@@ -441,9 +441,9 @@ private:
   // Current <...> expression depth.
   unsigned AngleBracketDepth = 0U;
 
-  // Number of locals defined. 
-  uint16_t LocalCounter = 0; 
- 
+  // Number of locals defined.
+  uint16_t LocalCounter = 0;
+
 public:
   MasmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
              const MCAsmInfo &MAI, unsigned CB);
@@ -501,14 +501,14 @@ public:
 
   bool isParsingMasm() const override { return true; }
 
-  bool defineMacro(StringRef Name, StringRef Value) override; 
+  bool defineMacro(StringRef Name, StringRef Value) override;
+
+  bool lookUpField(StringRef Name, AsmFieldInfo &Info) const override;
+  bool lookUpField(StringRef Base, StringRef Member,
+                   AsmFieldInfo &Info) const override;
+
+  bool lookUpType(StringRef Name, AsmTypeInfo &Info) const override;
 
-  bool lookUpField(StringRef Name, AsmFieldInfo &Info) const override; 
-  bool lookUpField(StringRef Base, StringRef Member, 
-                   AsmFieldInfo &Info) const override; 
- 
-  bool lookUpType(StringRef Name, AsmTypeInfo &Info) const override; 
- 
   bool parseMSInlineAsm(void *AsmLoc, std::string &AsmString,
                         unsigned &NumOutputs, unsigned &NumInputs,
                         SmallVectorImpl<std::pair<void *,bool>> &OpDecls,
@@ -519,8 +519,8 @@ public:
 
   bool parseExpression(const MCExpr *&Res);
   bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
-  bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc, 
-                        AsmTypeInfo *TypeInfo) override; 
+  bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
+                        AsmTypeInfo *TypeInfo) override;
   bool parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
   bool parseParenExprOfDepth(unsigned ParenDepth, const MCExpr *&Res,
                              SMLoc &EndLoc) override;
@@ -547,8 +547,8 @@ private:
 
   bool expandMacro(raw_svector_ostream &OS, StringRef Body,
                    ArrayRef<MCAsmMacroParameter> Parameters,
-                   ArrayRef<MCAsmMacroArgument> A, 
-                   const std::vector<std::string> &Locals, SMLoc L); 
+                   ArrayRef<MCAsmMacroArgument> A,
+                   const std::vector<std::string> &Locals, SMLoc L);
 
   /// Are we inside a macro instantiation?
   bool isInsideMacroInstantiation() {return !ActiveMacros.empty();}
@@ -557,33 +557,33 @@ private:
   ///
   /// \param M The macro.
   /// \param NameLoc Instantiation location.
-  bool handleMacroEntry( 
-      const MCAsmMacro *M, SMLoc NameLoc, 
-      AsmToken::TokenKind ArgumentEndTok = AsmToken::EndOfStatement); 
-
-  /// Handle invocation of macro function. 
-  /// 
-  /// \param M The macro. 
-  /// \param NameLoc Invocation location. 
-  bool handleMacroInvocation(const MCAsmMacro *M, SMLoc NameLoc); 
- 
+  bool handleMacroEntry(
+      const MCAsmMacro *M, SMLoc NameLoc,
+      AsmToken::TokenKind ArgumentEndTok = AsmToken::EndOfStatement);
+
+  /// Handle invocation of macro function.
+  ///
+  /// \param M The macro.
+  /// \param NameLoc Invocation location.
+  bool handleMacroInvocation(const MCAsmMacro *M, SMLoc NameLoc);
+
   /// Handle exit from macro instantiation.
   void handleMacroExit();
 
   /// Extract AsmTokens for a macro argument.
-  bool 
-  parseMacroArgument(const MCAsmMacroParameter *MP, MCAsmMacroArgument &MA, 
-                     AsmToken::TokenKind EndTok = AsmToken::EndOfStatement); 
+  bool
+  parseMacroArgument(const MCAsmMacroParameter *MP, MCAsmMacroArgument &MA,
+                     AsmToken::TokenKind EndTok = AsmToken::EndOfStatement);
 
   /// Parse all macro arguments for a given macro.
-  bool 
-  parseMacroArguments(const MCAsmMacro *M, MCAsmMacroArguments &A, 
-                      AsmToken::TokenKind EndTok = AsmToken::EndOfStatement); 
+  bool
+  parseMacroArguments(const MCAsmMacro *M, MCAsmMacroArguments &A,
+                      AsmToken::TokenKind EndTok = AsmToken::EndOfStatement);
 
   void printMacroInstantiations();
- 
-  bool expandStatement(SMLoc Loc); 
- 
+
+  bool expandStatement(SMLoc Loc);
+
   void printMessage(SMLoc Loc, SourceMgr::DiagKind Kind, const Twine &Msg,
                     SMRange Range = None) const {
     ArrayRef<SMRange> Ranges(Range);
@@ -592,7 +592,7 @@ private:
   static void DiagHandler(const SMDiagnostic &Diag, void *Context);
 
   bool lookUpField(const StructInfo &Structure, StringRef Member,
-                   AsmFieldInfo &Info) const; 
+                   AsmFieldInfo &Info) const;
 
   /// Should we emit DWARF describing this assembler source?  (Returns false if
   /// the source has .file directives, which means we don't want to generate
@@ -608,19 +608,19 @@ private:
   ///
   /// \param InBuffer If not 0, should be the known buffer id that contains the
   /// location.
-  void jumpToLoc(SMLoc Loc, unsigned InBuffer = 0, 
-                 bool EndStatementAtEOF = true); 
-
-  /// Parse up to a token of kind \p EndTok and return the contents from the 
-  /// current token up to (but not including) this token; the current token on 
-  /// exit will be either this kind or EOF. Reads through instantiated macro 
-  /// functions and text macros. 
-  SmallVector<StringRef, 1> parseStringRefsTo(AsmToken::TokenKind EndTok); 
-  std::string parseStringTo(AsmToken::TokenKind EndTok); 
- 
-  /// Parse up to the end of statement and return the contents from the current 
-  /// token until the end of the statement; the current token on exit will be 
-  /// either the EndOfStatement or EOF. 
+  void jumpToLoc(SMLoc Loc, unsigned InBuffer = 0,
+                 bool EndStatementAtEOF = true);
+
+  /// Parse up to a token of kind \p EndTok and return the contents from the
+  /// current token up to (but not including) this token; the current token on
+  /// exit will be either this kind or EOF. Reads through instantiated macro
+  /// functions and text macros.
+  SmallVector<StringRef, 1> parseStringRefsTo(AsmToken::TokenKind EndTok);
+  std::string parseStringTo(AsmToken::TokenKind EndTok);
+
+  /// Parse up to the end of statement and return the contents from the current
+  /// token until the end of the statement; the current token on exit will be
+  /// either the EndOfStatement or EOF.
   StringRef parseStringToEndOfStatement() override;
 
   bool parseTextItem(std::string &Data);
@@ -658,12 +658,12 @@ private:
     DK_SQWORD,
     DK_DB,
     DK_DD,
-    DK_DF, 
+    DK_DF,
     DK_DQ,
     DK_DW,
     DK_REAL4,
     DK_REAL8,
-    DK_REAL10, 
+    DK_REAL10,
     DK_ALIGN,
     DK_ORG,
     DK_ENDR,
@@ -672,10 +672,10 @@ private:
     DK_COMM,
     DK_COMMENT,
     DK_INCLUDE,
-    DK_REPEAT, 
-    DK_WHILE, 
-    DK_FOR, 
-    DK_FORC, 
+    DK_REPEAT,
+    DK_WHILE,
+    DK_FOR,
+    DK_FORC,
     DK_IF,
     DK_IFE,
     DK_IFB,
@@ -739,7 +739,7 @@ private:
     DK_MACRO,
     DK_EXITM,
     DK_ENDM,
-    DK_PURGE, 
+    DK_PURGE,
     DK_ERR,
     DK_ERRB,
     DK_ERRNB,
@@ -755,21 +755,21 @@ private:
     DK_STRUCT,
     DK_UNION,
     DK_ENDS,
-    DK_END, 
-    DK_PUSHFRAME, 
-    DK_PUSHREG, 
-    DK_SAVEREG, 
-    DK_SAVEXMM128, 
-    DK_SETFRAME, 
-    DK_RADIX, 
+    DK_END,
+    DK_PUSHFRAME,
+    DK_PUSHREG,
+    DK_SAVEREG,
+    DK_SAVEXMM128,
+    DK_SETFRAME,
+    DK_RADIX,
   };
 
   /// Maps directive name --> DirectiveKind enum, for directives parsed by this
   /// class.
   StringMap<DirectiveKind> DirectiveKindMap;
 
-  bool isMacroLikeDirective(); 
- 
+  bool isMacroLikeDirective();
+
   // Codeview def_range type parsing.
   enum CVDefRangeType {
     CVDR_DEFRANGE = 0, // Placeholder
@@ -794,24 +794,24 @@ private:
   bool parseScalarInstList(
       unsigned Size, SmallVectorImpl<const MCExpr *> &Values,
       const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
-  bool emitIntegralValues(unsigned Size, unsigned *Count = nullptr); 
+  bool emitIntegralValues(unsigned Size, unsigned *Count = nullptr);
   bool addIntegralField(StringRef Name, unsigned Size);
   bool parseDirectiveValue(StringRef IDVal, unsigned Size);
-  bool parseDirectiveNamedValue(StringRef TypeName, unsigned Size, 
-                                StringRef Name, SMLoc NameLoc); 
-
-  // "real4", "real8", "real10" 
-  bool emitRealValues(const fltSemantics &Semantics, unsigned *Count = nullptr); 
-  bool addRealField(StringRef Name, const fltSemantics &Semantics, size_t Size); 
-  bool parseDirectiveRealValue(StringRef IDVal, const fltSemantics &Semantics, 
-                               size_t Size); 
+  bool parseDirectiveNamedValue(StringRef TypeName, unsigned Size,
+                                StringRef Name, SMLoc NameLoc);
+
+  // "real4", "real8", "real10"
+  bool emitRealValues(const fltSemantics &Semantics, unsigned *Count = nullptr);
+  bool addRealField(StringRef Name, const fltSemantics &Semantics, size_t Size);
+  bool parseDirectiveRealValue(StringRef IDVal, const fltSemantics &Semantics,
+                               size_t Size);
   bool parseRealInstList(
       const fltSemantics &Semantics, SmallVectorImpl<APInt> &Values,
       const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
-  bool parseDirectiveNamedRealValue(StringRef TypeName, 
+  bool parseDirectiveNamedRealValue(StringRef TypeName,
                                     const fltSemantics &Semantics,
-                                    unsigned Size, StringRef Name, 
-                                    SMLoc NameLoc); 
+                                    unsigned Size, StringRef Name,
+                                    SMLoc NameLoc);
 
   bool parseOptionalAngleBracketOpen();
   bool parseAngleBracketClose(const Twine &Msg = "expected '>'");
@@ -855,7 +855,7 @@ private:
                              const StructInitializer &Initializer);
 
   // User-defined types (structs, unions):
-  bool emitStructValues(const StructInfo &Structure, unsigned *Count = nullptr); 
+  bool emitStructValues(const StructInfo &Structure, unsigned *Count = nullptr);
   bool addStructField(StringRef Name, const StructInfo &Structure);
   bool parseDirectiveStructValue(const StructInfo &Structure,
                                  StringRef Directive, SMLoc DirLoc);
@@ -915,10 +915,10 @@ private:
 
   // macro directives
   bool parseDirectivePurgeMacro(SMLoc DirectiveLoc);
-  bool parseDirectiveExitMacro(SMLoc DirectiveLoc, StringRef Directive, 
-                               std::string &Value); 
+  bool parseDirectiveExitMacro(SMLoc DirectiveLoc, StringRef Directive,
+                               std::string &Value);
   bool parseDirectiveEndMacro(StringRef Directive);
-  bool parseDirectiveMacro(StringRef Name, SMLoc NameLoc); 
+  bool parseDirectiveMacro(StringRef Name, SMLoc NameLoc);
 
   bool parseDirectiveStruct(StringRef Directive, DirectiveKind DirKind,
                             StringRef Name, SMLoc NameLoc);
@@ -965,12 +965,12 @@ private:
   MCAsmMacro *parseMacroLikeBody(SMLoc DirectiveLoc);
   void instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,
                                 raw_svector_ostream &OS);
-  void instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc, 
-                                SMLoc ExitLoc, raw_svector_ostream &OS); 
-  bool parseDirectiveRepeat(SMLoc DirectiveLoc, StringRef Directive); 
-  bool parseDirectiveFor(SMLoc DirectiveLoc, StringRef Directive); 
-  bool parseDirectiveForc(SMLoc DirectiveLoc, StringRef Directive); 
-  bool parseDirectiveWhile(SMLoc DirectiveLoc); 
+  void instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,
+                                SMLoc ExitLoc, raw_svector_ostream &OS);
+  bool parseDirectiveRepeat(SMLoc DirectiveLoc, StringRef Directive);
+  bool parseDirectiveFor(SMLoc DirectiveLoc, StringRef Directive);
+  bool parseDirectiveForc(SMLoc DirectiveLoc, StringRef Directive);
+  bool parseDirectiveWhile(SMLoc DirectiveLoc);
 
   // "_emit" or "__emit"
   bool parseDirectiveMSEmit(SMLoc DirectiveLoc, ParseStatementInfo &Info,
@@ -995,9 +995,9 @@ private:
   // ".erre" or ".errnz", depending on ExpectZero.
   bool parseDirectiveErrorIfe(SMLoc DirectiveLoc, bool ExpectZero);
 
-  // ".radix" 
-  bool parseDirectiveRadix(SMLoc DirectiveLoc); 
- 
+  // ".radix"
+  bool parseDirectiveRadix(SMLoc DirectiveLoc);
+
   // "echo"
   bool parseDirectiveEcho();
 
@@ -1026,7 +1026,7 @@ MasmParser::MasmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
   // Set our own handler which calls the saved handler.
   SrcMgr.setDiagHandler(DiagHandler, this);
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
-  EndStatementAtEOFStack.push_back(true); 
+  EndStatementAtEOFStack.push_back(true);
 
   // Initialize the platform / file format parser.
   switch (Ctx.getObjectFileInfo()->getObjectFileType()) {
@@ -1096,15 +1096,15 @@ bool MasmParser::enterIncludeFile(const std::string &Filename) {
 
   CurBuffer = NewBuf;
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
-  EndStatementAtEOFStack.push_back(true); 
+  EndStatementAtEOFStack.push_back(true);
   return false;
 }
 
-void MasmParser::jumpToLoc(SMLoc Loc, unsigned InBuffer, 
-                           bool EndStatementAtEOF) { 
+void MasmParser::jumpToLoc(SMLoc Loc, unsigned InBuffer,
+                           bool EndStatementAtEOF) {
   CurBuffer = InBuffer ? InBuffer : SrcMgr.FindBufferContainingLoc(Loc);
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer(),
-                  Loc.getPointer(), EndStatementAtEOF); 
+                  Loc.getPointer(), EndStatementAtEOF);
 }
 
 const AsmToken &MasmParser::Lex() {
@@ -1122,11 +1122,11 @@ const AsmToken &MasmParser::Lex() {
   const AsmToken *tok = &Lexer.Lex();
 
   while (tok->is(AsmToken::Identifier)) {
-    auto it = Variables.find(tok->getIdentifier().lower()); 
-    const llvm::MCAsmMacro *M = 
-        getContext().lookupMacro(tok->getIdentifier().lower()); 
+    auto it = Variables.find(tok->getIdentifier().lower());
+    const llvm::MCAsmMacro *M =
+        getContext().lookupMacro(tok->getIdentifier().lower());
     if (it != Variables.end() && it->second.IsText) {
-      // This is a textmacro; expand it in place. 
+      // This is a textmacro; expand it in place.
       std::unique_ptr<MemoryBuffer> Instantiation =
           MemoryBuffer::getMemBufferCopy(it->second.TextValue,
                                          "<instantiation>");
@@ -1136,17 +1136,17 @@ const AsmToken &MasmParser::Lex() {
                                             getTok().getEndLoc());
       Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer(), nullptr,
                       /*EndStatementAtEOF=*/false);
-      EndStatementAtEOFStack.push_back(false); 
+      EndStatementAtEOFStack.push_back(false);
+      tok = &Lexer.Lex();
+    } else if (M && M->IsFunction && Lexer.peekTok().is(AsmToken::LParen)) {
+      // This is a macro function invocation; expand it in place.
+      const AsmToken MacroTok = *tok;
       tok = &Lexer.Lex();
-    } else if (M && M->IsFunction && Lexer.peekTok().is(AsmToken::LParen)) { 
-      // This is a macro function invocation; expand it in place. 
-      const AsmToken MacroTok = *tok; 
-      tok = &Lexer.Lex(); 
-      if (handleMacroInvocation(M, MacroTok.getLoc())) { 
-        Lexer.UnLex(AsmToken(AsmToken::Error, MacroTok.getIdentifier())); 
-        tok = &Lexer.Lex(); 
-      } 
-      continue; 
+      if (handleMacroInvocation(M, MacroTok.getLoc())) {
+        Lexer.UnLex(AsmToken(AsmToken::Error, MacroTok.getIdentifier()));
+        tok = &Lexer.Lex();
+      }
+      continue;
     } else {
       break;
     }
@@ -1159,25 +1159,25 @@ const AsmToken &MasmParser::Lex() {
     tok = &Lexer.Lex();
   }
 
-  // Recognize and bypass line continuations. 
-  while (tok->is(AsmToken::BackSlash) && 
-         Lexer.peekTok().is(AsmToken::EndOfStatement)) { 
-    // Eat both the backslash and the end of statement. 
-    Lexer.Lex(); 
-    tok = &Lexer.Lex(); 
-  } 
- 
+  // Recognize and bypass line continuations.
+  while (tok->is(AsmToken::BackSlash) &&
+         Lexer.peekTok().is(AsmToken::EndOfStatement)) {
+    // Eat both the backslash and the end of statement.
+    Lexer.Lex();
+    tok = &Lexer.Lex();
+  }
+
   if (tok->is(AsmToken::Eof)) {
     // If this is the end of an included file, pop the parent file off the
     // include stack.
     SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer);
     if (ParentIncludeLoc != SMLoc()) {
-      EndStatementAtEOFStack.pop_back(); 
-      jumpToLoc(ParentIncludeLoc, 0, EndStatementAtEOFStack.back()); 
+      EndStatementAtEOFStack.pop_back();
+      jumpToLoc(ParentIncludeLoc, 0, EndStatementAtEOFStack.back());
       return Lex();
     }
-    EndStatementAtEOFStack.pop_back(); 
-    assert(EndStatementAtEOFStack.empty()); 
+    EndStatementAtEOFStack.pop_back();
+    assert(EndStatementAtEOFStack.empty());
   }
 
   return *tok;
@@ -1236,12 +1236,12 @@ bool MasmParser::Run(bool NoInitialTextSection, bool NoFinalize) {
   }
 
   // While we have input, parse each statement.
-  while (Lexer.isNot(AsmToken::Eof) || 
-         SrcMgr.getParentIncludeLoc(CurBuffer) != SMLoc()) { 
-    // Skip through the EOF at the end of an inclusion. 
-    if (Lexer.is(AsmToken::Eof)) 
-      Lex(); 
- 
+  while (Lexer.isNot(AsmToken::Eof) ||
+         SrcMgr.getParentIncludeLoc(CurBuffer) != SMLoc()) {
+    // Skip through the EOF at the end of an inclusion.
+    if (Lexer.is(AsmToken::Eof))
+      Lex();
+
     ParseStatementInfo Info(&AsmStrRewrites);
     bool Parsed = parseStatement(Info, nullptr);
 
@@ -1319,7 +1319,7 @@ bool MasmParser::Run(bool NoInitialTextSection, bool NoFinalize) {
   // Finalize the output stream if there are no errors and if the client wants
   // us to.
   if (!HadError && !NoFinalize)
-    Out.Finish(Lexer.getLoc()); 
+    Out.Finish(Lexer.getLoc());
 
   return HadError || getContext().hadError();
 }
@@ -1335,58 +1335,58 @@ bool MasmParser::checkForValidSection() {
 
 /// Throw away the rest of the line for testing purposes.
 void MasmParser::eatToEndOfStatement() {
-  while (Lexer.isNot(AsmToken::EndOfStatement)) { 
-    if (Lexer.is(AsmToken::Eof)) { 
-      SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer); 
-      if (ParentIncludeLoc == SMLoc()) { 
-        break; 
-      } 
- 
-      EndStatementAtEOFStack.pop_back(); 
-      jumpToLoc(ParentIncludeLoc, 0, EndStatementAtEOFStack.back()); 
-    } 
- 
+  while (Lexer.isNot(AsmToken::EndOfStatement)) {
+    if (Lexer.is(AsmToken::Eof)) {
+      SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer);
+      if (ParentIncludeLoc == SMLoc()) {
+        break;
+      }
+
+      EndStatementAtEOFStack.pop_back();
+      jumpToLoc(ParentIncludeLoc, 0, EndStatementAtEOFStack.back());
+    }
+
     Lexer.Lex();
-  } 
+  }
 
   // Eat EOL.
   if (Lexer.is(AsmToken::EndOfStatement))
     Lexer.Lex();
 }
 
-SmallVector<StringRef, 1> 
-MasmParser::parseStringRefsTo(AsmToken::TokenKind EndTok) { 
-  SmallVector<StringRef, 1> Refs; 
-  const char *Start = getTok().getLoc().getPointer(); 
-  while (Lexer.isNot(EndTok)) { 
-    if (Lexer.is(AsmToken::Eof)) { 
-      SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer); 
-      if (ParentIncludeLoc == SMLoc()) { 
-        break; 
-      } 
-      Refs.emplace_back(Start, getTok().getLoc().getPointer() - Start); 
- 
-      EndStatementAtEOFStack.pop_back(); 
-      jumpToLoc(ParentIncludeLoc, 0, EndStatementAtEOFStack.back()); 
-      Lexer.Lex(); 
-      Start = getTok().getLoc().getPointer(); 
-    } else { 
-      Lexer.Lex(); 
-    } 
-  } 
-  Refs.emplace_back(Start, getTok().getLoc().getPointer() - Start); 
-  return Refs; 
-} 
- 
-std::string MasmParser::parseStringTo(AsmToken::TokenKind EndTok) { 
-  SmallVector<StringRef, 1> Refs = parseStringRefsTo(EndTok); 
-  std::string Str; 
-  for (StringRef S : Refs) { 
-    Str.append(S.str()); 
-  } 
-  return Str; 
-} 
- 
+SmallVector<StringRef, 1>
+MasmParser::parseStringRefsTo(AsmToken::TokenKind EndTok) {
+  SmallVector<StringRef, 1> Refs;
+  const char *Start = getTok().getLoc().getPointer();
+  while (Lexer.isNot(EndTok)) {
+    if (Lexer.is(AsmToken::Eof)) {
+      SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer);
+      if (ParentIncludeLoc == SMLoc()) {
+        break;
+      }
+      Refs.emplace_back(Start, getTok().getLoc().getPointer() - Start);
+
+      EndStatementAtEOFStack.pop_back();
+      jumpToLoc(ParentIncludeLoc, 0, EndStatementAtEOFStack.back());
+      Lexer.Lex();
+      Start = getTok().getLoc().getPointer();
+    } else {
+      Lexer.Lex();
+    }
+  }
+  Refs.emplace_back(Start, getTok().getLoc().getPointer() - Start);
+  return Refs;
+}
+
+std::string MasmParser::parseStringTo(AsmToken::TokenKind EndTok) {
+  SmallVector<StringRef, 1> Refs = parseStringRefsTo(EndTok);
+  std::string Str;
+  for (StringRef S : Refs) {
+    Str.append(S.str());
+  }
+  return Str;
+}
+
 StringRef MasmParser::parseStringToEndOfStatement() {
   const char *Start = getTok().getLoc().getPointer();
 
@@ -1431,11 +1431,11 @@ bool MasmParser::parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc) {
 ///  primaryexpr ::= symbol
 ///  primaryexpr ::= number
 ///  primaryexpr ::= '.'
-///  primaryexpr ::= ~,+,-,'not' primaryexpr 
-///  primaryexpr ::= string 
-///          (a string is interpreted as a 64-bit number in big-endian base-256) 
-bool MasmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc, 
-                                  AsmTypeInfo *TypeInfo) { 
+///  primaryexpr ::= ~,+,-,'not' primaryexpr
+///  primaryexpr ::= string
+///          (a string is interpreted as a 64-bit number in big-endian base-256)
+bool MasmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
+                                  AsmTypeInfo *TypeInfo) {
   SMLoc FirstTokenLoc = getLexer().getLoc();
   AsmToken::TokenKind FirstTokenKind = Lexer.getKind();
   switch (FirstTokenKind) {
@@ -1446,7 +1446,7 @@ bool MasmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
     return true;
   case AsmToken::Exclaim:
     Lex(); // Eat the operator.
-    if (parsePrimaryExpr(Res, EndLoc, nullptr)) 
+    if (parsePrimaryExpr(Res, EndLoc, nullptr))
       return true;
     Res = MCUnaryExpr::createLNot(Res, getContext(), FirstTokenLoc);
     return false;
@@ -1471,13 +1471,13 @@ bool MasmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
         return Error(FirstTokenLoc, "invalid token in expression");
       }
     }
-    // Parse named bitwise negation. 
-    if (Identifier.equals_lower("not")) { 
-      if (parsePrimaryExpr(Res, EndLoc, nullptr)) 
-        return true; 
-      Res = MCUnaryExpr::createNot(Res, getContext(), FirstTokenLoc); 
-      return false; 
-    } 
+    // Parse named bitwise negation.
+    if (Identifier.equals_lower("not")) {
+      if (parsePrimaryExpr(Res, EndLoc, nullptr))
+        return true;
+      Res = MCUnaryExpr::createNot(Res, getContext(), FirstTokenLoc);
+      return false;
+    }
     // Parse symbol variant.
     std::pair<StringRef, StringRef> Split;
     if (!MAI.useParensForSymbolVariant()) {
@@ -1528,18 +1528,18 @@ bool MasmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
     }
 
     // Find the field offset if used.
-    AsmFieldInfo Info; 
+    AsmFieldInfo Info;
     Split = SymbolName.split('.');
-    if (Split.second.empty()) { 
-    } else { 
+    if (Split.second.empty()) {
+    } else {
       SymbolName = Split.first;
-      if (lookUpField(SymbolName, Split.second, Info)) { 
-        std::pair<StringRef, StringRef> BaseMember = Split.second.split('.'); 
-        StringRef Base = BaseMember.first, Member = BaseMember.second; 
-        lookUpField(Base, Member, Info); 
-      } else if (Structs.count(SymbolName.lower())) { 
+      if (lookUpField(SymbolName, Split.second, Info)) {
+        std::pair<StringRef, StringRef> BaseMember = Split.second.split('.');
+        StringRef Base = BaseMember.first, Member = BaseMember.second;
+        lookUpField(Base, Member, Info);
+      } else if (Structs.count(SymbolName.lower())) {
         // This is actually a reference to a field offset.
-        Res = MCConstantExpr::create(Info.Offset, getContext()); 
+        Res = MCConstantExpr::create(Info.Offset, getContext());
         return false;
       }
     }
@@ -1566,23 +1566,23 @@ bool MasmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
     // Otherwise create a symbol ref.
     const MCExpr *SymRef =
         MCSymbolRefExpr::create(Sym, Variant, getContext(), FirstTokenLoc);
-    if (Info.Offset) { 
-      Res = MCBinaryExpr::create( 
-          MCBinaryExpr::Add, SymRef, 
-          MCConstantExpr::create(Info.Offset, getContext()), getContext()); 
+    if (Info.Offset) {
+      Res = MCBinaryExpr::create(
+          MCBinaryExpr::Add, SymRef,
+          MCConstantExpr::create(Info.Offset, getContext()), getContext());
     } else {
       Res = SymRef;
     }
-    if (TypeInfo) { 
-      if (Info.Type.Name.empty()) { 
-        auto TypeIt = KnownType.find(Identifier.lower()); 
-        if (TypeIt != KnownType.end()) { 
-          Info.Type = TypeIt->second; 
-        } 
-      } 
- 
-      *TypeInfo = Info.Type; 
-    } 
+    if (TypeInfo) {
+      if (Info.Type.Name.empty()) {
+        auto TypeIt = KnownType.find(Identifier.lower());
+        if (TypeIt != KnownType.end()) {
+          Info.Type = TypeIt->second;
+        }
+      }
+
+      *TypeInfo = Info.Type;
+    }
     return false;
   }
   case AsmToken::BigNum:
@@ -1618,20 +1618,20 @@ bool MasmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
     }
     return false;
   }
-  case AsmToken::String: { 
-    // MASM strings (used as constants) are interpreted as big-endian base-256. 
-    SMLoc ValueLoc = getTok().getLoc(); 
-    std::string Value; 
-    if (parseEscapedString(Value)) 
-      return true; 
-    if (Value.size() > 8) 
-      return Error(ValueLoc, "literal value out of range"); 
-    uint64_t IntValue = 0; 
-    for (const unsigned char CharVal : Value) 
-      IntValue = (IntValue << 8) | CharVal; 
-    Res = MCConstantExpr::create(IntValue, getContext()); 
-    return false; 
-  } 
+  case AsmToken::String: {
+    // MASM strings (used as constants) are interpreted as big-endian base-256.
+    SMLoc ValueLoc = getTok().getLoc();
+    std::string Value;
+    if (parseEscapedString(Value))
+      return true;
+    if (Value.size() > 8)
+      return Error(ValueLoc, "literal value out of range");
+    uint64_t IntValue = 0;
+    for (const unsigned char CharVal : Value)
+      IntValue = (IntValue << 8) | CharVal;
+    Res = MCConstantExpr::create(IntValue, getContext());
+    return false;
+  }
   case AsmToken::Real: {
     APFloat RealVal(APFloat::IEEEdouble(), getTok().getString());
     uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();
@@ -1660,19 +1660,19 @@ bool MasmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
     return parseBracketExpr(Res, EndLoc);
   case AsmToken::Minus:
     Lex(); // Eat the operator.
-    if (parsePrimaryExpr(Res, EndLoc, nullptr)) 
+    if (parsePrimaryExpr(Res, EndLoc, nullptr))
       return true;
     Res = MCUnaryExpr::createMinus(Res, getContext(), FirstTokenLoc);
     return false;
   case AsmToken::Plus:
     Lex(); // Eat the operator.
-    if (parsePrimaryExpr(Res, EndLoc, nullptr)) 
+    if (parsePrimaryExpr(Res, EndLoc, nullptr))
       return true;
     Res = MCUnaryExpr::createPlus(Res, getContext(), FirstTokenLoc);
     return false;
   case AsmToken::Tilde:
     Lex(); // Eat the operator.
-    if (parsePrimaryExpr(Res, EndLoc, nullptr)) 
+    if (parsePrimaryExpr(Res, EndLoc, nullptr))
       return true;
     Res = MCUnaryExpr::createNot(Res, getContext(), FirstTokenLoc);
     return false;
@@ -1745,12 +1745,12 @@ static bool isAngleBracketString(SMLoc &StrLoc, SMLoc &EndLoc) {
 }
 
 /// creating a string without the escape characters '!'.
-static std::string angleBracketString(StringRef BracketContents) { 
+static std::string angleBracketString(StringRef BracketContents) {
   std::string Res;
-  for (size_t Pos = 0; Pos < BracketContents.size(); Pos++) { 
-    if (BracketContents[Pos] == '!') 
+  for (size_t Pos = 0; Pos < BracketContents.size(); Pos++) {
+    if (BracketContents[Pos] == '!')
       Pos++;
-    Res += BracketContents[Pos]; 
+    Res += BracketContents[Pos];
   }
   return Res;
 }
@@ -1912,22 +1912,22 @@ bool MasmParser::parseBinOpRHS(unsigned Precedence, const MCExpr *&Res,
                                SMLoc &EndLoc) {
   SMLoc StartLoc = Lexer.getLoc();
   while (true) {
-    AsmToken::TokenKind TokKind = Lexer.getKind(); 
-    if (Lexer.getKind() == AsmToken::Identifier) { 
-      TokKind = StringSwitch<AsmToken::TokenKind>(Lexer.getTok().getString()) 
-                    .CaseLower("and", AsmToken::Amp) 
-                    .CaseLower("not", AsmToken::Exclaim) 
-                    .CaseLower("or", AsmToken::Pipe) 
-                    .CaseLower("eq", AsmToken::EqualEqual) 
-                    .CaseLower("ne", AsmToken::ExclaimEqual) 
-                    .CaseLower("lt", AsmToken::Less) 
-                    .CaseLower("le", AsmToken::LessEqual) 
-                    .CaseLower("gt", AsmToken::Greater) 
-                    .CaseLower("ge", AsmToken::GreaterEqual) 
-                    .Default(TokKind); 
-    } 
+    AsmToken::TokenKind TokKind = Lexer.getKind();
+    if (Lexer.getKind() == AsmToken::Identifier) {
+      TokKind = StringSwitch<AsmToken::TokenKind>(Lexer.getTok().getString())
+                    .CaseLower("and", AsmToken::Amp)
+                    .CaseLower("not", AsmToken::Exclaim)
+                    .CaseLower("or", AsmToken::Pipe)
+                    .CaseLower("eq", AsmToken::EqualEqual)
+                    .CaseLower("ne", AsmToken::ExclaimEqual)
+                    .CaseLower("lt", AsmToken::Less)
+                    .CaseLower("le", AsmToken::LessEqual)
+                    .CaseLower("gt", AsmToken::Greater)
+                    .CaseLower("ge", AsmToken::GreaterEqual)
+                    .Default(TokKind);
+    }
     MCBinaryExpr::Opcode Kind = MCBinaryExpr::Add;
-    unsigned TokPrec = getBinOpPrecedence(TokKind, Kind); 
+    unsigned TokPrec = getBinOpPrecedence(TokKind, Kind);
 
     // If the next token is lower precedence than we are allowed to eat, return
     // successfully with what we ate already.
@@ -1954,7 +1954,7 @@ bool MasmParser::parseBinOpRHS(unsigned Precedence, const MCExpr *&Res,
 }
 
 /// ParseStatement:
-///   ::= % statement 
+///   ::= % statement
 ///   ::= EndOfStatement
 ///   ::= Label* Directive ...Operands... EndOfStatement
 ///   ::= Label* Identifier OperandList* EndOfStatement
@@ -1972,15 +1972,15 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info,
     Lex();
     return false;
   }
- 
-  // If preceded by an expansion operator, first expand all text macros and 
-  // macro functions. 
-  if (getTok().is(AsmToken::Percent)) { 
-    SMLoc ExpansionLoc = getTok().getLoc(); 
-    if (parseToken(AsmToken::Percent) || expandStatement(ExpansionLoc)) 
-      return true; 
-  } 
- 
+
+  // If preceded by an expansion operator, first expand all text macros and
+  // macro functions.
+  if (getTok().is(AsmToken::Percent)) {
+    SMLoc ExpansionLoc = getTok().getLoc();
+    if (parseToken(AsmToken::Percent) || expandStatement(ExpansionLoc))
+      return true;
+  }
+
   // Statements always start with an identifier, unless we're dealing with a
   // processor directive (.386, .686, etc.) that lexes as a real.
   AsmToken ID = getTok();
@@ -2032,11 +2032,11 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info,
     Lex(); // always eat a token
     if (!IDVal.startswith("."))
       return Error(IDLoc, "unexpected token at start of statement");
-  } else if (Lexer.is(AsmToken::Identifier) && 
-             getTok().getString().equals_lower("echo")) { 
-    // Intercept echo early to avoid lexical substitution in its message, and 
-    // delegate all handling to the appropriate function. 
-    return parseDirectiveEcho(); 
+  } else if (Lexer.is(AsmToken::Identifier) &&
+             getTok().getString().equals_lower("echo")) {
+    // Intercept echo early to avoid lexical substitution in its message, and
+    // delegate all handling to the appropriate function.
+    return parseDirectiveEcho();
   } else if (parseIdentifier(IDVal)) {
     if (!TheCondState.Ignore) {
       Lex(); // always eat a token
@@ -2156,7 +2156,7 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info,
     // does not understand Labels. This may cause us to see a Hash
     // here instead of a preprocessor line comment.
     if (getTok().is(AsmToken::Hash)) {
-      std::string CommentStr = parseStringTo(AsmToken::EndOfStatement); 
+      std::string CommentStr = parseStringTo(AsmToken::EndOfStatement);
       Lexer.Lex();
       Lexer.UnLex(AsmToken(AsmToken::EndOfStatement, CommentStr));
     }
@@ -2189,7 +2189,7 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info,
   }
 
   // If macros are enabled, check to see if this is a macro instantiation.
-  if (const MCAsmMacro *M = getContext().lookupMacro(IDVal.lower())) { 
+  if (const MCAsmMacro *M = getContext().lookupMacro(IDVal.lower())) {
     return handleMacroEntry(M, IDLoc);
   }
 
@@ -2264,18 +2264,18 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info,
     case DK_DD:
       return parseDirectiveValue(IDVal, 4);
     case DK_FWORD:
-    case DK_DF: 
+    case DK_DF:
       return parseDirectiveValue(IDVal, 6);
     case DK_QWORD:
     case DK_SQWORD:
     case DK_DQ:
       return parseDirectiveValue(IDVal, 8);
     case DK_REAL4:
-      return parseDirectiveRealValue(IDVal, APFloat::IEEEsingle(), 4); 
+      return parseDirectiveRealValue(IDVal, APFloat::IEEEsingle(), 4);
     case DK_REAL8:
-      return parseDirectiveRealValue(IDVal, APFloat::IEEEdouble(), 8); 
-    case DK_REAL10: 
-      return parseDirectiveRealValue(IDVal, APFloat::x87DoubleExtended(), 10); 
+      return parseDirectiveRealValue(IDVal, APFloat::IEEEdouble(), 8);
+    case DK_REAL10:
+      return parseDirectiveRealValue(IDVal, APFloat::x87DoubleExtended(), 10);
     case DK_STRUCT:
     case DK_UNION:
       return parseDirectiveNestedStruct(IDVal, DirKind);
@@ -2296,14 +2296,14 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info,
       return parseDirectiveComment(IDLoc);
     case DK_INCLUDE:
       return parseDirectiveInclude();
-    case DK_REPEAT: 
-      return parseDirectiveRepeat(IDLoc, IDVal); 
-    case DK_WHILE: 
-      return parseDirectiveWhile(IDLoc); 
-    case DK_FOR: 
-      return parseDirectiveFor(IDLoc, IDVal); 
-    case DK_FORC: 
-      return parseDirectiveForc(IDLoc, IDVal); 
+    case DK_REPEAT:
+      return parseDirectiveRepeat(IDLoc, IDVal);
+    case DK_WHILE:
+      return parseDirectiveWhile(IDLoc);
+    case DK_FOR:
+      return parseDirectiveFor(IDLoc, IDVal);
+    case DK_FORC:
+      return parseDirectiveForc(IDLoc, IDVal);
     case DK_FILE:
       return parseDirectiveFile(IDLoc);
     case DK_LINE:
@@ -2379,12 +2379,12 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info,
     case DK_CFI_WINDOW_SAVE:
       return parseDirectiveCFIWindowSave();
     case DK_EXITM:
-      Info.ExitValue = ""; 
-      return parseDirectiveExitMacro(IDLoc, IDVal, *Info.ExitValue); 
+      Info.ExitValue = "";
+      return parseDirectiveExitMacro(IDLoc, IDVal, *Info.ExitValue);
     case DK_ENDM:
-      Info.ExitValue = ""; 
+      Info.ExitValue = "";
       return parseDirectiveEndMacro(IDVal);
-    case DK_PURGE: 
+    case DK_PURGE:
       return parseDirectivePurgeMacro(IDLoc);
     case DK_END:
       return parseDirectiveEnd(IDLoc);
@@ -2414,8 +2414,8 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info,
       return parseDirectiveErrorIfe(IDLoc, true);
     case DK_ERRNZ:
       return parseDirectiveErrorIfe(IDLoc, false);
-    case DK_RADIX: 
-      return parseDirectiveRadix(IDLoc); 
+    case DK_RADIX:
+      return parseDirectiveRadix(IDLoc);
     }
 
     return Error(IDLoc, "unknown directive");
@@ -2475,41 +2475,41 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info,
     Lex();
     return parseDirectiveEquate(nextVal, IDVal, DirKind);
   case DK_BYTE:
-  case DK_SBYTE: 
+  case DK_SBYTE:
   case DK_DB:
     Lex();
     return parseDirectiveNamedValue(nextVal, 1, IDVal, IDLoc);
   case DK_WORD:
-  case DK_SWORD: 
+  case DK_SWORD:
   case DK_DW:
     Lex();
     return parseDirectiveNamedValue(nextVal, 2, IDVal, IDLoc);
   case DK_DWORD:
-  case DK_SDWORD: 
+  case DK_SDWORD:
   case DK_DD:
     Lex();
     return parseDirectiveNamedValue(nextVal, 4, IDVal, IDLoc);
   case DK_FWORD:
-  case DK_DF: 
+  case DK_DF:
     Lex();
     return parseDirectiveNamedValue(nextVal, 6, IDVal, IDLoc);
   case DK_QWORD:
-  case DK_SQWORD: 
+  case DK_SQWORD:
   case DK_DQ:
     Lex();
     return parseDirectiveNamedValue(nextVal, 8, IDVal, IDLoc);
   case DK_REAL4:
     Lex();
-    return parseDirectiveNamedRealValue(nextVal, APFloat::IEEEsingle(), 4, 
-                                        IDVal, IDLoc); 
+    return parseDirectiveNamedRealValue(nextVal, APFloat::IEEEsingle(), 4,
+                                        IDVal, IDLoc);
   case DK_REAL8:
     Lex();
-    return parseDirectiveNamedRealValue(nextVal, APFloat::IEEEdouble(), 8, 
-                                        IDVal, IDLoc); 
-  case DK_REAL10: 
-    Lex(); 
-    return parseDirectiveNamedRealValue(nextVal, APFloat::x87DoubleExtended(), 
-                                        10, IDVal, IDLoc); 
+    return parseDirectiveNamedRealValue(nextVal, APFloat::IEEEdouble(), 8,
+                                        IDVal, IDLoc);
+  case DK_REAL10:
+    Lex();
+    return parseDirectiveNamedRealValue(nextVal, APFloat::x87DoubleExtended(),
+                                        10, IDVal, IDLoc);
   case DK_STRUCT:
   case DK_UNION:
     Lex();
@@ -2517,9 +2517,9 @@ bool MasmParser::parseStatement(ParseStatementInfo &Info,
   case DK_ENDS:
     Lex();
     return parseDirectiveEnds(IDVal, IDLoc);
-  case DK_MACRO: 
-    Lex(); 
-    return parseDirectiveMacro(IDVal, IDLoc); 
+  case DK_MACRO:
+    Lex();
+    return parseDirectiveMacro(IDVal, IDLoc);
   }
 
   // Finally, we check if this is allocating a variable with user-defined type.
@@ -2713,69 +2713,69 @@ void MasmParser::DiagHandler(const SMDiagnostic &Diag, void *Context) {
     NewDiag.print(nullptr, OS);
 }
 
-// This is similar to the IsIdentifierChar function in AsmLexer.cpp, but does 
-// not accept '.'. 
-static bool isMacroParameterChar(char C) { 
-  return isAlnum(C) || C == '_' || C == '$' || C == '@' || C == '?'; 
+// This is similar to the IsIdentifierChar function in AsmLexer.cpp, but does
+// not accept '.'.
+static bool isMacroParameterChar(char C) {
+  return isAlnum(C) || C == '_' || C == '$' || C == '@' || C == '?';
 }
 
 bool MasmParser::expandMacro(raw_svector_ostream &OS, StringRef Body,
                              ArrayRef<MCAsmMacroParameter> Parameters,
                              ArrayRef<MCAsmMacroArgument> A,
-                             const std::vector<std::string> &Locals, SMLoc L) { 
+                             const std::vector<std::string> &Locals, SMLoc L) {
   unsigned NParameters = Parameters.size();
-  if (NParameters != A.size()) 
+  if (NParameters != A.size())
     return Error(L, "Wrong number of arguments");
-  StringMap<std::string> LocalSymbols; 
-  std::string Name; 
-  Name.reserve(6); 
-  for (StringRef Local : Locals) { 
-    raw_string_ostream LocalName(Name); 
-    LocalName << "??" 
-              << format_hex_no_prefix(LocalCounter++, 4, /*Upper=*/true); 
-    LocalSymbols.insert({Local, LocalName.str()}); 
-    Name.clear(); 
-  } 
-
-  Optional<char> CurrentQuote; 
+  StringMap<std::string> LocalSymbols;
+  std::string Name;
+  Name.reserve(6);
+  for (StringRef Local : Locals) {
+    raw_string_ostream LocalName(Name);
+    LocalName << "??"
+              << format_hex_no_prefix(LocalCounter++, 4, /*Upper=*/true);
+    LocalSymbols.insert({Local, LocalName.str()});
+    Name.clear();
+  }
+
+  Optional<char> CurrentQuote;
   while (!Body.empty()) {
     // Scan for the next substitution.
     std::size_t End = Body.size(), Pos = 0;
-    std::size_t IdentifierPos = End; 
+    std::size_t IdentifierPos = End;
     for (; Pos != End; ++Pos) {
-      // Find the next possible macro parameter, including preceding a '&' 
-      // inside quotes. 
-      if (Body[Pos] == '&') 
-        break; 
-      if (isMacroParameterChar(Body[Pos])) { 
-        if (!CurrentQuote.hasValue()) 
+      // Find the next possible macro parameter, including preceding a '&'
+      // inside quotes.
+      if (Body[Pos] == '&')
+        break;
+      if (isMacroParameterChar(Body[Pos])) {
+        if (!CurrentQuote.hasValue())
           break;
-        if (IdentifierPos == End) 
-          IdentifierPos = Pos; 
+        if (IdentifierPos == End)
+          IdentifierPos = Pos;
       } else {
-        IdentifierPos = End; 
+        IdentifierPos = End;
+      }
+
+      // Track quotation status
+      if (!CurrentQuote.hasValue()) {
+        if (Body[Pos] == '\'' || Body[Pos] == '"')
+          CurrentQuote = Body[Pos];
+      } else if (Body[Pos] == CurrentQuote) {
+        if (Pos + 1 != End && Body[Pos + 1] == CurrentQuote) {
+          // Escaped quote, and quotes aren't identifier chars; skip
+          ++Pos;
+          continue;
+        } else {
+          CurrentQuote.reset();
+        }
       }
- 
-      // Track quotation status 
-      if (!CurrentQuote.hasValue()) { 
-        if (Body[Pos] == '\'' || Body[Pos] == '"') 
-          CurrentQuote = Body[Pos]; 
-      } else if (Body[Pos] == CurrentQuote) { 
-        if (Pos + 1 != End && Body[Pos + 1] == CurrentQuote) { 
-          // Escaped quote, and quotes aren't identifier chars; skip 
-          ++Pos; 
-          continue; 
-        } else { 
-          CurrentQuote.reset(); 
-        } 
-      } 
     }
-    if (IdentifierPos != End) { 
-      // We've recognized an identifier before an apostrophe inside quotes; 
-      // check once to see if we can expand it. 
-      Pos = IdentifierPos; 
-      IdentifierPos = End; 
-    } 
+    if (IdentifierPos != End) {
+      // We've recognized an identifier before an apostrophe inside quotes;
+      // check once to see if we can expand it.
+      Pos = IdentifierPos;
+      IdentifierPos = End;
+    }
 
     // Add the prefix.
     OS << Body.slice(0, Pos);
@@ -2784,51 +2784,51 @@ bool MasmParser::expandMacro(raw_svector_ostream &OS, StringRef Body,
     if (Pos == End)
       break;
 
-    unsigned I = Pos; 
-    bool InitialAmpersand = (Body[I] == '&'); 
-    if (InitialAmpersand) { 
-      ++I; 
-      ++Pos; 
-    } 
-    while (I < End && isMacroParameterChar(Body[I])) 
-      ++I; 
-
-    const char *Begin = Body.data() + Pos; 
-    StringRef Argument(Begin, I - Pos); 
-    unsigned Index = 0; 
- 
-    for (; Index < NParameters; ++Index) 
-      if (Parameters[Index].Name == Argument) 
+    unsigned I = Pos;
+    bool InitialAmpersand = (Body[I] == '&');
+    if (InitialAmpersand) {
+      ++I;
+      ++Pos;
+    }
+    while (I < End && isMacroParameterChar(Body[I]))
+      ++I;
+
+    const char *Begin = Body.data() + Pos;
+    StringRef Argument(Begin, I - Pos);
+    unsigned Index = 0;
+
+    for (; Index < NParameters; ++Index)
+      if (Parameters[Index].Name == Argument)
         break;
 
-    if (Index == NParameters) { 
-      if (InitialAmpersand) 
-        OS << '&'; 
-      auto it = LocalSymbols.find(Argument.lower()); 
-      if (it != LocalSymbols.end()) 
-        OS << it->second; 
-      else 
-        OS << Argument; 
-      Pos = I; 
-    } else { 
-      for (const AsmToken &Token : A[Index]) { 
-        // In MASM, you can write '%expr'. 
-        // The prefix '%' evaluates the expression 'expr' 
-        // and uses the result as a string (e.g. replace %(1+2) with the 
-        // string "3"). 
-        // Here, we identify the integer token which is the result of the 
-        // absolute expression evaluation and replace it with its string 
-        // representation. 
-        if (Token.getString().front() == '%' && Token.is(AsmToken::Integer)) 
-          // Emit an integer value to the buffer. 
-          OS << Token.getIntVal(); 
-        else 
+    if (Index == NParameters) {
+      if (InitialAmpersand)
+        OS << '&';
+      auto it = LocalSymbols.find(Argument.lower());
+      if (it != LocalSymbols.end())
+        OS << it->second;
+      else
+        OS << Argument;
+      Pos = I;
+    } else {
+      for (const AsmToken &Token : A[Index]) {
+        // In MASM, you can write '%expr'.
+        // The prefix '%' evaluates the expression 'expr'
+        // and uses the result as a string (e.g. replace %(1+2) with the
+        // string "3").
+        // Here, we identify the integer token which is the result of the
+        // absolute expression evaluation and replace it with its string
+        // representation.
+        if (Token.getString().front() == '%' && Token.is(AsmToken::Integer))
+          // Emit an integer value to the buffer.
+          OS << Token.getIntVal();
+        else
           OS << Token.getString();
       }
 
-      Pos += Argument.size(); 
-      if (Pos < End && Body[Pos] == '&') { 
-        ++Pos; 
+      Pos += Argument.size();
+      if (Pos < End && Body[Pos] == '&') {
+        ++Pos;
       }
     }
     // Update the scan point.
@@ -2886,30 +2886,30 @@ private:
 
 } // end anonymous namespace
 
-bool MasmParser::parseMacroArgument(const MCAsmMacroParameter *MP, 
-                                    MCAsmMacroArgument &MA, 
-                                    AsmToken::TokenKind EndTok) { 
-  if (MP && MP->Vararg) { 
-    if (Lexer.isNot(EndTok)) { 
-      SmallVector<StringRef, 1> Str = parseStringRefsTo(EndTok); 
-      for (StringRef S : Str) { 
-        MA.emplace_back(AsmToken::String, S); 
-      } 
+bool MasmParser::parseMacroArgument(const MCAsmMacroParameter *MP,
+                                    MCAsmMacroArgument &MA,
+                                    AsmToken::TokenKind EndTok) {
+  if (MP && MP->Vararg) {
+    if (Lexer.isNot(EndTok)) {
+      SmallVector<StringRef, 1> Str = parseStringRefsTo(EndTok);
+      for (StringRef S : Str) {
+        MA.emplace_back(AsmToken::String, S);
+      }
     }
     return false;
   }
 
-  SMLoc StrLoc = Lexer.getLoc(), EndLoc; 
-  if (Lexer.is(AsmToken::Less) && isAngleBracketString(StrLoc, EndLoc)) { 
-    const char *StrChar = StrLoc.getPointer() + 1; 
-    const char *EndChar = EndLoc.getPointer() - 1; 
-    jumpToLoc(EndLoc, CurBuffer, EndStatementAtEOFStack.back()); 
-    /// Eat from '<' to '>'. 
-    Lex(); 
-    MA.emplace_back(AsmToken::String, StringRef(StrChar, EndChar - StrChar)); 
-    return false; 
-  } 
- 
+  SMLoc StrLoc = Lexer.getLoc(), EndLoc;
+  if (Lexer.is(AsmToken::Less) && isAngleBracketString(StrLoc, EndLoc)) {
+    const char *StrChar = StrLoc.getPointer() + 1;
+    const char *EndChar = EndLoc.getPointer() - 1;
+    jumpToLoc(EndLoc, CurBuffer, EndStatementAtEOFStack.back());
+    /// Eat from '<' to '>'.
+    Lex();
+    MA.emplace_back(AsmToken::String, StringRef(StrChar, EndChar - StrChar));
+    return false;
+  }
+
   unsigned ParenLevel = 0;
 
   // Darwin doesn't use spaces to delmit arguments.
@@ -2920,7 +2920,7 @@ bool MasmParser::parseMacroArgument(const MCAsmMacroParameter *MP,
   while (true) {
     SpaceEaten = false;
     if (Lexer.is(AsmToken::Eof) || Lexer.is(AsmToken::Equal))
-      return TokError("unexpected token"); 
+      return TokError("unexpected token");
 
     if (ParenLevel == 0) {
       if (Lexer.is(AsmToken::Comma))
@@ -2928,20 +2928,20 @@ bool MasmParser::parseMacroArgument(const MCAsmMacroParameter *MP,
 
       if (Lexer.is(AsmToken::Space)) {
         SpaceEaten = true;
-        Lex(); // Eat spaces. 
+        Lex(); // Eat spaces.
       }
 
       // Spaces can delimit parameters, but could also be part an expression.
       // If the token after a space is an operator, add the token and the next
       // one into this argument
       if (!IsDarwin) {
-        if (isOperator(Lexer.getKind()) && Lexer.isNot(EndTok)) { 
+        if (isOperator(Lexer.getKind()) && Lexer.isNot(EndTok)) {
           MA.push_back(getTok());
-          Lex(); 
+          Lex();
 
           // Whitespace after an operator can be ignored.
           if (Lexer.is(AsmToken::Space))
-            Lex(); 
+            Lex();
 
           continue;
         }
@@ -2952,7 +2952,7 @@ bool MasmParser::parseMacroArgument(const MCAsmMacroParameter *MP,
 
     // handleMacroEntry relies on not advancing the lexer here
     // to be able to fill in the remaining default parameter values
-    if (Lexer.is(EndTok) && (EndTok != AsmToken::RParen || ParenLevel == 0)) 
+    if (Lexer.is(EndTok) && (EndTok != AsmToken::RParen || ParenLevel == 0))
       break;
 
     // Adjust the current parentheses level.
@@ -2963,27 +2963,27 @@ bool MasmParser::parseMacroArgument(const MCAsmMacroParameter *MP,
 
     // Append the token to the current argument list.
     MA.push_back(getTok());
-    Lex(); 
+    Lex();
   }
 
   if (ParenLevel != 0)
-    return TokError("unbalanced parentheses in argument"); 
- 
-  if (MA.empty() && MP) { 
-    if (MP->Required) { 
-      return TokError("missing value for required parameter '" + MP->Name + 
-                      "'"); 
-    } else { 
-      MA = MP->Value; 
-    } 
-  } 
+    return TokError("unbalanced parentheses in argument");
+
+  if (MA.empty() && MP) {
+    if (MP->Required) {
+      return TokError("missing value for required parameter '" + MP->Name +
+                      "'");
+    } else {
+      MA = MP->Value;
+    }
+  }
   return false;
 }
 
 // Parse the macro instantiation arguments.
 bool MasmParser::parseMacroArguments(const MCAsmMacro *M,
-                                     MCAsmMacroArguments &A, 
-                                     AsmToken::TokenKind EndTok) { 
+                                     MCAsmMacroArguments &A,
+                                     AsmToken::TokenKind EndTok) {
   const unsigned NParameters = M ? M->Parameters.size() : 0;
   bool NamedParametersFound = false;
   SmallVector<SMLoc, 4> FALocs;
@@ -3014,27 +3014,27 @@ bool MasmParser::parseMacroArguments(const MCAsmMacro *M,
     if (NamedParametersFound && FA.Name.empty())
       return Error(IDLoc, "cannot mix positional and keyword arguments");
 
-    unsigned PI = Parameter; 
-    if (!FA.Name.empty()) { 
-      assert(M && "expected macro to be defined"); 
-      unsigned FAI = 0; 
-      for (FAI = 0; FAI < NParameters; ++FAI) 
-        if (M->Parameters[FAI].Name == FA.Name) 
-          break; 
- 
-      if (FAI >= NParameters) { 
-        return Error(IDLoc, "parameter named '" + FA.Name + 
-                                "' does not exist for macro '" + M->Name + "'"); 
-      } 
-      PI = FAI; 
-    } 
-    const MCAsmMacroParameter *MP = nullptr; 
-    if (M && PI < NParameters) 
-      MP = &M->Parameters[PI]; 
- 
+    unsigned PI = Parameter;
+    if (!FA.Name.empty()) {
+      assert(M && "expected macro to be defined");
+      unsigned FAI = 0;
+      for (FAI = 0; FAI < NParameters; ++FAI)
+        if (M->Parameters[FAI].Name == FA.Name)
+          break;
+
+      if (FAI >= NParameters) {
+        return Error(IDLoc, "parameter named '" + FA.Name +
+                                "' does not exist for macro '" + M->Name + "'");
+      }
+      PI = FAI;
+    }
+    const MCAsmMacroParameter *MP = nullptr;
+    if (M && PI < NParameters)
+      MP = &M->Parameters[PI];
+
     SMLoc StrLoc = Lexer.getLoc();
     SMLoc EndLoc;
-    if (Lexer.is(AsmToken::Percent)) { 
+    if (Lexer.is(AsmToken::Percent)) {
       const MCExpr *AbsoluteExp;
       int64_t Value;
       /// Eat '%'.
@@ -3049,11 +3049,11 @@ bool MasmParser::parseMacroArguments(const MCAsmMacro *M,
       AsmToken newToken(AsmToken::Integer,
                         StringRef(StrChar, EndChar - StrChar), Value);
       FA.Value.push_back(newToken);
-    } else if (parseMacroArgument(MP, FA.Value, EndTok)) { 
-      if (M) 
-        return addErrorSuffix(" in '" + M->Name + "' macro"); 
-      else 
-        return true; 
+    } else if (parseMacroArgument(MP, FA.Value, EndTok)) {
+      if (M)
+        return addErrorSuffix(" in '" + M->Name + "' macro");
+      else
+        return true;
     }
 
     if (!FA.Value.empty()) {
@@ -3070,15 +3070,15 @@ bool MasmParser::parseMacroArguments(const MCAsmMacro *M,
     // At the end of the statement, fill in remaining arguments that have
     // default values. If there aren't any, then the next argument is
     // required but missing
-    if (Lexer.is(EndTok)) { 
+    if (Lexer.is(EndTok)) {
       bool Failure = false;
       for (unsigned FAI = 0; FAI < NParameters; ++FAI) {
         if (A[FAI].empty()) {
           if (M->Parameters[FAI].Required) {
             Error(FALocs[FAI].isValid() ? FALocs[FAI] : Lexer.getLoc(),
                   "missing value for required parameter "
-                  "'" + 
-                      M->Parameters[FAI].Name + "' in macro '" + M->Name + "'"); 
+                  "'" +
+                      M->Parameters[FAI].Name + "' in macro '" + M->Name + "'");
             Failure = true;
           }
 
@@ -3096,8 +3096,8 @@ bool MasmParser::parseMacroArguments(const MCAsmMacro *M,
   return TokError("too many positional arguments");
 }
 
-bool MasmParser::handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc, 
-                                  AsmToken::TokenKind ArgumentEndTok) { 
+bool MasmParser::handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc,
+                                  AsmToken::TokenKind ArgumentEndTok) {
   // Arbitrarily limit macro nesting depth (default matches 'as'). We can
   // eliminate this, although we should protect against infinite loops.
   unsigned MaxNestingDepth = AsmMacroMaxNestingDepth;
@@ -3111,7 +3111,7 @@ bool MasmParser::handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc,
   }
 
   MCAsmMacroArguments A;
-  if (parseMacroArguments(M, A, ArgumentEndTok)) 
+  if (parseMacroArguments(M, A, ArgumentEndTok))
     return true;
 
   // Macro instantiation is lexical, unfortunately. We construct a new buffer
@@ -3120,12 +3120,12 @@ bool MasmParser::handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc,
   StringRef Body = M->Body;
   raw_svector_ostream OS(Buf);
 
-  if (expandMacro(OS, Body, M->Parameters, A, M->Locals, getTok().getLoc())) 
+  if (expandMacro(OS, Body, M->Parameters, A, M->Locals, getTok().getLoc()))
     return true;
 
-  // We include the endm in the buffer as our cue to exit the macro 
+  // We include the endm in the buffer as our cue to exit the macro
   // instantiation.
-  OS << "endm\n"; 
+  OS << "endm\n";
 
   std::unique_ptr<MemoryBuffer> Instantiation =
       MemoryBuffer::getMemBufferCopy(OS.str(), "<instantiation>");
@@ -3141,17 +3141,17 @@ bool MasmParser::handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc,
   // Jump to the macro instantiation and prime the lexer.
   CurBuffer = SrcMgr.AddNewSourceBuffer(std::move(Instantiation), SMLoc());
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
-  EndStatementAtEOFStack.push_back(true); 
+  EndStatementAtEOFStack.push_back(true);
   Lex();
 
   return false;
 }
 
 void MasmParser::handleMacroExit() {
-  // Jump to the token we should return to, and consume it. 
-  EndStatementAtEOFStack.pop_back(); 
-  jumpToLoc(ActiveMacros.back()->ExitLoc, ActiveMacros.back()->ExitBuffer, 
-            EndStatementAtEOFStack.back()); 
+  // Jump to the token we should return to, and consume it.
+  EndStatementAtEOFStack.pop_back();
+  jumpToLoc(ActiveMacros.back()->ExitLoc, ActiveMacros.back()->ExitBuffer,
+            EndStatementAtEOFStack.back());
   Lex();
 
   // Pop the instantiation entry.
@@ -3159,63 +3159,63 @@ void MasmParser::handleMacroExit() {
   ActiveMacros.pop_back();
 }
 
-bool MasmParser::handleMacroInvocation(const MCAsmMacro *M, SMLoc NameLoc) { 
-  if (!M->IsFunction) 
-    return Error(NameLoc, "cannot invoke macro procedure as function"); 
- 
-  if (parseToken(AsmToken::LParen, "invoking macro function '" + M->Name + 
-                                       "' requires arguments in parentheses") || 
-      handleMacroEntry(M, NameLoc, AsmToken::RParen)) 
-    return true; 
- 
-  // Parse all statements in the macro, retrieving the exit value when it ends. 
-  std::string ExitValue; 
-  SmallVector<AsmRewrite, 4> AsmStrRewrites; 
-  while (Lexer.isNot(AsmToken::Eof)) { 
-    ParseStatementInfo Info(&AsmStrRewrites); 
-    bool Parsed = parseStatement(Info, nullptr); 
- 
-    if (!Parsed && Info.ExitValue.hasValue()) { 
-      ExitValue = std::move(*Info.ExitValue); 
-      break; 
-    } 
- 
-    // If we have a Lexer Error we are on an Error Token. Load in Lexer Error 
-    // for printing ErrMsg via Lex() only if no (presumably better) parser error 
-    // exists. 
-    if (Parsed && !hasPendingError() && Lexer.getTok().is(AsmToken::Error)) { 
-      Lex(); 
-    } 
- 
-    // parseStatement returned true so may need to emit an error. 
-    printPendingErrors(); 
- 
-    // Skipping to the next line if needed. 
-    if (Parsed && !getLexer().isAtStartOfStatement()) 
-      eatToEndOfStatement(); 
-  } 
- 
-  // Consume the right-parenthesis on the other side of the arguments. 
-  if (parseToken(AsmToken::RParen, "invoking macro function '" + M->Name + 
-                                       "' requires arguments in parentheses")) 
-    return true; 
- 
-  // Exit values may require lexing, unfortunately. We construct a new buffer to 
-  // hold the exit value. 
-  std::unique_ptr<MemoryBuffer> MacroValue = 
-      MemoryBuffer::getMemBufferCopy(ExitValue, "<macro-value>"); 
- 
-  // Jump from this location to the instantiated exit value, and prime the 
-  // lexer. 
-  CurBuffer = SrcMgr.AddNewSourceBuffer(std::move(MacroValue), Lexer.getLoc()); 
-  Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer(), nullptr, 
-                  /*EndStatementAtEOF=*/false); 
-  EndStatementAtEOFStack.push_back(false); 
-  Lex(); 
- 
-  return false; 
-} 
- 
+bool MasmParser::handleMacroInvocation(const MCAsmMacro *M, SMLoc NameLoc) {
+  if (!M->IsFunction)
+    return Error(NameLoc, "cannot invoke macro procedure as function");
+
+  if (parseToken(AsmToken::LParen, "invoking macro function '" + M->Name +
+                                       "' requires arguments in parentheses") ||
+      handleMacroEntry(M, NameLoc, AsmToken::RParen))
+    return true;
+
+  // Parse all statements in the macro, retrieving the exit value when it ends.
+  std::string ExitValue;
+  SmallVector<AsmRewrite, 4> AsmStrRewrites;
+  while (Lexer.isNot(AsmToken::Eof)) {
+    ParseStatementInfo Info(&AsmStrRewrites);
+    bool Parsed = parseStatement(Info, nullptr);
+
+    if (!Parsed && Info.ExitValue.hasValue()) {
+      ExitValue = std::move(*Info.ExitValue);
+      break;
+    }
+
+    // If we have a Lexer Error we are on an Error Token. Load in Lexer Error
+    // for printing ErrMsg via Lex() only if no (presumably better) parser error
+    // exists.
+    if (Parsed && !hasPendingError() && Lexer.getTok().is(AsmToken::Error)) {
+      Lex();
+    }
+
+    // parseStatement returned true so may need to emit an error.
+    printPendingErrors();
+
+    // Skipping to the next line if needed.
+    if (Parsed && !getLexer().isAtStartOfStatement())
+      eatToEndOfStatement();
+  }
+
+  // Consume the right-parenthesis on the other side of the arguments.
+  if (parseToken(AsmToken::RParen, "invoking macro function '" + M->Name +
+                                       "' requires arguments in parentheses"))
+    return true;
+
+  // Exit values may require lexing, unfortunately. We construct a new buffer to
+  // hold the exit value.
+  std::unique_ptr<MemoryBuffer> MacroValue =
+      MemoryBuffer::getMemBufferCopy(ExitValue, "<macro-value>");
+
+  // Jump from this location to the instantiated exit value, and prime the
+  // lexer.
+  CurBuffer = SrcMgr.AddNewSourceBuffer(std::move(MacroValue), Lexer.getLoc());
+  Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer(), nullptr,
+                  /*EndStatementAtEOF=*/false);
+  EndStatementAtEOFStack.push_back(false);
+  Lex();
+
+  return false;
+}
+
 /// parseIdentifier:
 ///   ::= identifier
 ///   ::= string
@@ -3284,7 +3284,7 @@ bool MasmParser::parseDirectiveEquate(StringRef IDVal, StringRef Name,
       // Accept a text-list, not just one text-item.
       auto parseItem = [&]() -> bool {
         if (parseTextItem(Value))
-          return TokError("expected text item"); 
+          return TokError("expected text item");
         Var.TextValue += Value;
         return false;
       };
@@ -3302,11 +3302,11 @@ bool MasmParser::parseDirectiveEquate(StringRef IDVal, StringRef Name,
   SMLoc EndLoc, StartLoc = Lexer.getLoc();
   if (parseExpression(Expr, EndLoc))
     return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
-  MCSymbol *Sym = getContext().getOrCreateSymbol(Var.Name); 
-  Sym->setRedefinable(Var.Redefinable); 
-  Sym->setVariableValue(Expr); 
-  Sym->setExternal(false); 
- 
+  MCSymbol *Sym = getContext().getOrCreateSymbol(Var.Name);
+  Sym->setRedefinable(Var.Redefinable);
+  Sym->setVariableValue(Expr);
+  Sym->setExternal(false);
+
   if (Expr->evaluateAsAbsolute(Var.NumericValue,
                                getStreamer().getAssemblerPtr()))
     return false;
@@ -3323,18 +3323,18 @@ bool MasmParser::parseEscapedString(std::string &Data) {
     return true;
 
   Data = "";
-  char Quote = getTok().getString().front(); 
+  char Quote = getTok().getString().front();
   StringRef Str = getTok().getStringContents();
-  Data.reserve(Str.size()); 
-  for (size_t i = 0, e = Str.size(); i != e; ++i) { 
-    Data.push_back(Str[i]); 
-    if (Str[i] == Quote) { 
-      // MASM treats doubled delimiting quotes as an escaped delimiting quote. 
-      // If we're escaping the string's trailing delimiter, we're definitely 
-      // missing a quotation mark. 
-      if (i + 1 == Str.size()) 
-        return Error(getTok().getLoc(), "missing quotation mark in string"); 
-      if (Str[i + 1] == Quote) 
+  Data.reserve(Str.size());
+  for (size_t i = 0, e = Str.size(); i != e; ++i) {
+    Data.push_back(Str[i]);
+    if (Str[i] == Quote) {
+      // MASM treats doubled delimiting quotes as an escaped delimiting quote.
+      // If we're escaping the string's trailing delimiter, we're definitely
+      // missing a quotation mark.
+      if (i + 1 == Str.size())
+        return Error(getTok().getLoc(), "missing quotation mark in string");
+      if (Str[i + 1] == Quote)
         ++i;
     }
   }
@@ -3348,7 +3348,7 @@ bool MasmParser::parseAngleBracketString(std::string &Data) {
   if (isAngleBracketString(StartLoc, EndLoc)) {
     const char *StartChar = StartLoc.getPointer() + 1;
     const char *EndChar = EndLoc.getPointer() - 1;
-    jumpToLoc(EndLoc, CurBuffer, EndStatementAtEOFStack.back()); 
+    jumpToLoc(EndLoc, CurBuffer, EndStatementAtEOFStack.back());
     // Eat from '<' to '>'.
     Lex();
 
@@ -3360,42 +3360,42 @@ bool MasmParser::parseAngleBracketString(std::string &Data) {
 
 /// textItem ::= textLiteral | textMacroID | % constExpr
 bool MasmParser::parseTextItem(std::string &Data) {
-  switch (getTok().getKind()) { 
-  default: 
-    return true; 
-  case AsmToken::Percent: { 
-    int64_t Res; 
-    if (parseToken(AsmToken::Percent) || parseAbsoluteExpression(Res)) 
-      return true; 
-    Data = std::to_string(Res); 
-    return false; 
-  } 
-  case AsmToken::Less: 
-  case AsmToken::LessEqual: 
-  case AsmToken::LessLess: 
-  case AsmToken::LessGreater: 
-    return parseAngleBracketString(Data); 
-  case AsmToken::Identifier: { 
-    StringRef ID; 
-    if (parseIdentifier(ID)) 
-      return true; 
-    Data = ID.str(); 
- 
-    auto it = Variables.find(ID); 
-    if (it == Variables.end()) 
-      return true; 
- 
-    while (it != Variables.end()) { 
-      const Variable &Var = it->second; 
-      if (!Var.IsText) 
-        return true; 
-      Data = Var.TextValue; 
-      it = Variables.find(Data); 
-    } 
-    return false; 
-  } 
-  } 
-  llvm_unreachable("unhandled token kind"); 
+  switch (getTok().getKind()) {
+  default:
+    return true;
+  case AsmToken::Percent: {
+    int64_t Res;
+    if (parseToken(AsmToken::Percent) || parseAbsoluteExpression(Res))
+      return true;
+    Data = std::to_string(Res);
+    return false;
+  }
+  case AsmToken::Less:
+  case AsmToken::LessEqual:
+  case AsmToken::LessLess:
+  case AsmToken::LessGreater:
+    return parseAngleBracketString(Data);
+  case AsmToken::Identifier: {
+    StringRef ID;
+    if (parseIdentifier(ID))
+      return true;
+    Data = ID.str();
+
+    auto it = Variables.find(ID);
+    if (it == Variables.end())
+      return true;
+
+    while (it != Variables.end()) {
+      const Variable &Var = it->second;
+      if (!Var.IsText)
+        return true;
+      Data = Var.TextValue;
+      it = Variables.find(Data);
+    }
+    return false;
+  }
+  }
+  llvm_unreachable("unhandled token kind");
 }
 
 /// parseDirectiveAscii:
@@ -3439,20 +3439,20 @@ bool MasmParser::emitIntValue(const MCExpr *Value, unsigned Size) {
 bool MasmParser::parseScalarInitializer(unsigned Size,
                                         SmallVectorImpl<const MCExpr *> &Values,
                                         unsigned StringPadLength) {
-  if (Size == 1 && getTok().is(AsmToken::String)) { 
-    std::string Value; 
-    if (parseEscapedString(Value)) 
-      return true; 
-    // Treat each character as an initializer. 
-    for (const unsigned char CharVal : Value) 
-      Values.push_back(MCConstantExpr::create(CharVal, getContext())); 
-
-    // Pad the string with spaces to the specified length. 
-    for (size_t i = Value.size(); i < StringPadLength; ++i) 
-      Values.push_back(MCConstantExpr::create(' ', getContext())); 
+  if (Size == 1 && getTok().is(AsmToken::String)) {
+    std::string Value;
+    if (parseEscapedString(Value))
+      return true;
+    // Treat each character as an initializer.
+    for (const unsigned char CharVal : Value)
+      Values.push_back(MCConstantExpr::create(CharVal, getContext()));
+
+    // Pad the string with spaces to the specified length.
+    for (size_t i = Value.size(); i < StringPadLength; ++i)
+      Values.push_back(MCConstantExpr::create(' ', getContext()));
   } else {
     const MCExpr *Value;
-    if (parseExpression(Value)) 
+    if (parseExpression(Value))
       return true;
     if (getTok().is(AsmToken::Identifier) &&
         getTok().getString().equals_lower("dup")) {
@@ -3498,7 +3498,7 @@ bool MasmParser::parseScalarInstList(unsigned Size,
   return false;
 }
 
-bool MasmParser::emitIntegralValues(unsigned Size, unsigned *Count) { 
+bool MasmParser::emitIntegralValues(unsigned Size, unsigned *Count) {
   SmallVector<const MCExpr *, 1> Values;
   if (checkForValidSection() || parseScalarInstList(Size, Values))
     return true;
@@ -3506,15 +3506,15 @@ bool MasmParser::emitIntegralValues(unsigned Size, unsigned *Count) {
   for (auto Value : Values) {
     emitIntValue(Value, Size);
   }
-  if (Count) 
-    *Count = Values.size(); 
+  if (Count)
+    *Count = Values.size();
   return false;
 }
 
 // Add a field to the current structure.
 bool MasmParser::addIntegralField(StringRef Name, unsigned Size) {
   StructInfo &Struct = StructInProgress.back();
-  FieldInfo &Field = Struct.addField(Name, FT_INTEGRAL, Size); 
+  FieldInfo &Field = Struct.addField(Name, FT_INTEGRAL, Size);
   IntFieldInfo &IntInfo = Field.Contents.IntInfo;
 
   Field.Type = Size;
@@ -3547,24 +3547,24 @@ bool MasmParser::parseDirectiveValue(StringRef IDVal, unsigned Size) {
 
 /// parseDirectiveNamedValue
 ///  ::= name (byte | word | ... ) [ expression (, expression)* ]
-bool MasmParser::parseDirectiveNamedValue(StringRef TypeName, unsigned Size, 
+bool MasmParser::parseDirectiveNamedValue(StringRef TypeName, unsigned Size,
                                           StringRef Name, SMLoc NameLoc) {
   if (StructInProgress.empty()) {
     // Initialize named data value.
     MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     getStreamer().emitLabel(Sym);
-    unsigned Count; 
-    if (emitIntegralValues(Size, &Count)) 
-      return addErrorSuffix(" in '" + Twine(TypeName) + "' directive"); 
- 
-    AsmTypeInfo Type; 
-    Type.Name = TypeName; 
-    Type.Size = Size * Count; 
-    Type.ElementSize = Size; 
-    Type.Length = Count; 
-    KnownType[Name.lower()] = Type; 
+    unsigned Count;
+    if (emitIntegralValues(Size, &Count))
+      return addErrorSuffix(" in '" + Twine(TypeName) + "' directive");
+
+    AsmTypeInfo Type;
+    Type.Name = TypeName;
+    Type.Size = Size * Count;
+    Type.ElementSize = Size;
+    Type.Length = Count;
+    KnownType[Name.lower()] = Type;
   } else if (addIntegralField(Name, Size)) {
-    return addErrorSuffix(" in '" + Twine(TypeName) + "' directive"); 
+    return addErrorSuffix(" in '" + Twine(TypeName) + "' directive");
   }
 
   return false;
@@ -3593,13 +3593,13 @@ bool MasmParser::parseRealValue(const fltSemantics &Semantics, APInt &Res) {
   // We don't truly support arithmetic on floating point expressions, so we
   // have to manually parse unary prefixes.
   bool IsNeg = false;
-  SMLoc SignLoc; 
+  SMLoc SignLoc;
   if (getLexer().is(AsmToken::Minus)) {
-    SignLoc = getLexer().getLoc(); 
+    SignLoc = getLexer().getLoc();
     Lexer.Lex();
     IsNeg = true;
   } else if (getLexer().is(AsmToken::Plus)) {
-    SignLoc = getLexer().getLoc(); 
+    SignLoc = getLexer().getLoc();
     Lexer.Lex();
   }
 
@@ -3621,20 +3621,20 @@ bool MasmParser::parseRealValue(const fltSemantics &Semantics, APInt &Res) {
       Value = APFloat::getZero(Semantics);
     else
       return TokError("invalid floating point literal");
-  } else if (IDVal.consume_back("r") || IDVal.consume_back("R")) { 
-    // MASM hexadecimal floating-point literal; no APFloat conversion needed. 
-    // To match ML64.exe, ignore the initial sign. 
-    unsigned SizeInBits = Value.getSizeInBits(Semantics); 
-    if (SizeInBits != (IDVal.size() << 2)) 
-      return TokError("invalid floating point literal"); 
- 
-    // Consume the numeric token. 
-    Lex(); 
- 
-    Res = APInt(SizeInBits, IDVal, 16); 
-    if (SignLoc.isValid()) 
-      return Warning(SignLoc, "MASM-style hex floats ignore explicit sign"); 
-    return false; 
+  } else if (IDVal.consume_back("r") || IDVal.consume_back("R")) {
+    // MASM hexadecimal floating-point literal; no APFloat conversion needed.
+    // To match ML64.exe, ignore the initial sign.
+    unsigned SizeInBits = Value.getSizeInBits(Semantics);
+    if (SizeInBits != (IDVal.size() << 2))
+      return TokError("invalid floating point literal");
+
+    // Consume the numeric token.
+    Lex();
+
+    Res = APInt(SizeInBits, IDVal, 16);
+    if (SignLoc.isValid())
+      return Warning(SignLoc, "MASM-style hex floats ignore explicit sign");
+    return false;
   } else if (errorToBool(
                  Value.convertFromString(IDVal, APFloat::rmNearestTiesToEven)
                      .takeError())) {
@@ -3698,33 +3698,33 @@ bool MasmParser::parseRealInstList(const fltSemantics &Semantics,
 }
 
 // Initialize real data values.
-bool MasmParser::emitRealValues(const fltSemantics &Semantics, 
-                                unsigned *Count) { 
-  if (checkForValidSection()) 
-    return true; 
- 
+bool MasmParser::emitRealValues(const fltSemantics &Semantics,
+                                unsigned *Count) {
+  if (checkForValidSection())
+    return true;
+
   SmallVector<APInt, 1> ValuesAsInt;
   if (parseRealInstList(Semantics, ValuesAsInt))
     return true;
 
   for (const APInt &AsInt : ValuesAsInt) {
-    getStreamer().emitIntValue(AsInt); 
+    getStreamer().emitIntValue(AsInt);
   }
-  if (Count) 
-    *Count = ValuesAsInt.size(); 
+  if (Count)
+    *Count = ValuesAsInt.size();
   return false;
 }
 
 // Add a real field to the current struct.
-bool MasmParser::addRealField(StringRef Name, const fltSemantics &Semantics, 
-                              size_t Size) { 
+bool MasmParser::addRealField(StringRef Name, const fltSemantics &Semantics,
+                              size_t Size) {
   StructInfo &Struct = StructInProgress.back();
-  FieldInfo &Field = Struct.addField(Name, FT_REAL, Size); 
+  FieldInfo &Field = Struct.addField(Name, FT_REAL, Size);
   RealFieldInfo &RealInfo = Field.Contents.RealInfo;
 
   Field.SizeOf = 0;
 
-  if (parseRealInstList(Semantics, RealInfo.AsIntValues)) 
+  if (parseRealInstList(Semantics, RealInfo.AsIntValues))
     return true;
 
   Field.Type = RealInfo.AsIntValues.back().getBitWidth() / 8;
@@ -3738,42 +3738,42 @@ bool MasmParser::addRealField(StringRef Name, const fltSemantics &Semantics,
 }
 
 /// parseDirectiveRealValue
-///  ::= (real4 | real8 | real10) [ expression (, expression)* ] 
+///  ::= (real4 | real8 | real10) [ expression (, expression)* ]
 bool MasmParser::parseDirectiveRealValue(StringRef IDVal,
-                                         const fltSemantics &Semantics, 
-                                         size_t Size) { 
+                                         const fltSemantics &Semantics,
+                                         size_t Size) {
   if (StructInProgress.empty()) {
     // Initialize data value.
     if (emitRealValues(Semantics))
       return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
-  } else if (addRealField("", Semantics, Size)) { 
+  } else if (addRealField("", Semantics, Size)) {
     return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
   }
   return false;
 }
 
 /// parseDirectiveNamedRealValue
-///  ::= name (real4 | real8 | real10) [ expression (, expression)* ] 
-bool MasmParser::parseDirectiveNamedRealValue(StringRef TypeName, 
+///  ::= name (real4 | real8 | real10) [ expression (, expression)* ]
+bool MasmParser::parseDirectiveNamedRealValue(StringRef TypeName,
                                               const fltSemantics &Semantics,
-                                              unsigned Size, StringRef Name, 
-                                              SMLoc NameLoc) { 
+                                              unsigned Size, StringRef Name,
+                                              SMLoc NameLoc) {
   if (StructInProgress.empty()) {
     // Initialize named data value.
     MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     getStreamer().emitLabel(Sym);
-    unsigned Count; 
-    if (emitRealValues(Semantics, &Count)) 
-      return addErrorSuffix(" in '" + TypeName + "' directive"); 
- 
-    AsmTypeInfo Type; 
-    Type.Name = TypeName; 
-    Type.Size = Size * Count; 
-    Type.ElementSize = Size; 
-    Type.Length = Count; 
-    KnownType[Name.lower()] = Type; 
-  } else if (addRealField(Name, Semantics, Size)) { 
-    return addErrorSuffix(" in '" + TypeName + "' directive"); 
+    unsigned Count;
+    if (emitRealValues(Semantics, &Count))
+      return addErrorSuffix(" in '" + TypeName + "' directive");
+
+    AsmTypeInfo Type;
+    Type.Name = TypeName;
+    Type.Size = Size * Count;
+    Type.ElementSize = Size;
+    Type.Length = Count;
+    KnownType[Name.lower()] = Type;
+  } else if (addRealField(Name, Semantics, Size)) {
+    return addErrorSuffix(" in '" + TypeName + "' directive");
   }
   return false;
 }
@@ -3847,20 +3847,20 @@ bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
 bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
                                        const RealFieldInfo &Contents,
                                        FieldInitializer &Initializer) {
-  const fltSemantics *Semantics; 
-  switch (Field.Type) { 
-  case 4: 
-    Semantics = &APFloat::IEEEsingle(); 
-    break; 
-  case 8: 
-    Semantics = &APFloat::IEEEdouble(); 
-    break; 
-  case 10: 
-    Semantics = &APFloat::x87DoubleExtended(); 
-    break; 
-  default: 
-    llvm_unreachable("unknown real field type"); 
-  } 
+  const fltSemantics *Semantics;
+  switch (Field.Type) {
+  case 4:
+    Semantics = &APFloat::IEEEsingle();
+    break;
+  case 8:
+    Semantics = &APFloat::IEEEdouble();
+    break;
+  case 10:
+    Semantics = &APFloat::x87DoubleExtended();
+    break;
+  default:
+    llvm_unreachable("unknown real field type");
+  }
 
   SMLoc Loc = getTok().getLoc();
 
@@ -3868,20 +3868,20 @@ bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
   if (parseOptionalToken(AsmToken::LCurly)) {
     if (Field.LengthOf == 1)
       return Error(Loc, "Cannot initialize scalar field with array value");
-    if (parseRealInstList(*Semantics, AsIntValues, AsmToken::RCurly) || 
+    if (parseRealInstList(*Semantics, AsIntValues, AsmToken::RCurly) ||
         parseToken(AsmToken::RCurly))
       return true;
   } else if (parseOptionalAngleBracketOpen()) {
     if (Field.LengthOf == 1)
       return Error(Loc, "Cannot initialize scalar field with array value");
-    if (parseRealInstList(*Semantics, AsIntValues, AsmToken::Greater) || 
+    if (parseRealInstList(*Semantics, AsIntValues, AsmToken::Greater) ||
         parseAngleBracketClose())
       return true;
   } else if (Field.LengthOf > 1) {
     return Error(Loc, "Cannot initialize array field with scalar value");
   } else {
     AsIntValues.emplace_back();
-    if (parseRealValue(*Semantics, AsIntValues.back())) 
+    if (parseRealValue(*Semantics, AsIntValues.back()))
       return true;
   }
 
@@ -4044,7 +4044,7 @@ bool MasmParser::parseStructInstList(
         return true;
 
       for (int i = 0; i < Repetitions; ++i)
-        llvm::append_range(Initializers, DuplicatedValues); 
+        llvm::append_range(Initializers, DuplicatedValues);
     } else {
       Initializers.emplace_back();
       if (parseStructInitializer(Structure, Initializers.back()))
@@ -4197,8 +4197,8 @@ bool MasmParser::emitStructInitializer(const StructInfo &Structure,
 }
 
 // Set data values from initializers.
-bool MasmParser::emitStructValues(const StructInfo &Structure, 
-                                  unsigned *Count) { 
+bool MasmParser::emitStructValues(const StructInfo &Structure,
+                                  unsigned *Count) {
   std::vector<StructInitializer> Initializers;
   if (parseStructInstList(Structure, Initializers))
     return true;
@@ -4208,16 +4208,16 @@ bool MasmParser::emitStructValues(const StructInfo &Structure,
       return true;
   }
 
-  if (Count) 
-    *Count = Initializers.size(); 
+  if (Count)
+    *Count = Initializers.size();
   return false;
 }
 
 // Declare a field in the current struct.
 bool MasmParser::addStructField(StringRef Name, const StructInfo &Structure) {
   StructInfo &OwningStruct = StructInProgress.back();
-  FieldInfo &Field = 
-      OwningStruct.addField(Name, FT_STRUCT, Structure.AlignmentSize); 
+  FieldInfo &Field =
+      OwningStruct.addField(Name, FT_STRUCT, Structure.AlignmentSize);
   StructFieldInfo &StructInfo = Field.Contents.StructInfo;
 
   StructInfo.Structure = Structure;
@@ -4260,15 +4260,15 @@ bool MasmParser::parseDirectiveNamedStructValue(const StructInfo &Structure,
     // Initialize named data value.
     MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     getStreamer().emitLabel(Sym);
-    unsigned Count; 
-    if (emitStructValues(Structure, &Count)) 
+    unsigned Count;
+    if (emitStructValues(Structure, &Count))
       return true;
-    AsmTypeInfo Type; 
-    Type.Name = Structure.Name; 
-    Type.Size = Structure.Size * Count; 
-    Type.ElementSize = Structure.Size; 
-    Type.Length = Count; 
-    KnownType[Name.lower()] = Type; 
+    AsmTypeInfo Type;
+    Type.Name = Structure.Name;
+    Type.Size = Structure.Size * Count;
+    Type.ElementSize = Structure.Size;
+    Type.Length = Count;
+    KnownType[Name.lower()] = Type;
   } else if (addStructField(Name, Structure)) {
     return addErrorSuffix(" in '" + Twine(Directive) + "' directive");
   }
@@ -4337,9 +4337,9 @@ bool MasmParser::parseDirectiveNestedStruct(StringRef Directive,
   if (parseToken(AsmToken::EndOfStatement))
     return addErrorSuffix(" in '" + Twine(Directive) + "' directive");
 
-  // Reserve space to ensure Alignment doesn't get invalidated when 
-  // StructInProgress grows. 
-  StructInProgress.reserve(StructInProgress.size() + 1); 
+  // Reserve space to ensure Alignment doesn't get invalidated when
+  // StructInProgress grows.
+  StructInProgress.reserve(StructInProgress.size() + 1);
   StructInProgress.emplace_back(Name, DirKind == DK_UNION,
                                 StructInProgress.back().Alignment);
   return false;
@@ -4354,10 +4354,10 @@ bool MasmParser::parseDirectiveEnds(StringRef Name, SMLoc NameLoc) {
     return Error(NameLoc, "mismatched name in ENDS directive; expected '" +
                               StructInProgress.back().Name + "'");
   StructInfo Structure = StructInProgress.pop_back_val();
-  // Pad to make the structure's size divisible by the smaller of its alignment 
-  // and the size of its largest field. 
-  Structure.Size = llvm::alignTo( 
-      Structure.Size, std::min(Structure.Alignment, Structure.AlignmentSize)); 
+  // Pad to make the structure's size divisible by the smaller of its alignment
+  // and the size of its largest field.
+  Structure.Size = llvm::alignTo(
+      Structure.Size, std::min(Structure.Alignment, Structure.AlignmentSize));
   Structs[Name.lower()] = Structure;
 
   if (parseToken(AsmToken::EndOfStatement))
@@ -4402,8 +4402,8 @@ bool MasmParser::parseDirectiveNestedEnds() {
     else
       ParentStruct.Size += Structure.Size;
   } else {
-    FieldInfo &Field = ParentStruct.addField(Structure.Name, FT_STRUCT, 
-                                             Structure.AlignmentSize); 
+    FieldInfo &Field = ParentStruct.addField(Structure.Name, FT_STRUCT,
+                                             Structure.AlignmentSize);
     StructFieldInfo &StructInfo = Field.Contents.StructInfo;
     Field.Type = Structure.Size;
     Field.LengthOf = 1;
@@ -5476,59 +5476,59 @@ bool MasmParser::parseDirectiveCFIUndefined(SMLoc DirectiveLoc) {
 }
 
 /// parseDirectiveMacro
-/// ::= name macro [parameters] 
-///     ["LOCAL" identifiers] 
-///   parameters ::= parameter [, parameter]* 
-///   parameter ::= name ":" qualifier 
-///   qualifier ::= "req" | "vararg" | "=" macro_argument 
-bool MasmParser::parseDirectiveMacro(StringRef Name, SMLoc NameLoc) { 
+/// ::= name macro [parameters]
+///     ["LOCAL" identifiers]
+///   parameters ::= parameter [, parameter]*
+///   parameter ::= name ":" qualifier
+///   qualifier ::= "req" | "vararg" | "=" macro_argument
+bool MasmParser::parseDirectiveMacro(StringRef Name, SMLoc NameLoc) {
   MCAsmMacroParameters Parameters;
   while (getLexer().isNot(AsmToken::EndOfStatement)) {
     if (!Parameters.empty() && Parameters.back().Vararg)
       return Error(Lexer.getLoc(),
                    "Vararg parameter '" + Parameters.back().Name +
-                       "' should be last in the list of parameters"); 
+                       "' should be last in the list of parameters");
 
     MCAsmMacroParameter Parameter;
     if (parseIdentifier(Parameter.Name))
-      return TokError("expected identifier in 'macro' directive"); 
+      return TokError("expected identifier in 'macro' directive");
 
     // Emit an error if two (or more) named parameters share the same name.
     for (const MCAsmMacroParameter& CurrParam : Parameters)
-      if (CurrParam.Name.equals_lower(Parameter.Name)) 
+      if (CurrParam.Name.equals_lower(Parameter.Name))
         return TokError("macro '" + Name + "' has multiple parameters"
                         " named '" + Parameter.Name + "'");
 
     if (Lexer.is(AsmToken::Colon)) {
       Lex();  // consume ':'
 
-      if (parseOptionalToken(AsmToken::Equal)) { 
-        // Default value 
-        SMLoc ParamLoc; 
-
-        ParamLoc = Lexer.getLoc(); 
-        if (parseMacroArgument(nullptr, Parameter.Value)) 
-          return true; 
-      } else { 
-        SMLoc QualLoc; 
-        StringRef Qualifier; 
-
-        QualLoc = Lexer.getLoc(); 
-        if (parseIdentifier(Qualifier)) 
-          return Error(QualLoc, "missing parameter qualifier for " 
-                                "'" + 
-                                    Parameter.Name + "' in macro '" + Name + 
-                                    "'"); 
-
-        if (Qualifier.equals_lower("req")) 
-          Parameter.Required = true; 
-        else if (Qualifier.equals_lower("vararg")) 
-          Parameter.Vararg = true; 
-        else 
-          return Error(QualLoc, 
-                       Qualifier + " is not a valid parameter qualifier for '" + 
-                           Parameter.Name + "' in macro '" + Name + "'"); 
-      } 
+      if (parseOptionalToken(AsmToken::Equal)) {
+        // Default value
+        SMLoc ParamLoc;
+
+        ParamLoc = Lexer.getLoc();
+        if (parseMacroArgument(nullptr, Parameter.Value))
+          return true;
+      } else {
+        SMLoc QualLoc;
+        StringRef Qualifier;
+
+        QualLoc = Lexer.getLoc();
+        if (parseIdentifier(Qualifier))
+          return Error(QualLoc, "missing parameter qualifier for "
+                                "'" +
+                                    Parameter.Name + "' in macro '" + Name +
+                                    "'");
+
+        if (Qualifier.equals_lower("req"))
+          Parameter.Required = true;
+        else if (Qualifier.equals_lower("vararg"))
+          Parameter.Vararg = true;
+        else
+          return Error(QualLoc,
+                       Qualifier + " is not a valid parameter qualifier for '" +
+                           Parameter.Name + "' in macro '" + Name + "'");
+      }
     }
 
     Parameters.push_back(std::move(Parameter));
@@ -5540,28 +5540,28 @@ bool MasmParser::parseDirectiveMacro(StringRef Name, SMLoc NameLoc) {
   // Eat just the end of statement.
   Lexer.Lex();
 
-  std::vector<std::string> Locals; 
-  if (getTok().is(AsmToken::Identifier) && 
-      getTok().getIdentifier().equals_lower("local")) { 
-    Lex(); // Eat the LOCAL directive. 
- 
-    StringRef ID; 
-    while (true) { 
-      if (parseIdentifier(ID)) 
-        return true; 
-      Locals.push_back(ID.lower()); 
- 
-      // If we see a comma, continue (and allow line continuation). 
-      if (!parseOptionalToken(AsmToken::Comma)) 
-        break; 
-      parseOptionalToken(AsmToken::EndOfStatement); 
-    } 
-  } 
- 
+  std::vector<std::string> Locals;
+  if (getTok().is(AsmToken::Identifier) &&
+      getTok().getIdentifier().equals_lower("local")) {
+    Lex(); // Eat the LOCAL directive.
+
+    StringRef ID;
+    while (true) {
+      if (parseIdentifier(ID))
+        return true;
+      Locals.push_back(ID.lower());
+
+      // If we see a comma, continue (and allow line continuation).
+      if (!parseOptionalToken(AsmToken::Comma))
+        break;
+      parseOptionalToken(AsmToken::EndOfStatement);
+    }
+  }
+
   // Consuming deferred text, so use Lexer.Lex to ignore Lexing Errors.
   AsmToken EndToken, StartToken = getTok();
   unsigned MacroDepth = 0;
-  bool IsMacroFunction = false; 
+  bool IsMacroFunction = false;
   // Lex the macro definition.
   while (true) {
     // Ignore Lexing errors in macros.
@@ -5571,12 +5571,12 @@ bool MasmParser::parseDirectiveMacro(StringRef Name, SMLoc NameLoc) {
 
     // Check whether we have reached the end of the file.
     if (getLexer().is(AsmToken::Eof))
-      return Error(NameLoc, "no matching 'endm' in definition"); 
+      return Error(NameLoc, "no matching 'endm' in definition");
 
-    // Otherwise, check whether we have reached the 'endm'... and determine if 
-    // this is a macro function. 
+    // Otherwise, check whether we have reached the 'endm'... and determine if
+    // this is a macro function.
     if (getLexer().is(AsmToken::Identifier)) {
-      if (getTok().getIdentifier().equals_lower("endm")) { 
+      if (getTok().getIdentifier().equals_lower("endm")) {
         if (MacroDepth == 0) { // Outermost macro.
           EndToken = getTok();
           Lexer.Lex();
@@ -5588,14 +5588,14 @@ bool MasmParser::parseDirectiveMacro(StringRef Name, SMLoc NameLoc) {
           // Otherwise we just found the end of an inner macro.
           --MacroDepth;
         }
-      } else if (getTok().getIdentifier().equals_lower("exitm")) { 
-        if (MacroDepth == 0 && 
-            getLexer().peekTok().isNot(AsmToken::EndOfStatement)) { 
-          IsMacroFunction = true; 
-        } 
-      } else if (isMacroLikeDirective()) { 
-        // We allow nested macros. Those aren't instantiated until the 
-        // outermost macro is expanded so just ignore them for now. 
+      } else if (getTok().getIdentifier().equals_lower("exitm")) {
+        if (MacroDepth == 0 &&
+            getLexer().peekTok().isNot(AsmToken::EndOfStatement)) {
+          IsMacroFunction = true;
+        }
+      } else if (isMacroLikeDirective()) {
+        // We allow nested macros. Those aren't instantiated until the
+        // outermost macro is expanded so just ignore them for now.
         ++MacroDepth;
       }
     }
@@ -5604,15 +5604,15 @@ bool MasmParser::parseDirectiveMacro(StringRef Name, SMLoc NameLoc) {
     eatToEndOfStatement();
   }
 
-  if (getContext().lookupMacro(Name.lower())) { 
-    return Error(NameLoc, "macro '" + Name + "' is already defined"); 
+  if (getContext().lookupMacro(Name.lower())) {
+    return Error(NameLoc, "macro '" + Name + "' is already defined");
   }
 
   const char *BodyStart = StartToken.getLoc().getPointer();
   const char *BodyEnd = EndToken.getLoc().getPointer();
   StringRef Body = StringRef(BodyStart, BodyEnd - BodyStart);
-  MCAsmMacro Macro(Name, Body, std::move(Parameters), std::move(Locals), 
-                   IsMacroFunction); 
+  MCAsmMacro Macro(Name, Body, std::move(Parameters), std::move(Locals),
+                   IsMacroFunction);
   DEBUG_WITH_TYPE("asm-macros", dbgs() << "Defining new macro:\n";
                   Macro.dump());
   getContext().defineMacro(Name, std::move(Macro));
@@ -5620,15 +5620,15 @@ bool MasmParser::parseDirectiveMacro(StringRef Name, SMLoc NameLoc) {
 }
 
 /// parseDirectiveExitMacro
-/// ::= "exitm" [textitem] 
-bool MasmParser::parseDirectiveExitMacro(SMLoc DirectiveLoc, 
-                                         StringRef Directive, 
-                                         std::string &Value) { 
-  SMLoc EndLoc = getTok().getLoc(); 
-  if (getTok().isNot(AsmToken::EndOfStatement) && parseTextItem(Value)) 
-    return Error(EndLoc, 
-                 "unable to parse text item in '" + Directive + "' directive"); 
-  eatToEndOfStatement(); 
+/// ::= "exitm" [textitem]
+bool MasmParser::parseDirectiveExitMacro(SMLoc DirectiveLoc,
+                                         StringRef Directive,
+                                         std::string &Value) {
+  SMLoc EndLoc = getTok().getLoc();
+  if (getTok().isNot(AsmToken::EndOfStatement) && parseTextItem(Value))
+    return Error(EndLoc,
+                 "unable to parse text item in '" + Directive + "' directive");
+  eatToEndOfStatement();
 
   if (!isInsideMacroInstantiation())
     return TokError("unexpected '" + Directive + "' in file, "
@@ -5645,7 +5645,7 @@ bool MasmParser::parseDirectiveExitMacro(SMLoc DirectiveLoc,
 }
 
 /// parseDirectiveEndMacro
-/// ::= endm 
+/// ::= endm
 bool MasmParser::parseDirectiveEndMacro(StringRef Directive) {
   if (getLexer().isNot(AsmToken::EndOfStatement))
     return TokError("unexpected token in '" + Directive + "' directive");
@@ -5664,27 +5664,27 @@ bool MasmParser::parseDirectiveEndMacro(StringRef Directive) {
 }
 
 /// parseDirectivePurgeMacro
-/// ::= purge identifier ( , identifier )* 
+/// ::= purge identifier ( , identifier )*
 bool MasmParser::parseDirectivePurgeMacro(SMLoc DirectiveLoc) {
   StringRef Name;
-  while (true) { 
-    SMLoc NameLoc; 
-    if (parseTokenLoc(NameLoc) || 
-        check(parseIdentifier(Name), NameLoc, 
-              "expected identifier in 'purge' directive")) 
-      return true; 
-
-    DEBUG_WITH_TYPE("asm-macros", dbgs() 
-                                      << "Un-defining macro: " << Name << "\n"); 
-    if (!getContext().lookupMacro(Name.lower())) 
-      return Error(NameLoc, "macro '" + Name + "' is not defined"); 
-    getContext().undefineMacro(Name.lower()); 
-
-    if (!parseOptionalToken(AsmToken::Comma)) 
-      break; 
-    parseOptionalToken(AsmToken::EndOfStatement); 
-  } 
- 
+  while (true) {
+    SMLoc NameLoc;
+    if (parseTokenLoc(NameLoc) ||
+        check(parseIdentifier(Name), NameLoc,
+              "expected identifier in 'purge' directive"))
+      return true;
+
+    DEBUG_WITH_TYPE("asm-macros", dbgs()
+                                      << "Un-defining macro: " << Name << "\n");
+    if (!getContext().lookupMacro(Name.lower()))
+      return Error(NameLoc, "macro '" + Name + "' is not defined");
+    getContext().undefineMacro(Name.lower());
+
+    if (!parseOptionalToken(AsmToken::Comma))
+      break;
+    parseOptionalToken(AsmToken::EndOfStatement);
+  }
+
   return false;
 }
 
@@ -5792,17 +5792,17 @@ bool MasmParser::parseDirectiveComm(bool IsLocal) {
 ///              [[text]]
 ///              [[text]] delimiter [[text]]
 bool MasmParser::parseDirectiveComment(SMLoc DirectiveLoc) {
-  std::string FirstLine = parseStringTo(AsmToken::EndOfStatement); 
+  std::string FirstLine = parseStringTo(AsmToken::EndOfStatement);
   size_t DelimiterEnd = FirstLine.find_first_of("\b\t\v\f\r\x1A ");
-  StringRef Delimiter = StringRef(FirstLine).take_front(DelimiterEnd); 
+  StringRef Delimiter = StringRef(FirstLine).take_front(DelimiterEnd);
   if (Delimiter.empty())
     return Error(DirectiveLoc, "no delimiter in 'comment' directive");
   do {
     if (getTok().is(AsmToken::Eof))
       return Error(DirectiveLoc, "unmatched delimiter in 'comment' directive");
     Lex();  // eat end of statement
-  } while ( 
-      !StringRef(parseStringTo(AsmToken::EndOfStatement)).contains(Delimiter)); 
+  } while (
+      !StringRef(parseStringTo(AsmToken::EndOfStatement)).contains(Delimiter));
   return parseToken(AsmToken::EndOfStatement,
                     "unexpected token in 'comment' directive");
 }
@@ -5816,7 +5816,7 @@ bool MasmParser::parseDirectiveInclude() {
   SMLoc IncludeLoc = getTok().getLoc();
 
   if (!parseAngleBracketString(Filename))
-    Filename = parseStringTo(AsmToken::EndOfStatement); 
+    Filename = parseStringTo(AsmToken::EndOfStatement);
   if (check(!Filename.empty(), "missing filename in 'include' directive") ||
       check(getTok().isNot(AsmToken::EndOfStatement),
             "unexpected token in 'include' directive") ||
@@ -5861,7 +5861,7 @@ bool MasmParser::parseDirectiveIf(SMLoc DirectiveLoc, DirectiveKind DirKind) {
 }
 
 /// parseDirectiveIfb
-/// ::= .ifb textitem 
+/// ::= .ifb textitem
 bool MasmParser::parseDirectiveIfb(SMLoc DirectiveLoc, bool ExpectBlank) {
   TheCondStack.push_back(TheCondState);
   TheCondState.TheCond = AsmCond::IfCond;
@@ -5871,7 +5871,7 @@ bool MasmParser::parseDirectiveIfb(SMLoc DirectiveLoc, bool ExpectBlank) {
   } else {
     std::string Str;
     if (parseTextItem(Str))
-      return TokError("expected text item parameter for 'ifb' directive"); 
+      return TokError("expected text item parameter for 'ifb' directive");
 
     if (parseToken(AsmToken::EndOfStatement,
                    "unexpected token in 'ifb' directive"))
@@ -5885,15 +5885,15 @@ bool MasmParser::parseDirectiveIfb(SMLoc DirectiveLoc, bool ExpectBlank) {
 }
 
 /// parseDirectiveIfidn
-///   ::= ifidn textitem, textitem 
-bool MasmParser::parseDirectiveIfidn(SMLoc DirectiveLoc, bool ExpectEqual, 
-                                     bool CaseInsensitive) { 
+///   ::= ifidn textitem, textitem
+bool MasmParser::parseDirectiveIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
+                                     bool CaseInsensitive) {
   std::string String1, String2;
 
   if (parseTextItem(String1)) {
     if (ExpectEqual)
-      return TokError("expected text item parameter for 'ifidn' directive"); 
-    return TokError("expected text item parameter for 'ifdif' directive"); 
+      return TokError("expected text item parameter for 'ifidn' directive");
+    return TokError("expected text item parameter for 'ifdif' directive");
   }
 
   if (Lexer.isNot(AsmToken::Comma)) {
@@ -5906,8 +5906,8 @@ bool MasmParser::parseDirectiveIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
 
   if (parseTextItem(String2)) {
     if (ExpectEqual)
-      return TokError("expected text item parameter for 'ifidn' directive"); 
-    return TokError("expected text item parameter for 'ifdif' directive"); 
+      return TokError("expected text item parameter for 'ifidn' directive");
+    return TokError("expected text item parameter for 'ifdif' directive");
   }
 
   TheCondStack.push_back(TheCondState);
@@ -6001,7 +6001,7 @@ bool MasmParser::parseDirectiveElseIf(SMLoc DirectiveLoc,
 }
 
 /// parseDirectiveElseIfb
-/// ::= elseifb textitem 
+/// ::= elseifb textitem
 bool MasmParser::parseDirectiveElseIfb(SMLoc DirectiveLoc, bool ExpectBlank) {
   if (TheCondState.TheCond != AsmCond::IfCond &&
       TheCondState.TheCond != AsmCond::ElseIfCond)
@@ -6017,11 +6017,11 @@ bool MasmParser::parseDirectiveElseIfb(SMLoc DirectiveLoc, bool ExpectBlank) {
     eatToEndOfStatement();
   } else {
     std::string Str;
-    if (parseTextItem(Str)) { 
-      if (ExpectBlank) 
-        return TokError("expected text item parameter for 'elseifb' directive"); 
-      return TokError("expected text item parameter for 'elseifnb' directive"); 
-    } 
+    if (parseTextItem(Str)) {
+      if (ExpectBlank)
+        return TokError("expected text item parameter for 'elseifb' directive");
+      return TokError("expected text item parameter for 'elseifnb' directive");
+    }
 
     if (parseToken(AsmToken::EndOfStatement,
                    "unexpected token in 'elseifb' directive"))
@@ -6081,7 +6081,7 @@ bool MasmParser::parseDirectiveElseIfdef(SMLoc DirectiveLoc,
 }
 
 /// parseDirectiveElseIfidn
-/// ::= elseifidn textitem, textitem 
+/// ::= elseifidn textitem, textitem
 bool MasmParser::parseDirectiveElseIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
                                          bool CaseInsensitive) {
   if (TheCondState.TheCond != AsmCond::IfCond &&
@@ -6101,9 +6101,9 @@ bool MasmParser::parseDirectiveElseIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
 
     if (parseTextItem(String1)) {
       if (ExpectEqual)
-        return TokError( 
-            "expected text item parameter for 'elseifidn' directive"); 
-      return TokError("expected text item parameter for 'elseifdif' directive"); 
+        return TokError(
+            "expected text item parameter for 'elseifidn' directive");
+      return TokError("expected text item parameter for 'elseifdif' directive");
     }
 
     if (Lexer.isNot(AsmToken::Comma)) {
@@ -6117,9 +6117,9 @@ bool MasmParser::parseDirectiveElseIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
 
     if (parseTextItem(String2)) {
       if (ExpectEqual)
-        return TokError( 
-            "expected text item parameter for 'elseifidn' directive"); 
-      return TokError("expected text item parameter for 'elseifdif' directive"); 
+        return TokError(
+            "expected text item parameter for 'elseifidn' directive");
+      return TokError("expected text item parameter for 'elseifdif' directive");
     }
 
     if (CaseInsensitive)
@@ -6179,9 +6179,9 @@ bool MasmParser::parseDirectiveError(SMLoc DirectiveLoc) {
     }
   }
 
-  std::string Message = ".err directive invoked in source file"; 
+  std::string Message = ".err directive invoked in source file";
   if (Lexer.isNot(AsmToken::EndOfStatement))
-    Message = parseStringTo(AsmToken::EndOfStatement); 
+    Message = parseStringTo(AsmToken::EndOfStatement);
   Lex();
 
   return Error(DirectiveLoc, Message);
@@ -6201,11 +6201,11 @@ bool MasmParser::parseDirectiveErrorIfb(SMLoc DirectiveLoc, bool ExpectBlank) {
   if (parseTextItem(Text))
     return Error(getTok().getLoc(), "missing text item in '.errb' directive");
 
-  std::string Message = ".errb directive invoked in source file"; 
+  std::string Message = ".errb directive invoked in source file";
   if (Lexer.isNot(AsmToken::EndOfStatement)) {
     if (parseToken(AsmToken::Comma))
       return addErrorSuffix(" in '.errb' directive");
-    Message = parseStringTo(AsmToken::EndOfStatement); 
+    Message = parseStringTo(AsmToken::EndOfStatement);
   }
   Lex();
 
@@ -6243,11 +6243,11 @@ bool MasmParser::parseDirectiveErrorIfdef(SMLoc DirectiveLoc,
     }
   }
 
-  std::string Message = ".errdef directive invoked in source file"; 
+  std::string Message = ".errdef directive invoked in source file";
   if (Lexer.isNot(AsmToken::EndOfStatement)) {
     if (parseToken(AsmToken::Comma))
       return addErrorSuffix(" in '.errdef' directive");
-    Message = parseStringTo(AsmToken::EndOfStatement); 
+    Message = parseStringTo(AsmToken::EndOfStatement);
   }
   Lex();
 
@@ -6257,7 +6257,7 @@ bool MasmParser::parseDirectiveErrorIfdef(SMLoc DirectiveLoc,
 }
 
 /// parseDirectiveErrorIfidn
-///   ::= .erridn textitem, textitem[, message] 
+///   ::= .erridn textitem, textitem[, message]
 bool MasmParser::parseDirectiveErrorIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
                                           bool CaseInsensitive) {
   if (!TheCondStack.empty()) {
@@ -6290,7 +6290,7 @@ bool MasmParser::parseDirectiveErrorIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
     return TokError("expected string parameter for '.errdif' directive");
   }
 
-  std::string Message; 
+  std::string Message;
   if (ExpectEqual)
     Message = ".erridn directive invoked in source file";
   else
@@ -6298,7 +6298,7 @@ bool MasmParser::parseDirectiveErrorIfidn(SMLoc DirectiveLoc, bool ExpectEqual,
   if (Lexer.isNot(AsmToken::EndOfStatement)) {
     if (parseToken(AsmToken::Comma))
       return addErrorSuffix(" in '.erridn' directive");
-    Message = parseStringTo(AsmToken::EndOfStatement); 
+    Message = parseStringTo(AsmToken::EndOfStatement);
   }
   Lex();
 
@@ -6330,11 +6330,11 @@ bool MasmParser::parseDirectiveErrorIfe(SMLoc DirectiveLoc, bool ExpectZero) {
   if (parseAbsoluteExpression(ExprValue))
     return addErrorSuffix(" in '.erre' directive");
 
-  std::string Message = ".erre directive invoked in source file"; 
+  std::string Message = ".erre directive invoked in source file";
   if (Lexer.isNot(AsmToken::EndOfStatement)) {
     if (parseToken(AsmToken::Comma))
       return addErrorSuffix(" in '.erre' directive");
-    Message = parseStringTo(AsmToken::EndOfStatement); 
+    Message = parseStringTo(AsmToken::EndOfStatement);
   }
   Lex();
 
@@ -6379,7 +6379,7 @@ void MasmParser::initializeDirectiveKindMap() {
   DirectiveKindMap["sqword"] = DK_SQWORD;
   DirectiveKindMap["real4"] = DK_REAL4;
   DirectiveKindMap["real8"] = DK_REAL8;
-  DirectiveKindMap["real10"] = DK_REAL10; 
+  DirectiveKindMap["real10"] = DK_REAL10;
   DirectiveKindMap["align"] = DK_ALIGN;
   // DirectiveKindMap[".org"] = DK_ORG;
   DirectiveKindMap["extern"] = DK_EXTERN;
@@ -6387,13 +6387,13 @@ void MasmParser::initializeDirectiveKindMap() {
   // DirectiveKindMap[".comm"] = DK_COMM;
   DirectiveKindMap["comment"] = DK_COMMENT;
   DirectiveKindMap["include"] = DK_INCLUDE;
-  DirectiveKindMap["repeat"] = DK_REPEAT; 
-  DirectiveKindMap["rept"] = DK_REPEAT; 
-  DirectiveKindMap["while"] = DK_WHILE; 
-  DirectiveKindMap["for"] = DK_FOR; 
-  DirectiveKindMap["irp"] = DK_FOR; 
-  DirectiveKindMap["forc"] = DK_FORC; 
-  DirectiveKindMap["irpc"] = DK_FORC; 
+  DirectiveKindMap["repeat"] = DK_REPEAT;
+  DirectiveKindMap["rept"] = DK_REPEAT;
+  DirectiveKindMap["while"] = DK_WHILE;
+  DirectiveKindMap["for"] = DK_FOR;
+  DirectiveKindMap["irp"] = DK_FOR;
+  DirectiveKindMap["forc"] = DK_FORC;
+  DirectiveKindMap["irpc"] = DK_FORC;
   DirectiveKindMap["if"] = DK_IF;
   DirectiveKindMap["ife"] = DK_IFE;
   DirectiveKindMap["ifb"] = DK_IFB;
@@ -6450,10 +6450,10 @@ void MasmParser::initializeDirectiveKindMap() {
   // DirectiveKindMap[".cfi_register"] = DK_CFI_REGISTER;
   // DirectiveKindMap[".cfi_window_save"] = DK_CFI_WINDOW_SAVE;
   // DirectiveKindMap[".cfi_b_key_frame"] = DK_CFI_B_KEY_FRAME;
-  DirectiveKindMap["macro"] = DK_MACRO; 
-  DirectiveKindMap["exitm"] = DK_EXITM; 
-  DirectiveKindMap["endm"] = DK_ENDM; 
-  DirectiveKindMap["purge"] = DK_PURGE; 
+  DirectiveKindMap["macro"] = DK_MACRO;
+  DirectiveKindMap["exitm"] = DK_EXITM;
+  DirectiveKindMap["endm"] = DK_ENDM;
+  DirectiveKindMap["purge"] = DK_PURGE;
   DirectiveKindMap[".err"] = DK_ERR;
   DirectiveKindMap[".errb"] = DK_ERRB;
   DirectiveKindMap[".errnb"] = DK_ERRNB;
@@ -6465,15 +6465,15 @@ void MasmParser::initializeDirectiveKindMap() {
   DirectiveKindMap[".erridni"] = DK_ERRIDNI;
   DirectiveKindMap[".erre"] = DK_ERRE;
   DirectiveKindMap[".errnz"] = DK_ERRNZ;
-  DirectiveKindMap[".pushframe"] = DK_PUSHFRAME; 
-  DirectiveKindMap[".pushreg"] = DK_PUSHREG; 
-  DirectiveKindMap[".savereg"] = DK_SAVEREG; 
-  DirectiveKindMap[".savexmm128"] = DK_SAVEXMM128; 
-  DirectiveKindMap[".setframe"] = DK_SETFRAME; 
-  DirectiveKindMap[".radix"] = DK_RADIX; 
+  DirectiveKindMap[".pushframe"] = DK_PUSHFRAME;
+  DirectiveKindMap[".pushreg"] = DK_PUSHREG;
+  DirectiveKindMap[".savereg"] = DK_SAVEREG;
+  DirectiveKindMap[".savexmm128"] = DK_SAVEXMM128;
+  DirectiveKindMap[".setframe"] = DK_SETFRAME;
+  DirectiveKindMap[".radix"] = DK_RADIX;
   DirectiveKindMap["db"] = DK_DB;
   DirectiveKindMap["dd"] = DK_DD;
-  DirectiveKindMap["df"] = DK_DF; 
+  DirectiveKindMap["df"] = DK_DF;
   DirectiveKindMap["dq"] = DK_DQ;
   DirectiveKindMap["dw"] = DK_DW;
   DirectiveKindMap["echo"] = DK_ECHO;
@@ -6483,24 +6483,24 @@ void MasmParser::initializeDirectiveKindMap() {
   DirectiveKindMap["ends"] = DK_ENDS;
 }
 
-bool MasmParser::isMacroLikeDirective() { 
-  if (getLexer().is(AsmToken::Identifier)) { 
-    bool IsMacroLike = StringSwitch<bool>(getTok().getIdentifier()) 
-                           .CasesLower("repeat", "rept", true) 
-                           .CaseLower("while", true) 
-                           .CasesLower("for", "irp", true) 
-                           .CasesLower("forc", "irpc", true) 
-                           .Default(false); 
-    if (IsMacroLike) 
-      return true; 
-  } 
-  if (getLexer().peekTok().is(AsmToken::Identifier) && 
-      getLexer().peekTok().getIdentifier().equals_lower("macro")) 
-    return true; 
- 
-  return false; 
-} 
- 
+bool MasmParser::isMacroLikeDirective() {
+  if (getLexer().is(AsmToken::Identifier)) {
+    bool IsMacroLike = StringSwitch<bool>(getTok().getIdentifier())
+                           .CasesLower("repeat", "rept", true)
+                           .CaseLower("while", true)
+                           .CasesLower("for", "irp", true)
+                           .CasesLower("forc", "irpc", true)
+                           .Default(false);
+    if (IsMacroLike)
+      return true;
+  }
+  if (getLexer().peekTok().is(AsmToken::Identifier) &&
+      getLexer().peekTok().getIdentifier().equals_lower("macro"))
+    return true;
+
+  return false;
+}
+
 MCAsmMacro *MasmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
   AsmToken EndToken, StartToken = getTok();
 
@@ -6508,21 +6508,21 @@ MCAsmMacro *MasmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
   while (true) {
     // Check whether we have reached the end of the file.
     if (getLexer().is(AsmToken::Eof)) {
-      printError(DirectiveLoc, "no matching 'endm' in definition"); 
+      printError(DirectiveLoc, "no matching 'endm' in definition");
       return nullptr;
     }
 
-    if (isMacroLikeDirective()) 
+    if (isMacroLikeDirective())
       ++NestLevel;
 
-    // Otherwise, check whether we have reached the endm. 
-    if (Lexer.is(AsmToken::Identifier) && 
-        getTok().getIdentifier().equals_lower("endm")) { 
+    // Otherwise, check whether we have reached the endm.
+    if (Lexer.is(AsmToken::Identifier) &&
+        getTok().getIdentifier().equals_lower("endm")) {
       if (NestLevel == 0) {
         EndToken = getTok();
         Lex();
         if (Lexer.isNot(AsmToken::EndOfStatement)) {
-          printError(getTok().getLoc(), "unexpected token in 'endm' directive"); 
+          printError(getTok().getLoc(), "unexpected token in 'endm' directive");
           return nullptr;
         }
         break;
@@ -6543,73 +6543,73 @@ MCAsmMacro *MasmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
   return &MacroLikeBodies.back();
 }
 
-bool MasmParser::expandStatement(SMLoc Loc) { 
-  std::string Body = parseStringTo(AsmToken::EndOfStatement); 
-  SMLoc EndLoc = getTok().getLoc(); 
- 
-  MCAsmMacroParameters Parameters; 
-  MCAsmMacroArguments Arguments; 
-  for (const auto &V : Variables) { 
-    const Variable &Var = V.getValue(); 
-    if (Var.IsText) { 
-      Parameters.emplace_back(); 
-      Arguments.emplace_back(); 
-      MCAsmMacroParameter &P = Parameters.back(); 
-      MCAsmMacroArgument &A = Arguments.back(); 
-      P.Name = Var.Name; 
-      P.Required = true; 
-      A.push_back(AsmToken(AsmToken::String, Var.TextValue)); 
-    } 
-  } 
-  MacroLikeBodies.emplace_back(StringRef(), Body, Parameters); 
-  MCAsmMacro M = MacroLikeBodies.back(); 
- 
-  // Expand the statement in a new buffer. 
-  SmallString<80> Buf; 
-  raw_svector_ostream OS(Buf); 
-  if (expandMacro(OS, M.Body, M.Parameters, Arguments, M.Locals, EndLoc)) 
-    return true; 
-  std::unique_ptr<MemoryBuffer> Expansion = 
-      MemoryBuffer::getMemBufferCopy(OS.str(), "<expansion>"); 
- 
-  // Jump to the expanded statement and prime the lexer. 
-  CurBuffer = SrcMgr.AddNewSourceBuffer(std::move(Expansion), EndLoc); 
-  Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer()); 
-  EndStatementAtEOFStack.push_back(false); 
-  Lex(); 
-  return false; 
-} 
- 
+bool MasmParser::expandStatement(SMLoc Loc) {
+  std::string Body = parseStringTo(AsmToken::EndOfStatement);
+  SMLoc EndLoc = getTok().getLoc();
+
+  MCAsmMacroParameters Parameters;
+  MCAsmMacroArguments Arguments;
+  for (const auto &V : Variables) {
+    const Variable &Var = V.getValue();
+    if (Var.IsText) {
+      Parameters.emplace_back();
+      Arguments.emplace_back();
+      MCAsmMacroParameter &P = Parameters.back();
+      MCAsmMacroArgument &A = Arguments.back();
+      P.Name = Var.Name;
+      P.Required = true;
+      A.push_back(AsmToken(AsmToken::String, Var.TextValue));
+    }
+  }
+  MacroLikeBodies.emplace_back(StringRef(), Body, Parameters);
+  MCAsmMacro M = MacroLikeBodies.back();
+
+  // Expand the statement in a new buffer.
+  SmallString<80> Buf;
+  raw_svector_ostream OS(Buf);
+  if (expandMacro(OS, M.Body, M.Parameters, Arguments, M.Locals, EndLoc))
+    return true;
+  std::unique_ptr<MemoryBuffer> Expansion =
+      MemoryBuffer::getMemBufferCopy(OS.str(), "<expansion>");
+
+  // Jump to the expanded statement and prime the lexer.
+  CurBuffer = SrcMgr.AddNewSourceBuffer(std::move(Expansion), EndLoc);
+  Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
+  EndStatementAtEOFStack.push_back(false);
+  Lex();
+  return false;
+}
+
+void MasmParser::instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,
+                                          raw_svector_ostream &OS) {
+  instantiateMacroLikeBody(M, DirectiveLoc, /*ExitLoc=*/getTok().getLoc(), OS);
+}
 void MasmParser::instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc,
+                                          SMLoc ExitLoc,
                                           raw_svector_ostream &OS) {
-  instantiateMacroLikeBody(M, DirectiveLoc, /*ExitLoc=*/getTok().getLoc(), OS); 
-} 
-void MasmParser::instantiateMacroLikeBody(MCAsmMacro *M, SMLoc DirectiveLoc, 
-                                          SMLoc ExitLoc, 
-                                          raw_svector_ostream &OS) { 
-  OS << "endm\n"; 
+  OS << "endm\n";
 
   std::unique_ptr<MemoryBuffer> Instantiation =
       MemoryBuffer::getMemBufferCopy(OS.str(), "<instantiation>");
 
   // Create the macro instantiation object and add to the current macro
   // instantiation stack.
-  MacroInstantiation *MI = new MacroInstantiation{DirectiveLoc, CurBuffer, 
-                                                  ExitLoc, TheCondStack.size()}; 
+  MacroInstantiation *MI = new MacroInstantiation{DirectiveLoc, CurBuffer,
+                                                  ExitLoc, TheCondStack.size()};
   ActiveMacros.push_back(MI);
 
   // Jump to the macro instantiation and prime the lexer.
   CurBuffer = SrcMgr.AddNewSourceBuffer(std::move(Instantiation), SMLoc());
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
-  EndStatementAtEOFStack.push_back(true); 
+  EndStatementAtEOFStack.push_back(true);
   Lex();
 }
 
-/// parseDirectiveRepeat 
-///   ::= ("repeat" | "rept") count 
-///       body 
-///     endm 
-bool MasmParser::parseDirectiveRepeat(SMLoc DirectiveLoc, StringRef Dir) { 
+/// parseDirectiveRepeat
+///   ::= ("repeat" | "rept") count
+///       body
+///     endm
+bool MasmParser::parseDirectiveRepeat(SMLoc DirectiveLoc, StringRef Dir) {
   const MCExpr *CountExpr;
   SMLoc CountLoc = getTok().getLoc();
   if (parseExpression(CountExpr))
@@ -6625,7 +6625,7 @@ bool MasmParser::parseDirectiveRepeat(SMLoc DirectiveLoc, StringRef Dir) {
                  "unexpected token in '" + Dir + "' directive"))
     return true;
 
-  // Lex the repeat definition. 
+  // Lex the repeat definition.
   MCAsmMacro *M = parseMacroLikeBody(DirectiveLoc);
   if (!M)
     return true;
@@ -6635,7 +6635,7 @@ bool MasmParser::parseDirectiveRepeat(SMLoc DirectiveLoc, StringRef Dir) {
   SmallString<256> Buf;
   raw_svector_ostream OS(Buf);
   while (Count--) {
-    if (expandMacro(OS, M->Body, None, None, M->Locals, getTok().getLoc())) 
+    if (expandMacro(OS, M->Body, None, None, M->Locals, getTok().getLoc()))
       return true;
   }
   instantiateMacroLikeBody(M, DirectiveLoc, OS);
@@ -6643,104 +6643,104 @@ bool MasmParser::parseDirectiveRepeat(SMLoc DirectiveLoc, StringRef Dir) {
   return false;
 }
 
-/// parseDirectiveWhile 
-/// ::= "while" expression 
-///       body 
-///     endm 
-bool MasmParser::parseDirectiveWhile(SMLoc DirectiveLoc) { 
-  const MCExpr *CondExpr; 
-  SMLoc CondLoc = getTok().getLoc(); 
-  if (parseExpression(CondExpr)) 
-    return true; 
- 
-  // Lex the repeat definition. 
-  MCAsmMacro *M = parseMacroLikeBody(DirectiveLoc); 
-  if (!M) 
-    return true; 
- 
-  // Macro instantiation is lexical, unfortunately. We construct a new buffer 
-  // to hold the macro body with substitutions. 
-  SmallString<256> Buf; 
-  raw_svector_ostream OS(Buf); 
-  int64_t Condition; 
-  if (!CondExpr->evaluateAsAbsolute(Condition, getStreamer().getAssemblerPtr())) 
-    return Error(CondLoc, "expected absolute expression in 'while' directive"); 
-  if (Condition) { 
-    // Instantiate the macro, then resume at this directive to recheck the 
-    // condition. 
-    if (expandMacro(OS, M->Body, None, None, M->Locals, getTok().getLoc())) 
-      return true; 
-    instantiateMacroLikeBody(M, DirectiveLoc, /*ExitLoc=*/DirectiveLoc, OS); 
-  } 
- 
-  return false; 
-} 
- 
-/// parseDirectiveFor 
-/// ::= ("for" | "irp") symbol [":" qualifier], <values> 
-///       body 
-///     endm 
-bool MasmParser::parseDirectiveFor(SMLoc DirectiveLoc, StringRef Dir) { 
+/// parseDirectiveWhile
+/// ::= "while" expression
+///       body
+///     endm
+bool MasmParser::parseDirectiveWhile(SMLoc DirectiveLoc) {
+  const MCExpr *CondExpr;
+  SMLoc CondLoc = getTok().getLoc();
+  if (parseExpression(CondExpr))
+    return true;
+
+  // Lex the repeat definition.
+  MCAsmMacro *M = parseMacroLikeBody(DirectiveLoc);
+  if (!M)
+    return true;
+
+  // Macro instantiation is lexical, unfortunately. We construct a new buffer
+  // to hold the macro body with substitutions.
+  SmallString<256> Buf;
+  raw_svector_ostream OS(Buf);
+  int64_t Condition;
+  if (!CondExpr->evaluateAsAbsolute(Condition, getStreamer().getAssemblerPtr()))
+    return Error(CondLoc, "expected absolute expression in 'while' directive");
+  if (Condition) {
+    // Instantiate the macro, then resume at this directive to recheck the
+    // condition.
+    if (expandMacro(OS, M->Body, None, None, M->Locals, getTok().getLoc()))
+      return true;
+    instantiateMacroLikeBody(M, DirectiveLoc, /*ExitLoc=*/DirectiveLoc, OS);
+  }
+
+  return false;
+}
+
+/// parseDirectiveFor
+/// ::= ("for" | "irp") symbol [":" qualifier], <values>
+///       body
+///     endm
+bool MasmParser::parseDirectiveFor(SMLoc DirectiveLoc, StringRef Dir) {
   MCAsmMacroParameter Parameter;
   MCAsmMacroArguments A;
   if (check(parseIdentifier(Parameter.Name),
-            "expected identifier in '" + Dir + "' directive")) 
-    return true; 
- 
-  // Parse optional qualifier (default value, or "req") 
-  if (parseOptionalToken(AsmToken::Colon)) { 
-    if (parseOptionalToken(AsmToken::Equal)) { 
-      // Default value 
-      SMLoc ParamLoc; 
- 
-      ParamLoc = Lexer.getLoc(); 
-      if (parseMacroArgument(nullptr, Parameter.Value)) 
-        return true; 
-    } else { 
-      SMLoc QualLoc; 
-      StringRef Qualifier; 
- 
-      QualLoc = Lexer.getLoc(); 
-      if (parseIdentifier(Qualifier)) 
-        return Error(QualLoc, "missing parameter qualifier for " 
-                              "'" + 
-                                  Parameter.Name + "' in '" + Dir + 
-                                  "' directive"); 
- 
-      if (Qualifier.equals_lower("req")) 
-        Parameter.Required = true; 
-      else 
-        return Error(QualLoc, 
-                     Qualifier + " is not a valid parameter qualifier for '" + 
-                         Parameter.Name + "' in '" + Dir + "' directive"); 
-    } 
-  } 
- 
-  if (parseToken(AsmToken::Comma, 
-                 "expected comma in '" + Dir + "' directive") || 
-      parseToken(AsmToken::Less, 
-                 "values in '" + Dir + 
-                     "' directive must be enclosed in angle brackets")) 
-    return true; 
- 
-  while (true) { 
-    A.emplace_back(); 
-    if (parseMacroArgument(&Parameter, A.back(), /*EndTok=*/AsmToken::Greater)) 
-      return addErrorSuffix(" in arguments for '" + Dir + "' directive"); 
- 
-    // If we see a comma, continue, and allow line continuation. 
-    if (!parseOptionalToken(AsmToken::Comma)) 
-      break; 
-    parseOptionalToken(AsmToken::EndOfStatement); 
-  } 
- 
-  if (parseToken(AsmToken::Greater, 
-                 "values in '" + Dir + 
-                     "' directive must be enclosed in angle brackets") || 
+            "expected identifier in '" + Dir + "' directive"))
+    return true;
+
+  // Parse optional qualifier (default value, or "req")
+  if (parseOptionalToken(AsmToken::Colon)) {
+    if (parseOptionalToken(AsmToken::Equal)) {
+      // Default value
+      SMLoc ParamLoc;
+
+      ParamLoc = Lexer.getLoc();
+      if (parseMacroArgument(nullptr, Parameter.Value))
+        return true;
+    } else {
+      SMLoc QualLoc;
+      StringRef Qualifier;
+
+      QualLoc = Lexer.getLoc();
+      if (parseIdentifier(Qualifier))
+        return Error(QualLoc, "missing parameter qualifier for "
+                              "'" +
+                                  Parameter.Name + "' in '" + Dir +
+                                  "' directive");
+
+      if (Qualifier.equals_lower("req"))
+        Parameter.Required = true;
+      else
+        return Error(QualLoc,
+                     Qualifier + " is not a valid parameter qualifier for '" +
+                         Parameter.Name + "' in '" + Dir + "' directive");
+    }
+  }
+
+  if (parseToken(AsmToken::Comma,
+                 "expected comma in '" + Dir + "' directive") ||
+      parseToken(AsmToken::Less,
+                 "values in '" + Dir +
+                     "' directive must be enclosed in angle brackets"))
+    return true;
+
+  while (true) {
+    A.emplace_back();
+    if (parseMacroArgument(&Parameter, A.back(), /*EndTok=*/AsmToken::Greater))
+      return addErrorSuffix(" in arguments for '" + Dir + "' directive");
+
+    // If we see a comma, continue, and allow line continuation.
+    if (!parseOptionalToken(AsmToken::Comma))
+      break;
+    parseOptionalToken(AsmToken::EndOfStatement);
+  }
+
+  if (parseToken(AsmToken::Greater,
+                 "values in '" + Dir +
+                     "' directive must be enclosed in angle brackets") ||
       parseToken(AsmToken::EndOfStatement, "expected End of Statement"))
     return true;
 
-  // Lex the for definition. 
+  // Lex the for definition.
   MCAsmMacro *M = parseMacroLikeBody(DirectiveLoc);
   if (!M)
     return true;
@@ -6751,7 +6751,7 @@ bool MasmParser::parseDirectiveFor(SMLoc DirectiveLoc, StringRef Dir) {
   raw_svector_ostream OS(Buf);
 
   for (const MCAsmMacroArgument &Arg : A) {
-    if (expandMacro(OS, M->Body, Parameter, Arg, M->Locals, getTok().getLoc())) 
+    if (expandMacro(OS, M->Body, Parameter, Arg, M->Locals, getTok().getLoc()))
       return true;
   }
 
@@ -6760,33 +6760,33 @@ bool MasmParser::parseDirectiveFor(SMLoc DirectiveLoc, StringRef Dir) {
   return false;
 }
 
-/// parseDirectiveForc 
-/// ::= ("forc" | "irpc") symbol, <string> 
-///       body 
-///     endm 
-bool MasmParser::parseDirectiveForc(SMLoc DirectiveLoc, StringRef Directive) { 
+/// parseDirectiveForc
+/// ::= ("forc" | "irpc") symbol, <string>
+///       body
+///     endm
+bool MasmParser::parseDirectiveForc(SMLoc DirectiveLoc, StringRef Directive) {
   MCAsmMacroParameter Parameter;
 
-  std::string Argument; 
+  std::string Argument;
   if (check(parseIdentifier(Parameter.Name),
-            "expected identifier in '" + Directive + "' directive") || 
-      parseToken(AsmToken::Comma, 
-                 "expected comma in '" + Directive + "' directive")) 
+            "expected identifier in '" + Directive + "' directive") ||
+      parseToken(AsmToken::Comma,
+                 "expected comma in '" + Directive + "' directive"))
     return true;
-  if (parseAngleBracketString(Argument)) { 
-    // Match ml64.exe; treat all characters to end of statement as a string, 
-    // ignoring comment markers, then discard anything following a space (using 
-    // the C locale). 
-    Argument = parseStringTo(AsmToken::EndOfStatement); 
-    if (getTok().is(AsmToken::EndOfStatement)) 
-      Argument += getTok().getString(); 
-    size_t End = 0; 
-    for (; End < Argument.size(); ++End) { 
-      if (isSpace(Argument[End])) 
-        break; 
-    } 
-    Argument.resize(End); 
-  } 
+  if (parseAngleBracketString(Argument)) {
+    // Match ml64.exe; treat all characters to end of statement as a string,
+    // ignoring comment markers, then discard anything following a space (using
+    // the C locale).
+    Argument = parseStringTo(AsmToken::EndOfStatement);
+    if (getTok().is(AsmToken::EndOfStatement))
+      Argument += getTok().getString();
+    size_t End = 0;
+    for (; End < Argument.size(); ++End) {
+      if (isSpace(Argument[End]))
+        break;
+    }
+    Argument.resize(End);
+  }
   if (parseToken(AsmToken::EndOfStatement, "expected end of statement"))
     return true;
 
@@ -6800,12 +6800,12 @@ bool MasmParser::parseDirectiveForc(SMLoc DirectiveLoc, StringRef Directive) {
   SmallString<256> Buf;
   raw_svector_ostream OS(Buf);
 
-  StringRef Values(Argument); 
+  StringRef Values(Argument);
   for (std::size_t I = 0, End = Values.size(); I != End; ++I) {
     MCAsmMacroArgument Arg;
     Arg.emplace_back(AsmToken::Identifier, Values.slice(I, I + 1));
 
-    if (expandMacro(OS, M->Body, Parameter, Arg, M->Locals, getTok().getLoc())) 
+    if (expandMacro(OS, M->Body, Parameter, Arg, M->Locals, getTok().getLoc()))
       return true;
   }
 
@@ -6847,37 +6847,37 @@ bool MasmParser::parseDirectiveMSAlign(SMLoc IDLoc, ParseStatementInfo &Info) {
   return false;
 }
 
-bool MasmParser::parseDirectiveRadix(SMLoc DirectiveLoc) { 
-  const SMLoc Loc = getLexer().getLoc(); 
-  std::string RadixStringRaw = parseStringTo(AsmToken::EndOfStatement); 
-  StringRef RadixString = StringRef(RadixStringRaw).trim(); 
-  unsigned Radix; 
-  if (RadixString.getAsInteger(10, Radix)) { 
-    return Error(Loc, 
-                 "radix must be a decimal number in the range 2 to 16; was " + 
-                     RadixString); 
-  } 
-  if (Radix < 2 || Radix > 16) 
-    return Error(Loc, "radix must be in the range 2 to 16; was " + 
-                          std::to_string(Radix)); 
-  getLexer().setMasmDefaultRadix(Radix); 
-  return false; 
-} 
- 
-/// parseDirectiveEcho 
-///   ::= "echo" message 
+bool MasmParser::parseDirectiveRadix(SMLoc DirectiveLoc) {
+  const SMLoc Loc = getLexer().getLoc();
+  std::string RadixStringRaw = parseStringTo(AsmToken::EndOfStatement);
+  StringRef RadixString = StringRef(RadixStringRaw).trim();
+  unsigned Radix;
+  if (RadixString.getAsInteger(10, Radix)) {
+    return Error(Loc,
+                 "radix must be a decimal number in the range 2 to 16; was " +
+                     RadixString);
+  }
+  if (Radix < 2 || Radix > 16)
+    return Error(Loc, "radix must be in the range 2 to 16; was " +
+                          std::to_string(Radix));
+  getLexer().setMasmDefaultRadix(Radix);
+  return false;
+}
+
+/// parseDirectiveEcho
+///   ::= "echo" message
 bool MasmParser::parseDirectiveEcho() {
-  // We're called before the directive is parsed, to avoid triggering lexical 
-  // substitutions in the message. Assert that the next token is the directive, 
-  // then eat it without using the Parser's Lex method. 
-  assert(getTok().is(AsmToken::Identifier) && 
-         getTok().getString().equals_lower("echo")); 
-  Lexer.Lex(); 
- 
-  std::string Message = parseStringTo(AsmToken::EndOfStatement); 
-  llvm::outs() << Message; 
-  if (!StringRef(Message).endswith("\n")) 
-    llvm::outs() << '\n'; 
+  // We're called before the directive is parsed, to avoid triggering lexical
+  // substitutions in the message. Assert that the next token is the directive,
+  // then eat it without using the Parser's Lex method.
+  assert(getTok().is(AsmToken::Identifier) &&
+         getTok().getString().equals_lower("echo"));
+  Lexer.Lex();
+
+  std::string Message = parseStringTo(AsmToken::EndOfStatement);
+  llvm::outs() << Message;
+  if (!StringRef(Message).endswith("\n"))
+    llvm::outs() << '\n';
   return false;
 }
 
@@ -6904,52 +6904,52 @@ static int rewritesSort(const AsmRewrite *AsmRewriteA,
   llvm_unreachable("Unstable rewrite sort.");
 }
 
-bool MasmParser::defineMacro(StringRef Name, StringRef Value) { 
-  Variable &Var = Variables[Name.lower()]; 
-  if (Var.Name.empty()) { 
-    Var.Name = Name; 
-  } else if (!Var.Redefinable) { 
-    return TokError("invalid variable redefinition"); 
-  } 
-  Var.Redefinable = true; 
-  Var.IsText = true; 
-  Var.TextValue = Value.str(); 
-  return false; 
-} 
- 
-bool MasmParser::lookUpField(StringRef Name, AsmFieldInfo &Info) const { 
+bool MasmParser::defineMacro(StringRef Name, StringRef Value) {
+  Variable &Var = Variables[Name.lower()];
+  if (Var.Name.empty()) {
+    Var.Name = Name;
+  } else if (!Var.Redefinable) {
+    return TokError("invalid variable redefinition");
+  }
+  Var.Redefinable = true;
+  Var.IsText = true;
+  Var.TextValue = Value.str();
+  return false;
+}
+
+bool MasmParser::lookUpField(StringRef Name, AsmFieldInfo &Info) const {
   const std::pair<StringRef, StringRef> BaseMember = Name.split('.');
   const StringRef Base = BaseMember.first, Member = BaseMember.second;
-  return lookUpField(Base, Member, Info); 
+  return lookUpField(Base, Member, Info);
 }
 
-bool MasmParser::lookUpField(StringRef Base, StringRef Member, 
-                             AsmFieldInfo &Info) const { 
+bool MasmParser::lookUpField(StringRef Base, StringRef Member,
+                             AsmFieldInfo &Info) const {
   if (Base.empty())
     return true;
 
-  AsmFieldInfo BaseInfo; 
-  if (Base.contains('.') && !lookUpField(Base, BaseInfo)) 
-    Base = BaseInfo.Type.Name; 
+  AsmFieldInfo BaseInfo;
+  if (Base.contains('.') && !lookUpField(Base, BaseInfo))
+    Base = BaseInfo.Type.Name;
 
   auto StructIt = Structs.find(Base.lower());
-  auto TypeIt = KnownType.find(Base.lower()); 
-  if (TypeIt != KnownType.end()) { 
-    StructIt = Structs.find(TypeIt->second.Name.lower()); 
-  } 
+  auto TypeIt = KnownType.find(Base.lower());
+  if (TypeIt != KnownType.end()) {
+    StructIt = Structs.find(TypeIt->second.Name.lower());
+  }
   if (StructIt != Structs.end())
-    return lookUpField(StructIt->second, Member, Info); 
+    return lookUpField(StructIt->second, Member, Info);
 
   return true;
 }
 
 bool MasmParser::lookUpField(const StructInfo &Structure, StringRef Member,
-                             AsmFieldInfo &Info) const { 
+                             AsmFieldInfo &Info) const {
   if (Member.empty()) {
-    Info.Type.Name = Structure.Name; 
-    Info.Type.Size = Structure.Size; 
-    Info.Type.ElementSize = Structure.Size; 
-    Info.Type.Length = 1; 
+    Info.Type.Name = Structure.Name;
+    Info.Type.Size = Structure.Size;
+    Info.Type.ElementSize = Structure.Size;
+    Info.Type.Length = 1;
     return false;
   }
 
@@ -6958,7 +6958,7 @@ bool MasmParser::lookUpField(const StructInfo &Structure, StringRef Member,
 
   auto StructIt = Structs.find(FieldName.lower());
   if (StructIt != Structs.end())
-    return lookUpField(StructIt->second, FieldMember, Info); 
+    return lookUpField(StructIt->second, FieldMember, Info);
 
   auto FieldIt = Structure.FieldsByName.find(FieldName.lower());
   if (FieldIt == Structure.FieldsByName.end())
@@ -6966,14 +6966,14 @@ bool MasmParser::lookUpField(const StructInfo &Structure, StringRef Member,
 
   const FieldInfo &Field = Structure.Fields[FieldIt->second];
   if (FieldMember.empty()) {
-    Info.Offset += Field.Offset; 
-    Info.Type.Size = Field.SizeOf; 
-    Info.Type.ElementSize = Field.Type; 
-    Info.Type.Length = Field.LengthOf; 
+    Info.Offset += Field.Offset;
+    Info.Type.Size = Field.SizeOf;
+    Info.Type.ElementSize = Field.Type;
+    Info.Type.Length = Field.LengthOf;
     if (Field.Contents.FT == FT_STRUCT)
-      Info.Type.Name = Field.Contents.StructInfo.Structure.Name; 
-    else 
-      Info.Type.Name = ""; 
+      Info.Type.Name = Field.Contents.StructInfo.Structure.Name;
+    else
+      Info.Type.Name = "";
     return false;
   }
 
@@ -6981,45 +6981,45 @@ bool MasmParser::lookUpField(const StructInfo &Structure, StringRef Member,
     return true;
   const StructFieldInfo &StructInfo = Field.Contents.StructInfo;
 
-  if (lookUpField(StructInfo.Structure, FieldMember, Info)) 
+  if (lookUpField(StructInfo.Structure, FieldMember, Info))
     return true;
 
-  Info.Offset += Field.Offset; 
+  Info.Offset += Field.Offset;
   return false;
 }
 
-bool MasmParser::lookUpType(StringRef Name, AsmTypeInfo &Info) const { 
-  unsigned Size = StringSwitch<unsigned>(Name) 
-                      .CasesLower("byte", "db", "sbyte", 1) 
-                      .CasesLower("word", "dw", "sword", 2) 
-                      .CasesLower("dword", "dd", "sdword", 4) 
-                      .CasesLower("fword", "df", 6) 
-                      .CasesLower("qword", "dq", "sqword", 8) 
-                      .CaseLower("real4", 4) 
-                      .CaseLower("real8", 8) 
-                      .CaseLower("real10", 10) 
-                      .Default(0); 
-  if (Size) { 
-    Info.Name = Name; 
-    Info.ElementSize = Size; 
-    Info.Length = 1; 
-    Info.Size = Size; 
-    return false; 
-  } 
- 
-  auto StructIt = Structs.find(Name.lower()); 
-  if (StructIt != Structs.end()) { 
-    const StructInfo &Structure = StructIt->second; 
-    Info.Name = Name; 
-    Info.ElementSize = Structure.Size; 
-    Info.Length = 1; 
-    Info.Size = Structure.Size; 
-    return false; 
-  } 
- 
-  return true; 
-} 
- 
+bool MasmParser::lookUpType(StringRef Name, AsmTypeInfo &Info) const {
+  unsigned Size = StringSwitch<unsigned>(Name)
+                      .CasesLower("byte", "db", "sbyte", 1)
+                      .CasesLower("word", "dw", "sword", 2)
+                      .CasesLower("dword", "dd", "sdword", 4)
+                      .CasesLower("fword", "df", 6)
+                      .CasesLower("qword", "dq", "sqword", 8)
+                      .CaseLower("real4", 4)
+                      .CaseLower("real8", 8)
+                      .CaseLower("real10", 10)
+                      .Default(0);
+  if (Size) {
+    Info.Name = Name;
+    Info.ElementSize = Size;
+    Info.Length = 1;
+    Info.Size = Size;
+    return false;
+  }
+
+  auto StructIt = Structs.find(Name.lower());
+  if (StructIt != Structs.end()) {
+    const StructInfo &Structure = StructIt->second;
+    Info.Name = Name;
+    Info.ElementSize = Structure.Size;
+    Info.Length = 1;
+    Info.Size = Structure.Size;
+    return false;
+  }
+
+  return true;
+}
+
 bool MasmParser::parseMSInlineAsm(
     void *AsmLoc, std::string &AsmString, unsigned &NumOutputs,
     unsigned &NumInputs, SmallVectorImpl<std::pair<void *, bool>> &OpDecls,
@@ -7118,7 +7118,7 @@ bool MasmParser::parseMSInlineAsm(
     // Consider implicit defs to be clobbers.  Think of cpuid and push.
     ArrayRef<MCPhysReg> ImpDefs(Desc.getImplicitDefs(),
                                 Desc.getNumImplicitDefs());
-    llvm::append_range(ClobberRegs, ImpDefs); 
+    llvm::append_range(ClobberRegs, ImpDefs);
   }
 
   // Set the number of Outputs and Inputs.
diff --git a/contrib/libs/llvm12/lib/MC/MCParser/WasmAsmParser.cpp b/contrib/libs/llvm12/lib/MC/MCParser/WasmAsmParser.cpp
index d0673c2a44..0c255ef02d 100644
--- a/contrib/libs/llvm12/lib/MC/MCParser/WasmAsmParser.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCParser/WasmAsmParser.cpp
@@ -90,44 +90,44 @@ public:
     return false;
   }
 
-  bool parseSectionFlags(StringRef FlagStr, bool &Passive, bool &Group) { 
-    for (char C : FlagStr) { 
-      switch (C) { 
-      case 'p': 
+  bool parseSectionFlags(StringRef FlagStr, bool &Passive, bool &Group) {
+    for (char C : FlagStr) {
+      switch (C) {
+      case 'p':
         Passive = true;
-        break; 
-      case 'G': 
-        Group = true; 
-        break; 
-      default: 
-        return Parser->Error(getTok().getLoc(), 
-                             StringRef("Unexepcted section flag: ") + FlagStr); 
-      } 
+        break;
+      case 'G':
+        Group = true;
+        break;
+      default:
+        return Parser->Error(getTok().getLoc(),
+                             StringRef("Unexepcted section flag: ") + FlagStr);
+      }
+    }
+    return false;
+  }
+
+  bool parseGroup(StringRef &GroupName) {
+    if (Lexer->isNot(AsmToken::Comma))
+      return TokError("expected group name");
+    Lex();
+    if (Lexer->is(AsmToken::Integer)) {
+      GroupName = getTok().getString();
+      Lex();
+    } else if (Parser->parseIdentifier(GroupName)) {
+      return TokError("invalid group name");
+    }
+    if (Lexer->is(AsmToken::Comma)) {
+      Lex();
+      StringRef Linkage;
+      if (Parser->parseIdentifier(Linkage))
+        return TokError("invalid linkage");
+      if (Linkage != "comdat")
+        return TokError("Linkage must be 'comdat'");
     }
     return false;
   }
 
-  bool parseGroup(StringRef &GroupName) { 
-    if (Lexer->isNot(AsmToken::Comma)) 
-      return TokError("expected group name"); 
-    Lex(); 
-    if (Lexer->is(AsmToken::Integer)) { 
-      GroupName = getTok().getString(); 
-      Lex(); 
-    } else if (Parser->parseIdentifier(GroupName)) { 
-      return TokError("invalid group name"); 
-    } 
-    if (Lexer->is(AsmToken::Comma)) { 
-      Lex(); 
-      StringRef Linkage; 
-      if (Parser->parseIdentifier(Linkage)) 
-        return TokError("invalid linkage"); 
-      if (Linkage != "comdat") 
-        return TokError("Linkage must be 'comdat'"); 
-    } 
-    return false; 
-  } 
- 
   bool parseSectionDirective(StringRef, SMLoc) {
     StringRef Name;
     if (Parser->parseIdentifier(Name))
@@ -141,8 +141,8 @@ public:
 
     auto Kind = StringSwitch<Optional<SectionKind>>(Name)
                     .StartsWith(".data", SectionKind::getData())
-                    .StartsWith(".tdata", SectionKind::getThreadData()) 
-                    .StartsWith(".tbss", SectionKind::getThreadBSS()) 
+                    .StartsWith(".tdata", SectionKind::getThreadData())
+                    .StartsWith(".tbss", SectionKind::getThreadBSS())
                     .StartsWith(".rodata", SectionKind::getReadOnly())
                     .StartsWith(".text", SectionKind::getText())
                     .StartsWith(".custom_section", SectionKind::getMetadata())
@@ -158,30 +158,30 @@ public:
 
     // Update section flags if present in this .section directive
     bool Passive = false;
-    bool Group = false; 
-    if (parseSectionFlags(getTok().getStringContents(), Passive, Group)) 
+    bool Group = false;
+    if (parseSectionFlags(getTok().getStringContents(), Passive, Group))
+      return true;
+
+    Lex();
+
+    if (expect(AsmToken::Comma, ",") || expect(AsmToken::At, "@"))
+      return true;
+
+    StringRef GroupName;
+    if (Group && parseGroup(GroupName))
+      return true;
+
+    if (expect(AsmToken::EndOfStatement, "eol"))
       return true;
 
-    Lex(); 
- 
-    if (expect(AsmToken::Comma, ",") || expect(AsmToken::At, "@")) 
-      return true; 
- 
-    StringRef GroupName; 
-    if (Group && parseGroup(GroupName)) 
-      return true; 
- 
-    if (expect(AsmToken::EndOfStatement, "eol")) 
-      return true; 
- 
-    // TODO: Parse UniqueID 
-    MCSectionWasm *WS = getContext().getWasmSection( 
-        Name, Kind.getValue(), GroupName, MCContext::GenericSectionID); 
+    // TODO: Parse UniqueID
+    MCSectionWasm *WS = getContext().getWasmSection(
+        Name, Kind.getValue(), GroupName, MCContext::GenericSectionID);
     if (Passive) {
-      if (!WS->isWasmData()) 
+      if (!WS->isWasmData())
         return Parser->Error(getTok().getLoc(),
                              "Only data sections can be passive");
-      WS->setPassive(); 
+      WS->setPassive();
     }
     getStreamer().SwitchSection(WS);
     return false;
@@ -221,13 +221,13 @@ public:
           Lexer->is(AsmToken::Identifier)))
       return error("Expected label,@type declaration, got: ", Lexer->getTok());
     auto TypeName = Lexer->getTok().getString();
-    if (TypeName == "function") { 
+    if (TypeName == "function") {
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
-      auto *Current = 
-          cast<MCSectionWasm>(getStreamer().getCurrentSection().first); 
-      if (Current->getGroup()) 
-        WasmSym->setComdat(true); 
-    } else if (TypeName == "global") 
+      auto *Current =
+          cast<MCSectionWasm>(getStreamer().getCurrentSection().first);
+      if (Current->getGroup())
+        WasmSym->setComdat(true);
+    } else if (TypeName == "global")
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
     else if (TypeName == "object")
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_DATA);
diff --git a/contrib/libs/llvm12/lib/MC/MCParser/ya.make b/contrib/libs/llvm12/lib/MC/MCParser/ya.make
index f9e468b1c9..304ad7d65a 100644
--- a/contrib/libs/llvm12/lib/MC/MCParser/ya.make
+++ b/contrib/libs/llvm12/lib/MC/MCParser/ya.make
@@ -12,9 +12,9 @@ LICENSE(Apache-2.0 WITH LLVM-exception)
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
 PEERDIR(
-    contrib/libs/llvm12 
-    contrib/libs/llvm12/lib/MC 
-    contrib/libs/llvm12/lib/Support 
+    contrib/libs/llvm12
+    contrib/libs/llvm12/lib/MC
+    contrib/libs/llvm12/lib/Support
 )
 
 ADDINCL(
diff --git a/contrib/libs/llvm12/lib/MC/MCPseudoProbe.cpp b/contrib/libs/llvm12/lib/MC/MCPseudoProbe.cpp
index 9892994dc3..731831d3bc 100644
--- a/contrib/libs/llvm12/lib/MC/MCPseudoProbe.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCPseudoProbe.cpp
@@ -1,213 +1,213 @@
-//===- lib/MC/MCPseudoProbe.cpp - Pseudo probe encoding support ----------===// 
-// 
-// 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 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#include "llvm/MC/MCPseudoProbe.h" 
-#include "llvm/MC/MCAsmInfo.h" 
-#include "llvm/MC/MCContext.h" 
-#include "llvm/MC/MCObjectFileInfo.h" 
-#include "llvm/MC/MCObjectStreamer.h" 
-#include "llvm/MC/MCStreamer.h" 
- 
-#define DEBUG_TYPE "mcpseudoprobe" 
- 
-using namespace llvm; 
- 
-#ifndef NDEBUG 
-int MCPseudoProbeTable::DdgPrintIndent = 0; 
-#endif 
- 
-static const MCExpr *buildSymbolDiff(MCObjectStreamer *MCOS, const MCSymbol *A, 
-                                     const MCSymbol *B) { 
-  MCContext &Context = MCOS->getContext(); 
-  MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None; 
-  const MCExpr *ARef = MCSymbolRefExpr::create(A, Variant, Context); 
-  const MCExpr *BRef = MCSymbolRefExpr::create(B, Variant, Context); 
-  const MCExpr *AddrDelta = 
-      MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context); 
-  return AddrDelta; 
-} 
- 
-void MCPseudoProbe::emit(MCObjectStreamer *MCOS, 
-                         const MCPseudoProbe *LastProbe) const { 
-  // Emit Index 
-  MCOS->emitULEB128IntValue(Index); 
-  // Emit Type and the flag: 
-  // Type (bit 0 to 3), with bit 4 to 6 for attributes. 
-  // Flag (bit 7, 0 - code address, 1 - address delta). This indicates whether 
-  // the following field is a symbolic code address or an address delta. 
-  assert(Type <= 0xF && "Probe type too big to encode, exceeding 15"); 
-  assert(Attributes <= 0x7 && 
-         "Probe attributes too big to encode, exceeding 7"); 
-  uint8_t PackedType = Type | (Attributes << 4); 
-  uint8_t Flag = LastProbe ? ((int8_t)MCPseudoProbeFlag::AddressDelta << 7) : 0; 
-  MCOS->emitInt8(Flag | PackedType); 
- 
-  if (LastProbe) { 
-    // Emit the delta between the address label and LastProbe. 
-    const MCExpr *AddrDelta = 
-        buildSymbolDiff(MCOS, Label, LastProbe->getLabel()); 
-    int64_t Delta; 
-    if (AddrDelta->evaluateAsAbsolute(Delta, MCOS->getAssemblerPtr())) { 
-      MCOS->emitSLEB128IntValue(Delta); 
-    } else { 
-      MCOS->insert(new MCPseudoProbeAddrFragment(AddrDelta)); 
-    } 
-  } else { 
-    // Emit label as a symbolic code address. 
-    MCOS->emitSymbolValue( 
-        Label, MCOS->getContext().getAsmInfo()->getCodePointerSize()); 
-  } 
- 
-  LLVM_DEBUG({ 
-    dbgs().indent(MCPseudoProbeTable::DdgPrintIndent); 
-    dbgs() << "Probe: " << Index << "\n"; 
-  }); 
-} 
- 
-MCPseudoProbeInlineTree::~MCPseudoProbeInlineTree() { 
-  for (auto &Inlinee : Inlinees) 
-    delete Inlinee.second; 
-} 
- 
-MCPseudoProbeInlineTree * 
-MCPseudoProbeInlineTree::getOrAddNode(InlineSite Site) { 
-  auto Iter = Inlinees.find(Site); 
-  if (Iter == Inlinees.end()) { 
-    auto *Node = new MCPseudoProbeInlineTree(std::get<0>(Site)); 
-    Inlinees[Site] = Node; 
-    return Node; 
-  } else { 
-    return Iter->second; 
-  } 
-} 
- 
-void MCPseudoProbeInlineTree::addPseudoProbe( 
-    const MCPseudoProbe &Probe, const MCPseudoProbeInlineStack &InlineStack) { 
-  // The function should not be called on the root. 
-  assert(isRoot() && "Should not be called on root"); 
- 
-  // When it comes here, the input look like: 
-  //    Probe: GUID of C, ... 
-  //    InlineStack: [88, A], [66, B] 
-  // which means, Function A inlines function B at call site with a probe id of 
-  // 88, and B inlines C at probe 66. The tri-tree expects a tree path like {[0, 
-  // A], [88, B], [66, C]} to locate the tree node where the probe should be 
-  // added. Note that the edge [0, A] means A is the top-level function we are 
-  // emitting probes for. 
- 
-  // Make a [0, A] edge. 
-  // An empty inline stack means the function that the probe originates from 
-  // is a top-level function. 
-  InlineSite Top; 
-  if (InlineStack.empty()) { 
-    Top = InlineSite(Probe.getGuid(), 0); 
-  } else { 
-    Top = InlineSite(std::get<0>(InlineStack.front()), 0); 
-  } 
- 
-  auto *Cur = getOrAddNode(Top); 
- 
-  // Make interior edges by walking the inline stack. Once it's done, Cur should 
-  // point to the node that the probe originates from. 
-  if (!InlineStack.empty()) { 
-    auto Iter = InlineStack.begin(); 
-    auto Index = std::get<1>(*Iter); 
-    Iter++; 
-    for (; Iter != InlineStack.end(); Iter++) { 
-      // Make an edge by using the previous probe id and current GUID. 
-      Cur = Cur->getOrAddNode(InlineSite(std::get<0>(*Iter), Index)); 
-      Index = std::get<1>(*Iter); 
-    } 
-    Cur = Cur->getOrAddNode(InlineSite(Probe.getGuid(), Index)); 
-  } 
- 
-  Cur->Probes.push_back(Probe); 
-} 
- 
-void MCPseudoProbeInlineTree::emit(MCObjectStreamer *MCOS, 
-                                   const MCPseudoProbe *&LastProbe) { 
-  LLVM_DEBUG({ 
-    dbgs().indent(MCPseudoProbeTable::DdgPrintIndent); 
-    dbgs() << "Group [\n"; 
-    MCPseudoProbeTable::DdgPrintIndent += 2; 
-  }); 
-  // Emit probes grouped by GUID. 
-  if (Guid != 0) { 
-    LLVM_DEBUG({ 
-      dbgs().indent(MCPseudoProbeTable::DdgPrintIndent); 
-      dbgs() << "GUID: " << Guid << "\n"; 
-    }); 
-    // Emit Guid 
-    MCOS->emitInt64(Guid); 
-    // Emit number of probes in this node 
-    MCOS->emitULEB128IntValue(Probes.size()); 
-    // Emit number of direct inlinees 
-    MCOS->emitULEB128IntValue(Inlinees.size()); 
-    // Emit probes in this group 
-    for (const auto &Probe : Probes) { 
-      Probe.emit(MCOS, LastProbe); 
-      LastProbe = &Probe; 
-    } 
-  } else { 
-    assert(Probes.empty() && "Root should not have probes"); 
-  } 
- 
-  // Emit descendent 
-  for (const auto &Inlinee : Inlinees) { 
-    if (Guid) { 
-      // Emit probe index 
-      MCOS->emitULEB128IntValue(std::get<1>(Inlinee.first)); 
-      LLVM_DEBUG({ 
-        dbgs().indent(MCPseudoProbeTable::DdgPrintIndent); 
-        dbgs() << "InlineSite: " << std::get<1>(Inlinee.first) << "\n"; 
-      }); 
-    } 
-    // Emit the group 
-    Inlinee.second->emit(MCOS, LastProbe); 
-  } 
- 
-  LLVM_DEBUG({ 
-    MCPseudoProbeTable::DdgPrintIndent -= 2; 
-    dbgs().indent(MCPseudoProbeTable::DdgPrintIndent); 
-    dbgs() << "]\n"; 
-  }); 
-} 
- 
-void MCPseudoProbeSection::emit(MCObjectStreamer *MCOS) { 
-  MCContext &Ctx = MCOS->getContext(); 
- 
-  for (auto &ProbeSec : MCProbeDivisions) { 
-    const MCPseudoProbe *LastProbe = nullptr; 
-    if (auto *S = 
-            Ctx.getObjectFileInfo()->getPseudoProbeSection(ProbeSec.first)) { 
-      // Switch to the .pseudoprobe section or a comdat group. 
-      MCOS->SwitchSection(S); 
-      // Emit probes grouped by GUID. 
-      ProbeSec.second.emit(MCOS, LastProbe); 
-    } 
-  } 
-} 
- 
-// 
-// This emits the pseudo probe tables. 
-// 
-void MCPseudoProbeTable::emit(MCObjectStreamer *MCOS) { 
-  MCContext &Ctx = MCOS->getContext(); 
-  auto &ProbeTable = Ctx.getMCPseudoProbeTable(); 
- 
-  // Bail out early so we don't switch to the pseudo_probe section needlessly 
-  // and in doing so create an unnecessary (if empty) section. 
-  auto &ProbeSections = ProbeTable.getProbeSections(); 
-  if (ProbeSections.empty()) 
-    return; 
- 
-  LLVM_DEBUG(MCPseudoProbeTable::DdgPrintIndent = 0); 
- 
-  // Put out the probe. 
-  ProbeSections.emit(MCOS); 
-} 
+//===- lib/MC/MCPseudoProbe.cpp - Pseudo probe encoding support ----------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/MC/MCPseudoProbe.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCObjectFileInfo.h"
+#include "llvm/MC/MCObjectStreamer.h"
+#include "llvm/MC/MCStreamer.h"
+
+#define DEBUG_TYPE "mcpseudoprobe"
+
+using namespace llvm;
+
+#ifndef NDEBUG
+int MCPseudoProbeTable::DdgPrintIndent = 0;
+#endif
+
+static const MCExpr *buildSymbolDiff(MCObjectStreamer *MCOS, const MCSymbol *A,
+                                     const MCSymbol *B) {
+  MCContext &Context = MCOS->getContext();
+  MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
+  const MCExpr *ARef = MCSymbolRefExpr::create(A, Variant, Context);
+  const MCExpr *BRef = MCSymbolRefExpr::create(B, Variant, Context);
+  const MCExpr *AddrDelta =
+      MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context);
+  return AddrDelta;
+}
+
+void MCPseudoProbe::emit(MCObjectStreamer *MCOS,
+                         const MCPseudoProbe *LastProbe) const {
+  // Emit Index
+  MCOS->emitULEB128IntValue(Index);
+  // Emit Type and the flag:
+  // Type (bit 0 to 3), with bit 4 to 6 for attributes.
+  // Flag (bit 7, 0 - code address, 1 - address delta). This indicates whether
+  // the following field is a symbolic code address or an address delta.
+  assert(Type <= 0xF && "Probe type too big to encode, exceeding 15");
+  assert(Attributes <= 0x7 &&
+         "Probe attributes too big to encode, exceeding 7");
+  uint8_t PackedType = Type | (Attributes << 4);
+  uint8_t Flag = LastProbe ? ((int8_t)MCPseudoProbeFlag::AddressDelta << 7) : 0;
+  MCOS->emitInt8(Flag | PackedType);
+
+  if (LastProbe) {
+    // Emit the delta between the address label and LastProbe.
+    const MCExpr *AddrDelta =
+        buildSymbolDiff(MCOS, Label, LastProbe->getLabel());
+    int64_t Delta;
+    if (AddrDelta->evaluateAsAbsolute(Delta, MCOS->getAssemblerPtr())) {
+      MCOS->emitSLEB128IntValue(Delta);
+    } else {
+      MCOS->insert(new MCPseudoProbeAddrFragment(AddrDelta));
+    }
+  } else {
+    // Emit label as a symbolic code address.
+    MCOS->emitSymbolValue(
+        Label, MCOS->getContext().getAsmInfo()->getCodePointerSize());
+  }
+
+  LLVM_DEBUG({
+    dbgs().indent(MCPseudoProbeTable::DdgPrintIndent);
+    dbgs() << "Probe: " << Index << "\n";
+  });
+}
+
+MCPseudoProbeInlineTree::~MCPseudoProbeInlineTree() {
+  for (auto &Inlinee : Inlinees)
+    delete Inlinee.second;
+}
+
+MCPseudoProbeInlineTree *
+MCPseudoProbeInlineTree::getOrAddNode(InlineSite Site) {
+  auto Iter = Inlinees.find(Site);
+  if (Iter == Inlinees.end()) {
+    auto *Node = new MCPseudoProbeInlineTree(std::get<0>(Site));
+    Inlinees[Site] = Node;
+    return Node;
+  } else {
+    return Iter->second;
+  }
+}
+
+void MCPseudoProbeInlineTree::addPseudoProbe(
+    const MCPseudoProbe &Probe, const MCPseudoProbeInlineStack &InlineStack) {
+  // The function should not be called on the root.
+  assert(isRoot() && "Should not be called on root");
+
+  // When it comes here, the input look like:
+  //    Probe: GUID of C, ...
+  //    InlineStack: [88, A], [66, B]
+  // which means, Function A inlines function B at call site with a probe id of
+  // 88, and B inlines C at probe 66. The tri-tree expects a tree path like {[0,
+  // A], [88, B], [66, C]} to locate the tree node where the probe should be
+  // added. Note that the edge [0, A] means A is the top-level function we are
+  // emitting probes for.
+
+  // Make a [0, A] edge.
+  // An empty inline stack means the function that the probe originates from
+  // is a top-level function.
+  InlineSite Top;
+  if (InlineStack.empty()) {
+    Top = InlineSite(Probe.getGuid(), 0);
+  } else {
+    Top = InlineSite(std::get<0>(InlineStack.front()), 0);
+  }
+
+  auto *Cur = getOrAddNode(Top);
+
+  // Make interior edges by walking the inline stack. Once it's done, Cur should
+  // point to the node that the probe originates from.
+  if (!InlineStack.empty()) {
+    auto Iter = InlineStack.begin();
+    auto Index = std::get<1>(*Iter);
+    Iter++;
+    for (; Iter != InlineStack.end(); Iter++) {
+      // Make an edge by using the previous probe id and current GUID.
+      Cur = Cur->getOrAddNode(InlineSite(std::get<0>(*Iter), Index));
+      Index = std::get<1>(*Iter);
+    }
+    Cur = Cur->getOrAddNode(InlineSite(Probe.getGuid(), Index));
+  }
+
+  Cur->Probes.push_back(Probe);
+}
+
+void MCPseudoProbeInlineTree::emit(MCObjectStreamer *MCOS,
+                                   const MCPseudoProbe *&LastProbe) {
+  LLVM_DEBUG({
+    dbgs().indent(MCPseudoProbeTable::DdgPrintIndent);
+    dbgs() << "Group [\n";
+    MCPseudoProbeTable::DdgPrintIndent += 2;
+  });
+  // Emit probes grouped by GUID.
+  if (Guid != 0) {
+    LLVM_DEBUG({
+      dbgs().indent(MCPseudoProbeTable::DdgPrintIndent);
+      dbgs() << "GUID: " << Guid << "\n";
+    });
+    // Emit Guid
+    MCOS->emitInt64(Guid);
+    // Emit number of probes in this node
+    MCOS->emitULEB128IntValue(Probes.size());
+    // Emit number of direct inlinees
+    MCOS->emitULEB128IntValue(Inlinees.size());
+    // Emit probes in this group
+    for (const auto &Probe : Probes) {
+      Probe.emit(MCOS, LastProbe);
+      LastProbe = &Probe;
+    }
+  } else {
+    assert(Probes.empty() && "Root should not have probes");
+  }
+
+  // Emit descendent
+  for (const auto &Inlinee : Inlinees) {
+    if (Guid) {
+      // Emit probe index
+      MCOS->emitULEB128IntValue(std::get<1>(Inlinee.first));
+      LLVM_DEBUG({
+        dbgs().indent(MCPseudoProbeTable::DdgPrintIndent);
+        dbgs() << "InlineSite: " << std::get<1>(Inlinee.first) << "\n";
+      });
+    }
+    // Emit the group
+    Inlinee.second->emit(MCOS, LastProbe);
+  }
+
+  LLVM_DEBUG({
+    MCPseudoProbeTable::DdgPrintIndent -= 2;
+    dbgs().indent(MCPseudoProbeTable::DdgPrintIndent);
+    dbgs() << "]\n";
+  });
+}
+
+void MCPseudoProbeSection::emit(MCObjectStreamer *MCOS) {
+  MCContext &Ctx = MCOS->getContext();
+
+  for (auto &ProbeSec : MCProbeDivisions) {
+    const MCPseudoProbe *LastProbe = nullptr;
+    if (auto *S =
+            Ctx.getObjectFileInfo()->getPseudoProbeSection(ProbeSec.first)) {
+      // Switch to the .pseudoprobe section or a comdat group.
+      MCOS->SwitchSection(S);
+      // Emit probes grouped by GUID.
+      ProbeSec.second.emit(MCOS, LastProbe);
+    }
+  }
+}
+
+//
+// This emits the pseudo probe tables.
+//
+void MCPseudoProbeTable::emit(MCObjectStreamer *MCOS) {
+  MCContext &Ctx = MCOS->getContext();
+  auto &ProbeTable = Ctx.getMCPseudoProbeTable();
+
+  // Bail out early so we don't switch to the pseudo_probe section needlessly
+  // and in doing so create an unnecessary (if empty) section.
+  auto &ProbeSections = ProbeTable.getProbeSections();
+  if (ProbeSections.empty())
+    return;
+
+  LLVM_DEBUG(MCPseudoProbeTable::DdgPrintIndent = 0);
+
+  // Put out the probe.
+  ProbeSections.emit(MCOS);
+}
diff --git a/contrib/libs/llvm12/lib/MC/MCSchedule.cpp b/contrib/libs/llvm12/lib/MC/MCSchedule.cpp
index cf768b0fe1..db08e20441 100644
--- a/contrib/libs/llvm12/lib/MC/MCSchedule.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCSchedule.cpp
@@ -74,7 +74,7 @@ int MCSchedModel::computeInstrLatency(const MCSubtargetInfo &STI,
 
   unsigned CPUID = getProcessorID();
   while (SCDesc->isVariant()) {
-    SchedClass = STI.resolveVariantSchedClass(SchedClass, &Inst, &MCII, CPUID); 
+    SchedClass = STI.resolveVariantSchedClass(SchedClass, &Inst, &MCII, CPUID);
     SCDesc = getSchedClassDesc(SchedClass);
   }
 
@@ -120,7 +120,7 @@ MCSchedModel::getReciprocalThroughput(const MCSubtargetInfo &STI,
 
   unsigned CPUID = getProcessorID();
   while (SCDesc->isVariant()) {
-    SchedClass = STI.resolveVariantSchedClass(SchedClass, &Inst, &MCII, CPUID); 
+    SchedClass = STI.resolveVariantSchedClass(SchedClass, &Inst, &MCII, CPUID);
     SCDesc = getSchedClassDesc(SchedClass);
   }
 
diff --git a/contrib/libs/llvm12/lib/MC/MCSection.cpp b/contrib/libs/llvm12/lib/MC/MCSection.cpp
index c64af2bc0a..7997b237a7 100644
--- a/contrib/libs/llvm12/lib/MC/MCSection.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCSection.cpp
@@ -28,7 +28,7 @@ MCSection::MCSection(SectionVariant V, StringRef Name, SectionKind K,
 
 MCSymbol *MCSection::getEndSymbol(MCContext &Ctx) {
   if (!End)
-    End = Ctx.createTempSymbol("sec_end"); 
+    End = Ctx.createTempSymbol("sec_end");
   return End;
 }
 
@@ -82,7 +82,7 @@ MCSection::getSubsectionInsertionPoint(unsigned Subsection) {
     SubsectionFragmentMap.insert(MI, std::make_pair(Subsection, F));
     getFragmentList().insert(IP, F);
     F->setParent(this);
-    F->setSubsectionNumber(Subsection); 
+    F->setSubsectionNumber(Subsection);
   }
 
   return IP;
diff --git a/contrib/libs/llvm12/lib/MC/MCSectionELF.cpp b/contrib/libs/llvm12/lib/MC/MCSectionELF.cpp
index b51be9dcaa..27694cb144 100644
--- a/contrib/libs/llvm12/lib/MC/MCSectionELF.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCSectionELF.cpp
@@ -156,8 +156,8 @@ void MCSectionELF::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
     OS << "llvm_dependent_libraries";
   else if (Type == ELF::SHT_LLVM_SYMPART)
     OS << "llvm_sympart";
-  else if (Type == ELF::SHT_LLVM_BB_ADDR_MAP) 
-    OS << "llvm_bb_addr_map"; 
+  else if (Type == ELF::SHT_LLVM_BB_ADDR_MAP)
+    OS << "llvm_bb_addr_map";
   else
     report_fatal_error("unsupported type 0x" + Twine::utohexstr(Type) +
                        " for section " + getName());
@@ -175,10 +175,10 @@ void MCSectionELF::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
 
   if (Flags & ELF::SHF_LINK_ORDER) {
     OS << ",";
-    if (LinkedToSym) 
-      printName(OS, LinkedToSym->getName()); 
-    else 
-      OS << '0'; 
+    if (LinkedToSym)
+      printName(OS, LinkedToSym->getName());
+    else
+      OS << '0';
   }
 
   if (isUnique())
diff --git a/contrib/libs/llvm12/lib/MC/MCSectionMachO.cpp b/contrib/libs/llvm12/lib/MC/MCSectionMachO.cpp
index a54968d7b4..794d2c52d7 100644
--- a/contrib/libs/llvm12/lib/MC/MCSectionMachO.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCSectionMachO.cpp
@@ -215,11 +215,11 @@ std::string MCSectionMachO::ParseSectionSpecifier(StringRef Spec,        // In.
     return "";
 
   // Figure out which section type it is.
-  auto TypeDescriptor = 
-      llvm::find_if(SectionTypeDescriptors, 
-                    [&](decltype(*SectionTypeDescriptors) &Descriptor) { 
-                      return SectionType == Descriptor.AssemblerName; 
-                    }); 
+  auto TypeDescriptor =
+      llvm::find_if(SectionTypeDescriptors,
+                    [&](decltype(*SectionTypeDescriptors) &Descriptor) {
+                      return SectionType == Descriptor.AssemblerName;
+                    });
 
   // If we didn't find the section type, reject it.
   if (TypeDescriptor == std::end(SectionTypeDescriptors))
@@ -243,11 +243,11 @@ std::string MCSectionMachO::ParseSectionSpecifier(StringRef Spec,        // In.
   Attrs.split(SectionAttrs, '+', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
 
   for (StringRef &SectionAttr : SectionAttrs) {
-    auto AttrDescriptorI = 
-        llvm::find_if(SectionAttrDescriptors, 
-                      [&](decltype(*SectionAttrDescriptors) &Descriptor) { 
-                        return SectionAttr.trim() == Descriptor.AssemblerName; 
-                      }); 
+    auto AttrDescriptorI =
+        llvm::find_if(SectionAttrDescriptors,
+                      [&](decltype(*SectionAttrDescriptors) &Descriptor) {
+                        return SectionAttr.trim() == Descriptor.AssemblerName;
+                      });
     if (AttrDescriptorI == std::end(SectionAttrDescriptors))
       return "mach-o section specifier has invalid attribute";
 
diff --git a/contrib/libs/llvm12/lib/MC/MCSectionWasm.cpp b/contrib/libs/llvm12/lib/MC/MCSectionWasm.cpp
index ce9e1b19cf..81dc4329be 100644
--- a/contrib/libs/llvm12/lib/MC/MCSectionWasm.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCSectionWasm.cpp
@@ -64,9 +64,9 @@ void MCSectionWasm::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
   OS << ",\"";
 
   if (IsPassive)
-    OS << "p"; 
-  if (Group) 
-    OS << "G"; 
+    OS << "p";
+  if (Group)
+    OS << "G";
 
   OS << '"';
 
@@ -80,12 +80,12 @@ void MCSectionWasm::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
 
   // TODO: Print section type.
 
-  if (Group) { 
-    OS << ","; 
-    printName(OS, Group->getName()); 
-    OS << ",comdat"; 
-  } 
- 
+  if (Group) {
+    OS << ",";
+    printName(OS, Group->getName());
+    OS << ",comdat";
+  }
+
   if (isUnique())
     OS << ",unique," << UniqueID;
 
diff --git a/contrib/libs/llvm12/lib/MC/MCSectionXCOFF.cpp b/contrib/libs/llvm12/lib/MC/MCSectionXCOFF.cpp
index 6a036ae884..17b7b60a04 100644
--- a/contrib/libs/llvm12/lib/MC/MCSectionXCOFF.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCSectionXCOFF.cpp
@@ -45,7 +45,7 @@ void MCSectionXCOFF::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
       printCsectDirective(OS);
       break;
     case XCOFF::XMC_TC:
-    case XCOFF::XMC_TE: 
+    case XCOFF::XMC_TE:
       break;
     case XCOFF::XMC_TC0:
       OS << "\t.toc\n";
diff --git a/contrib/libs/llvm12/lib/MC/MCStreamer.cpp b/contrib/libs/llvm12/lib/MC/MCStreamer.cpp
index 50d3fc3c28..4b5ae3cc20 100644
--- a/contrib/libs/llvm12/lib/MC/MCStreamer.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCStreamer.cpp
@@ -22,7 +22,7 @@
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCObjectFileInfo.h"
-#include "llvm/MC/MCPseudoProbe.h" 
+#include "llvm/MC/MCPseudoProbe.h"
 #include "llvm/MC/MCRegister.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSection.h"
@@ -91,7 +91,7 @@ void MCTargetStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {}
 
 MCStreamer::MCStreamer(MCContext &Ctx)
     : Context(Ctx), CurrentWinFrameInfo(nullptr),
-      CurrentProcWinFrameInfoStartIndex(0), UseAssemblerInfoForParsing(false) { 
+      CurrentProcWinFrameInfoStartIndex(0), UseAssemblerInfoForParsing(false) {
   SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
 }
 
@@ -139,22 +139,22 @@ void MCStreamer::emitIntValue(uint64_t Value, unsigned Size) {
   unsigned Index = IsLittleEndian ? 0 : 8 - Size;
   emitBytes(StringRef(reinterpret_cast<char *>(&Swapped) + Index, Size));
 }
-void MCStreamer::emitIntValue(APInt Value) { 
-  if (Value.getNumWords() == 1) { 
-    emitIntValue(Value.getLimitedValue(), Value.getBitWidth() / 8); 
-    return; 
-  } 
-
-  const bool IsLittleEndianTarget = Context.getAsmInfo()->isLittleEndian(); 
-  const bool ShouldSwap = sys::IsLittleEndianHost != IsLittleEndianTarget; 
-  const APInt Swapped = ShouldSwap ? Value.byteSwap() : Value; 
-  const unsigned Size = Value.getBitWidth() / 8; 
-  SmallString<10> Tmp; 
-  Tmp.resize(Size); 
-  StoreIntToMemory(Swapped, reinterpret_cast<uint8_t *>(Tmp.data()), Size); 
-  emitBytes(Tmp.str()); 
-} 
- 
+void MCStreamer::emitIntValue(APInt Value) {
+  if (Value.getNumWords() == 1) {
+    emitIntValue(Value.getLimitedValue(), Value.getBitWidth() / 8);
+    return;
+  }
+
+  const bool IsLittleEndianTarget = Context.getAsmInfo()->isLittleEndian();
+  const bool ShouldSwap = sys::IsLittleEndianHost != IsLittleEndianTarget;
+  const APInt Swapped = ShouldSwap ? Value.byteSwap() : Value;
+  const unsigned Size = Value.getBitWidth() / 8;
+  SmallString<10> Tmp;
+  Tmp.resize(Size);
+  StoreIntToMemory(Swapped, reinterpret_cast<uint8_t *>(Tmp.data()), Size);
+  emitBytes(Tmp.str());
+}
+
 /// EmitULEB128IntValue - Special case of EmitULEB128Value that avoids the
 /// client having to pass in a MCExpr for constant integers.
 void MCStreamer::emitULEB128IntValue(uint64_t Value, unsigned PadTo) {
@@ -218,9 +218,9 @@ void MCStreamer::emitFill(uint64_t NumBytes, uint8_t FillValue) {
   emitFill(*MCConstantExpr::create(NumBytes, getContext()), FillValue);
 }
 
-void llvm::MCStreamer::emitNops(int64_t NumBytes, int64_t ControlledNopLen, 
-                                llvm::SMLoc) {} 
- 
+void llvm::MCStreamer::emitNops(int64_t NumBytes, int64_t ControlledNopLen,
+                                llvm::SMLoc) {}
+
 /// The implementation in this class just redirects to emitFill.
 void MCStreamer::emitZeros(uint64_t NumBytes) { emitFill(NumBytes, 0); }
 
@@ -274,9 +274,9 @@ bool MCStreamer::hasUnfinishedDwarfFrameInfo() {
 
 MCDwarfFrameInfo *MCStreamer::getCurrentDwarfFrameInfo() {
   if (!hasUnfinishedDwarfFrameInfo()) {
-    getContext().reportError(getStartTokLoc(), 
-                             "this directive must appear between " 
-                             ".cfi_startproc and .cfi_endproc directives"); 
+    getContext().reportError(getStartTokLoc(),
+                             "this directive must appear between "
+                             ".cfi_startproc and .cfi_endproc directives");
     return nullptr;
   }
   return &DwarfFrameInfos.back();
@@ -693,7 +693,7 @@ void MCStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc) {
 
   MCSymbol *StartProc = emitCFILabel();
 
-  CurrentProcWinFrameInfoStartIndex = WinFrameInfos.size(); 
+  CurrentProcWinFrameInfoStartIndex = WinFrameInfos.size();
   WinFrameInfos.emplace_back(
       std::make_unique<WinEH::FrameInfo>(Symbol, StartProc));
   CurrentWinFrameInfo = WinFrameInfos.back().get();
@@ -709,13 +709,13 @@ void MCStreamer::EmitWinCFIEndProc(SMLoc Loc) {
 
   MCSymbol *Label = emitCFILabel();
   CurFrame->End = Label;
-  if (!CurFrame->FuncletOrFuncEnd) 
-    CurFrame->FuncletOrFuncEnd = CurFrame->End; 
- 
-  for (size_t I = CurrentProcWinFrameInfoStartIndex, E = WinFrameInfos.size(); 
-       I != E; ++I) 
-    EmitWindowsUnwindTables(WinFrameInfos[I].get()); 
-  SwitchSection(CurFrame->TextSection); 
+  if (!CurFrame->FuncletOrFuncEnd)
+    CurFrame->FuncletOrFuncEnd = CurFrame->End;
+
+  for (size_t I = CurrentProcWinFrameInfoStartIndex, E = WinFrameInfos.size();
+       I != E; ++I)
+    EmitWindowsUnwindTables(WinFrameInfos[I].get());
+  SwitchSection(CurFrame->TextSection);
 }
 
 void MCStreamer::EmitWinCFIFuncletOrFuncEnd(SMLoc Loc) {
@@ -974,13 +974,13 @@ void MCStreamer::emitRawText(const Twine &T) {
 void MCStreamer::EmitWindowsUnwindTables() {
 }
 
-void MCStreamer::EmitWindowsUnwindTables(WinEH::FrameInfo *Frame) { 
-} 
- 
-void MCStreamer::Finish(SMLoc EndLoc) { 
+void MCStreamer::EmitWindowsUnwindTables(WinEH::FrameInfo *Frame) {
+}
+
+void MCStreamer::Finish(SMLoc EndLoc) {
   if ((!DwarfFrameInfos.empty() && !DwarfFrameInfos.back().End) ||
       (!WinFrameInfos.empty() && !WinFrameInfos.back()->End)) {
-    getContext().reportError(EndLoc, "Unfinished frame!"); 
+    getContext().reportError(EndLoc, "Unfinished frame!");
     return;
   }
 
@@ -1043,25 +1043,25 @@ void MCStreamer::emitInstruction(const MCInst &Inst, const MCSubtargetInfo &) {
       visitUsedExpr(*Inst.getOperand(i).getExpr());
 }
 
-void MCStreamer::emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type, 
-                                 uint64_t Attr, 
-                                 const MCPseudoProbeInlineStack &InlineStack) { 
-  auto &Context = getContext(); 
- 
-  // Create a symbol at in the current section for use in the probe. 
-  MCSymbol *ProbeSym = Context.createTempSymbol(); 
- 
-  // Set the value of the symbol to use for the MCPseudoProbe. 
-  emitLabel(ProbeSym); 
- 
-  // Create a (local) probe entry with the symbol. 
-  MCPseudoProbe Probe(ProbeSym, Guid, Index, Type, Attr); 
- 
-  // Add the probe entry to this section's entries. 
-  Context.getMCPseudoProbeTable().getProbeSections().addPseudoProbe( 
-      getCurrentSectionOnly(), Probe, InlineStack); 
-} 
- 
+void MCStreamer::emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type,
+                                 uint64_t Attr,
+                                 const MCPseudoProbeInlineStack &InlineStack) {
+  auto &Context = getContext();
+
+  // Create a symbol at in the current section for use in the probe.
+  MCSymbol *ProbeSym = Context.createTempSymbol();
+
+  // Set the value of the symbol to use for the MCPseudoProbe.
+  emitLabel(ProbeSym);
+
+  // Create a (local) probe entry with the symbol.
+  MCPseudoProbe Probe(ProbeSym, Guid, Index, Type, Attr);
+
+  // Add the probe entry to this section's entries.
+  Context.getMCPseudoProbeTable().getProbeSections().addPseudoProbe(
+      getCurrentSectionOnly(), Probe, InlineStack);
+}
+
 void MCStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
                                         unsigned Size) {
   // Get the Hi-Lo expression.
@@ -1076,7 +1076,7 @@ void MCStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
   }
 
   // Otherwise, emit with .set (aka assignment).
-  MCSymbol *SetLabel = Context.createTempSymbol("set"); 
+  MCSymbol *SetLabel = Context.createTempSymbol("set");
   emitAssignment(SetLabel, Diff);
   emitSymbolValue(SetLabel, Size);
 }
diff --git a/contrib/libs/llvm12/lib/MC/MCSubtargetInfo.cpp b/contrib/libs/llvm12/lib/MC/MCSubtargetInfo.cpp
index 18bace3057..55ada91857 100644
--- a/contrib/libs/llvm12/lib/MC/MCSubtargetInfo.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCSubtargetInfo.cpp
@@ -147,7 +147,7 @@ static void cpuHelp(ArrayRef<SubtargetSubTypeKV> CPUTable) {
   PrintOnce = true;
 }
 
-static FeatureBitset getFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS, 
+static FeatureBitset getFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS,
                                  ArrayRef<SubtargetSubTypeKV> ProcDesc,
                                  ArrayRef<SubtargetFeatureKV> ProcFeatures) {
   SubtargetFeatures Features(FS);
@@ -178,19 +178,19 @@ static FeatureBitset getFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS,
     }
   }
 
-  if (!TuneCPU.empty()) { 
-    const SubtargetSubTypeKV *CPUEntry = Find(TuneCPU, ProcDesc); 
- 
-    // If there is a match 
-    if (CPUEntry) { 
-      // Set the features implied by this CPU feature, if any. 
-      SetImpliedBits(Bits, CPUEntry->TuneImplies.getAsBitset(), ProcFeatures); 
-    } else if (TuneCPU != CPU) { 
-      errs() << "'" << TuneCPU << "' is not a recognized processor for this " 
-             << "target (ignoring processor)\n"; 
-    } 
-  } 
- 
+  if (!TuneCPU.empty()) {
+    const SubtargetSubTypeKV *CPUEntry = Find(TuneCPU, ProcDesc);
+
+    // If there is a match
+    if (CPUEntry) {
+      // Set the features implied by this CPU feature, if any.
+      SetImpliedBits(Bits, CPUEntry->TuneImplies.getAsBitset(), ProcFeatures);
+    } else if (TuneCPU != CPU) {
+      errs() << "'" << TuneCPU << "' is not a recognized processor for this "
+             << "target (ignoring processor)\n";
+    }
+  }
+
   // Iterate through each feature
   for (const std::string &Feature : Features.getFeatures()) {
     // Check for help
@@ -205,33 +205,33 @@ static FeatureBitset getFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS,
   return Bits;
 }
 
-void MCSubtargetInfo::InitMCProcessorInfo(StringRef CPU, StringRef TuneCPU, 
-                                          StringRef FS) { 
-  FeatureBits = getFeatures(CPU, TuneCPU, FS, ProcDesc, ProcFeatures); 
-  if (!TuneCPU.empty()) 
-    CPUSchedModel = &getSchedModelForCPU(TuneCPU); 
+void MCSubtargetInfo::InitMCProcessorInfo(StringRef CPU, StringRef TuneCPU,
+                                          StringRef FS) {
+  FeatureBits = getFeatures(CPU, TuneCPU, FS, ProcDesc, ProcFeatures);
+  if (!TuneCPU.empty())
+    CPUSchedModel = &getSchedModelForCPU(TuneCPU);
   else
     CPUSchedModel = &MCSchedModel::GetDefaultSchedModel();
 }
 
-void MCSubtargetInfo::setDefaultFeatures(StringRef CPU, StringRef TuneCPU, 
-                                         StringRef FS) { 
-  FeatureBits = getFeatures(CPU, TuneCPU, FS, ProcDesc, ProcFeatures); 
+void MCSubtargetInfo::setDefaultFeatures(StringRef CPU, StringRef TuneCPU,
+                                         StringRef FS) {
+  FeatureBits = getFeatures(CPU, TuneCPU, FS, ProcDesc, ProcFeatures);
 }
 
-MCSubtargetInfo::MCSubtargetInfo(const Triple &TT, StringRef C, StringRef TC, 
-                                 StringRef FS, ArrayRef<SubtargetFeatureKV> PF, 
+MCSubtargetInfo::MCSubtargetInfo(const Triple &TT, StringRef C, StringRef TC,
+                                 StringRef FS, ArrayRef<SubtargetFeatureKV> PF,
                                  ArrayRef<SubtargetSubTypeKV> PD,
                                  const MCWriteProcResEntry *WPR,
                                  const MCWriteLatencyEntry *WL,
                                  const MCReadAdvanceEntry *RA,
                                  const InstrStage *IS, const unsigned *OC,
                                  const unsigned *FP)
-    : TargetTriple(TT), CPU(std::string(C)), TuneCPU(std::string(TC)), 
-      ProcFeatures(PF), ProcDesc(PD), WriteProcResTable(WPR), 
-      WriteLatencyTable(WL), ReadAdvanceTable(RA), Stages(IS), 
-      OperandCycles(OC), ForwardingPaths(FP) { 
-  InitMCProcessorInfo(CPU, TuneCPU, FS); 
+    : TargetTriple(TT), CPU(std::string(C)), TuneCPU(std::string(TC)),
+      ProcFeatures(PF), ProcDesc(PD), WriteProcResTable(WPR),
+      WriteLatencyTable(WL), ReadAdvanceTable(RA), Stages(IS),
+      OperandCycles(OC), ForwardingPaths(FP) {
+  InitMCProcessorInfo(CPU, TuneCPU, FS);
 }
 
 FeatureBitset MCSubtargetInfo::ToggleFeature(uint64_t FB) {
diff --git a/contrib/libs/llvm12/lib/MC/MCSymbolXCOFF.cpp b/contrib/libs/llvm12/lib/MC/MCSymbolXCOFF.cpp
index 3f53ebfb26..b9dd2908b4 100644
--- a/contrib/libs/llvm12/lib/MC/MCSymbolXCOFF.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCSymbolXCOFF.cpp
@@ -13,7 +13,7 @@ using namespace llvm;
 MCSectionXCOFF *MCSymbolXCOFF::getRepresentedCsect() const {
   assert(RepresentedCsect &&
          "Trying to get csect representation of this symbol but none was set.");
-  assert(!getName().equals(getUnqualifiedName()) && 
+  assert(!getName().equals(getUnqualifiedName()) &&
          "Symbol does not represent a csect; MCSectionXCOFF that represents "
          "the symbol should not be (but is) set.");
   assert(getSymbolTableName().equals(RepresentedCsect->getSymbolTableName()) &&
@@ -25,9 +25,9 @@ MCSectionXCOFF *MCSymbolXCOFF::getRepresentedCsect() const {
 void MCSymbolXCOFF::setRepresentedCsect(MCSectionXCOFF *C) {
   assert(C && "Assigned csect should not be null.");
   assert((!RepresentedCsect || RepresentedCsect == C) &&
-         "Trying to set a csect that doesn't match the one that this symbol is " 
-         "already mapped to."); 
-  assert(!getName().equals(getUnqualifiedName()) && 
+         "Trying to set a csect that doesn't match the one that this symbol is "
+         "already mapped to.");
+  assert(!getName().equals(getUnqualifiedName()) &&
          "Symbol does not represent a csect; can only set a MCSectionXCOFF "
          "representation for a csect.");
   assert(getSymbolTableName().equals(C->getSymbolTableName()) &&
diff --git a/contrib/libs/llvm12/lib/MC/MCWin64EH.cpp b/contrib/libs/llvm12/lib/MC/MCWin64EH.cpp
index d1f6dca06c..de1b0fd3c7 100644
--- a/contrib/libs/llvm12/lib/MC/MCWin64EH.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCWin64EH.cpp
@@ -238,9 +238,9 @@ void llvm::Win64EH::UnwindEmitter::Emit(MCStreamer &Streamer) const {
   }
 }
 
-void llvm::Win64EH::UnwindEmitter::EmitUnwindInfo(MCStreamer &Streamer, 
-                                                  WinEH::FrameInfo *info, 
-                                                  bool HandlerData) const { 
+void llvm::Win64EH::UnwindEmitter::EmitUnwindInfo(MCStreamer &Streamer,
+                                                  WinEH::FrameInfo *info,
+                                                  bool HandlerData) const {
   // Switch sections (the static function above is meant to be called from
   // here and from Emit().
   MCSection *XData = Streamer.getAssociatedXDataSection(info->TextSection);
@@ -265,7 +265,7 @@ static int64_t GetAbsDifference(MCStreamer &Streamer, const MCSymbol *LHS,
   return value;
 }
 
-static uint32_t ARM64CountOfUnwindCodes(ArrayRef<WinEH::Instruction> Insns) { 
+static uint32_t ARM64CountOfUnwindCodes(ArrayRef<WinEH::Instruction> Insns) {
   uint32_t Count = 0;
   for (const auto &I : Insns) {
     switch (static_cast<Win64EH::UnwindOpcodes>(I.Operation)) {
@@ -280,9 +280,9 @@ static uint32_t ARM64CountOfUnwindCodes(ArrayRef<WinEH::Instruction> Insns) {
     case Win64EH::UOP_AllocLarge:
       Count += 4;
       break;
-    case Win64EH::UOP_SaveR19R20X: 
-      Count += 1; 
-      break; 
+    case Win64EH::UOP_SaveR19R20X:
+      Count += 1;
+      break;
     case Win64EH::UOP_SaveFPLRX:
       Count += 1;
       break;
@@ -301,9 +301,9 @@ static uint32_t ARM64CountOfUnwindCodes(ArrayRef<WinEH::Instruction> Insns) {
     case Win64EH::UOP_SaveRegX:
       Count += 2;
       break;
-    case Win64EH::UOP_SaveLRPair: 
-      Count += 2; 
-      break; 
+    case Win64EH::UOP_SaveLRPair:
+      Count += 2;
+      break;
     case Win64EH::UOP_SaveFReg:
       Count += 2;
       break;
@@ -328,21 +328,21 @@ static uint32_t ARM64CountOfUnwindCodes(ArrayRef<WinEH::Instruction> Insns) {
     case Win64EH::UOP_End:
       Count += 1;
       break;
-    case Win64EH::UOP_SaveNext: 
-      Count += 1; 
-      break; 
-    case Win64EH::UOP_TrapFrame: 
-      Count += 1; 
-      break; 
-    case Win64EH::UOP_PushMachFrame: 
-      Count += 1; 
-      break; 
-    case Win64EH::UOP_Context: 
-      Count += 1; 
-      break; 
-    case Win64EH::UOP_ClearUnwoundToCall: 
-      Count += 1; 
-      break; 
+    case Win64EH::UOP_SaveNext:
+      Count += 1;
+      break;
+    case Win64EH::UOP_TrapFrame:
+      Count += 1;
+      break;
+    case Win64EH::UOP_PushMachFrame:
+      Count += 1;
+      break;
+    case Win64EH::UOP_Context:
+      Count += 1;
+      break;
+    case Win64EH::UOP_ClearUnwoundToCall:
+      Count += 1;
+      break;
     }
   }
   return Count;
@@ -396,11 +396,11 @@ static void ARM64EmitUnwindCode(MCStreamer &streamer, const MCSymbol *begin,
     b = 0xE3;
     streamer.emitInt8(b);
     break;
-  case Win64EH::UOP_SaveR19R20X: 
-    b = 0x20; 
-    b |= (inst.Offset >> 3) & 0x1F; 
-    streamer.emitInt8(b); 
-    break; 
+  case Win64EH::UOP_SaveR19R20X:
+    b = 0x20;
+    b |= (inst.Offset >> 3) & 0x1F;
+    streamer.emitInt8(b);
+    break;
   case Win64EH::UOP_SaveFPLRX:
     b = 0x80;
     b |= ((inst.Offset - 1) >> 3) & 0x3F;
@@ -443,16 +443,16 @@ static void ARM64EmitUnwindCode(MCStreamer &streamer, const MCSymbol *begin,
     b = ((reg & 0x3) << 6) | ((inst.Offset >> 3) - 1);
     streamer.emitInt8(b);
     break;
-  case Win64EH::UOP_SaveLRPair: 
-    assert(inst.Register >= 19 && "Saved reg must be >= 19"); 
-    reg = inst.Register - 19; 
-    assert((reg % 2) == 0 && "Saved reg must be 19+2*X"); 
-    reg /= 2; 
-    b = 0xD6 | ((reg & 0x7) >> 2); 
-    streamer.emitInt8(b); 
-    b = ((reg & 0x3) << 6) | (inst.Offset >> 3); 
-    streamer.emitInt8(b); 
-    break; 
+  case Win64EH::UOP_SaveLRPair:
+    assert(inst.Register >= 19 && "Saved reg must be >= 19");
+    reg = inst.Register - 19;
+    assert((reg % 2) == 0 && "Saved reg must be 19+2*X");
+    reg /= 2;
+    b = 0xD6 | ((reg & 0x7) >> 2);
+    streamer.emitInt8(b);
+    b = ((reg & 0x3) << 6) | (inst.Offset >> 3);
+    streamer.emitInt8(b);
+    break;
   case Win64EH::UOP_SaveFReg:
     assert(inst.Register >= 8 && "Saved dreg must be >= 8");
     reg = inst.Register - 8;
@@ -489,26 +489,26 @@ static void ARM64EmitUnwindCode(MCStreamer &streamer, const MCSymbol *begin,
     b = 0xE4;
     streamer.emitInt8(b);
     break;
-  case Win64EH::UOP_SaveNext: 
-    b = 0xE6; 
-    streamer.emitInt8(b); 
-    break; 
-  case Win64EH::UOP_TrapFrame: 
-    b = 0xE8; 
-    streamer.emitInt8(b); 
-    break; 
-  case Win64EH::UOP_PushMachFrame: 
-    b = 0xE9; 
-    streamer.emitInt8(b); 
-    break; 
-  case Win64EH::UOP_Context: 
-    b = 0xEA; 
-    streamer.emitInt8(b); 
-    break; 
-  case Win64EH::UOP_ClearUnwoundToCall: 
-    b = 0xEC; 
-    streamer.emitInt8(b); 
-    break; 
+  case Win64EH::UOP_SaveNext:
+    b = 0xE6;
+    streamer.emitInt8(b);
+    break;
+  case Win64EH::UOP_TrapFrame:
+    b = 0xE8;
+    streamer.emitInt8(b);
+    break;
+  case Win64EH::UOP_PushMachFrame:
+    b = 0xE9;
+    streamer.emitInt8(b);
+    break;
+  case Win64EH::UOP_Context:
+    b = 0xEA;
+    streamer.emitInt8(b);
+    break;
+  case Win64EH::UOP_ClearUnwoundToCall:
+    b = 0xEC;
+    streamer.emitInt8(b);
+    break;
   }
 }
 
@@ -544,367 +544,367 @@ FindMatchingEpilog(const std::vector<WinEH::Instruction>& EpilogInstrs,
   return nullptr;
 }
 
-static void simplifyOpcodes(std::vector<WinEH::Instruction> &Instructions, 
-                            bool Reverse) { 
-  unsigned PrevOffset = -1; 
-  unsigned PrevRegister = -1; 
- 
-  auto VisitInstruction = [&](WinEH::Instruction &Inst) { 
-    // Convert 2-byte opcodes into equivalent 1-byte ones. 
-    if (Inst.Operation == Win64EH::UOP_SaveRegP && Inst.Register == 29) { 
-      Inst.Operation = Win64EH::UOP_SaveFPLR; 
-      Inst.Register = -1; 
-    } else if (Inst.Operation == Win64EH::UOP_SaveRegPX && 
-               Inst.Register == 29) { 
-      Inst.Operation = Win64EH::UOP_SaveFPLRX; 
-      Inst.Register = -1; 
-    } else if (Inst.Operation == Win64EH::UOP_SaveRegPX && 
-               Inst.Register == 19 && Inst.Offset <= 248) { 
-      Inst.Operation = Win64EH::UOP_SaveR19R20X; 
-      Inst.Register = -1; 
-    } else if (Inst.Operation == Win64EH::UOP_AddFP && Inst.Offset == 0) { 
-      Inst.Operation = Win64EH::UOP_SetFP; 
-    } else if (Inst.Operation == Win64EH::UOP_SaveRegP && 
-               Inst.Register == PrevRegister + 2 && 
-               Inst.Offset == PrevOffset + 16) { 
-      Inst.Operation = Win64EH::UOP_SaveNext; 
-      Inst.Register = -1; 
-      Inst.Offset = 0; 
-      // Intentionally not creating UOP_SaveNext for float register pairs, 
-      // as current versions of Windows (up to at least 20.04) is buggy 
-      // regarding SaveNext for float pairs. 
-    } 
-    // Update info about the previous instruction, for detecting if 
-    // the next one can be made a UOP_SaveNext 
-    if (Inst.Operation == Win64EH::UOP_SaveR19R20X) { 
-      PrevOffset = 0; 
-      PrevRegister = 19; 
-    } else if (Inst.Operation == Win64EH::UOP_SaveRegPX) { 
-      PrevOffset = 0; 
-      PrevRegister = Inst.Register; 
-    } else if (Inst.Operation == Win64EH::UOP_SaveRegP) { 
-      PrevOffset = Inst.Offset; 
-      PrevRegister = Inst.Register; 
-    } else if (Inst.Operation == Win64EH::UOP_SaveNext) { 
-      PrevRegister += 2; 
-      PrevOffset += 16; 
-    } else { 
-      PrevRegister = -1; 
-      PrevOffset = -1; 
-    } 
-  }; 
- 
-  // Iterate over instructions in a forward order (for prologues), 
-  // backwards for epilogues (i.e. always reverse compared to how the 
-  // opcodes are stored). 
-  if (Reverse) { 
-    for (auto It = Instructions.rbegin(); It != Instructions.rend(); It++) 
-      VisitInstruction(*It); 
-  } else { 
-    for (WinEH::Instruction &Inst : Instructions) 
-      VisitInstruction(Inst); 
-  } 
-} 
- 
-static int checkPackedEpilog(MCStreamer &streamer, WinEH::FrameInfo *info, 
-                             int PrologCodeBytes) { 
-  // Can only pack if there's one single epilog 
-  if (info->EpilogMap.size() != 1) 
-    return -1; 
- 
-  const std::vector<WinEH::Instruction> &Epilog = 
-      info->EpilogMap.begin()->second; 
- 
-  // Can pack if the epilog is a subset of the prolog but not vice versa 
-  if (Epilog.size() > info->Instructions.size()) 
-    return -1; 
- 
-  // Check that the epilog actually is a perfect match for the end (backwrds) 
-  // of the prolog. 
-  for (int I = Epilog.size() - 1; I >= 0; I--) { 
-    if (info->Instructions[I] != Epilog[Epilog.size() - 1 - I]) 
-      return -1; 
-  } 
- 
-  // Check that the epilog actually is at the very end of the function, 
-  // otherwise it can't be packed. 
-  uint32_t DistanceFromEnd = (uint32_t)GetAbsDifference( 
-      streamer, info->FuncletOrFuncEnd, info->EpilogMap.begin()->first); 
-  if (DistanceFromEnd / 4 != Epilog.size()) 
-    return -1; 
- 
-  int Offset = Epilog.size() == info->Instructions.size() 
-                   ? 0 
-                   : ARM64CountOfUnwindCodes(ArrayRef<WinEH::Instruction>( 
-                         &info->Instructions[Epilog.size()], 
-                         info->Instructions.size() - Epilog.size())); 
- 
-  // Check that the offset and prolog size fits in the first word; it's 
-  // unclear whether the epilog count in the extension word can be taken 
-  // as packed epilog offset. 
-  if (Offset > 31 || PrologCodeBytes > 124) 
-    return -1; 
- 
-  info->EpilogMap.clear(); 
-  return Offset; 
-} 
- 
-static bool tryPackedUnwind(WinEH::FrameInfo *info, uint32_t FuncLength, 
-                            int PackedEpilogOffset) { 
-  if (PackedEpilogOffset == 0) { 
-    // Fully symmetric prolog and epilog, should be ok for packed format. 
-    // For CR=3, the corresponding synthesized epilog actually lacks the 
-    // SetFP opcode, but unwinding should work just fine despite that 
-    // (if at the SetFP opcode, the unwinder considers it as part of the 
-    // function body and just unwinds the full prolog instead). 
-  } else if (PackedEpilogOffset == 1) { 
-    // One single case of differences between prolog and epilog is allowed: 
-    // The epilog can lack a single SetFP that is the last opcode in the 
-    // prolog, for the CR=3 case. 
-    if (info->Instructions.back().Operation != Win64EH::UOP_SetFP) 
-      return false; 
-  } else { 
-    // Too much difference between prolog and epilog. 
-    return false; 
-  } 
-  unsigned RegI = 0, RegF = 0; 
-  int Predecrement = 0; 
-  enum { 
-    Start, 
-    Start2, 
-    IntRegs, 
-    FloatRegs, 
-    InputArgs, 
-    StackAdjust, 
-    FrameRecord, 
-    End 
-  } Location = Start; 
-  bool StandaloneLR = false, FPLRPair = false; 
-  int StackOffset = 0; 
-  int Nops = 0; 
-  // Iterate over the prolog and check that all opcodes exactly match 
-  // the canonical order and form. A more lax check could verify that 
-  // all saved registers are in the expected locations, but not enforce 
-  // the order - that would work fine when unwinding from within 
-  // functions, but not be exactly right if unwinding happens within 
-  // prologs/epilogs. 
-  for (const WinEH::Instruction &Inst : info->Instructions) { 
-    switch (Inst.Operation) { 
-    case Win64EH::UOP_End: 
-      if (Location != Start) 
-        return false; 
-      Location = Start2; 
-      break; 
-    case Win64EH::UOP_SaveR19R20X: 
-      if (Location != Start2) 
-        return false; 
-      Predecrement = Inst.Offset; 
-      RegI = 2; 
-      Location = IntRegs; 
-      break; 
-    case Win64EH::UOP_SaveRegX: 
-      if (Location != Start2) 
-        return false; 
-      Predecrement = Inst.Offset; 
-      if (Inst.Register == 19) 
-        RegI += 1; 
-      else if (Inst.Register == 30) 
-        StandaloneLR = true; 
-      else 
-        return false; 
-      // Odd register; can't be any further int registers. 
-      Location = FloatRegs; 
-      break; 
-    case Win64EH::UOP_SaveRegPX: 
-      // Can't have this in a canonical prologue. Either this has been 
-      // canonicalized into SaveR19R20X or SaveFPLRX, or it's an unsupported 
-      // register pair. 
-      // It can't be canonicalized into SaveR19R20X if the offset is 
-      // larger than 248 bytes, but even with the maximum case with 
-      // RegI=10/RegF=8/CR=1/H=1, we end up with SavSZ = 216, which should 
-      // fit into SaveR19R20X. 
-      // The unwinding opcodes can't describe the otherwise seemingly valid 
-      // case for RegI=1 CR=1, that would start with a 
-      // "stp x19, lr, [sp, #-...]!" as that fits neither SaveRegPX nor 
-      // SaveLRPair. 
-      return false; 
-    case Win64EH::UOP_SaveRegP: 
-      if (Location != IntRegs || Inst.Offset != 8 * RegI || 
-          Inst.Register != 19 + RegI) 
-        return false; 
-      RegI += 2; 
-      break; 
-    case Win64EH::UOP_SaveReg: 
-      if (Location != IntRegs || Inst.Offset != 8 * RegI) 
-        return false; 
-      if (Inst.Register == 19 + RegI) 
-        RegI += 1; 
-      else if (Inst.Register == 30) 
-        StandaloneLR = true; 
-      else 
-        return false; 
-      // Odd register; can't be any further int registers. 
-      Location = FloatRegs; 
-      break; 
-    case Win64EH::UOP_SaveLRPair: 
-      if (Location != IntRegs || Inst.Offset != 8 * RegI || 
-          Inst.Register != 19 + RegI) 
-        return false; 
-      RegI += 1; 
-      StandaloneLR = true; 
-      Location = FloatRegs; 
-      break; 
-    case Win64EH::UOP_SaveFRegX: 
-      // Packed unwind can't handle prologs that only save one single 
-      // float register. 
-      return false; 
-    case Win64EH::UOP_SaveFReg: 
-      if (Location != FloatRegs || RegF == 0 || Inst.Register != 8 + RegF || 
-          Inst.Offset != 8 * (RegI + (StandaloneLR ? 1 : 0) + RegF)) 
-        return false; 
-      RegF += 1; 
-      Location = InputArgs; 
-      break; 
-    case Win64EH::UOP_SaveFRegPX: 
-      if (Location != Start2 || Inst.Register != 8) 
-        return false; 
-      Predecrement = Inst.Offset; 
-      RegF = 2; 
-      Location = FloatRegs; 
-      break; 
-    case Win64EH::UOP_SaveFRegP: 
-      if ((Location != IntRegs && Location != FloatRegs) || 
-          Inst.Register != 8 + RegF || 
-          Inst.Offset != 8 * (RegI + (StandaloneLR ? 1 : 0) + RegF)) 
-        return false; 
-      RegF += 2; 
-      Location = FloatRegs; 
-      break; 
-    case Win64EH::UOP_SaveNext: 
-      if (Location == IntRegs) 
-        RegI += 2; 
-      else if (Location == FloatRegs) 
-        RegF += 2; 
-      else 
-        return false; 
-      break; 
-    case Win64EH::UOP_Nop: 
-      if (Location != IntRegs && Location != FloatRegs && Location != InputArgs) 
-        return false; 
-      Location = InputArgs; 
-      Nops++; 
-      break; 
-    case Win64EH::UOP_AllocSmall: 
-    case Win64EH::UOP_AllocMedium: 
-      if (Location != Start2 && Location != IntRegs && Location != FloatRegs && 
-          Location != InputArgs && Location != StackAdjust) 
-        return false; 
-      // Can have either a single decrement, or a pair of decrements with 
-      // 4080 and another decrement. 
-      if (StackOffset == 0) 
-        StackOffset = Inst.Offset; 
-      else if (StackOffset != 4080) 
-        return false; 
-      else 
-        StackOffset += Inst.Offset; 
-      Location = StackAdjust; 
-      break; 
-    case Win64EH::UOP_SaveFPLRX: 
-      // Not allowing FPLRX after StackAdjust; if a StackAdjust is used, it 
-      // should be followed by a FPLR instead. 
-      if (Location != Start2 && Location != IntRegs && Location != FloatRegs && 
-          Location != InputArgs) 
-        return false; 
-      StackOffset = Inst.Offset; 
-      Location = FrameRecord; 
-      FPLRPair = true; 
-      break; 
-    case Win64EH::UOP_SaveFPLR: 
-      // This can only follow after a StackAdjust 
-      if (Location != StackAdjust || Inst.Offset != 0) 
-        return false; 
-      Location = FrameRecord; 
-      FPLRPair = true; 
-      break; 
-    case Win64EH::UOP_SetFP: 
-      if (Location != FrameRecord) 
-        return false; 
-      Location = End; 
-      break; 
-    } 
-  } 
-  if (RegI > 10 || RegF > 8) 
-    return false; 
-  if (StandaloneLR && FPLRPair) 
-    return false; 
-  if (FPLRPair && Location != End) 
-    return false; 
-  if (Nops != 0 && Nops != 4) 
-    return false; 
-  int H = Nops == 4; 
-  int IntSZ = 8 * RegI; 
-  if (StandaloneLR) 
-    IntSZ += 8; 
-  int FpSZ = 8 * RegF; // RegF not yet decremented 
-  int SavSZ = (IntSZ + FpSZ + 8 * 8 * H + 0xF) & ~0xF; 
-  if (Predecrement != SavSZ) 
-    return false; 
-  if (FPLRPair && StackOffset < 16) 
-    return false; 
-  if (StackOffset % 16) 
-    return false; 
-  uint32_t FrameSize = (StackOffset + SavSZ) / 16; 
-  if (FrameSize > 0x1FF) 
-    return false; 
-  assert(RegF != 1 && "One single float reg not allowed"); 
-  if (RegF > 0) 
-    RegF--; // Convert from actual number of registers, to value stored 
-  assert(FuncLength <= 0x7FF && "FuncLength should have been checked earlier"); 
-  int Flag = 0x01; // Function segments not supported yet 
-  int CR = FPLRPair ? 3 : StandaloneLR ? 1 : 0; 
-  info->PackedInfo |= Flag << 0; 
-  info->PackedInfo |= (FuncLength & 0x7FF) << 2; 
-  info->PackedInfo |= (RegF & 0x7) << 13; 
-  info->PackedInfo |= (RegI & 0xF) << 16; 
-  info->PackedInfo |= (H & 0x1) << 20; 
-  info->PackedInfo |= (CR & 0x3) << 21; 
-  info->PackedInfo |= (FrameSize & 0x1FF) << 23; 
-  return true; 
-} 
- 
+static void simplifyOpcodes(std::vector<WinEH::Instruction> &Instructions,
+                            bool Reverse) {
+  unsigned PrevOffset = -1;
+  unsigned PrevRegister = -1;
+
+  auto VisitInstruction = [&](WinEH::Instruction &Inst) {
+    // Convert 2-byte opcodes into equivalent 1-byte ones.
+    if (Inst.Operation == Win64EH::UOP_SaveRegP && Inst.Register == 29) {
+      Inst.Operation = Win64EH::UOP_SaveFPLR;
+      Inst.Register = -1;
+    } else if (Inst.Operation == Win64EH::UOP_SaveRegPX &&
+               Inst.Register == 29) {
+      Inst.Operation = Win64EH::UOP_SaveFPLRX;
+      Inst.Register = -1;
+    } else if (Inst.Operation == Win64EH::UOP_SaveRegPX &&
+               Inst.Register == 19 && Inst.Offset <= 248) {
+      Inst.Operation = Win64EH::UOP_SaveR19R20X;
+      Inst.Register = -1;
+    } else if (Inst.Operation == Win64EH::UOP_AddFP && Inst.Offset == 0) {
+      Inst.Operation = Win64EH::UOP_SetFP;
+    } else if (Inst.Operation == Win64EH::UOP_SaveRegP &&
+               Inst.Register == PrevRegister + 2 &&
+               Inst.Offset == PrevOffset + 16) {
+      Inst.Operation = Win64EH::UOP_SaveNext;
+      Inst.Register = -1;
+      Inst.Offset = 0;
+      // Intentionally not creating UOP_SaveNext for float register pairs,
+      // as current versions of Windows (up to at least 20.04) is buggy
+      // regarding SaveNext for float pairs.
+    }
+    // Update info about the previous instruction, for detecting if
+    // the next one can be made a UOP_SaveNext
+    if (Inst.Operation == Win64EH::UOP_SaveR19R20X) {
+      PrevOffset = 0;
+      PrevRegister = 19;
+    } else if (Inst.Operation == Win64EH::UOP_SaveRegPX) {
+      PrevOffset = 0;
+      PrevRegister = Inst.Register;
+    } else if (Inst.Operation == Win64EH::UOP_SaveRegP) {
+      PrevOffset = Inst.Offset;
+      PrevRegister = Inst.Register;
+    } else if (Inst.Operation == Win64EH::UOP_SaveNext) {
+      PrevRegister += 2;
+      PrevOffset += 16;
+    } else {
+      PrevRegister = -1;
+      PrevOffset = -1;
+    }
+  };
+
+  // Iterate over instructions in a forward order (for prologues),
+  // backwards for epilogues (i.e. always reverse compared to how the
+  // opcodes are stored).
+  if (Reverse) {
+    for (auto It = Instructions.rbegin(); It != Instructions.rend(); It++)
+      VisitInstruction(*It);
+  } else {
+    for (WinEH::Instruction &Inst : Instructions)
+      VisitInstruction(Inst);
+  }
+}
+
+static int checkPackedEpilog(MCStreamer &streamer, WinEH::FrameInfo *info,
+                             int PrologCodeBytes) {
+  // Can only pack if there's one single epilog
+  if (info->EpilogMap.size() != 1)
+    return -1;
+
+  const std::vector<WinEH::Instruction> &Epilog =
+      info->EpilogMap.begin()->second;
+
+  // Can pack if the epilog is a subset of the prolog but not vice versa
+  if (Epilog.size() > info->Instructions.size())
+    return -1;
+
+  // Check that the epilog actually is a perfect match for the end (backwrds)
+  // of the prolog.
+  for (int I = Epilog.size() - 1; I >= 0; I--) {
+    if (info->Instructions[I] != Epilog[Epilog.size() - 1 - I])
+      return -1;
+  }
+
+  // Check that the epilog actually is at the very end of the function,
+  // otherwise it can't be packed.
+  uint32_t DistanceFromEnd = (uint32_t)GetAbsDifference(
+      streamer, info->FuncletOrFuncEnd, info->EpilogMap.begin()->first);
+  if (DistanceFromEnd / 4 != Epilog.size())
+    return -1;
+
+  int Offset = Epilog.size() == info->Instructions.size()
+                   ? 0
+                   : ARM64CountOfUnwindCodes(ArrayRef<WinEH::Instruction>(
+                         &info->Instructions[Epilog.size()],
+                         info->Instructions.size() - Epilog.size()));
+
+  // Check that the offset and prolog size fits in the first word; it's
+  // unclear whether the epilog count in the extension word can be taken
+  // as packed epilog offset.
+  if (Offset > 31 || PrologCodeBytes > 124)
+    return -1;
+
+  info->EpilogMap.clear();
+  return Offset;
+}
+
+static bool tryPackedUnwind(WinEH::FrameInfo *info, uint32_t FuncLength,
+                            int PackedEpilogOffset) {
+  if (PackedEpilogOffset == 0) {
+    // Fully symmetric prolog and epilog, should be ok for packed format.
+    // For CR=3, the corresponding synthesized epilog actually lacks the
+    // SetFP opcode, but unwinding should work just fine despite that
+    // (if at the SetFP opcode, the unwinder considers it as part of the
+    // function body and just unwinds the full prolog instead).
+  } else if (PackedEpilogOffset == 1) {
+    // One single case of differences between prolog and epilog is allowed:
+    // The epilog can lack a single SetFP that is the last opcode in the
+    // prolog, for the CR=3 case.
+    if (info->Instructions.back().Operation != Win64EH::UOP_SetFP)
+      return false;
+  } else {
+    // Too much difference between prolog and epilog.
+    return false;
+  }
+  unsigned RegI = 0, RegF = 0;
+  int Predecrement = 0;
+  enum {
+    Start,
+    Start2,
+    IntRegs,
+    FloatRegs,
+    InputArgs,
+    StackAdjust,
+    FrameRecord,
+    End
+  } Location = Start;
+  bool StandaloneLR = false, FPLRPair = false;
+  int StackOffset = 0;
+  int Nops = 0;
+  // Iterate over the prolog and check that all opcodes exactly match
+  // the canonical order and form. A more lax check could verify that
+  // all saved registers are in the expected locations, but not enforce
+  // the order - that would work fine when unwinding from within
+  // functions, but not be exactly right if unwinding happens within
+  // prologs/epilogs.
+  for (const WinEH::Instruction &Inst : info->Instructions) {
+    switch (Inst.Operation) {
+    case Win64EH::UOP_End:
+      if (Location != Start)
+        return false;
+      Location = Start2;
+      break;
+    case Win64EH::UOP_SaveR19R20X:
+      if (Location != Start2)
+        return false;
+      Predecrement = Inst.Offset;
+      RegI = 2;
+      Location = IntRegs;
+      break;
+    case Win64EH::UOP_SaveRegX:
+      if (Location != Start2)
+        return false;
+      Predecrement = Inst.Offset;
+      if (Inst.Register == 19)
+        RegI += 1;
+      else if (Inst.Register == 30)
+        StandaloneLR = true;
+      else
+        return false;
+      // Odd register; can't be any further int registers.
+      Location = FloatRegs;
+      break;
+    case Win64EH::UOP_SaveRegPX:
+      // Can't have this in a canonical prologue. Either this has been
+      // canonicalized into SaveR19R20X or SaveFPLRX, or it's an unsupported
+      // register pair.
+      // It can't be canonicalized into SaveR19R20X if the offset is
+      // larger than 248 bytes, but even with the maximum case with
+      // RegI=10/RegF=8/CR=1/H=1, we end up with SavSZ = 216, which should
+      // fit into SaveR19R20X.
+      // The unwinding opcodes can't describe the otherwise seemingly valid
+      // case for RegI=1 CR=1, that would start with a
+      // "stp x19, lr, [sp, #-...]!" as that fits neither SaveRegPX nor
+      // SaveLRPair.
+      return false;
+    case Win64EH::UOP_SaveRegP:
+      if (Location != IntRegs || Inst.Offset != 8 * RegI ||
+          Inst.Register != 19 + RegI)
+        return false;
+      RegI += 2;
+      break;
+    case Win64EH::UOP_SaveReg:
+      if (Location != IntRegs || Inst.Offset != 8 * RegI)
+        return false;
+      if (Inst.Register == 19 + RegI)
+        RegI += 1;
+      else if (Inst.Register == 30)
+        StandaloneLR = true;
+      else
+        return false;
+      // Odd register; can't be any further int registers.
+      Location = FloatRegs;
+      break;
+    case Win64EH::UOP_SaveLRPair:
+      if (Location != IntRegs || Inst.Offset != 8 * RegI ||
+          Inst.Register != 19 + RegI)
+        return false;
+      RegI += 1;
+      StandaloneLR = true;
+      Location = FloatRegs;
+      break;
+    case Win64EH::UOP_SaveFRegX:
+      // Packed unwind can't handle prologs that only save one single
+      // float register.
+      return false;
+    case Win64EH::UOP_SaveFReg:
+      if (Location != FloatRegs || RegF == 0 || Inst.Register != 8 + RegF ||
+          Inst.Offset != 8 * (RegI + (StandaloneLR ? 1 : 0) + RegF))
+        return false;
+      RegF += 1;
+      Location = InputArgs;
+      break;
+    case Win64EH::UOP_SaveFRegPX:
+      if (Location != Start2 || Inst.Register != 8)
+        return false;
+      Predecrement = Inst.Offset;
+      RegF = 2;
+      Location = FloatRegs;
+      break;
+    case Win64EH::UOP_SaveFRegP:
+      if ((Location != IntRegs && Location != FloatRegs) ||
+          Inst.Register != 8 + RegF ||
+          Inst.Offset != 8 * (RegI + (StandaloneLR ? 1 : 0) + RegF))
+        return false;
+      RegF += 2;
+      Location = FloatRegs;
+      break;
+    case Win64EH::UOP_SaveNext:
+      if (Location == IntRegs)
+        RegI += 2;
+      else if (Location == FloatRegs)
+        RegF += 2;
+      else
+        return false;
+      break;
+    case Win64EH::UOP_Nop:
+      if (Location != IntRegs && Location != FloatRegs && Location != InputArgs)
+        return false;
+      Location = InputArgs;
+      Nops++;
+      break;
+    case Win64EH::UOP_AllocSmall:
+    case Win64EH::UOP_AllocMedium:
+      if (Location != Start2 && Location != IntRegs && Location != FloatRegs &&
+          Location != InputArgs && Location != StackAdjust)
+        return false;
+      // Can have either a single decrement, or a pair of decrements with
+      // 4080 and another decrement.
+      if (StackOffset == 0)
+        StackOffset = Inst.Offset;
+      else if (StackOffset != 4080)
+        return false;
+      else
+        StackOffset += Inst.Offset;
+      Location = StackAdjust;
+      break;
+    case Win64EH::UOP_SaveFPLRX:
+      // Not allowing FPLRX after StackAdjust; if a StackAdjust is used, it
+      // should be followed by a FPLR instead.
+      if (Location != Start2 && Location != IntRegs && Location != FloatRegs &&
+          Location != InputArgs)
+        return false;
+      StackOffset = Inst.Offset;
+      Location = FrameRecord;
+      FPLRPair = true;
+      break;
+    case Win64EH::UOP_SaveFPLR:
+      // This can only follow after a StackAdjust
+      if (Location != StackAdjust || Inst.Offset != 0)
+        return false;
+      Location = FrameRecord;
+      FPLRPair = true;
+      break;
+    case Win64EH::UOP_SetFP:
+      if (Location != FrameRecord)
+        return false;
+      Location = End;
+      break;
+    }
+  }
+  if (RegI > 10 || RegF > 8)
+    return false;
+  if (StandaloneLR && FPLRPair)
+    return false;
+  if (FPLRPair && Location != End)
+    return false;
+  if (Nops != 0 && Nops != 4)
+    return false;
+  int H = Nops == 4;
+  int IntSZ = 8 * RegI;
+  if (StandaloneLR)
+    IntSZ += 8;
+  int FpSZ = 8 * RegF; // RegF not yet decremented
+  int SavSZ = (IntSZ + FpSZ + 8 * 8 * H + 0xF) & ~0xF;
+  if (Predecrement != SavSZ)
+    return false;
+  if (FPLRPair && StackOffset < 16)
+    return false;
+  if (StackOffset % 16)
+    return false;
+  uint32_t FrameSize = (StackOffset + SavSZ) / 16;
+  if (FrameSize > 0x1FF)
+    return false;
+  assert(RegF != 1 && "One single float reg not allowed");
+  if (RegF > 0)
+    RegF--; // Convert from actual number of registers, to value stored
+  assert(FuncLength <= 0x7FF && "FuncLength should have been checked earlier");
+  int Flag = 0x01; // Function segments not supported yet
+  int CR = FPLRPair ? 3 : StandaloneLR ? 1 : 0;
+  info->PackedInfo |= Flag << 0;
+  info->PackedInfo |= (FuncLength & 0x7FF) << 2;
+  info->PackedInfo |= (RegF & 0x7) << 13;
+  info->PackedInfo |= (RegI & 0xF) << 16;
+  info->PackedInfo |= (H & 0x1) << 20;
+  info->PackedInfo |= (CR & 0x3) << 21;
+  info->PackedInfo |= (FrameSize & 0x1FF) << 23;
+  return true;
+}
+
 // Populate the .xdata section.  The format of .xdata on ARM64 is documented at
 // https://docs.microsoft.com/en-us/cpp/build/arm64-exception-handling
-static void ARM64EmitUnwindInfo(MCStreamer &streamer, WinEH::FrameInfo *info, 
-                                bool TryPacked = true) { 
+static void ARM64EmitUnwindInfo(MCStreamer &streamer, WinEH::FrameInfo *info,
+                                bool TryPacked = true) {
   // If this UNWIND_INFO already has a symbol, it's already been emitted.
   if (info->Symbol)
     return;
-  // If there's no unwind info here (not even a terminating UOP_End), the 
-  // unwind info is considered bogus and skipped. If this was done in 
-  // response to an explicit .seh_handlerdata, the associated trailing 
-  // handler data is left orphaned in the xdata section. 
-  if (info->empty()) { 
-    info->EmitAttempted = true; 
-    return; 
-  } 
-  if (info->EmitAttempted) { 
-    // If we tried to emit unwind info before (due to an explicit 
-    // .seh_handlerdata directive), but skipped it (because there was no 
-    // valid information to emit at the time), and it later got valid unwind 
-    // opcodes, we can't emit it here, because the trailing handler data 
-    // was already emitted elsewhere in the xdata section. 
-    streamer.getContext().reportError( 
-        SMLoc(), "Earlier .seh_handlerdata for " + info->Function->getName() + 
-                     " skipped due to no unwind info at the time " 
-                     "(.seh_handlerdata too early?), but the function later " 
-                     "did get unwind info that can't be emitted"); 
-    return; 
-  } 
-
-  simplifyOpcodes(info->Instructions, false); 
-  for (auto &I : info->EpilogMap) 
-    simplifyOpcodes(I.second, true); 
- 
+  // If there's no unwind info here (not even a terminating UOP_End), the
+  // unwind info is considered bogus and skipped. If this was done in
+  // response to an explicit .seh_handlerdata, the associated trailing
+  // handler data is left orphaned in the xdata section.
+  if (info->empty()) {
+    info->EmitAttempted = true;
+    return;
+  }
+  if (info->EmitAttempted) {
+    // If we tried to emit unwind info before (due to an explicit
+    // .seh_handlerdata directive), but skipped it (because there was no
+    // valid information to emit at the time), and it later got valid unwind
+    // opcodes, we can't emit it here, because the trailing handler data
+    // was already emitted elsewhere in the xdata section.
+    streamer.getContext().reportError(
+        SMLoc(), "Earlier .seh_handlerdata for " + info->Function->getName() +
+                     " skipped due to no unwind info at the time "
+                     "(.seh_handlerdata too early?), but the function later "
+                     "did get unwind info that can't be emitted");
+    return;
+  }
+
+  simplifyOpcodes(info->Instructions, false);
+  for (auto &I : info->EpilogMap)
+    simplifyOpcodes(I.second, true);
+
   MCContext &context = streamer.getContext();
   MCSymbol *Label = context.createTempSymbol();
 
@@ -914,7 +914,7 @@ static void ARM64EmitUnwindInfo(MCStreamer &streamer, WinEH::FrameInfo *info,
 
   int64_t RawFuncLength;
   if (!info->FuncletOrFuncEnd) {
-    report_fatal_error("FuncletOrFuncEnd not set"); 
+    report_fatal_error("FuncletOrFuncEnd not set");
   } else {
     // FIXME: GetAbsDifference tries to compute the length of the function
     // immediately, before the whole file is emitted, but in general
@@ -951,22 +951,22 @@ static void ARM64EmitUnwindInfo(MCStreamer &streamer, WinEH::FrameInfo *info,
   uint32_t PrologCodeBytes = ARM64CountOfUnwindCodes(info->Instructions);
   uint32_t TotalCodeBytes = PrologCodeBytes;
 
-  int PackedEpilogOffset = checkPackedEpilog(streamer, info, PrologCodeBytes); 
- 
-  if (PackedEpilogOffset >= 0 && !info->HandlesExceptions && 
-      FuncLength <= 0x7ff && TryPacked) { 
-    // Matching prolog/epilog and no exception handlers; check if the 
-    // prolog matches the patterns that can be described by the packed 
-    // format. 
- 
-    // info->Symbol was already set even if we didn't actually write any 
-    // unwind info there. Keep using that as indicator that this unwind 
-    // info has been generated already. 
- 
-    if (tryPackedUnwind(info, FuncLength, PackedEpilogOffset)) 
-      return; 
-  } 
- 
+  int PackedEpilogOffset = checkPackedEpilog(streamer, info, PrologCodeBytes);
+
+  if (PackedEpilogOffset >= 0 && !info->HandlesExceptions &&
+      FuncLength <= 0x7ff && TryPacked) {
+    // Matching prolog/epilog and no exception handlers; check if the
+    // prolog matches the patterns that can be described by the packed
+    // format.
+
+    // info->Symbol was already set even if we didn't actually write any
+    // unwind info there. Keep using that as indicator that this unwind
+    // info has been generated already.
+
+    if (tryPackedUnwind(info, FuncLength, PackedEpilogOffset))
+      return;
+  }
+
   // Process epilogs.
   MapVector<MCSymbol *, uint32_t> EpilogInfo;
   // Epilogs processed so far.
@@ -999,8 +999,8 @@ static void ARM64EmitUnwindInfo(MCStreamer &streamer, WinEH::FrameInfo *info,
   uint32_t CodeWordsMod = TotalCodeBytes % 4;
   if (CodeWordsMod)
     CodeWords++;
-  uint32_t EpilogCount = 
-      PackedEpilogOffset >= 0 ? PackedEpilogOffset : info->EpilogMap.size(); 
+  uint32_t EpilogCount =
+      PackedEpilogOffset >= 0 ? PackedEpilogOffset : info->EpilogMap.size();
   bool ExtensionWord = EpilogCount > 31 || TotalCodeBytes > 124;
   if (!ExtensionWord) {
     row1 |= (EpilogCount & 0x1F) << 22;
@@ -1008,8 +1008,8 @@ static void ARM64EmitUnwindInfo(MCStreamer &streamer, WinEH::FrameInfo *info,
   }
   if (info->HandlesExceptions) // X
     row1 |= 1 << 20;
-  if (PackedEpilogOffset >= 0) // E 
-    row1 |= 1 << 21; 
+  if (PackedEpilogOffset >= 0) // E
+    row1 |= 1 << 21;
   row1 |= FuncLength & 0x3FFFF;
   streamer.emitInt32(row1);
 
@@ -1074,56 +1074,56 @@ static void ARM64EmitRuntimeFunction(MCStreamer &streamer,
 
   streamer.emitValueToAlignment(4);
   EmitSymbolRefWithOfs(streamer, info->Function, info->Begin);
-  if (info->PackedInfo) 
-    streamer.emitInt32(info->PackedInfo); 
-  else 
-    streamer.emitValue( 
-        MCSymbolRefExpr::create(info->Symbol, MCSymbolRefExpr::VK_COFF_IMGREL32, 
-                                context), 
-        4); 
+  if (info->PackedInfo)
+    streamer.emitInt32(info->PackedInfo);
+  else
+    streamer.emitValue(
+        MCSymbolRefExpr::create(info->Symbol, MCSymbolRefExpr::VK_COFF_IMGREL32,
+                                context),
+        4);
 }
 
 void llvm::Win64EH::ARM64UnwindEmitter::Emit(MCStreamer &Streamer) const {
   // Emit the unwind info structs first.
   for (const auto &CFI : Streamer.getWinFrameInfos()) {
-    WinEH::FrameInfo *Info = CFI.get(); 
-    if (Info->empty()) 
-      continue; 
+    WinEH::FrameInfo *Info = CFI.get();
+    if (Info->empty())
+      continue;
     MCSection *XData = Streamer.getAssociatedXDataSection(CFI->TextSection);
     Streamer.SwitchSection(XData);
-    ARM64EmitUnwindInfo(Streamer, Info); 
+    ARM64EmitUnwindInfo(Streamer, Info);
   }
 
   // Now emit RUNTIME_FUNCTION entries.
   for (const auto &CFI : Streamer.getWinFrameInfos()) {
-    WinEH::FrameInfo *Info = CFI.get(); 
-    // ARM64EmitUnwindInfo above clears the info struct, so we can't check 
-    // empty here. But if a Symbol is set, we should create the corresponding 
-    // pdata entry. 
-    if (!Info->Symbol) 
-      continue; 
+    WinEH::FrameInfo *Info = CFI.get();
+    // ARM64EmitUnwindInfo above clears the info struct, so we can't check
+    // empty here. But if a Symbol is set, we should create the corresponding
+    // pdata entry.
+    if (!Info->Symbol)
+      continue;
     MCSection *PData = Streamer.getAssociatedPDataSection(CFI->TextSection);
     Streamer.SwitchSection(PData);
-    ARM64EmitRuntimeFunction(Streamer, Info); 
+    ARM64EmitRuntimeFunction(Streamer, Info);
   }
 }
 
-void llvm::Win64EH::ARM64UnwindEmitter::EmitUnwindInfo(MCStreamer &Streamer, 
-                                                       WinEH::FrameInfo *info, 
-                                                       bool HandlerData) const { 
-  // Called if there's an .seh_handlerdata directive before the end of the 
-  // function. This forces writing the xdata record already here - and 
-  // in this case, the function isn't actually ended already, but the xdata 
-  // record needs to know the function length. In these cases, if the funclet 
-  // end hasn't been marked yet, the xdata function length won't cover the 
-  // whole function, only up to this point. 
-  if (!info->FuncletOrFuncEnd) { 
-    Streamer.SwitchSection(info->TextSection); 
-    info->FuncletOrFuncEnd = Streamer.emitCFILabel(); 
-  } 
+void llvm::Win64EH::ARM64UnwindEmitter::EmitUnwindInfo(MCStreamer &Streamer,
+                                                       WinEH::FrameInfo *info,
+                                                       bool HandlerData) const {
+  // Called if there's an .seh_handlerdata directive before the end of the
+  // function. This forces writing the xdata record already here - and
+  // in this case, the function isn't actually ended already, but the xdata
+  // record needs to know the function length. In these cases, if the funclet
+  // end hasn't been marked yet, the xdata function length won't cover the
+  // whole function, only up to this point.
+  if (!info->FuncletOrFuncEnd) {
+    Streamer.SwitchSection(info->TextSection);
+    info->FuncletOrFuncEnd = Streamer.emitCFILabel();
+  }
   // Switch sections (the static function above is meant to be called from
   // here and from Emit().
   MCSection *XData = Streamer.getAssociatedXDataSection(info->TextSection);
   Streamer.SwitchSection(XData);
-  ARM64EmitUnwindInfo(Streamer, info, /* TryPacked = */ !HandlerData); 
+  ARM64EmitUnwindInfo(Streamer, info, /* TryPacked = */ !HandlerData);
 }
diff --git a/contrib/libs/llvm12/lib/MC/MCWinCOFFStreamer.cpp b/contrib/libs/llvm12/lib/MC/MCWinCOFFStreamer.cpp
index 6bc934cecf..97cceac74a 100644
--- a/contrib/libs/llvm12/lib/MC/MCWinCOFFStreamer.cpp
+++ b/contrib/libs/llvm12/lib/MC/MCWinCOFFStreamer.cpp
@@ -308,16 +308,16 @@ void MCWinCOFFStreamer::emitLocalCommonSymbol(MCSymbol *S, uint64_t Size,
   PopSection();
 }
 
-void MCWinCOFFStreamer::emitWeakReference(MCSymbol *AliasS, 
-                                          const MCSymbol *Symbol) { 
-  auto *Alias = cast<MCSymbolCOFF>(AliasS); 
-  emitSymbolAttribute(Alias, MCSA_Weak); 
- 
-  getAssembler().registerSymbol(*Symbol); 
-  Alias->setVariableValue(MCSymbolRefExpr::create( 
-      Symbol, MCSymbolRefExpr::VK_WEAKREF, getContext())); 
-} 
- 
+void MCWinCOFFStreamer::emitWeakReference(MCSymbol *AliasS,
+                                          const MCSymbol *Symbol) {
+  auto *Alias = cast<MCSymbolCOFF>(AliasS);
+  emitSymbolAttribute(Alias, MCSA_Weak);
+
+  getAssembler().registerSymbol(*Symbol);
+  Alias->setVariableValue(MCSymbolRefExpr::create(
+      Symbol, MCSymbolRefExpr::VK_WEAKREF, getContext()));
+}
+
 void MCWinCOFFStreamer::emitZerofill(MCSection *Section, MCSymbol *Symbol,
                                      uint64_t Size, unsigned ByteAlignment,
                                      SMLoc Loc) {
@@ -350,7 +350,7 @@ void MCWinCOFFStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE) {
   const MCSymbol *S = &SRE->getSymbol();
   bool Created;
   getAssembler().registerSymbol(*S, &Created);
-  if (Created) 
+  if (Created)
     cast<MCSymbolCOFF>(S)->setExternal(true);
 }
 
diff --git a/contrib/libs/llvm12/lib/MC/StringTableBuilder.cpp b/contrib/libs/llvm12/lib/MC/StringTableBuilder.cpp
index dd852d6ef7..973c59057c 100644
--- a/contrib/libs/llvm12/lib/MC/StringTableBuilder.cpp
+++ b/contrib/libs/llvm12/lib/MC/StringTableBuilder.cpp
@@ -33,12 +33,12 @@ void StringTableBuilder::initSize() {
   case DWARF:
     Size = 0;
     break;
-  case MachOLinked: 
-  case MachO64Linked: 
-    Size = 2; 
-    break; 
+  case MachOLinked:
+  case MachO64Linked:
+    Size = 2;
+    break;
   case MachO:
-  case MachO64: 
+  case MachO64:
   case ELF:
     // Start the table with a NUL byte.
     Size = 1;
@@ -166,17 +166,17 @@ void StringTableBuilder::finalizeStringTable(bool Optimize) {
     }
   }
 
-  if (K == MachO || K == MachOLinked) 
+  if (K == MachO || K == MachOLinked)
     Size = alignTo(Size, 4); // Pad to multiple of 4.
-  if (K == MachO64 || K == MachO64Linked) 
-    Size = alignTo(Size, 8); // Pad to multiple of 8. 
-
-  // According to ld64 the string table of a final linked Mach-O binary starts 
-  // with " ", i.e. the first byte is ' ' and the second byte is zero. In 
-  // 'initSize()' we reserved the first two bytes for holding this string. 
-  if (K == MachOLinked || K == MachO64Linked) 
-    StringIndexMap[CachedHashStringRef(" ")] = 0; 
- 
+  if (K == MachO64 || K == MachO64Linked)
+    Size = alignTo(Size, 8); // Pad to multiple of 8.
+
+  // According to ld64 the string table of a final linked Mach-O binary starts
+  // with " ", i.e. the first byte is ' ' and the second byte is zero. In
+  // 'initSize()' we reserved the first two bytes for holding this string.
+  if (K == MachOLinked || K == MachO64Linked)
+    StringIndexMap[CachedHashStringRef(" ")] = 0;
+
   // The first byte in an ELF string table must be null, according to the ELF
   // specification. In 'initSize()' we reserved the first byte to hold null for
   // this purpose and here we actually add the string to allow 'getOffset()' to
diff --git a/contrib/libs/llvm12/lib/MC/WasmObjectWriter.cpp b/contrib/libs/llvm12/lib/MC/WasmObjectWriter.cpp
index e99bcb980e..930413e834 100644
--- a/contrib/libs/llvm12/lib/MC/WasmObjectWriter.cpp
+++ b/contrib/libs/llvm12/lib/MC/WasmObjectWriter.cpp
@@ -13,7 +13,7 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/BinaryFormat/Wasm.h"
-#include "llvm/BinaryFormat/WasmTraits.h" 
+#include "llvm/BinaryFormat/WasmTraits.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmLayout.h"
@@ -40,8 +40,8 @@ using namespace llvm;
 
 namespace {
 
-// When we create the indirect function table we start at 1, so that there is 
-// and empty slot at 0 and therefore calling a null function pointer will trap. 
+// When we create the indirect function table we start at 1, so that there is
+// and empty slot at 0 and therefore calling a null function pointer will trap.
 static const uint32_t InitialTableOffset = 1;
 
 // For patching purposes, we need to remember where each section starts, both
@@ -173,12 +173,12 @@ static void patchI64(raw_pwrite_stream &Stream, uint64_t X, uint64_t Offset) {
   Stream.pwrite((char *)Buffer, sizeof(Buffer), Offset);
 }
 
-bool isDwoSection(const MCSection &Sec) { 
-  return Sec.getName().endswith(".dwo"); 
-} 
- 
+bool isDwoSection(const MCSection &Sec) {
+  return Sec.getName().endswith(".dwo");
+}
+
 class WasmObjectWriter : public MCObjectWriter {
-  support::endian::Writer *W; 
+  support::endian::Writer *W;
 
   /// The target specific Wasm writer instance.
   std::unique_ptr<MCWasmObjectTargetWriter> TargetObjectWriter;
@@ -194,8 +194,8 @@ class WasmObjectWriter : public MCObjectWriter {
   // Maps function symbols to the table element index space. Used
   // for TABLE_INDEX relocation types (i.e. address taken functions).
   DenseMap<const MCSymbolWasm *, uint32_t> TableIndices;
-  // Maps function/global/table symbols to the 
-  // function/global/table/event/section index space. 
+  // Maps function/global/table symbols to the
+  // function/global/table/event/section index space.
   DenseMap<const MCSymbolWasm *, uint32_t> WasmIndices;
   DenseMap<const MCSymbolWasm *, uint32_t> GOTIndices;
   // Maps data symbols to the Wasm segment and offset/size with the segment.
@@ -213,25 +213,25 @@ class WasmObjectWriter : public MCObjectWriter {
   // Map from section to defining function symbol.
   DenseMap<const MCSection *, const MCSymbol *> SectionFunctions;
 
-  DenseMap<wasm::WasmSignature, uint32_t> SignatureIndices; 
-  SmallVector<wasm::WasmSignature, 4> Signatures; 
+  DenseMap<wasm::WasmSignature, uint32_t> SignatureIndices;
+  SmallVector<wasm::WasmSignature, 4> Signatures;
   SmallVector<WasmDataSegment, 4> DataSegments;
   unsigned NumFunctionImports = 0;
   unsigned NumGlobalImports = 0;
-  unsigned NumTableImports = 0; 
+  unsigned NumTableImports = 0;
   unsigned NumEventImports = 0;
   uint32_t SectionCount = 0;
 
-  enum class DwoMode { 
-    AllSections, 
-    NonDwoOnly, 
-    DwoOnly, 
-  }; 
-  bool IsSplitDwarf = false; 
-  raw_pwrite_stream *OS = nullptr; 
-  raw_pwrite_stream *DwoOS = nullptr; 
- 
-  // TargetObjectWriter wranppers. 
+  enum class DwoMode {
+    AllSections,
+    NonDwoOnly,
+    DwoOnly,
+  };
+  bool IsSplitDwarf = false;
+  raw_pwrite_stream *OS = nullptr;
+  raw_pwrite_stream *DwoOS = nullptr;
+
+  // TargetObjectWriter wranppers.
   bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
   bool isEmscripten() const { return TargetObjectWriter->isEmscripten(); }
 
@@ -241,14 +241,14 @@ class WasmObjectWriter : public MCObjectWriter {
 
 public:
   WasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
-                   raw_pwrite_stream &OS_) 
-      : TargetObjectWriter(std::move(MOTW)), OS(&OS_) {} 
-
-  WasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW, 
-                   raw_pwrite_stream &OS_, raw_pwrite_stream &DwoOS_) 
-      : TargetObjectWriter(std::move(MOTW)), IsSplitDwarf(true), OS(&OS_), 
-        DwoOS(&DwoOS_) {} 
- 
+                   raw_pwrite_stream &OS_)
+      : TargetObjectWriter(std::move(MOTW)), OS(&OS_) {}
+
+  WasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
+                   raw_pwrite_stream &OS_, raw_pwrite_stream &DwoOS_)
+      : TargetObjectWriter(std::move(MOTW)), IsSplitDwarf(true), OS(&OS_),
+        DwoOS(&DwoOS_) {}
+
 private:
   void reset() override {
     CodeRelocations.clear();
@@ -268,7 +268,7 @@ private:
     SectionFunctions.clear();
     NumFunctionImports = 0;
     NumGlobalImports = 0;
-    NumTableImports = 0; 
+    NumTableImports = 0;
     MCObjectWriter::reset();
   }
 
@@ -280,33 +280,33 @@ private:
 
   void executePostLayoutBinding(MCAssembler &Asm,
                                 const MCAsmLayout &Layout) override;
-  void prepareImports(SmallVectorImpl<wasm::WasmImport> &Imports, 
-                      MCAssembler &Asm, const MCAsmLayout &Layout); 
+  void prepareImports(SmallVectorImpl<wasm::WasmImport> &Imports,
+                      MCAssembler &Asm, const MCAsmLayout &Layout);
   uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
 
-  uint64_t writeOneObject(MCAssembler &Asm, const MCAsmLayout &Layout, 
-                          DwoMode Mode); 
- 
+  uint64_t writeOneObject(MCAssembler &Asm, const MCAsmLayout &Layout,
+                          DwoMode Mode);
+
   void writeString(const StringRef Str) {
-    encodeULEB128(Str.size(), W->OS); 
-    W->OS << Str; 
+    encodeULEB128(Str.size(), W->OS);
+    W->OS << Str;
   }
 
   void writeI32(int32_t val) {
     char Buffer[4];
     support::endian::write32le(Buffer, val);
-    W->OS.write(Buffer, sizeof(Buffer)); 
+    W->OS.write(Buffer, sizeof(Buffer));
   }
 
   void writeI64(int64_t val) {
     char Buffer[8];
     support::endian::write64le(Buffer, val);
-    W->OS.write(Buffer, sizeof(Buffer)); 
+    W->OS.write(Buffer, sizeof(Buffer));
   }
 
-  void writeValueType(wasm::ValType Ty) { W->OS << static_cast<char>(Ty); } 
+  void writeValueType(wasm::ValType Ty) { W->OS << static_cast<char>(Ty); }
 
-  void writeTypeSection(ArrayRef<wasm::WasmSignature> Signatures); 
+  void writeTypeSection(ArrayRef<wasm::WasmSignature> Signatures);
   void writeImportSection(ArrayRef<wasm::WasmImport> Imports, uint64_t DataSize,
                           uint32_t NumElements);
   void writeFunctionSection(ArrayRef<WasmFunction> Functions);
@@ -318,7 +318,7 @@ private:
   uint32_t writeDataSection(const MCAsmLayout &Layout);
   void writeEventSection(ArrayRef<wasm::WasmEventType> Events);
   void writeGlobalSection(ArrayRef<wasm::WasmGlobal> Globals);
-  void writeTableSection(ArrayRef<wasm::WasmTable> Tables); 
+  void writeTableSection(ArrayRef<wasm::WasmTable> Tables);
   void writeRelocSection(uint32_t SectionIndex, StringRef Name,
                          std::vector<WasmRelocationEntry> &Relocations);
   void writeLinkingMetaDataSection(
@@ -347,17 +347,17 @@ private:
 void WasmObjectWriter::startSection(SectionBookkeeping &Section,
                                     unsigned SectionId) {
   LLVM_DEBUG(dbgs() << "startSection " << SectionId << "\n");
-  W->OS << char(SectionId); 
+  W->OS << char(SectionId);
 
-  Section.SizeOffset = W->OS.tell(); 
+  Section.SizeOffset = W->OS.tell();
 
   // The section size. We don't know the size yet, so reserve enough space
   // for any 32-bit value; we'll patch it later.
-  encodeULEB128(0, W->OS, 5); 
+  encodeULEB128(0, W->OS, 5);
 
   // The position where the section starts, for measuring its size.
-  Section.ContentsOffset = W->OS.tell(); 
-  Section.PayloadOffset = W->OS.tell(); 
+  Section.ContentsOffset = W->OS.tell();
+  Section.PayloadOffset = W->OS.tell();
   Section.Index = SectionCount++;
 }
 
@@ -367,19 +367,19 @@ void WasmObjectWriter::startCustomSection(SectionBookkeeping &Section,
   startSection(Section, wasm::WASM_SEC_CUSTOM);
 
   // The position where the section header ends, for measuring its size.
-  Section.PayloadOffset = W->OS.tell(); 
+  Section.PayloadOffset = W->OS.tell();
 
   // Custom sections in wasm also have a string identifier.
   writeString(Name);
 
   // The position where the custom section starts.
-  Section.ContentsOffset = W->OS.tell(); 
+  Section.ContentsOffset = W->OS.tell();
 }
 
 // Now that the section is complete and we know how big it is, patch up the
 // section size field at the start of the section.
 void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
-  uint64_t Size = W->OS.tell(); 
+  uint64_t Size = W->OS.tell();
   // /dev/null doesn't support seek/tell and can report offset of 0.
   // Simply skip this patching in that case.
   if (!Size)
@@ -393,25 +393,25 @@ void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
 
   // Write the final section size to the payload_len field, which follows
   // the section id byte.
-  writePatchableLEB<5>(static_cast<raw_pwrite_stream &>(W->OS), Size, 
+  writePatchableLEB<5>(static_cast<raw_pwrite_stream &>(W->OS), Size,
                        Section.SizeOffset);
 }
 
 // Emit the Wasm header.
 void WasmObjectWriter::writeHeader(const MCAssembler &Asm) {
-  W->OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic)); 
-  W->write<uint32_t>(wasm::WasmVersion); 
+  W->OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
+  W->write<uint32_t>(wasm::WasmVersion);
 }
 
 void WasmObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
                                                 const MCAsmLayout &Layout) {
-  // As a stopgap measure until call_indirect instructions start explicitly 
-  // referencing the indirect function table via TABLE_NUMBER relocs, ensure 
-  // that the indirect function table import makes it to the output if anything 
-  // in the compilation unit has caused it to be present. 
-  if (auto *Sym = Asm.getContext().lookupSymbol("__indirect_function_table")) 
-    Asm.registerSymbol(*Sym); 
- 
+  // As a stopgap measure until call_indirect instructions start explicitly
+  // referencing the indirect function table via TABLE_NUMBER relocs, ensure
+  // that the indirect function table import makes it to the output if anything
+  // in the compilation unit has caused it to be present.
+  if (auto *Sym = Asm.getContext().lookupSymbol("__indirect_function_table"))
+    Asm.registerSymbol(*Sym);
+
   // Build a map of sections to the function that defines them, for use
   // in recordRelocation.
   for (const MCSymbol &S : Asm.symbols()) {
@@ -480,7 +480,7 @@ void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
   // Currently only supported for for metadata sections.
   // See: test/MC/WebAssembly/blockaddress.ll
   if (Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
-      Type == wasm::R_WASM_FUNCTION_OFFSET_I64 || 
+      Type == wasm::R_WASM_FUNCTION_OFFSET_I64 ||
       Type == wasm::R_WASM_SECTION_OFFSET_I32) {
     if (!FixupSection.getKind().isMetadata())
       report_fatal_error("relocations for function or section offsets are "
@@ -499,29 +499,29 @@ void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
     SymA = cast<MCSymbolWasm>(SectionSymbol);
   }
 
-  if (Type == wasm::R_WASM_TABLE_INDEX_REL_SLEB || 
-      Type == wasm::R_WASM_TABLE_INDEX_SLEB || 
-      Type == wasm::R_WASM_TABLE_INDEX_SLEB64 || 
-      Type == wasm::R_WASM_TABLE_INDEX_I32 || 
-      Type == wasm::R_WASM_TABLE_INDEX_I64) { 
-    // TABLE_INDEX relocs implicitly use the default indirect function table. 
-    auto TableName = "__indirect_function_table"; 
-    MCSymbolWasm *Sym = cast_or_null<MCSymbolWasm>(Ctx.lookupSymbol(TableName)); 
-    if (Sym) { 
-      if (!Sym->isFunctionTable()) 
-        Ctx.reportError( 
-            Fixup.getLoc(), 
-            "symbol '__indirect_function_table' is not a function table"); 
-    } else { 
-      Sym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(TableName)); 
-      Sym->setFunctionTable(); 
-      // The default function table is synthesized by the linker. 
-      Sym->setUndefined(); 
-    } 
-    Sym->setUsedInReloc(); 
-    Asm.registerSymbol(*Sym); 
-  } 
- 
+  if (Type == wasm::R_WASM_TABLE_INDEX_REL_SLEB ||
+      Type == wasm::R_WASM_TABLE_INDEX_SLEB ||
+      Type == wasm::R_WASM_TABLE_INDEX_SLEB64 ||
+      Type == wasm::R_WASM_TABLE_INDEX_I32 ||
+      Type == wasm::R_WASM_TABLE_INDEX_I64) {
+    // TABLE_INDEX relocs implicitly use the default indirect function table.
+    auto TableName = "__indirect_function_table";
+    MCSymbolWasm *Sym = cast_or_null<MCSymbolWasm>(Ctx.lookupSymbol(TableName));
+    if (Sym) {
+      if (!Sym->isFunctionTable())
+        Ctx.reportError(
+            Fixup.getLoc(),
+            "symbol '__indirect_function_table' is not a function table");
+    } else {
+      Sym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(TableName));
+      Sym->setFunctionTable();
+      // The default function table is synthesized by the linker.
+      Sym->setUndefined();
+    }
+    Sym->setUsedInReloc();
+    Asm.registerSymbol(*Sym);
+  }
+
   // Relocation other than R_WASM_TYPE_INDEX_LEB are required to be
   // against a named symbol.
   if (Type != wasm::R_WASM_TYPE_INDEX_LEB) {
@@ -566,9 +566,9 @@ WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry,
   switch (RelEntry.Type) {
   case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
   case wasm::R_WASM_TABLE_INDEX_SLEB:
-  case wasm::R_WASM_TABLE_INDEX_SLEB64: 
-  case wasm::R_WASM_TABLE_INDEX_I32: 
-  case wasm::R_WASM_TABLE_INDEX_I64: { 
+  case wasm::R_WASM_TABLE_INDEX_SLEB64:
+  case wasm::R_WASM_TABLE_INDEX_I32:
+  case wasm::R_WASM_TABLE_INDEX_I64: {
     // Provisional value is table address of the resolved symbol itself
     const MCSymbolWasm *Base =
         cast<MCSymbolWasm>(Layout.getBaseSymbol(*RelEntry.Symbol));
@@ -585,12 +585,12 @@ WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry,
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_I32:
   case wasm::R_WASM_EVENT_INDEX_LEB:
-  case wasm::R_WASM_TABLE_NUMBER_LEB: 
+  case wasm::R_WASM_TABLE_NUMBER_LEB:
     // Provisional value is function/global/event Wasm index
     assert(WasmIndices.count(RelEntry.Symbol) > 0 && "symbol not found in wasm index space");
     return WasmIndices[RelEntry.Symbol];
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
-  case wasm::R_WASM_FUNCTION_OFFSET_I64: 
+  case wasm::R_WASM_FUNCTION_OFFSET_I64:
   case wasm::R_WASM_SECTION_OFFSET_I32: {
     const auto &Section =
         static_cast<const MCSectionWasm &>(RelEntry.Symbol->getSection());
@@ -603,19 +603,19 @@ WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry,
   case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
   case wasm::R_WASM_MEMORY_ADDR_I32:
-  case wasm::R_WASM_MEMORY_ADDR_I64: 
-  case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB: { 
-    // Provisional value is address of the global plus the offset 
+  case wasm::R_WASM_MEMORY_ADDR_I64:
+  case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB: {
+    // Provisional value is address of the global plus the offset
     const MCSymbolWasm *Base =
         cast<MCSymbolWasm>(Layout.getBaseSymbol(*RelEntry.Symbol));
     // For undefined symbols, use zero
     if (!Base->isDefined())
       return 0;
-    const wasm::WasmDataReference &BaseRef = DataLocations[Base], 
-                                  &SymRef = DataLocations[RelEntry.Symbol]; 
-    const WasmDataSegment &Segment = DataSegments[BaseRef.Segment]; 
+    const wasm::WasmDataReference &BaseRef = DataLocations[Base],
+                                  &SymRef = DataLocations[RelEntry.Symbol];
+    const WasmDataSegment &Segment = DataSegments[BaseRef.Segment];
     // Ignore overflow. LLVM allows address arithmetic to silently wrap.
-    return Segment.Offset + BaseRef.Offset + SymRef.Offset + RelEntry.Addend; 
+    return Segment.Offset + BaseRef.Offset + SymRef.Offset + RelEntry.Addend;
   }
   default:
     llvm_unreachable("invalid relocation type");
@@ -649,11 +649,11 @@ static void addData(SmallVectorImpl<char> &DataBytes,
                        Fill->getValue());
     } else if (auto *LEB = dyn_cast<MCLEBFragment>(&Frag)) {
       const SmallVectorImpl<char> &Contents = LEB->getContents();
-      llvm::append_range(DataBytes, Contents); 
+      llvm::append_range(DataBytes, Contents);
     } else {
       const auto &DataFrag = cast<MCDataFragment>(Frag);
       const SmallVectorImpl<char> &Contents = DataFrag.getContents();
-      llvm::append_range(DataBytes, Contents); 
+      llvm::append_range(DataBytes, Contents);
     }
   }
 
@@ -677,7 +677,7 @@ WasmObjectWriter::getRelocationIndexValue(const WasmRelocationEntry &RelEntry) {
 void WasmObjectWriter::applyRelocations(
     ArrayRef<WasmRelocationEntry> Relocations, uint64_t ContentsOffset,
     const MCAsmLayout &Layout) {
-  auto &Stream = static_cast<raw_pwrite_stream &>(W->OS); 
+  auto &Stream = static_cast<raw_pwrite_stream &>(W->OS);
   for (const WasmRelocationEntry &RelEntry : Relocations) {
     uint64_t Offset = ContentsOffset +
                       RelEntry.FixupSection->getSectionOffset() +
@@ -692,7 +692,7 @@ void WasmObjectWriter::applyRelocations(
     case wasm::R_WASM_GLOBAL_INDEX_LEB:
     case wasm::R_WASM_MEMORY_ADDR_LEB:
     case wasm::R_WASM_EVENT_INDEX_LEB:
-    case wasm::R_WASM_TABLE_NUMBER_LEB: 
+    case wasm::R_WASM_TABLE_NUMBER_LEB:
       writePatchableLEB<5>(Stream, Value, Offset);
       break;
     case wasm::R_WASM_MEMORY_ADDR_LEB64:
@@ -705,19 +705,19 @@ void WasmObjectWriter::applyRelocations(
     case wasm::R_WASM_GLOBAL_INDEX_I32:
       patchI32(Stream, Value, Offset);
       break;
-    case wasm::R_WASM_TABLE_INDEX_I64: 
+    case wasm::R_WASM_TABLE_INDEX_I64:
     case wasm::R_WASM_MEMORY_ADDR_I64:
-    case wasm::R_WASM_FUNCTION_OFFSET_I64: 
+    case wasm::R_WASM_FUNCTION_OFFSET_I64:
       patchI64(Stream, Value, Offset);
       break;
     case wasm::R_WASM_TABLE_INDEX_SLEB:
     case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
-    case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB: 
+    case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB:
       writePatchableSLEB<5>(Stream, Value, Offset);
       break;
-    case wasm::R_WASM_TABLE_INDEX_SLEB64: 
+    case wasm::R_WASM_TABLE_INDEX_SLEB64:
     case wasm::R_WASM_MEMORY_ADDR_SLEB64:
     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
       writePatchableSLEB<10>(Stream, Value, Offset);
@@ -728,22 +728,22 @@ void WasmObjectWriter::applyRelocations(
   }
 }
 
-void WasmObjectWriter::writeTypeSection( 
-    ArrayRef<wasm::WasmSignature> Signatures) { 
+void WasmObjectWriter::writeTypeSection(
+    ArrayRef<wasm::WasmSignature> Signatures) {
   if (Signatures.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_TYPE);
 
-  encodeULEB128(Signatures.size(), W->OS); 
+  encodeULEB128(Signatures.size(), W->OS);
 
-  for (const wasm::WasmSignature &Sig : Signatures) { 
-    W->OS << char(wasm::WASM_TYPE_FUNC); 
-    encodeULEB128(Sig.Params.size(), W->OS); 
+  for (const wasm::WasmSignature &Sig : Signatures) {
+    W->OS << char(wasm::WASM_TYPE_FUNC);
+    encodeULEB128(Sig.Params.size(), W->OS);
     for (wasm::ValType Ty : Sig.Params)
       writeValueType(Ty);
-    encodeULEB128(Sig.Returns.size(), W->OS); 
+    encodeULEB128(Sig.Returns.size(), W->OS);
     for (wasm::ValType Ty : Sig.Returns)
       writeValueType(Ty);
   }
@@ -762,32 +762,32 @@ void WasmObjectWriter::writeImportSection(ArrayRef<wasm::WasmImport> Imports,
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_IMPORT);
 
-  encodeULEB128(Imports.size(), W->OS); 
+  encodeULEB128(Imports.size(), W->OS);
   for (const wasm::WasmImport &Import : Imports) {
     writeString(Import.Module);
     writeString(Import.Field);
-    W->OS << char(Import.Kind); 
+    W->OS << char(Import.Kind);
 
     switch (Import.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
-      encodeULEB128(Import.SigIndex, W->OS); 
+      encodeULEB128(Import.SigIndex, W->OS);
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
-      W->OS << char(Import.Global.Type); 
-      W->OS << char(Import.Global.Mutable ? 1 : 0); 
+      W->OS << char(Import.Global.Type);
+      W->OS << char(Import.Global.Mutable ? 1 : 0);
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
-      encodeULEB128(Import.Memory.Flags, W->OS); 
-      encodeULEB128(NumPages, W->OS); // initial 
+      encodeULEB128(Import.Memory.Flags, W->OS);
+      encodeULEB128(NumPages, W->OS); // initial
       break;
     case wasm::WASM_EXTERNAL_TABLE:
-      W->OS << char(Import.Table.ElemType); 
-      encodeULEB128(0, W->OS);           // flags 
-      encodeULEB128(NumElements, W->OS); // initial 
+      W->OS << char(Import.Table.ElemType);
+      encodeULEB128(0, W->OS);           // flags
+      encodeULEB128(NumElements, W->OS); // initial
       break;
     case wasm::WASM_EXTERNAL_EVENT:
-      encodeULEB128(Import.Event.Attribute, W->OS); 
-      encodeULEB128(Import.Event.SigIndex, W->OS); 
+      encodeULEB128(Import.Event.Attribute, W->OS);
+      encodeULEB128(Import.Event.SigIndex, W->OS);
       break;
     default:
       llvm_unreachable("unsupported import kind");
@@ -804,9 +804,9 @@ void WasmObjectWriter::writeFunctionSection(ArrayRef<WasmFunction> Functions) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_FUNCTION);
 
-  encodeULEB128(Functions.size(), W->OS); 
+  encodeULEB128(Functions.size(), W->OS);
   for (const WasmFunction &Func : Functions)
-    encodeULEB128(Func.SigIndex, W->OS); 
+    encodeULEB128(Func.SigIndex, W->OS);
 
   endSection(Section);
 }
@@ -818,10 +818,10 @@ void WasmObjectWriter::writeEventSection(ArrayRef<wasm::WasmEventType> Events) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_EVENT);
 
-  encodeULEB128(Events.size(), W->OS); 
+  encodeULEB128(Events.size(), W->OS);
   for (const wasm::WasmEventType &Event : Events) {
-    encodeULEB128(Event.Attribute, W->OS); 
-    encodeULEB128(Event.SigIndex, W->OS); 
+    encodeULEB128(Event.Attribute, W->OS);
+    encodeULEB128(Event.SigIndex, W->OS);
   }
 
   endSection(Section);
@@ -834,17 +834,17 @@ void WasmObjectWriter::writeGlobalSection(ArrayRef<wasm::WasmGlobal> Globals) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_GLOBAL);
 
-  encodeULEB128(Globals.size(), W->OS); 
+  encodeULEB128(Globals.size(), W->OS);
   for (const wasm::WasmGlobal &Global : Globals) {
-    encodeULEB128(Global.Type.Type, W->OS); 
-    W->OS << char(Global.Type.Mutable); 
-    W->OS << char(Global.InitExpr.Opcode); 
+    encodeULEB128(Global.Type.Type, W->OS);
+    W->OS << char(Global.Type.Mutable);
+    W->OS << char(Global.InitExpr.Opcode);
     switch (Global.Type.Type) {
     case wasm::WASM_TYPE_I32:
-      encodeSLEB128(0, W->OS); 
+      encodeSLEB128(0, W->OS);
       break;
     case wasm::WASM_TYPE_I64:
-      encodeSLEB128(0, W->OS); 
+      encodeSLEB128(0, W->OS);
       break;
     case wasm::WASM_TYPE_F32:
       writeI32(0);
@@ -858,30 +858,30 @@ void WasmObjectWriter::writeGlobalSection(ArrayRef<wasm::WasmGlobal> Globals) {
     default:
       llvm_unreachable("unexpected type");
     }
-    W->OS << char(wasm::WASM_OPCODE_END); 
+    W->OS << char(wasm::WASM_OPCODE_END);
   }
 
   endSection(Section);
 }
 
-void WasmObjectWriter::writeTableSection(ArrayRef<wasm::WasmTable> Tables) { 
-  if (Tables.empty()) 
-    return; 
- 
-  SectionBookkeeping Section; 
-  startSection(Section, wasm::WASM_SEC_TABLE); 
- 
-  encodeULEB128(Tables.size(), W->OS); 
-  for (const wasm::WasmTable &Table : Tables) { 
-    encodeULEB128(Table.Type.ElemType, W->OS); 
-    encodeULEB128(Table.Type.Limits.Flags, W->OS); 
-    encodeULEB128(Table.Type.Limits.Initial, W->OS); 
-    if (Table.Type.Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX) 
-      encodeULEB128(Table.Type.Limits.Maximum, W->OS); 
-  } 
-  endSection(Section); 
-} 
- 
+void WasmObjectWriter::writeTableSection(ArrayRef<wasm::WasmTable> Tables) {
+  if (Tables.empty())
+    return;
+
+  SectionBookkeeping Section;
+  startSection(Section, wasm::WASM_SEC_TABLE);
+
+  encodeULEB128(Tables.size(), W->OS);
+  for (const wasm::WasmTable &Table : Tables) {
+    encodeULEB128(Table.Type.ElemType, W->OS);
+    encodeULEB128(Table.Type.Limits.Flags, W->OS);
+    encodeULEB128(Table.Type.Limits.Initial, W->OS);
+    if (Table.Type.Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
+      encodeULEB128(Table.Type.Limits.Maximum, W->OS);
+  }
+  endSection(Section);
+}
+
 void WasmObjectWriter::writeExportSection(ArrayRef<wasm::WasmExport> Exports) {
   if (Exports.empty())
     return;
@@ -889,11 +889,11 @@ void WasmObjectWriter::writeExportSection(ArrayRef<wasm::WasmExport> Exports) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_EXPORT);
 
-  encodeULEB128(Exports.size(), W->OS); 
+  encodeULEB128(Exports.size(), W->OS);
   for (const wasm::WasmExport &Export : Exports) {
     writeString(Export.Name);
-    W->OS << char(Export.Kind); 
-    encodeULEB128(Export.Index, W->OS); 
+    W->OS << char(Export.Kind);
+    encodeULEB128(Export.Index, W->OS);
   }
 
   endSection(Section);
@@ -906,17 +906,17 @@ void WasmObjectWriter::writeElemSection(ArrayRef<uint32_t> TableElems) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_ELEM);
 
-  encodeULEB128(1, W->OS); // number of "segments" 
-  encodeULEB128(0, W->OS); // the table index 
+  encodeULEB128(1, W->OS); // number of "segments"
+  encodeULEB128(0, W->OS); // the table index
 
   // init expr for starting offset
-  W->OS << char(wasm::WASM_OPCODE_I32_CONST); 
-  encodeSLEB128(InitialTableOffset, W->OS); 
-  W->OS << char(wasm::WASM_OPCODE_END); 
+  W->OS << char(wasm::WASM_OPCODE_I32_CONST);
+  encodeSLEB128(InitialTableOffset, W->OS);
+  W->OS << char(wasm::WASM_OPCODE_END);
 
-  encodeULEB128(TableElems.size(), W->OS); 
+  encodeULEB128(TableElems.size(), W->OS);
   for (uint32_t Elem : TableElems)
-    encodeULEB128(Elem, W->OS); 
+    encodeULEB128(Elem, W->OS);
 
   endSection(Section);
 }
@@ -927,7 +927,7 @@ void WasmObjectWriter::writeDataCountSection() {
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_DATACOUNT);
-  encodeULEB128(DataSegments.size(), W->OS); 
+  encodeULEB128(DataSegments.size(), W->OS);
   endSection(Section);
 }
 
@@ -940,7 +940,7 @@ uint32_t WasmObjectWriter::writeCodeSection(const MCAssembler &Asm,
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CODE);
 
-  encodeULEB128(Functions.size(), W->OS); 
+  encodeULEB128(Functions.size(), W->OS);
 
   for (const WasmFunction &Func : Functions) {
     auto &FuncSection = static_cast<MCSectionWasm &>(Func.Sym->getSection());
@@ -949,9 +949,9 @@ uint32_t WasmObjectWriter::writeCodeSection(const MCAssembler &Asm,
     if (!Func.Sym->getSize()->evaluateAsAbsolute(Size, Layout))
       report_fatal_error(".size expression must be evaluatable");
 
-    encodeULEB128(Size, W->OS); 
-    FuncSection.setSectionOffset(W->OS.tell() - Section.ContentsOffset); 
-    Asm.writeSectionData(W->OS, &FuncSection, Layout); 
+    encodeULEB128(Size, W->OS);
+    FuncSection.setSectionOffset(W->OS.tell() - Section.ContentsOffset);
+    Asm.writeSectionData(W->OS, &FuncSection, Layout);
   }
 
   // Apply fixups.
@@ -968,21 +968,21 @@ uint32_t WasmObjectWriter::writeDataSection(const MCAsmLayout &Layout) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_DATA);
 
-  encodeULEB128(DataSegments.size(), W->OS); // count 
+  encodeULEB128(DataSegments.size(), W->OS); // count
 
   for (const WasmDataSegment &Segment : DataSegments) {
-    encodeULEB128(Segment.InitFlags, W->OS); // flags 
-    if (Segment.InitFlags & wasm::WASM_DATA_SEGMENT_HAS_MEMINDEX) 
-      encodeULEB128(0, W->OS); // memory index 
-    if ((Segment.InitFlags & wasm::WASM_DATA_SEGMENT_IS_PASSIVE) == 0) { 
-      W->OS << char(Segment.Offset > INT32_MAX ? wasm::WASM_OPCODE_I64_CONST 
-                                               : wasm::WASM_OPCODE_I32_CONST); 
-      encodeSLEB128(Segment.Offset, W->OS); // offset 
-      W->OS << char(wasm::WASM_OPCODE_END); 
+    encodeULEB128(Segment.InitFlags, W->OS); // flags
+    if (Segment.InitFlags & wasm::WASM_DATA_SEGMENT_HAS_MEMINDEX)
+      encodeULEB128(0, W->OS); // memory index
+    if ((Segment.InitFlags & wasm::WASM_DATA_SEGMENT_IS_PASSIVE) == 0) {
+      W->OS << char(Segment.Offset > INT32_MAX ? wasm::WASM_OPCODE_I64_CONST
+                                               : wasm::WASM_OPCODE_I32_CONST);
+      encodeSLEB128(Segment.Offset, W->OS); // offset
+      W->OS << char(wasm::WASM_OPCODE_END);
     }
-    encodeULEB128(Segment.Data.size(), W->OS); // size 
-    Segment.Section->setSectionOffset(W->OS.tell() - Section.ContentsOffset); 
-    W->OS << Segment.Data; // data 
+    encodeULEB128(Segment.Data.size(), W->OS); // size
+    Segment.Section->setSectionOffset(W->OS.tell() - Section.ContentsOffset);
+    W->OS << Segment.Data; // data
   }
 
   // Apply fixups.
@@ -1015,18 +1015,18 @@ void WasmObjectWriter::writeRelocSection(
   SectionBookkeeping Section;
   startCustomSection(Section, std::string("reloc.") + Name.str());
 
-  encodeULEB128(SectionIndex, W->OS); 
-  encodeULEB128(Relocs.size(), W->OS); 
+  encodeULEB128(SectionIndex, W->OS);
+  encodeULEB128(Relocs.size(), W->OS);
   for (const WasmRelocationEntry &RelEntry : Relocs) {
     uint64_t Offset =
         RelEntry.Offset + RelEntry.FixupSection->getSectionOffset();
     uint32_t Index = getRelocationIndexValue(RelEntry);
 
-    W->OS << char(RelEntry.Type); 
-    encodeULEB128(Offset, W->OS); 
-    encodeULEB128(Index, W->OS); 
+    W->OS << char(RelEntry.Type);
+    encodeULEB128(Offset, W->OS);
+    encodeULEB128(Index, W->OS);
     if (RelEntry.hasAddend())
-      encodeSLEB128(RelEntry.Addend, W->OS); 
+      encodeSLEB128(RelEntry.Addend, W->OS);
   }
 
   endSection(Section);
@@ -1045,21 +1045,21 @@ void WasmObjectWriter::writeLinkingMetaDataSection(
     const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats) {
   SectionBookkeeping Section;
   startCustomSection(Section, "linking");
-  encodeULEB128(wasm::WasmMetadataVersion, W->OS); 
+  encodeULEB128(wasm::WasmMetadataVersion, W->OS);
 
   SectionBookkeeping SubSection;
   if (SymbolInfos.size() != 0) {
     startSection(SubSection, wasm::WASM_SYMBOL_TABLE);
-    encodeULEB128(SymbolInfos.size(), W->OS); 
+    encodeULEB128(SymbolInfos.size(), W->OS);
     for (const wasm::WasmSymbolInfo &Sym : SymbolInfos) {
-      encodeULEB128(Sym.Kind, W->OS); 
-      encodeULEB128(Sym.Flags, W->OS); 
+      encodeULEB128(Sym.Kind, W->OS);
+      encodeULEB128(Sym.Flags, W->OS);
       switch (Sym.Kind) {
       case wasm::WASM_SYMBOL_TYPE_FUNCTION:
       case wasm::WASM_SYMBOL_TYPE_GLOBAL:
       case wasm::WASM_SYMBOL_TYPE_EVENT:
-      case wasm::WASM_SYMBOL_TYPE_TABLE: 
-        encodeULEB128(Sym.ElementIndex, W->OS); 
+      case wasm::WASM_SYMBOL_TYPE_TABLE:
+        encodeULEB128(Sym.ElementIndex, W->OS);
         if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0 ||
             (Sym.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeString(Sym.Name);
@@ -1067,15 +1067,15 @@ void WasmObjectWriter::writeLinkingMetaDataSection(
       case wasm::WASM_SYMBOL_TYPE_DATA:
         writeString(Sym.Name);
         if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
-          encodeULEB128(Sym.DataRef.Segment, W->OS); 
-          encodeULEB128(Sym.DataRef.Offset, W->OS); 
-          encodeULEB128(Sym.DataRef.Size, W->OS); 
+          encodeULEB128(Sym.DataRef.Segment, W->OS);
+          encodeULEB128(Sym.DataRef.Offset, W->OS);
+          encodeULEB128(Sym.DataRef.Size, W->OS);
         }
         break;
       case wasm::WASM_SYMBOL_TYPE_SECTION: {
         const uint32_t SectionIndex =
             CustomSections[Sym.ElementIndex].OutputIndex;
-        encodeULEB128(SectionIndex, W->OS); 
+        encodeULEB128(SectionIndex, W->OS);
         break;
       }
       default:
@@ -1087,35 +1087,35 @@ void WasmObjectWriter::writeLinkingMetaDataSection(
 
   if (DataSegments.size()) {
     startSection(SubSection, wasm::WASM_SEGMENT_INFO);
-    encodeULEB128(DataSegments.size(), W->OS); 
+    encodeULEB128(DataSegments.size(), W->OS);
     for (const WasmDataSegment &Segment : DataSegments) {
       writeString(Segment.Name);
-      encodeULEB128(Segment.Alignment, W->OS); 
-      encodeULEB128(Segment.LinkerFlags, W->OS); 
+      encodeULEB128(Segment.Alignment, W->OS);
+      encodeULEB128(Segment.LinkerFlags, W->OS);
     }
     endSection(SubSection);
   }
 
   if (!InitFuncs.empty()) {
     startSection(SubSection, wasm::WASM_INIT_FUNCS);
-    encodeULEB128(InitFuncs.size(), W->OS); 
+    encodeULEB128(InitFuncs.size(), W->OS);
     for (auto &StartFunc : InitFuncs) {
-      encodeULEB128(StartFunc.first, W->OS);  // priority 
-      encodeULEB128(StartFunc.second, W->OS); // function index 
+      encodeULEB128(StartFunc.first, W->OS);  // priority
+      encodeULEB128(StartFunc.second, W->OS); // function index
     }
     endSection(SubSection);
   }
 
   if (Comdats.size()) {
     startSection(SubSection, wasm::WASM_COMDAT_INFO);
-    encodeULEB128(Comdats.size(), W->OS); 
+    encodeULEB128(Comdats.size(), W->OS);
     for (const auto &C : Comdats) {
       writeString(C.first);
-      encodeULEB128(0, W->OS); // flags for future use 
-      encodeULEB128(C.second.size(), W->OS); 
+      encodeULEB128(0, W->OS); // flags for future use
+      encodeULEB128(C.second.size(), W->OS);
       for (const WasmComdatEntry &Entry : C.second) {
-        encodeULEB128(Entry.Kind, W->OS); 
-        encodeULEB128(Entry.Index, W->OS); 
+        encodeULEB128(Entry.Kind, W->OS);
+        encodeULEB128(Entry.Index, W->OS);
       }
     }
     endSection(SubSection);
@@ -1131,8 +1131,8 @@ void WasmObjectWriter::writeCustomSection(WasmCustomSection &CustomSection,
   auto *Sec = CustomSection.Section;
   startCustomSection(Section, CustomSection.Name);
 
-  Sec->setSectionOffset(W->OS.tell() - Section.ContentsOffset); 
-  Asm.writeSectionData(W->OS, Sec, Layout); 
+  Sec->setSectionOffset(W->OS.tell() - Section.ContentsOffset);
+  Asm.writeSectionData(W->OS, Sec, Layout);
 
   CustomSection.OutputContentsOffset = Section.ContentsOffset;
   CustomSection.OutputIndex = Section.Index;
@@ -1159,7 +1159,7 @@ uint32_t WasmObjectWriter::getEventType(const MCSymbolWasm &Symbol) {
 void WasmObjectWriter::registerFunctionType(const MCSymbolWasm &Symbol) {
   assert(Symbol.isFunction());
 
-  wasm::WasmSignature S; 
+  wasm::WasmSignature S;
 
   if (auto *Sig = Symbol.getSignature()) {
     S.Returns = Sig->Returns;
@@ -1181,7 +1181,7 @@ void WasmObjectWriter::registerEventType(const MCSymbolWasm &Symbol) {
 
   // TODO Currently we don't generate imported exceptions, but if we do, we
   // should have a way of infering types of imported exceptions.
-  wasm::WasmSignature S; 
+  wasm::WasmSignature S;
   if (auto *Sig = Symbol.getSignature()) {
     S.Returns = Sig->Returns;
     S.Params = Sig->Params;
@@ -1213,9 +1213,9 @@ static bool isInSymtab(const MCSymbolWasm &Sym) {
   return true;
 }
 
-void WasmObjectWriter::prepareImports( 
-    SmallVectorImpl<wasm::WasmImport> &Imports, MCAssembler &Asm, 
-    const MCAsmLayout &Layout) { 
+void WasmObjectWriter::prepareImports(
+    SmallVectorImpl<wasm::WasmImport> &Imports, MCAssembler &Asm,
+    const MCAsmLayout &Layout) {
   // For now, always emit the memory import, since loads and stores are not
   // valid without it. In the future, we could perhaps be more clever and omit
   // it if there are no loads or stores.
@@ -1236,11 +1236,11 @@ void WasmObjectWriter::prepareImports(
     // Register types for all functions, including those with private linkage
     // (because wasm always needs a type signature).
     if (WS.isFunction()) {
-      const auto *BS = Layout.getBaseSymbol(S); 
-      if (!BS) 
-        report_fatal_error(Twine(S.getName()) + 
-                           ": absolute addressing not supported!"); 
-      registerFunctionType(*cast<MCSymbolWasm>(BS)); 
+      const auto *BS = Layout.getBaseSymbol(S);
+      if (!BS)
+        report_fatal_error(Twine(S.getName()) +
+                           ": absolute addressing not supported!");
+      registerFunctionType(*cast<MCSymbolWasm>(BS));
     }
 
     if (WS.isEvent())
@@ -1285,23 +1285,23 @@ void WasmObjectWriter::prepareImports(
         Imports.push_back(Import);
         assert(WasmIndices.count(&WS) == 0);
         WasmIndices[&WS] = NumEventImports++;
-      } else if (WS.isTable()) { 
-        if (WS.isWeak()) 
-          report_fatal_error("undefined table symbol cannot be weak"); 
- 
-        wasm::WasmImport Import; 
-        Import.Module = WS.getImportModule(); 
-        Import.Field = WS.getImportName(); 
-        Import.Kind = wasm::WASM_EXTERNAL_TABLE; 
-        wasm::ValType ElemType = WS.getTableType(); 
-        Import.Table.ElemType = uint8_t(ElemType); 
-        // FIXME: Extend table type to include limits? For now we don't specify 
-        // a min or max which does not place any restrictions on the size of the 
-        // imported table. 
-        Import.Table.Limits = {wasm::WASM_LIMITS_FLAG_NONE, 0, 0}; 
-        Imports.push_back(Import); 
-        assert(WasmIndices.count(&WS) == 0); 
-        WasmIndices[&WS] = NumTableImports++; 
+      } else if (WS.isTable()) {
+        if (WS.isWeak())
+          report_fatal_error("undefined table symbol cannot be weak");
+
+        wasm::WasmImport Import;
+        Import.Module = WS.getImportModule();
+        Import.Field = WS.getImportName();
+        Import.Kind = wasm::WASM_EXTERNAL_TABLE;
+        wasm::ValType ElemType = WS.getTableType();
+        Import.Table.ElemType = uint8_t(ElemType);
+        // FIXME: Extend table type to include limits? For now we don't specify
+        // a min or max which does not place any restrictions on the size of the
+        // imported table.
+        Import.Table.Limits = {wasm::WASM_LIMITS_FLAG_NONE, 0, 0};
+        Imports.push_back(Import);
+        assert(WasmIndices.count(&WS) == 0);
+        WasmIndices[&WS] = NumTableImports++;
       }
     }
   }
@@ -1323,62 +1323,62 @@ void WasmObjectWriter::prepareImports(
       GOTIndices[&WS] = NumGlobalImports++;
     }
   }
-} 
-
-uint64_t WasmObjectWriter::writeObject(MCAssembler &Asm, 
-                                       const MCAsmLayout &Layout) { 
-  support::endian::Writer MainWriter(*OS, support::little); 
-  W = &MainWriter; 
-  if (IsSplitDwarf) { 
-    uint64_t TotalSize = writeOneObject(Asm, Layout, DwoMode::NonDwoOnly); 
-    assert(DwoOS); 
-    support::endian::Writer DwoWriter(*DwoOS, support::little); 
-    W = &DwoWriter; 
-    return TotalSize + writeOneObject(Asm, Layout, DwoMode::DwoOnly); 
-  } else { 
-    return writeOneObject(Asm, Layout, DwoMode::AllSections); 
-  } 
-} 
- 
-uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm, 
-                                          const MCAsmLayout &Layout, 
-                                          DwoMode Mode) { 
-  uint64_t StartOffset = W->OS.tell(); 
-  SectionCount = 0; 
-  CustomSections.clear(); 
- 
-  LLVM_DEBUG(dbgs() << "WasmObjectWriter::writeObject\n"); 
- 
-  // Collect information from the available symbols. 
-  SmallVector<WasmFunction, 4> Functions; 
-  SmallVector<uint32_t, 4> TableElems; 
-  SmallVector<wasm::WasmImport, 4> Imports; 
-  SmallVector<wasm::WasmExport, 4> Exports; 
-  SmallVector<wasm::WasmEventType, 1> Events; 
-  SmallVector<wasm::WasmGlobal, 1> Globals; 
-  SmallVector<wasm::WasmTable, 1> Tables; 
-  SmallVector<wasm::WasmSymbolInfo, 4> SymbolInfos; 
-  SmallVector<std::pair<uint16_t, uint32_t>, 2> InitFuncs; 
-  std::map<StringRef, std::vector<WasmComdatEntry>> Comdats; 
-  uint64_t DataSize = 0; 
-  if (Mode != DwoMode::DwoOnly) { 
-    prepareImports(Imports, Asm, Layout); 
-  } 
- 
+}
+
+uint64_t WasmObjectWriter::writeObject(MCAssembler &Asm,
+                                       const MCAsmLayout &Layout) {
+  support::endian::Writer MainWriter(*OS, support::little);
+  W = &MainWriter;
+  if (IsSplitDwarf) {
+    uint64_t TotalSize = writeOneObject(Asm, Layout, DwoMode::NonDwoOnly);
+    assert(DwoOS);
+    support::endian::Writer DwoWriter(*DwoOS, support::little);
+    W = &DwoWriter;
+    return TotalSize + writeOneObject(Asm, Layout, DwoMode::DwoOnly);
+  } else {
+    return writeOneObject(Asm, Layout, DwoMode::AllSections);
+  }
+}
+
+uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
+                                          const MCAsmLayout &Layout,
+                                          DwoMode Mode) {
+  uint64_t StartOffset = W->OS.tell();
+  SectionCount = 0;
+  CustomSections.clear();
+
+  LLVM_DEBUG(dbgs() << "WasmObjectWriter::writeObject\n");
+
+  // Collect information from the available symbols.
+  SmallVector<WasmFunction, 4> Functions;
+  SmallVector<uint32_t, 4> TableElems;
+  SmallVector<wasm::WasmImport, 4> Imports;
+  SmallVector<wasm::WasmExport, 4> Exports;
+  SmallVector<wasm::WasmEventType, 1> Events;
+  SmallVector<wasm::WasmGlobal, 1> Globals;
+  SmallVector<wasm::WasmTable, 1> Tables;
+  SmallVector<wasm::WasmSymbolInfo, 4> SymbolInfos;
+  SmallVector<std::pair<uint16_t, uint32_t>, 2> InitFuncs;
+  std::map<StringRef, std::vector<WasmComdatEntry>> Comdats;
+  uint64_t DataSize = 0;
+  if (Mode != DwoMode::DwoOnly) {
+    prepareImports(Imports, Asm, Layout);
+  }
+
   // Populate DataSegments and CustomSections, which must be done before
   // populating DataLocations.
   for (MCSection &Sec : Asm) {
     auto &Section = static_cast<MCSectionWasm &>(Sec);
     StringRef SectionName = Section.getName();
 
-    if (Mode == DwoMode::NonDwoOnly && isDwoSection(Sec)) 
-      continue; 
-    if (Mode == DwoMode::DwoOnly && !isDwoSection(Sec)) 
-      continue; 
- 
-    LLVM_DEBUG(dbgs() << "Processing Section " << SectionName << "  group " 
-                      << Section.getGroup() << "\n";); 
- 
+    if (Mode == DwoMode::NonDwoOnly && isDwoSection(Sec))
+      continue;
+    if (Mode == DwoMode::DwoOnly && !isDwoSection(Sec))
+      continue;
+
+    LLVM_DEBUG(dbgs() << "Processing Section " << SectionName << "  group "
+                      << Section.getGroup() << "\n";);
+
     // .init_array sections are handled specially elsewhere.
     if (SectionName.startswith(".init_array"))
       continue;
@@ -1393,9 +1393,9 @@ uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
       DataSegments.emplace_back();
       WasmDataSegment &Segment = DataSegments.back();
       Segment.Name = SectionName;
-      Segment.InitFlags = Section.getPassive() 
-                              ? (uint32_t)wasm::WASM_DATA_SEGMENT_IS_PASSIVE 
-                              : 0; 
+      Segment.InitFlags = Section.getPassive()
+                              ? (uint32_t)wasm::WASM_DATA_SEGMENT_IS_PASSIVE
+                              : 0;
       Segment.Offset = DataSize;
       Segment.Section = &Section;
       addData(Segment.Data, Section);
@@ -1420,7 +1420,7 @@ uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
 
       MCSymbol *Begin = Sec.getBeginSymbol();
       if (Begin) {
-        assert(WasmIndices.count(cast<MCSymbolWasm>(Begin)) == 0); 
+        assert(WasmIndices.count(cast<MCSymbolWasm>(Begin)) == 0);
         WasmIndices[cast<MCSymbolWasm>(Begin)] = CustomSections.size();
       }
 
@@ -1435,232 +1435,232 @@ uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
         continue;
       }
 
-      // Custom sections can also belong to COMDAT groups. In this case the 
-      // decriptor's "index" field is the section index (in the final object 
-      // file), but that is not known until after layout, so it must be fixed up 
-      // later 
-      if (const MCSymbolWasm *C = Section.getGroup()) { 
-        Comdats[C->getName()].emplace_back( 
-            WasmComdatEntry{wasm::WASM_COMDAT_SECTION, 
-                            static_cast<uint32_t>(CustomSections.size())}); 
-      } 
- 
+      // Custom sections can also belong to COMDAT groups. In this case the
+      // decriptor's "index" field is the section index (in the final object
+      // file), but that is not known until after layout, so it must be fixed up
+      // later
+      if (const MCSymbolWasm *C = Section.getGroup()) {
+        Comdats[C->getName()].emplace_back(
+            WasmComdatEntry{wasm::WASM_COMDAT_SECTION,
+                            static_cast<uint32_t>(CustomSections.size())});
+      }
+
       CustomSections.emplace_back(Name, &Section);
     }
   }
 
-  if (Mode != DwoMode::DwoOnly) { 
-    // Populate WasmIndices and DataLocations for defined symbols. 
-    for (const MCSymbol &S : Asm.symbols()) { 
-      // Ignore unnamed temporary symbols, which aren't ever exported, imported, 
-      // or used in relocations. 
-      if (S.isTemporary() && S.getName().empty()) 
-        continue; 
-
-      const auto &WS = static_cast<const MCSymbolWasm &>(S); 
-      LLVM_DEBUG( 
-          dbgs() << "MCSymbol: " << toString(WS.getType()) << " '" << S << "'" 
-                 << " isDefined=" << S.isDefined() << " isExternal=" 
-                 << S.isExternal() << " isTemporary=" << S.isTemporary() 
-                 << " isWeak=" << WS.isWeak() << " isHidden=" << WS.isHidden() 
-                 << " isVariable=" << WS.isVariable() << "\n"); 
-
-      if (WS.isVariable()) 
-        continue; 
-      if (WS.isComdat() && !WS.isDefined()) 
-        continue; 
-
-      if (WS.isFunction()) { 
-        unsigned Index; 
-        if (WS.isDefined()) { 
-          if (WS.getOffset() != 0) 
-            report_fatal_error( 
-                "function sections must contain one function each"); 
-
-          if (WS.getSize() == nullptr) 
-            report_fatal_error( 
-                "function symbols must have a size set with .size"); 
-
-          // A definition. Write out the function body. 
-          Index = NumFunctionImports + Functions.size(); 
-          WasmFunction Func; 
-          Func.SigIndex = getFunctionType(WS); 
-          Func.Sym = &WS; 
-          assert(WasmIndices.count(&WS) == 0); 
-          WasmIndices[&WS] = Index; 
-          Functions.push_back(Func); 
-
-          auto &Section = static_cast<MCSectionWasm &>(WS.getSection()); 
-          if (const MCSymbolWasm *C = Section.getGroup()) { 
-            Comdats[C->getName()].emplace_back( 
-                WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, Index}); 
-          } 
-
-          if (WS.hasExportName()) { 
-            wasm::WasmExport Export; 
-            Export.Name = WS.getExportName(); 
-            Export.Kind = wasm::WASM_EXTERNAL_FUNCTION; 
-            Export.Index = Index; 
-            Exports.push_back(Export); 
-          } 
-        } else { 
-          // An import; the index was assigned above. 
-          Index = WasmIndices.find(&WS)->second; 
+  if (Mode != DwoMode::DwoOnly) {
+    // Populate WasmIndices and DataLocations for defined symbols.
+    for (const MCSymbol &S : Asm.symbols()) {
+      // Ignore unnamed temporary symbols, which aren't ever exported, imported,
+      // or used in relocations.
+      if (S.isTemporary() && S.getName().empty())
+        continue;
+
+      const auto &WS = static_cast<const MCSymbolWasm &>(S);
+      LLVM_DEBUG(
+          dbgs() << "MCSymbol: " << toString(WS.getType()) << " '" << S << "'"
+                 << " isDefined=" << S.isDefined() << " isExternal="
+                 << S.isExternal() << " isTemporary=" << S.isTemporary()
+                 << " isWeak=" << WS.isWeak() << " isHidden=" << WS.isHidden()
+                 << " isVariable=" << WS.isVariable() << "\n");
+
+      if (WS.isVariable())
+        continue;
+      if (WS.isComdat() && !WS.isDefined())
+        continue;
+
+      if (WS.isFunction()) {
+        unsigned Index;
+        if (WS.isDefined()) {
+          if (WS.getOffset() != 0)
+            report_fatal_error(
+                "function sections must contain one function each");
+
+          if (WS.getSize() == nullptr)
+            report_fatal_error(
+                "function symbols must have a size set with .size");
+
+          // A definition. Write out the function body.
+          Index = NumFunctionImports + Functions.size();
+          WasmFunction Func;
+          Func.SigIndex = getFunctionType(WS);
+          Func.Sym = &WS;
+          assert(WasmIndices.count(&WS) == 0);
+          WasmIndices[&WS] = Index;
+          Functions.push_back(Func);
+
+          auto &Section = static_cast<MCSectionWasm &>(WS.getSection());
+          if (const MCSymbolWasm *C = Section.getGroup()) {
+            Comdats[C->getName()].emplace_back(
+                WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, Index});
+          }
+
+          if (WS.hasExportName()) {
+            wasm::WasmExport Export;
+            Export.Name = WS.getExportName();
+            Export.Kind = wasm::WASM_EXTERNAL_FUNCTION;
+            Export.Index = Index;
+            Exports.push_back(Export);
+          }
+        } else {
+          // An import; the index was assigned above.
+          Index = WasmIndices.find(&WS)->second;
         }
 
-        LLVM_DEBUG(dbgs() << "  -> function index: " << Index << "\n"); 
-
-      } else if (WS.isData()) { 
-        if (!isInSymtab(WS)) 
-          continue; 
-
-        if (!WS.isDefined()) { 
-          LLVM_DEBUG(dbgs() << "  -> segment index: -1" 
-                            << "\n"); 
-          continue; 
-        } 
-
-        if (!WS.getSize()) 
-          report_fatal_error("data symbols must have a size set with .size: " + 
-                             WS.getName()); 
-
-        int64_t Size = 0; 
-        if (!WS.getSize()->evaluateAsAbsolute(Size, Layout)) 
-          report_fatal_error(".size expression must be evaluatable"); 
-
-        auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection()); 
-        if (!DataSection.isWasmData()) 
-          report_fatal_error("data symbols must live in a data section: " + 
-                             WS.getName()); 
-
-        // For each data symbol, export it in the symtab as a reference to the 
-        // corresponding Wasm data segment. 
-        wasm::WasmDataReference Ref = wasm::WasmDataReference{ 
-            DataSection.getSegmentIndex(), Layout.getSymbolOffset(WS), 
-            static_cast<uint64_t>(Size)}; 
-        assert(DataLocations.count(&WS) == 0); 
-        DataLocations[&WS] = Ref; 
-        LLVM_DEBUG(dbgs() << "  -> segment index: " << Ref.Segment << "\n"); 
-
-      } else if (WS.isGlobal()) { 
-        // A "true" Wasm global (currently just __stack_pointer) 
-        if (WS.isDefined()) { 
-          wasm::WasmGlobal Global; 
-          Global.Type = WS.getGlobalType(); 
-          Global.Index = NumGlobalImports + Globals.size(); 
-          switch (Global.Type.Type) { 
-          case wasm::WASM_TYPE_I32: 
-            Global.InitExpr.Opcode = wasm::WASM_OPCODE_I32_CONST; 
-            break; 
-          case wasm::WASM_TYPE_I64: 
-            Global.InitExpr.Opcode = wasm::WASM_OPCODE_I64_CONST; 
-            break; 
-          case wasm::WASM_TYPE_F32: 
-            Global.InitExpr.Opcode = wasm::WASM_OPCODE_F32_CONST; 
-            break; 
-          case wasm::WASM_TYPE_F64: 
-            Global.InitExpr.Opcode = wasm::WASM_OPCODE_F64_CONST; 
-            break; 
-          case wasm::WASM_TYPE_EXTERNREF: 
-            Global.InitExpr.Opcode = wasm::WASM_OPCODE_REF_NULL; 
-            break; 
-          default: 
-            llvm_unreachable("unexpected type"); 
-          } 
-          assert(WasmIndices.count(&WS) == 0); 
-          WasmIndices[&WS] = Global.Index; 
-          Globals.push_back(Global); 
-        } else { 
-          // An import; the index was assigned above 
-          LLVM_DEBUG(dbgs() << "  -> global index: " 
-                            << WasmIndices.find(&WS)->second << "\n"); 
+        LLVM_DEBUG(dbgs() << "  -> function index: " << Index << "\n");
+
+      } else if (WS.isData()) {
+        if (!isInSymtab(WS))
+          continue;
+
+        if (!WS.isDefined()) {
+          LLVM_DEBUG(dbgs() << "  -> segment index: -1"
+                            << "\n");
+          continue;
         }
-      } else if (WS.isTable()) { 
-        if (WS.isDefined()) { 
-          wasm::WasmTable Table; 
-          Table.Index = NumTableImports + Tables.size(); 
-          Table.Type.ElemType = static_cast<uint8_t>(WS.getTableType()); 
-          // FIXME: Work on custom limits is ongoing 
-          Table.Type.Limits = {wasm::WASM_LIMITS_FLAG_NONE, 0, 0}; 
-          assert(WasmIndices.count(&WS) == 0); 
-          WasmIndices[&WS] = Table.Index; 
-          Tables.push_back(Table); 
-        } 
-        LLVM_DEBUG(dbgs() << " -> table index: " 
+
+        if (!WS.getSize())
+          report_fatal_error("data symbols must have a size set with .size: " +
+                             WS.getName());
+
+        int64_t Size = 0;
+        if (!WS.getSize()->evaluateAsAbsolute(Size, Layout))
+          report_fatal_error(".size expression must be evaluatable");
+
+        auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
+        if (!DataSection.isWasmData())
+          report_fatal_error("data symbols must live in a data section: " +
+                             WS.getName());
+
+        // For each data symbol, export it in the symtab as a reference to the
+        // corresponding Wasm data segment.
+        wasm::WasmDataReference Ref = wasm::WasmDataReference{
+            DataSection.getSegmentIndex(), Layout.getSymbolOffset(WS),
+            static_cast<uint64_t>(Size)};
+        assert(DataLocations.count(&WS) == 0);
+        DataLocations[&WS] = Ref;
+        LLVM_DEBUG(dbgs() << "  -> segment index: " << Ref.Segment << "\n");
+
+      } else if (WS.isGlobal()) {
+        // A "true" Wasm global (currently just __stack_pointer)
+        if (WS.isDefined()) {
+          wasm::WasmGlobal Global;
+          Global.Type = WS.getGlobalType();
+          Global.Index = NumGlobalImports + Globals.size();
+          switch (Global.Type.Type) {
+          case wasm::WASM_TYPE_I32:
+            Global.InitExpr.Opcode = wasm::WASM_OPCODE_I32_CONST;
+            break;
+          case wasm::WASM_TYPE_I64:
+            Global.InitExpr.Opcode = wasm::WASM_OPCODE_I64_CONST;
+            break;
+          case wasm::WASM_TYPE_F32:
+            Global.InitExpr.Opcode = wasm::WASM_OPCODE_F32_CONST;
+            break;
+          case wasm::WASM_TYPE_F64:
+            Global.InitExpr.Opcode = wasm::WASM_OPCODE_F64_CONST;
+            break;
+          case wasm::WASM_TYPE_EXTERNREF:
+            Global.InitExpr.Opcode = wasm::WASM_OPCODE_REF_NULL;
+            break;
+          default:
+            llvm_unreachable("unexpected type");
+          }
+          assert(WasmIndices.count(&WS) == 0);
+          WasmIndices[&WS] = Global.Index;
+          Globals.push_back(Global);
+        } else {
+          // An import; the index was assigned above
+          LLVM_DEBUG(dbgs() << "  -> global index: "
+                            << WasmIndices.find(&WS)->second << "\n");
+        }
+      } else if (WS.isTable()) {
+        if (WS.isDefined()) {
+          wasm::WasmTable Table;
+          Table.Index = NumTableImports + Tables.size();
+          Table.Type.ElemType = static_cast<uint8_t>(WS.getTableType());
+          // FIXME: Work on custom limits is ongoing
+          Table.Type.Limits = {wasm::WASM_LIMITS_FLAG_NONE, 0, 0};
+          assert(WasmIndices.count(&WS) == 0);
+          WasmIndices[&WS] = Table.Index;
+          Tables.push_back(Table);
+        }
+        LLVM_DEBUG(dbgs() << " -> table index: "
                           << WasmIndices.find(&WS)->second << "\n");
-      } else if (WS.isEvent()) { 
-        // C++ exception symbol (__cpp_exception) 
-        unsigned Index; 
-        if (WS.isDefined()) { 
-          Index = NumEventImports + Events.size(); 
-          wasm::WasmEventType Event; 
-          Event.SigIndex = getEventType(WS); 
-          Event.Attribute = wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION; 
-          assert(WasmIndices.count(&WS) == 0); 
-          WasmIndices[&WS] = Index; 
-          Events.push_back(Event); 
-        } else { 
-          // An import; the index was assigned above. 
-          assert(WasmIndices.count(&WS) > 0); 
-        } 
-        LLVM_DEBUG(dbgs() << "  -> event index: " 
-                          << WasmIndices.find(&WS)->second << "\n"); 
- 
+      } else if (WS.isEvent()) {
+        // C++ exception symbol (__cpp_exception)
+        unsigned Index;
+        if (WS.isDefined()) {
+          Index = NumEventImports + Events.size();
+          wasm::WasmEventType Event;
+          Event.SigIndex = getEventType(WS);
+          Event.Attribute = wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION;
+          assert(WasmIndices.count(&WS) == 0);
+          WasmIndices[&WS] = Index;
+          Events.push_back(Event);
+        } else {
+          // An import; the index was assigned above.
+          assert(WasmIndices.count(&WS) > 0);
+        }
+        LLVM_DEBUG(dbgs() << "  -> event index: "
+                          << WasmIndices.find(&WS)->second << "\n");
+
       } else {
-        assert(WS.isSection()); 
+        assert(WS.isSection());
       }
     }
 
-    // Populate WasmIndices and DataLocations for aliased symbols.  We need to 
-    // process these in a separate pass because we need to have processed the 
-    // target of the alias before the alias itself and the symbols are not 
-    // necessarily ordered in this way. 
-    for (const MCSymbol &S : Asm.symbols()) { 
-      if (!S.isVariable()) 
-        continue; 
-
-      assert(S.isDefined()); 
-
-      const auto *BS = Layout.getBaseSymbol(S); 
-      if (!BS) 
-        report_fatal_error(Twine(S.getName()) + 
-                           ": absolute addressing not supported!"); 
-      const MCSymbolWasm *Base = cast<MCSymbolWasm>(BS); 
-
-      // Find the target symbol of this weak alias and export that index 
-      const auto &WS = static_cast<const MCSymbolWasm &>(S); 
-      LLVM_DEBUG(dbgs() << WS.getName() << ": weak alias of '" << *Base 
-                        << "'\n"); 
-
-      if (Base->isFunction()) { 
-        assert(WasmIndices.count(Base) > 0); 
-        uint32_t WasmIndex = WasmIndices.find(Base)->second; 
-        assert(WasmIndices.count(&WS) == 0); 
-        WasmIndices[&WS] = WasmIndex; 
-        LLVM_DEBUG(dbgs() << "  -> index:" << WasmIndex << "\n"); 
-      } else if (Base->isData()) { 
-        auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection()); 
-        uint64_t Offset = Layout.getSymbolOffset(S); 
-        int64_t Size = 0; 
-        // For data symbol alias we use the size of the base symbol as the 
-        // size of the alias.  When an offset from the base is involved this 
-        // can result in a offset + size goes past the end of the data section 
-        // which out object format doesn't support.  So we must clamp it. 
-        if (!Base->getSize()->evaluateAsAbsolute(Size, Layout)) 
-          report_fatal_error(".size expression must be evaluatable"); 
-        const WasmDataSegment &Segment = 
-            DataSegments[DataSection.getSegmentIndex()]; 
-        Size = 
-            std::min(static_cast<uint64_t>(Size), Segment.Data.size() - Offset); 
-        wasm::WasmDataReference Ref = wasm::WasmDataReference{ 
-            DataSection.getSegmentIndex(), 
-            static_cast<uint32_t>(Layout.getSymbolOffset(S)), 
-            static_cast<uint32_t>(Size)}; 
-        DataLocations[&WS] = Ref; 
-        LLVM_DEBUG(dbgs() << "  -> index:" << Ref.Segment << "\n"); 
-      } else { 
-        report_fatal_error("don't yet support global/event aliases"); 
-      } 
+    // Populate WasmIndices and DataLocations for aliased symbols.  We need to
+    // process these in a separate pass because we need to have processed the
+    // target of the alias before the alias itself and the symbols are not
+    // necessarily ordered in this way.
+    for (const MCSymbol &S : Asm.symbols()) {
+      if (!S.isVariable())
+        continue;
+
+      assert(S.isDefined());
+
+      const auto *BS = Layout.getBaseSymbol(S);
+      if (!BS)
+        report_fatal_error(Twine(S.getName()) +
+                           ": absolute addressing not supported!");
+      const MCSymbolWasm *Base = cast<MCSymbolWasm>(BS);
+
+      // Find the target symbol of this weak alias and export that index
+      const auto &WS = static_cast<const MCSymbolWasm &>(S);
+      LLVM_DEBUG(dbgs() << WS.getName() << ": weak alias of '" << *Base
+                        << "'\n");
+
+      if (Base->isFunction()) {
+        assert(WasmIndices.count(Base) > 0);
+        uint32_t WasmIndex = WasmIndices.find(Base)->second;
+        assert(WasmIndices.count(&WS) == 0);
+        WasmIndices[&WS] = WasmIndex;
+        LLVM_DEBUG(dbgs() << "  -> index:" << WasmIndex << "\n");
+      } else if (Base->isData()) {
+        auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
+        uint64_t Offset = Layout.getSymbolOffset(S);
+        int64_t Size = 0;
+        // For data symbol alias we use the size of the base symbol as the
+        // size of the alias.  When an offset from the base is involved this
+        // can result in a offset + size goes past the end of the data section
+        // which out object format doesn't support.  So we must clamp it.
+        if (!Base->getSize()->evaluateAsAbsolute(Size, Layout))
+          report_fatal_error(".size expression must be evaluatable");
+        const WasmDataSegment &Segment =
+            DataSegments[DataSection.getSegmentIndex()];
+        Size =
+            std::min(static_cast<uint64_t>(Size), Segment.Data.size() - Offset);
+        wasm::WasmDataReference Ref = wasm::WasmDataReference{
+            DataSection.getSegmentIndex(),
+            static_cast<uint32_t>(Layout.getSymbolOffset(S)),
+            static_cast<uint32_t>(Size)};
+        DataLocations[&WS] = Ref;
+        LLVM_DEBUG(dbgs() << "  -> index:" << Ref.Segment << "\n");
+      } else {
+        report_fatal_error("don't yet support global/event aliases");
+      }
     }
   }
 
@@ -1671,10 +1671,10 @@ uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
       WS.setIndex(InvalidIndex);
       continue;
     }
-    if (WS.isTable() && WS.getName() == "__indirect_function_table") { 
-      // For the moment, don't emit table symbols -- wasm-ld can't handle them. 
-      continue; 
-    } 
+    if (WS.isTable() && WS.getName() == "__indirect_function_table") {
+      // For the moment, don't emit table symbols -- wasm-ld can't handle them.
+      continue;
+    }
     LLVM_DEBUG(dbgs() << "adding to symtab: " << WS << "\n");
 
     uint32_t Flags = 0;
@@ -1718,9 +1718,9 @@ uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
       // purely to make the object file's provisional values readable, and is
       // ignored by the linker, which re-calculates the relocations itself.
       if (Rel.Type != wasm::R_WASM_TABLE_INDEX_I32 &&
-          Rel.Type != wasm::R_WASM_TABLE_INDEX_I64 && 
+          Rel.Type != wasm::R_WASM_TABLE_INDEX_I64 &&
           Rel.Type != wasm::R_WASM_TABLE_INDEX_SLEB &&
-          Rel.Type != wasm::R_WASM_TABLE_INDEX_SLEB64 && 
+          Rel.Type != wasm::R_WASM_TABLE_INDEX_SLEB64 &&
           Rel.Type != wasm::R_WASM_TABLE_INDEX_REL_SLEB)
         return;
       assert(Rel.Symbol->isFunction());
@@ -1810,41 +1810,41 @@ uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
   // Write out the Wasm header.
   writeHeader(Asm);
 
-  uint32_t CodeSectionIndex, DataSectionIndex; 
-  if (Mode != DwoMode::DwoOnly) { 
-    writeTypeSection(Signatures); 
-    writeImportSection(Imports, DataSize, TableElems.size()); 
-    writeFunctionSection(Functions); 
-    writeTableSection(Tables); 
-    // Skip the "memory" section; we import the memory instead. 
-    writeEventSection(Events); 
-    writeGlobalSection(Globals); 
-    writeExportSection(Exports); 
-    writeElemSection(TableElems); 
-    writeDataCountSection(); 
- 
-    CodeSectionIndex = writeCodeSection(Asm, Layout, Functions); 
-    DataSectionIndex = writeDataSection(Layout); 
-  } 
- 
-  // The Sections in the COMDAT list have placeholder indices (their index among 
-  // custom sections, rather than among all sections). Fix them up here. 
-  for (auto &Group : Comdats) { 
-    for (auto &Entry : Group.second) { 
-      if (Entry.Kind == wasm::WASM_COMDAT_SECTION) { 
-        Entry.Index += SectionCount; 
-      } 
-    } 
-  } 
+  uint32_t CodeSectionIndex, DataSectionIndex;
+  if (Mode != DwoMode::DwoOnly) {
+    writeTypeSection(Signatures);
+    writeImportSection(Imports, DataSize, TableElems.size());
+    writeFunctionSection(Functions);
+    writeTableSection(Tables);
+    // Skip the "memory" section; we import the memory instead.
+    writeEventSection(Events);
+    writeGlobalSection(Globals);
+    writeExportSection(Exports);
+    writeElemSection(TableElems);
+    writeDataCountSection();
+
+    CodeSectionIndex = writeCodeSection(Asm, Layout, Functions);
+    DataSectionIndex = writeDataSection(Layout);
+  }
+
+  // The Sections in the COMDAT list have placeholder indices (their index among
+  // custom sections, rather than among all sections). Fix them up here.
+  for (auto &Group : Comdats) {
+    for (auto &Entry : Group.second) {
+      if (Entry.Kind == wasm::WASM_COMDAT_SECTION) {
+        Entry.Index += SectionCount;
+      }
+    }
+  }
   for (auto &CustomSection : CustomSections)
     writeCustomSection(CustomSection, Asm, Layout);
- 
-  if (Mode != DwoMode::DwoOnly) { 
-    writeLinkingMetaDataSection(SymbolInfos, InitFuncs, Comdats); 
- 
-    writeRelocSection(CodeSectionIndex, "CODE", CodeRelocations); 
-    writeRelocSection(DataSectionIndex, "DATA", DataRelocations); 
-  } 
+
+  if (Mode != DwoMode::DwoOnly) {
+    writeLinkingMetaDataSection(SymbolInfos, InitFuncs, Comdats);
+
+    writeRelocSection(CodeSectionIndex, "CODE", CodeRelocations);
+    writeRelocSection(DataSectionIndex, "DATA", DataRelocations);
+  }
   writeCustomRelocSections();
   if (ProducersSection)
     writeCustomSection(*ProducersSection, Asm, Layout);
@@ -1852,7 +1852,7 @@ uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
     writeCustomSection(*TargetFeaturesSection, Asm, Layout);
 
   // TODO: Translate the .comment section to the output.
-  return W->OS.tell() - StartOffset; 
+  return W->OS.tell() - StartOffset;
 }
 
 std::unique_ptr<MCObjectWriter>
@@ -1860,10 +1860,10 @@ llvm::createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
                              raw_pwrite_stream &OS) {
   return std::make_unique<WasmObjectWriter>(std::move(MOTW), OS);
 }
- 
-std::unique_ptr<MCObjectWriter> 
-llvm::createWasmDwoObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW, 
-                                raw_pwrite_stream &OS, 
-                                raw_pwrite_stream &DwoOS) { 
-  return std::make_unique<WasmObjectWriter>(std::move(MOTW), OS, DwoOS); 
-} 
+
+std::unique_ptr<MCObjectWriter>
+llvm::createWasmDwoObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
+                                raw_pwrite_stream &OS,
+                                raw_pwrite_stream &DwoOS) {
+  return std::make_unique<WasmObjectWriter>(std::move(MOTW), OS, DwoOS);
+}
diff --git a/contrib/libs/llvm12/lib/MC/WinCOFFObjectWriter.cpp b/contrib/libs/llvm12/lib/MC/WinCOFFObjectWriter.cpp
index 08ae059f7e..901d2c06e7 100644
--- a/contrib/libs/llvm12/lib/MC/WinCOFFObjectWriter.cpp
+++ b/contrib/libs/llvm12/lib/MC/WinCOFFObjectWriter.cpp
@@ -353,9 +353,9 @@ COFFSymbol *WinCOFFObjectWriter::getLinkedSymbol(const MCSymbol &Symbol) {
     return nullptr;
 
   const MCSymbol &Aliasee = SymRef->getSymbol();
-  if (Aliasee.isUndefined() || Aliasee.isExternal()) 
-    return GetOrCreateCOFFSymbol(&Aliasee); 
-  else 
+  if (Aliasee.isUndefined() || Aliasee.isExternal())
+    return GetOrCreateCOFFSymbol(&Aliasee);
+  else
     return nullptr;
 }
 
diff --git a/contrib/libs/llvm12/lib/MC/XCOFFObjectWriter.cpp b/contrib/libs/llvm12/lib/MC/XCOFFObjectWriter.cpp
index bec0d1d8da..031eceaadf 100644
--- a/contrib/libs/llvm12/lib/MC/XCOFFObjectWriter.cpp
+++ b/contrib/libs/llvm12/lib/MC/XCOFFObjectWriter.cpp
@@ -138,13 +138,13 @@ struct Section {
       Group->clear();
   }
 
-  Section(StringRef N, XCOFF::SectionTypeFlags Flags, bool IsVirtual, 
+  Section(StringRef N, XCOFF::SectionTypeFlags Flags, bool IsVirtual,
           CsectGroups Groups)
-      : Name(), Address(0), Size(0), FileOffsetToData(0), 
-        FileOffsetToRelocations(0), RelocationCount(0), Flags(Flags), 
-        Index(UninitializedIndex), IsVirtual(IsVirtual), Groups(Groups) { 
-    assert(N.size() <= XCOFF::NameSize && "section name too long"); 
-    memcpy(Name, N.data(), N.size()); 
+      : Name(), Address(0), Size(0), FileOffsetToData(0),
+        FileOffsetToRelocations(0), RelocationCount(0), Flags(Flags),
+        Index(UninitializedIndex), IsVirtual(IsVirtual), Groups(Groups) {
+    assert(N.size() <= XCOFF::NameSize && "section name too long");
+    memcpy(Name, N.data(), N.size());
   }
 };
 
@@ -305,7 +305,7 @@ CsectGroup &XCOFFObjectWriter::getCsectGroup(const MCSectionXCOFF *MCSec) {
            "in this CsectGroup.");
     return TOCCsects;
   case XCOFF::XMC_TC:
-  case XCOFF::XMC_TE: 
+  case XCOFF::XMC_TE:
     assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
            "Only an initialized csect can contain TC entry.");
     assert(!TOCCsects.empty() &&
@@ -429,19 +429,19 @@ void XCOFFObjectWriter::recordRelocation(MCAssembler &Asm,
     // The FixedValue should be symbol's virtual address in this object file
     // plus any constant value that we might get.
     FixedValue = getVirtualAddress(SymA, SymASec) + Target.getConstant();
-  else if (Type == XCOFF::RelocationType::R_TOC || 
-           Type == XCOFF::RelocationType::R_TOCL) { 
-    // The FixedValue should be the TOC entry offset from the TOC-base plus any 
-    // constant offset value. 
-    const int64_t TOCEntryOffset = SectionMap[SymASec]->Address - 
-                                   TOCCsects.front().Address + 
-                                   Target.getConstant(); 
-    if (Type == XCOFF::RelocationType::R_TOC && !isInt<16>(TOCEntryOffset)) 
-      report_fatal_error("TOCEntryOffset overflows in small code model mode"); 
-
-    FixedValue = TOCEntryOffset; 
-  } 
- 
+  else if (Type == XCOFF::RelocationType::R_TOC ||
+           Type == XCOFF::RelocationType::R_TOCL) {
+    // The FixedValue should be the TOC entry offset from the TOC-base plus any
+    // constant offset value.
+    const int64_t TOCEntryOffset = SectionMap[SymASec]->Address -
+                                   TOCCsects.front().Address +
+                                   Target.getConstant();
+    if (Type == XCOFF::RelocationType::R_TOC && !isInt<16>(TOCEntryOffset))
+      report_fatal_error("TOCEntryOffset overflows in small code model mode");
+
+    FixedValue = TOCEntryOffset;
+  }
+
   assert(
       (TargetObjectWriter->is64Bit() ||
        Fixup.getOffset() <= UINT32_MAX - Layout.getFragmentOffset(Fragment)) &&
diff --git a/contrib/libs/llvm12/lib/MC/ya.make b/contrib/libs/llvm12/lib/MC/ya.make
index cd151df722..3d136d7426 100644
--- a/contrib/libs/llvm12/lib/MC/ya.make
+++ b/contrib/libs/llvm12/lib/MC/ya.make
@@ -12,10 +12,10 @@ LICENSE(Apache-2.0 WITH LLVM-exception)
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
 PEERDIR(
-    contrib/libs/llvm12 
-    contrib/libs/llvm12/lib/BinaryFormat 
-    contrib/libs/llvm12/lib/DebugInfo/CodeView 
-    contrib/libs/llvm12/lib/Support 
+    contrib/libs/llvm12
+    contrib/libs/llvm12/lib/BinaryFormat
+    contrib/libs/llvm12/lib/DebugInfo/CodeView
+    contrib/libs/llvm12/lib/Support
 )
 
 ADDINCL(
@@ -60,7 +60,7 @@ SRCS(
     MCObjectFileInfo.cpp
     MCObjectStreamer.cpp
     MCObjectWriter.cpp
-    MCPseudoProbe.cpp 
+    MCPseudoProbe.cpp
     MCRegisterInfo.cpp
     MCSchedule.cpp
     MCSection.cpp