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

40 files changed, 2179 insertions, 2179 deletions

diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AIXException.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AIXException.cpp
index 95d878e65b..e91d2e6a88 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AIXException.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AIXException.cpp
@@ -1,79 +1,79 @@
-//===-- CodeGen/AsmPrinter/AIXException.cpp - AIX Exception Impl ----------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains support for writing AIX exception info into asm files.
-//
-//===----------------------------------------------------------------------===//
-
-#include "DwarfException.h"
-#include "llvm/CodeGen/AsmPrinter.h"
-#include "llvm/CodeGen/MachineModuleInfo.h"
-#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
-#include "llvm/MC/MCSectionXCOFF.h"
-#include "llvm/MC/MCStreamer.h"
-#include "llvm/Target/TargetLoweringObjectFile.h"
-#include "llvm/Target/TargetMachine.h"
-
-namespace llvm {
-
-AIXException::AIXException(AsmPrinter *A) : DwarfCFIExceptionBase(A) {}
-
-void AIXException::emitExceptionInfoTable(const MCSymbol *LSDA,
-                                          const MCSymbol *PerSym) {
-  // Generate EH Info Table.
-  // The EH Info Table, aka, 'compat unwind section' on AIX, have the following
-  // format: struct eh_info_t {
-  //   unsigned version;           /* EH info verion 0 */
-  // #if defined(__64BIT__)
-  //   char _pad[4];               /* padding */
-  // #endif
-  //   unsigned long lsda;         /* Pointer to LSDA */
-  //   unsigned long personality;  /* Pointer to the personality routine */
-  //   }
-
-  Asm->OutStreamer->SwitchSection(
-      Asm->getObjFileLowering().getCompactUnwindSection());
-  MCSymbol *EHInfoLabel =
-      TargetLoweringObjectFileXCOFF::getEHInfoTableSymbol(Asm->MF);
-  Asm->OutStreamer->emitLabel(EHInfoLabel);
-
-  // Version number.
-  Asm->emitInt32(0);
-
-  const DataLayout &DL = MMI->getModule()->getDataLayout();
-  const unsigned PointerSize = DL.getPointerSize();
-
-  // Add necessary paddings in 64 bit mode.
-  Asm->OutStreamer->emitValueToAlignment(PointerSize);
-
-  // LSDA location.
-  Asm->OutStreamer->emitValue(MCSymbolRefExpr::create(LSDA, Asm->OutContext),
-                              PointerSize);
-
-  // Personality routine.
-  Asm->OutStreamer->emitValue(MCSymbolRefExpr::create(PerSym, Asm->OutContext),
-                              PointerSize);
-}
-
-void AIXException::endFunction(const MachineFunction *MF) {
-  if (!TargetLoweringObjectFileXCOFF::ShouldEmitEHBlock(MF))
-    return;
-
-  const MCSymbol *LSDALabel = emitExceptionTable();
-
-  const Function &F = MF->getFunction();
-  assert(F.hasPersonalityFn() &&
-         "Landingpads are presented, but no personality routine is found.");
-  const Function *Per =
-      dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
-  const MCSymbol *PerSym = Asm->TM.getSymbol(Per);
-
-  emitExceptionInfoTable(LSDALabel, PerSym);
-}
-
-} // End of namespace llvm
+//===-- CodeGen/AsmPrinter/AIXException.cpp - AIX Exception Impl ----------===// 
+// 
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
+// See https://llvm.org/LICENSE.txt for license information. 
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
+// 
+//===----------------------------------------------------------------------===// 
+// 
+// This file contains support for writing AIX exception info into asm files. 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include "DwarfException.h" 
+#include "llvm/CodeGen/AsmPrinter.h" 
+#include "llvm/CodeGen/MachineModuleInfo.h" 
+#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h" 
+#include "llvm/MC/MCSectionXCOFF.h" 
+#include "llvm/MC/MCStreamer.h" 
+#include "llvm/Target/TargetLoweringObjectFile.h" 
+#include "llvm/Target/TargetMachine.h" 
+ 
+namespace llvm { 
+ 
+AIXException::AIXException(AsmPrinter *A) : DwarfCFIExceptionBase(A) {} 
+ 
+void AIXException::emitExceptionInfoTable(const MCSymbol *LSDA, 
+                                          const MCSymbol *PerSym) { 
+  // Generate EH Info Table. 
+  // The EH Info Table, aka, 'compat unwind section' on AIX, have the following 
+  // format: struct eh_info_t { 
+  //   unsigned version;           /* EH info verion 0 */ 
+  // #if defined(__64BIT__) 
+  //   char _pad[4];               /* padding */ 
+  // #endif 
+  //   unsigned long lsda;         /* Pointer to LSDA */ 
+  //   unsigned long personality;  /* Pointer to the personality routine */ 
+  //   } 
+ 
+  Asm->OutStreamer->SwitchSection( 
+      Asm->getObjFileLowering().getCompactUnwindSection()); 
+  MCSymbol *EHInfoLabel = 
+      TargetLoweringObjectFileXCOFF::getEHInfoTableSymbol(Asm->MF); 
+  Asm->OutStreamer->emitLabel(EHInfoLabel); 
+ 
+  // Version number. 
+  Asm->emitInt32(0); 
+ 
+  const DataLayout &DL = MMI->getModule()->getDataLayout(); 
+  const unsigned PointerSize = DL.getPointerSize(); 
+ 
+  // Add necessary paddings in 64 bit mode. 
+  Asm->OutStreamer->emitValueToAlignment(PointerSize); 
+ 
+  // LSDA location. 
+  Asm->OutStreamer->emitValue(MCSymbolRefExpr::create(LSDA, Asm->OutContext), 
+                              PointerSize); 
+ 
+  // Personality routine. 
+  Asm->OutStreamer->emitValue(MCSymbolRefExpr::create(PerSym, Asm->OutContext), 
+                              PointerSize); 
+} 
+ 
+void AIXException::endFunction(const MachineFunction *MF) { 
+  if (!TargetLoweringObjectFileXCOFF::ShouldEmitEHBlock(MF)) 
+    return; 
+ 
+  const MCSymbol *LSDALabel = emitExceptionTable(); 
+ 
+  const Function &F = MF->getFunction(); 
+  assert(F.hasPersonalityFn() && 
+         "Landingpads are presented, but no personality routine is found."); 
+  const Function *Per = 
+      dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts()); 
+  const MCSymbol *PerSym = Asm->TM.getSymbol(Per); 
+ 
+  emitExceptionInfoTable(LSDALabel, PerSym); 
+} 
+ 
+} // End of namespace llvm 
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AccelTable.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AccelTable.cpp
index 4e45a0ffc6..ae8cd3b886 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AccelTable.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AccelTable.cpp
@@ -270,7 +270,7 @@ void AccelTableWriter::emitOffsets(const MCSymbol *Base) const {
         continue;
       PrevHash = HashValue;
       Asm->OutStreamer->AddComment("Offset in Bucket " + Twine(i));
-      Asm->emitLabelDifference(Hash->Sym, Base, Asm->getDwarfOffsetByteSize());
+      Asm->emitLabelDifference(Hash->Sym, Base, Asm->getDwarfOffsetByteSize()); 
     }
   }
 }
@@ -366,8 +366,8 @@ void Dwarf5AccelTableWriter<DataT>::Header::emit(
   assert(CompUnitCount > 0 && "Index must have at least one CU.");
 
   AsmPrinter *Asm = Ctx.Asm;
-  Asm->emitDwarfUnitLength(Ctx.ContributionEnd, Ctx.ContributionStart,
-                           "Header: unit length");
+  Asm->emitDwarfUnitLength(Ctx.ContributionEnd, Ctx.ContributionStart, 
+                           "Header: unit length"); 
   Asm->OutStreamer->emitLabel(Ctx.ContributionStart);
   Asm->OutStreamer->AddComment("Header: version");
   Asm->emitInt16(Version);
@@ -504,7 +504,7 @@ template <typename DataT> void Dwarf5AccelTableWriter<DataT>::emitData() const {
       for (const auto *Value : Hash->Values)
         emitEntry(*static_cast<const DataT *>(Value));
       Asm->OutStreamer->AddComment("End of list: " + Hash->Name.getString());
-      Asm->emitInt8(0);
+      Asm->emitInt8(0); 
     }
   }
 }
@@ -591,14 +591,14 @@ void llvm::emitDWARF5AccelTable(
 }
 
 void AppleAccelTableOffsetData::emit(AsmPrinter *Asm) const {
-  assert(Die.getDebugSectionOffset() <= UINT32_MAX &&
-         "The section offset exceeds the limit.");
+  assert(Die.getDebugSectionOffset() <= UINT32_MAX && 
+         "The section offset exceeds the limit."); 
   Asm->emitInt32(Die.getDebugSectionOffset());
 }
 
 void AppleAccelTableTypeData::emit(AsmPrinter *Asm) const {
-  assert(Die.getDebugSectionOffset() <= UINT32_MAX &&
-         "The section offset exceeds the limit.");
+  assert(Die.getDebugSectionOffset() <= UINT32_MAX && 
+         "The section offset exceeds the limit."); 
   Asm->emitInt32(Die.getDebugSectionOffset());
   Asm->emitInt16(Die.getTag());
   Asm->emitInt8(0);
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AddressPool.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AddressPool.cpp
index 3df8e35acc..3ff0dd1487 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AddressPool.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AddressPool.cpp
@@ -29,7 +29,7 @@ MCSymbol *AddressPool::emitHeader(AsmPrinter &Asm, MCSection *Section) {
   MCSymbol *BeginLabel = Asm.createTempSymbol(Prefix + "start");
   MCSymbol *EndLabel = Asm.createTempSymbol(Prefix + "end");
 
-  Asm.emitDwarfUnitLength(EndLabel, BeginLabel, "Length of contribution");
+  Asm.emitDwarfUnitLength(EndLabel, BeginLabel, "Length of contribution"); 
   Asm.OutStreamer->emitLabel(BeginLabel);
   Asm.OutStreamer->AddComment("DWARF version number");
   Asm.emitInt16(Asm.getDwarfVersion());
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AddressPool.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AddressPool.h
index f1edc6c330..4c444998af 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AddressPool.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AddressPool.h
@@ -48,7 +48,7 @@ public:
 
   bool hasBeenUsed() const { return HasBeenUsed; }
 
-  void resetUsedFlag(bool HasBeenUsed = false) { this->HasBeenUsed = HasBeenUsed; }
+  void resetUsedFlag(bool HasBeenUsed = false) { this->HasBeenUsed = HasBeenUsed; } 
 
   MCSymbol *getLabel() { return AddressTableBaseSym; }
   void setLabel(MCSymbol *Sym) { AddressTableBaseSym = Sym; }
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
index 85754bf29d..a21f2c8ca8 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
@@ -14,7 +14,7 @@
 #include "CodeViewDebug.h"
 #include "DwarfDebug.h"
 #include "DwarfException.h"
-#include "PseudoProbePrinter.h"
+#include "PseudoProbePrinter.h" 
 #include "WasmException.h"
 #include "WinCFGuard.h"
 #include "WinException.h"
@@ -31,7 +31,7 @@
 #include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/EHPersonalities.h"
-#include "llvm/Analysis/MemoryLocation.h"
+#include "llvm/Analysis/MemoryLocation.h" 
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/Dwarf.h"
@@ -79,7 +79,7 @@
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
-#include "llvm/IR/PseudoProbe.h"
+#include "llvm/IR/PseudoProbe.h" 
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/MC/MCAsmInfo.h"
@@ -134,26 +134,26 @@ using namespace llvm;
 
 #define DEBUG_TYPE "asm-printer"
 
-// FIXME: this option currently only applies to DWARF, and not CodeView, tables
-static cl::opt<bool>
-    DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
-                             cl::desc("Disable debug info printing"));
-
-const char DWARFGroupName[] = "dwarf";
-const char DWARFGroupDescription[] = "DWARF Emission";
-const char DbgTimerName[] = "emit";
-const char DbgTimerDescription[] = "Debug Info Emission";
-const char EHTimerName[] = "write_exception";
-const char EHTimerDescription[] = "DWARF Exception Writer";
-const char CFGuardName[] = "Control Flow Guard";
-const char CFGuardDescription[] = "Control Flow Guard";
-const char CodeViewLineTablesGroupName[] = "linetables";
-const char CodeViewLineTablesGroupDescription[] = "CodeView Line Tables";
-const char PPTimerName[] = "emit";
-const char PPTimerDescription[] = "Pseudo Probe Emission";
-const char PPGroupName[] = "pseudo probe";
-const char PPGroupDescription[] = "Pseudo Probe Emission";
-
+// FIXME: this option currently only applies to DWARF, and not CodeView, tables 
+static cl::opt<bool> 
+    DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden, 
+                             cl::desc("Disable debug info printing")); 
+
+const char DWARFGroupName[] = "dwarf"; 
+const char DWARFGroupDescription[] = "DWARF Emission"; 
+const char DbgTimerName[] = "emit"; 
+const char DbgTimerDescription[] = "Debug Info Emission"; 
+const char EHTimerName[] = "write_exception"; 
+const char EHTimerDescription[] = "DWARF Exception Writer"; 
+const char CFGuardName[] = "Control Flow Guard"; 
+const char CFGuardDescription[] = "Control Flow Guard"; 
+const char CodeViewLineTablesGroupName[] = "linetables"; 
+const char CodeViewLineTablesGroupDescription[] = "CodeView Line Tables"; 
+const char PPTimerName[] = "emit"; 
+const char PPTimerDescription[] = "Pseudo Probe Emission"; 
+const char PPGroupName[] = "pseudo probe"; 
+const char PPGroupDescription[] = "Pseudo Probe Emission"; 
+ 
 STATISTIC(EmittedInsts, "Number of machine instrs printed");
 
 char AsmPrinter::ID = 0;
@@ -199,8 +199,8 @@ AsmPrinter::AsmPrinter(TargetMachine &tm, std::unique_ptr<MCStreamer> Streamer)
 }
 
 AsmPrinter::~AsmPrinter() {
-  assert(!DD && Handlers.size() == NumUserHandlers &&
-         "Debug/EH info didn't get finalized");
+  assert(!DD && Handlers.size() == NumUserHandlers && 
+         "Debug/EH info didn't get finalized"); 
 
   if (GCMetadataPrinters) {
     gcp_map_type &GCMap = getGCMap(GCMetadataPrinters);
@@ -243,11 +243,11 @@ void AsmPrinter::EmitToStreamer(MCStreamer &S, const MCInst &Inst) {
 }
 
 void AsmPrinter::emitInitialRawDwarfLocDirective(const MachineFunction &MF) {
-  if (DD) {
-    assert(OutStreamer->hasRawTextSupport() &&
-           "Expected assembly output mode.");
-    (void)DD->emitInitialLocDirective(MF, /*CUID=*/0);
-  }
+  if (DD) { 
+    assert(OutStreamer->hasRawTextSupport() && 
+           "Expected assembly output mode."); 
+    (void)DD->emitInitialLocDirective(MF, /*CUID=*/0); 
+  } 
 }
 
 /// getCurrentSection() - Return the current section we are emitting to.
@@ -275,9 +275,9 @@ bool AsmPrinter::doInitialization(Module &M) {
 
   OutStreamer->InitSections(false);
 
-  if (DisableDebugInfoPrinting)
-    MMI->setDebugInfoAvailability(false);
-
+  if (DisableDebugInfoPrinting) 
+    MMI->setDebugInfoAvailability(false); 
+ 
   // Emit the version-min deployment target directive if needed.
   //
   // FIXME: If we end up with a collection of these sorts of Darwin-specific
@@ -313,7 +313,7 @@ bool AsmPrinter::doInitialization(Module &M) {
     std::unique_ptr<MCSubtargetInfo> STI(TM.getTarget().createMCSubtargetInfo(
         TM.getTargetTriple().str(), TM.getTargetCPU(),
         TM.getTargetFeatureString()));
-    assert(STI && "Unable to create subtarget info");
+    assert(STI && "Unable to create subtarget info"); 
     OutStreamer->AddComment("Start of file scope inline assembly");
     OutStreamer->AddBlankLine();
     emitInlineAsm(M.getModuleInlineAsm() + "\n",
@@ -331,21 +331,21 @@ bool AsmPrinter::doInitialization(Module &M) {
                             CodeViewLineTablesGroupDescription);
     }
     if (!EmitCodeView || M.getDwarfVersion()) {
-      if (!DisableDebugInfoPrinting) {
-        DD = new DwarfDebug(this);
-        Handlers.emplace_back(std::unique_ptr<DwarfDebug>(DD), DbgTimerName,
-                              DbgTimerDescription, DWARFGroupName,
-                              DWARFGroupDescription);
-      }
+      if (!DisableDebugInfoPrinting) { 
+        DD = new DwarfDebug(this); 
+        Handlers.emplace_back(std::unique_ptr<DwarfDebug>(DD), DbgTimerName, 
+                              DbgTimerDescription, DWARFGroupName, 
+                              DWARFGroupDescription); 
+      } 
     }
   }
 
-  if (M.getNamedMetadata(PseudoProbeDescMetadataName)) {
-    PP = new PseudoProbeHandler(this, &M);
-    Handlers.emplace_back(std::unique_ptr<PseudoProbeHandler>(PP), PPTimerName,
-                          PPTimerDescription, PPGroupName, PPGroupDescription);
-  }
-
+  if (M.getNamedMetadata(PseudoProbeDescMetadataName)) { 
+    PP = new PseudoProbeHandler(this, &M); 
+    Handlers.emplace_back(std::unique_ptr<PseudoProbeHandler>(PP), PPTimerName, 
+                          PPTimerDescription, PPGroupName, PPGroupDescription); 
+  } 
+ 
   switch (MAI->getExceptionHandlingType()) {
   case ExceptionHandling::SjLj:
   case ExceptionHandling::DwarfCFI:
@@ -393,9 +393,9 @@ bool AsmPrinter::doInitialization(Module &M) {
   case ExceptionHandling::Wasm:
     ES = new WasmException(this);
     break;
-  case ExceptionHandling::AIX:
-    ES = new AIXException(this);
-    break;
+  case ExceptionHandling::AIX: 
+    ES = new AIXException(this); 
+    break; 
   }
   if (ES)
     Handlers.emplace_back(std::unique_ptr<EHStreamer>(ES), EHTimerName,
@@ -407,13 +407,13 @@ bool AsmPrinter::doInitialization(Module &M) {
     Handlers.emplace_back(std::make_unique<WinCFGuard>(this), CFGuardName,
                           CFGuardDescription, DWARFGroupName,
                           DWARFGroupDescription);
-
-  for (const HandlerInfo &HI : Handlers) {
-    NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
-                       HI.TimerGroupDescription, TimePassesIsEnabled);
-    HI.Handler->beginModule(&M);
-  }
-
+ 
+  for (const HandlerInfo &HI : Handlers) { 
+    NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName, 
+                       HI.TimerGroupDescription, TimePassesIsEnabled); 
+    HI.Handler->beginModule(&M); 
+  } 
+ 
   return false;
 }
 
@@ -484,8 +484,8 @@ MCSymbol *AsmPrinter::getSymbolPreferLocal(const GlobalValue &GV) const {
   if (TM.getTargetTriple().isOSBinFormatELF() && GV.canBenefitFromLocalAlias()) {
     const Module &M = *GV.getParent();
     if (TM.getRelocationModel() != Reloc::Static &&
-        M.getPIELevel() == PIELevel::Default && GV.isDSOLocal())
-      return getSymbolWithGlobalValueBase(&GV, "$local");
+        M.getPIELevel() == PIELevel::Default && GV.isDSOLocal()) 
+      return getSymbolWithGlobalValueBase(&GV, "$local"); 
   }
   return TM.getSymbol(&GV);
 }
@@ -533,8 +533,8 @@ void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
 
   GVSym->redefineIfPossible();
   if (GVSym->isDefined() || GVSym->isVariable())
-    OutContext.reportError(SMLoc(), "symbol '" + Twine(GVSym->getName()) +
-                                        "' is already defined");
+    OutContext.reportError(SMLoc(), "symbol '" + Twine(GVSym->getName()) + 
+                                        "' is already defined"); 
 
   if (MAI->hasDotTypeDotSizeDirective())
     OutStreamer->emitSymbolAttribute(EmittedSym, MCSA_ELF_TypeObject);
@@ -845,21 +845,21 @@ static void emitComments(const MachineInstr &MI, raw_ostream &CommentOS) {
   if ((Size = MI.getRestoreSize(TII))) {
     CommentOS << *Size << "-byte Reload\n";
   } else if ((Size = MI.getFoldedRestoreSize(TII))) {
-    if (*Size) {
-      if (*Size == unsigned(MemoryLocation::UnknownSize))
-        CommentOS << "Unknown-size Folded Reload\n";
-      else
-        CommentOS << *Size << "-byte Folded Reload\n";
-    }
+    if (*Size) { 
+      if (*Size == unsigned(MemoryLocation::UnknownSize)) 
+        CommentOS << "Unknown-size Folded Reload\n"; 
+      else 
+        CommentOS << *Size << "-byte Folded Reload\n"; 
+    } 
   } else if ((Size = MI.getSpillSize(TII))) {
     CommentOS << *Size << "-byte Spill\n";
   } else if ((Size = MI.getFoldedSpillSize(TII))) {
-    if (*Size) {
-      if (*Size == unsigned(MemoryLocation::UnknownSize))
-        CommentOS << "Unknown-size Folded Spill\n";
-      else
-        CommentOS << *Size << "-byte Folded Spill\n";
-    }
+    if (*Size) { 
+      if (*Size == unsigned(MemoryLocation::UnknownSize)) 
+        CommentOS << "Unknown-size Folded Spill\n"; 
+      else 
+        CommentOS << *Size << "-byte Folded Spill\n"; 
+    } 
   }
 
   // Check for spill-induced copies
@@ -918,7 +918,7 @@ static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP) {
 
   // The second operand is only an offset if it's an immediate.
   bool MemLoc = MI->isIndirectDebugValue();
-  auto Offset = StackOffset::getFixed(MemLoc ? MI->getOperand(1).getImm() : 0);
+  auto Offset = StackOffset::getFixed(MemLoc ? MI->getOperand(1).getImm() : 0); 
   const DIExpression *Expr = MI->getDebugExpression();
   if (Expr->getNumElements()) {
     OS << '[';
@@ -957,8 +957,8 @@ static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP) {
   } else if (MI->getDebugOperand(0).isTargetIndex()) {
     auto Op = MI->getDebugOperand(0);
     OS << "!target-index(" << Op.getIndex() << "," << Op.getOffset() << ")";
-    // NOTE: Want this comment at start of line, don't emit with AddComment.
-    AP.OutStreamer->emitRawComment(OS.str());
+    // NOTE: Want this comment at start of line, don't emit with AddComment. 
+    AP.OutStreamer->emitRawComment(OS.str()); 
     return true;
   } else {
     Register Reg;
@@ -984,7 +984,7 @@ static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP) {
   }
 
   if (MemLoc)
-    OS << '+' << Offset.getFixed() << ']';
+    OS << '+' << Offset.getFixed() << ']'; 
 
   // NOTE: Want this comment at start of line, don't emit with AddComment.
   AP.OutStreamer->emitRawComment(OS.str());
@@ -1066,56 +1066,56 @@ void AsmPrinter::emitFrameAlloc(const MachineInstr &MI) {
                              MCConstantExpr::create(FrameOffset, OutContext));
 }
 
-/// Returns the BB metadata to be emitted in the .llvm_bb_addr_map section for a
-/// given basic block. This can be used to capture more precise profile
-/// information. We use the last 3 bits (LSBs) to ecnode the following
-/// information:
-///  * (1): set if return block (ret or tail call).
-///  * (2): set if ends with a tail call.
-///  * (3): set if exception handling (EH) landing pad.
-/// The remaining bits are zero.
-static unsigned getBBAddrMapMetadata(const MachineBasicBlock &MBB) {
-  const TargetInstrInfo *TII = MBB.getParent()->getSubtarget().getInstrInfo();
-  return ((unsigned)MBB.isReturnBlock()) |
-         ((!MBB.empty() && TII->isTailCall(MBB.back())) << 1) |
-         (MBB.isEHPad() << 2);
-}
-
-void AsmPrinter::emitBBAddrMapSection(const MachineFunction &MF) {
-  MCSection *BBAddrMapSection =
-      getObjFileLowering().getBBAddrMapSection(*MF.getSection());
-  assert(BBAddrMapSection && ".llvm_bb_addr_map section is not initialized.");
-
-  const MCSymbol *FunctionSymbol = getFunctionBegin();
-
-  OutStreamer->PushSection();
-  OutStreamer->SwitchSection(BBAddrMapSection);
-  OutStreamer->emitSymbolValue(FunctionSymbol, getPointerSize());
-  // Emit the total number of basic blocks in this function.
-  OutStreamer->emitULEB128IntValue(MF.size());
-  // Emit BB Information for each basic block in the funciton.
-  for (const MachineBasicBlock &MBB : MF) {
-    const MCSymbol *MBBSymbol =
-        MBB.isEntryBlock() ? FunctionSymbol : MBB.getSymbol();
-    // Emit the basic block offset.
-    emitLabelDifferenceAsULEB128(MBBSymbol, FunctionSymbol);
-    // Emit the basic block size. When BBs have alignments, their size cannot
-    // always be computed from their offsets.
-    emitLabelDifferenceAsULEB128(MBB.getEndSymbol(), MBBSymbol);
-    OutStreamer->emitULEB128IntValue(getBBAddrMapMetadata(MBB));
-  }
-  OutStreamer->PopSection();
-}
-
-void AsmPrinter::emitPseudoProbe(const MachineInstr &MI) {
-  auto GUID = MI.getOperand(0).getImm();
-  auto Index = MI.getOperand(1).getImm();
-  auto Type = MI.getOperand(2).getImm();
-  auto Attr = MI.getOperand(3).getImm();
-  DILocation *DebugLoc = MI.getDebugLoc();
-  PP->emitPseudoProbe(GUID, Index, Type, Attr, DebugLoc);
-}
-
+/// Returns the BB metadata to be emitted in the .llvm_bb_addr_map section for a 
+/// given basic block. This can be used to capture more precise profile 
+/// information. We use the last 3 bits (LSBs) to ecnode the following 
+/// information: 
+///  * (1): set if return block (ret or tail call). 
+///  * (2): set if ends with a tail call. 
+///  * (3): set if exception handling (EH) landing pad. 
+/// The remaining bits are zero. 
+static unsigned getBBAddrMapMetadata(const MachineBasicBlock &MBB) { 
+  const TargetInstrInfo *TII = MBB.getParent()->getSubtarget().getInstrInfo(); 
+  return ((unsigned)MBB.isReturnBlock()) | 
+         ((!MBB.empty() && TII->isTailCall(MBB.back())) << 1) | 
+         (MBB.isEHPad() << 2); 
+} 
+ 
+void AsmPrinter::emitBBAddrMapSection(const MachineFunction &MF) { 
+  MCSection *BBAddrMapSection = 
+      getObjFileLowering().getBBAddrMapSection(*MF.getSection()); 
+  assert(BBAddrMapSection && ".llvm_bb_addr_map section is not initialized."); 
+ 
+  const MCSymbol *FunctionSymbol = getFunctionBegin(); 
+ 
+  OutStreamer->PushSection(); 
+  OutStreamer->SwitchSection(BBAddrMapSection); 
+  OutStreamer->emitSymbolValue(FunctionSymbol, getPointerSize()); 
+  // Emit the total number of basic blocks in this function. 
+  OutStreamer->emitULEB128IntValue(MF.size()); 
+  // Emit BB Information for each basic block in the funciton. 
+  for (const MachineBasicBlock &MBB : MF) { 
+    const MCSymbol *MBBSymbol = 
+        MBB.isEntryBlock() ? FunctionSymbol : MBB.getSymbol(); 
+    // Emit the basic block offset. 
+    emitLabelDifferenceAsULEB128(MBBSymbol, FunctionSymbol); 
+    // Emit the basic block size. When BBs have alignments, their size cannot 
+    // always be computed from their offsets. 
+    emitLabelDifferenceAsULEB128(MBB.getEndSymbol(), MBBSymbol); 
+    OutStreamer->emitULEB128IntValue(getBBAddrMapMetadata(MBB)); 
+  } 
+  OutStreamer->PopSection(); 
+} 
+ 
+void AsmPrinter::emitPseudoProbe(const MachineInstr &MI) { 
+  auto GUID = MI.getOperand(0).getImm(); 
+  auto Index = MI.getOperand(1).getImm(); 
+  auto Type = MI.getOperand(2).getImm(); 
+  auto Attr = MI.getOperand(3).getImm(); 
+  DILocation *DebugLoc = MI.getDebugLoc(); 
+  PP->emitPseudoProbe(GUID, Index, Type, Attr, DebugLoc); 
+} 
+ 
 void AsmPrinter::emitStackSizeSection(const MachineFunction &MF) {
   if (!MF.getTarget().Options.EmitStackSizeSection)
     return;
@@ -1184,11 +1184,11 @@ void AsmPrinter::emitFunctionBody() {
   bool HasAnyRealCode = false;
   int NumInstsInFunction = 0;
 
-  bool CanDoExtraAnalysis = ORE->allowExtraAnalysis(DEBUG_TYPE);
+  bool CanDoExtraAnalysis = ORE->allowExtraAnalysis(DEBUG_TYPE); 
   for (auto &MBB : *MF) {
     // Print a label for the basic block.
     emitBasicBlockStart(MBB);
-    DenseMap<StringRef, unsigned> MnemonicCounts;
+    DenseMap<StringRef, unsigned> MnemonicCounts; 
     for (auto &MI : MBB) {
       // Print the assembly for the instruction.
       if (!MI.isPosition() && !MI.isImplicitDef() && !MI.isKill() &&
@@ -1201,10 +1201,10 @@ void AsmPrinter::emitFunctionBody() {
       if (MCSymbol *S = MI.getPreInstrSymbol())
         OutStreamer->emitLabel(S);
 
-      for (const HandlerInfo &HI : Handlers) {
-        NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
-                           HI.TimerGroupDescription, TimePassesIsEnabled);
-        HI.Handler->beginInstruction(&MI);
+      for (const HandlerInfo &HI : Handlers) { 
+        NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName, 
+                           HI.TimerGroupDescription, TimePassesIsEnabled); 
+        HI.Handler->beginInstruction(&MI); 
       }
 
       if (isVerbose())
@@ -1232,11 +1232,11 @@ void AsmPrinter::emitFunctionBody() {
             emitInstruction(&MI);
         }
         break;
-      case TargetOpcode::DBG_INSTR_REF:
-        // This instruction reference will have been resolved to a machine
-        // location, and a nearby DBG_VALUE created. We can safely ignore
-        // the instruction reference.
-        break;
+      case TargetOpcode::DBG_INSTR_REF: 
+        // This instruction reference will have been resolved to a machine 
+        // location, and a nearby DBG_VALUE created. We can safely ignore 
+        // the instruction reference. 
+        break; 
       case TargetOpcode::DBG_LABEL:
         if (isVerbose()) {
           if (!emitDebugLabelComment(&MI, *this))
@@ -1249,18 +1249,18 @@ void AsmPrinter::emitFunctionBody() {
       case TargetOpcode::KILL:
         if (isVerbose()) emitKill(&MI, *this);
         break;
-      case TargetOpcode::PSEUDO_PROBE:
-        emitPseudoProbe(MI);
-        break;
+      case TargetOpcode::PSEUDO_PROBE: 
+        emitPseudoProbe(MI); 
+        break; 
       default:
         emitInstruction(&MI);
-        if (CanDoExtraAnalysis) {
-          MCInst MCI;
-          MCI.setOpcode(MI.getOpcode());
-          auto Name = OutStreamer->getMnemonic(MCI);
-          auto I = MnemonicCounts.insert({Name, 0u});
-          I.first->second++;
-        }
+        if (CanDoExtraAnalysis) { 
+          MCInst MCI; 
+          MCI.setOpcode(MI.getOpcode()); 
+          auto Name = OutStreamer->getMnemonic(MCI); 
+          auto I = MnemonicCounts.insert({Name, 0u}); 
+          I.first->second++; 
+        } 
         break;
       }
 
@@ -1268,69 +1268,69 @@ void AsmPrinter::emitFunctionBody() {
       if (MCSymbol *S = MI.getPostInstrSymbol())
         OutStreamer->emitLabel(S);
 
-      for (const HandlerInfo &HI : Handlers) {
-        NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
-                           HI.TimerGroupDescription, TimePassesIsEnabled);
-        HI.Handler->endInstruction();
+      for (const HandlerInfo &HI : Handlers) { 
+        NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName, 
+                           HI.TimerGroupDescription, TimePassesIsEnabled); 
+        HI.Handler->endInstruction(); 
       }
     }
 
-    // We must emit temporary symbol for the end of this basic block, if either
-    // we have BBLabels enabled or if this basic blocks marks the end of a
-    // section (except the section containing the entry basic block as the end
-    // symbol for that section is CurrentFnEnd).
-    if (MF->hasBBLabels() ||
-        (MAI->hasDotTypeDotSizeDirective() && MBB.isEndSection() &&
-         !MBB.sameSection(&MF->front())))
-      OutStreamer->emitLabel(MBB.getEndSymbol());
+    // We must emit temporary symbol for the end of this basic block, if either 
+    // we have BBLabels enabled or if this basic blocks marks the end of a 
+    // section (except the section containing the entry basic block as the end 
+    // symbol for that section is CurrentFnEnd). 
+    if (MF->hasBBLabels() || 
+        (MAI->hasDotTypeDotSizeDirective() && MBB.isEndSection() && 
+         !MBB.sameSection(&MF->front()))) 
+      OutStreamer->emitLabel(MBB.getEndSymbol()); 
 
     if (MBB.isEndSection()) {
-      // The size directive for the section containing the entry block is
-      // handled separately by the function section.
+      // The size directive for the section containing the entry block is 
+      // handled separately by the function section. 
       if (!MBB.sameSection(&MF->front())) {
-        if (MAI->hasDotTypeDotSizeDirective()) {
-          // Emit the size directive for the basic block section.
-          const MCExpr *SizeExp = MCBinaryExpr::createSub(
-              MCSymbolRefExpr::create(MBB.getEndSymbol(), OutContext),
-              MCSymbolRefExpr::create(CurrentSectionBeginSym, OutContext),
-              OutContext);
-          OutStreamer->emitELFSize(CurrentSectionBeginSym, SizeExp);
-        }
+        if (MAI->hasDotTypeDotSizeDirective()) { 
+          // Emit the size directive for the basic block section. 
+          const MCExpr *SizeExp = MCBinaryExpr::createSub( 
+              MCSymbolRefExpr::create(MBB.getEndSymbol(), OutContext), 
+              MCSymbolRefExpr::create(CurrentSectionBeginSym, OutContext), 
+              OutContext); 
+          OutStreamer->emitELFSize(CurrentSectionBeginSym, SizeExp); 
+        } 
         MBBSectionRanges[MBB.getSectionIDNum()] =
-            MBBSectionRange{CurrentSectionBeginSym, MBB.getEndSymbol()};
+            MBBSectionRange{CurrentSectionBeginSym, MBB.getEndSymbol()}; 
       }
     }
     emitBasicBlockEnd(MBB);
-
-    if (CanDoExtraAnalysis) {
-      // Skip empty blocks.
-      if (MBB.empty())
-        continue;
-
-      MachineOptimizationRemarkAnalysis R(DEBUG_TYPE, "InstructionMix",
-                                          MBB.begin()->getDebugLoc(), &MBB);
-
-      // Generate instruction mix remark. First, sort counts in descending order
-      // by count and name.
-      SmallVector<std::pair<StringRef, unsigned>, 128> MnemonicVec;
-      for (auto &KV : MnemonicCounts)
-        MnemonicVec.emplace_back(KV.first, KV.second);
-
-      sort(MnemonicVec, [](const std::pair<StringRef, unsigned> &A,
-                           const std::pair<StringRef, unsigned> &B) {
-        if (A.second > B.second)
-          return true;
-        if (A.second == B.second)
-          return StringRef(A.first) < StringRef(B.first);
-        return false;
-      });
-      R << "BasicBlock: " << ore::NV("BasicBlock", MBB.getName()) << "\n";
-      for (auto &KV : MnemonicVec) {
-        auto Name = (Twine("INST_") + KV.first.trim()).str();
-        R << KV.first << ": " << ore::NV(Name, KV.second) << "\n";
-      }
-      ORE->emit(R);
-    }
+ 
+    if (CanDoExtraAnalysis) { 
+      // Skip empty blocks. 
+      if (MBB.empty()) 
+        continue; 
+ 
+      MachineOptimizationRemarkAnalysis R(DEBUG_TYPE, "InstructionMix", 
+                                          MBB.begin()->getDebugLoc(), &MBB); 
+ 
+      // Generate instruction mix remark. First, sort counts in descending order 
+      // by count and name. 
+      SmallVector<std::pair<StringRef, unsigned>, 128> MnemonicVec; 
+      for (auto &KV : MnemonicCounts) 
+        MnemonicVec.emplace_back(KV.first, KV.second); 
+ 
+      sort(MnemonicVec, [](const std::pair<StringRef, unsigned> &A, 
+                           const std::pair<StringRef, unsigned> &B) { 
+        if (A.second > B.second) 
+          return true; 
+        if (A.second == B.second) 
+          return StringRef(A.first) < StringRef(B.first); 
+        return false; 
+      }); 
+      R << "BasicBlock: " << ore::NV("BasicBlock", MBB.getName()) << "\n"; 
+      for (auto &KV : MnemonicVec) { 
+        auto Name = (Twine("INST_") + KV.first.trim()).str(); 
+        R << KV.first << ": " << ore::NV(Name, KV.second) << "\n"; 
+      } 
+      ORE->emit(R); 
+    } 
   }
 
   EmittedInsts += NumInstsInFunction;
@@ -1417,11 +1417,11 @@ void AsmPrinter::emitFunctionBody() {
     HI.Handler->endFunction(MF);
   }
 
-  // Emit section containing BB address offsets and their metadata, when
-  // BB labels are requested for this function.
-  if (MF->hasBBLabels())
-    emitBBAddrMapSection(*MF);
-
+  // Emit section containing BB address offsets and their metadata, when 
+  // BB labels are requested for this function. 
+  if (MF->hasBBLabels()) 
+    emitBBAddrMapSection(*MF); 
+ 
   // Emit section containing stack size metadata.
   emitStackSizeSection(*MF);
 
@@ -1524,30 +1524,30 @@ void AsmPrinter::emitGlobalIndirectSymbol(Module &M,
         IsFunction =
           CE->getOperand(0)->getType()->getPointerElementType()->isFunctionTy();
 
-  // AIX's assembly directive `.set` is not usable for aliasing purpose,
-  // so AIX has to use the extra-label-at-definition strategy. At this
-  // point, all the extra label is emitted, we just have to emit linkage for
-  // those labels.
-  if (TM.getTargetTriple().isOSBinFormatXCOFF()) {
-    assert(!isa<GlobalIFunc>(GIS) && "IFunc is not supported on AIX.");
-    assert(MAI->hasVisibilityOnlyWithLinkage() &&
-           "Visibility should be handled with emitLinkage() on AIX.");
-    emitLinkage(&GIS, Name);
-    // If it's a function, also emit linkage for aliases of function entry
-    // point.
-    if (IsFunction)
-      emitLinkage(&GIS,
-                  getObjFileLowering().getFunctionEntryPointSymbol(&GIS, TM));
-    return;
-  }
-
-  if (GIS.hasExternalLinkage() || !MAI->getWeakRefDirective())
-    OutStreamer->emitSymbolAttribute(Name, MCSA_Global);
-  else if (GIS.hasWeakLinkage() || GIS.hasLinkOnceLinkage())
-    OutStreamer->emitSymbolAttribute(Name, MCSA_WeakReference);
-  else
-    assert(GIS.hasLocalLinkage() && "Invalid alias or ifunc linkage");
-
+  // AIX's assembly directive `.set` is not usable for aliasing purpose, 
+  // so AIX has to use the extra-label-at-definition strategy. At this 
+  // point, all the extra label is emitted, we just have to emit linkage for 
+  // those labels. 
+  if (TM.getTargetTriple().isOSBinFormatXCOFF()) { 
+    assert(!isa<GlobalIFunc>(GIS) && "IFunc is not supported on AIX."); 
+    assert(MAI->hasVisibilityOnlyWithLinkage() && 
+           "Visibility should be handled with emitLinkage() on AIX."); 
+    emitLinkage(&GIS, Name); 
+    // If it's a function, also emit linkage for aliases of function entry 
+    // point. 
+    if (IsFunction) 
+      emitLinkage(&GIS, 
+                  getObjFileLowering().getFunctionEntryPointSymbol(&GIS, TM)); 
+    return; 
+  } 
+ 
+  if (GIS.hasExternalLinkage() || !MAI->getWeakRefDirective()) 
+    OutStreamer->emitSymbolAttribute(Name, MCSA_Global); 
+  else if (GIS.hasWeakLinkage() || GIS.hasLinkOnceLinkage()) 
+    OutStreamer->emitSymbolAttribute(Name, MCSA_WeakReference); 
+  else 
+    assert(GIS.hasLocalLinkage() && "Invalid alias or ifunc linkage"); 
+ 
   // Set the symbol type to function if the alias has a function type.
   // This affects codegen when the aliasee is not a function.
   if (IsFunction)
@@ -1657,8 +1657,8 @@ bool AsmPrinter::doFinalization(Module &M) {
     // Variable `Name` is the function descriptor symbol (see above). Get the
     // function entry point symbol.
     MCSymbol *FnEntryPointSym = TLOF.getFunctionEntryPointSymbol(&F, TM);
-    // Emit linkage for the function entry point.
-    emitLinkage(&F, FnEntryPointSym);
+    // Emit linkage for the function entry point. 
+    emitLinkage(&F, FnEntryPointSym); 
 
     // Emit linkage for the function descriptor.
     emitLinkage(&F, Name);
@@ -1723,11 +1723,11 @@ bool AsmPrinter::doFinalization(Module &M) {
                        HI.TimerGroupDescription, TimePassesIsEnabled);
     HI.Handler->endModule();
   }
-
-  // This deletes all the ephemeral handlers that AsmPrinter added, while
-  // keeping all the user-added handlers alive until the AsmPrinter is
-  // destroyed.
-  Handlers.erase(Handlers.begin() + NumUserHandlers, Handlers.end());
+ 
+  // This deletes all the ephemeral handlers that AsmPrinter added, while 
+  // keeping all the user-added handlers alive until the AsmPrinter is 
+  // destroyed. 
+  Handlers.erase(Handlers.begin() + NumUserHandlers, Handlers.end()); 
   DD = nullptr;
 
   // If the target wants to know about weak references, print them all.
@@ -1854,11 +1854,11 @@ bool AsmPrinter::doFinalization(Module &M) {
   return false;
 }
 
-MCSymbol *AsmPrinter::getMBBExceptionSym(const MachineBasicBlock &MBB) {
-  auto Res = MBBSectionExceptionSyms.try_emplace(MBB.getSectionIDNum());
-  if (Res.second)
-    Res.first->second = createTempSymbol("exception");
-  return Res.first->second;
+MCSymbol *AsmPrinter::getMBBExceptionSym(const MachineBasicBlock &MBB) { 
+  auto Res = MBBSectionExceptionSyms.try_emplace(MBB.getSectionIDNum()); 
+  if (Res.second) 
+    Res.first->second = createTempSymbol("exception"); 
+  return Res.first->second; 
 }
 
 void AsmPrinter::SetupMachineFunction(MachineFunction &MF) {
@@ -1885,13 +1885,13 @@ void AsmPrinter::SetupMachineFunction(MachineFunction &MF) {
   CurrentFnBegin = nullptr;
   CurrentSectionBeginSym = nullptr;
   MBBSectionRanges.clear();
-  MBBSectionExceptionSyms.clear();
+  MBBSectionExceptionSyms.clear(); 
   bool NeedsLocalForSize = MAI->needsLocalForSize();
   if (F.hasFnAttribute("patchable-function-entry") ||
       F.hasFnAttribute("function-instrument") ||
       F.hasFnAttribute("xray-instruction-threshold") ||
       needFuncLabelsForEHOrDebugInfo(MF) || NeedsLocalForSize ||
-      MF.getTarget().Options.EmitStackSizeSection || MF.hasBBLabels()) {
+      MF.getTarget().Options.EmitStackSizeSection || MF.hasBBLabels()) { 
     CurrentFnBegin = createTempSymbol("func_begin");
     if (NeedsLocalForSize)
       CurrentFnSymForSize = CurrentFnBegin;
@@ -1981,7 +1981,7 @@ void AsmPrinter::emitConstantPool() {
       unsigned NewOffset = alignTo(Offset, CPE.getAlign());
       OutStreamer->emitZeros(NewOffset - Offset);
 
-      Offset = NewOffset + CPE.getSizeInBytes(getDataLayout());
+      Offset = NewOffset + CPE.getSizeInBytes(getDataLayout()); 
 
       OutStreamer->emitLabel(Sym);
       if (CPE.isMachineConstantPoolEntry())
@@ -2181,50 +2181,50 @@ void AsmPrinter::emitLLVMUsedList(const ConstantArray *InitList) {
   }
 }
 
-void AsmPrinter::preprocessXXStructorList(const DataLayout &DL,
-                                          const Constant *List,
-                                          SmallVector<Structor, 8> &Structors) {
-  // Should be an array of '{ i32, void ()*, i8* }' structs.  The first value is
-  // the init priority.
-  if (!isa<ConstantArray>(List))
-    return;
+void AsmPrinter::preprocessXXStructorList(const DataLayout &DL, 
+                                          const Constant *List, 
+                                          SmallVector<Structor, 8> &Structors) { 
+  // Should be an array of '{ i32, void ()*, i8* }' structs.  The first value is 
+  // the init priority. 
+  if (!isa<ConstantArray>(List)) 
+    return; 
 
   // Gather the structors in a form that's convenient for sorting by priority.
   for (Value *O : cast<ConstantArray>(List)->operands()) {
     auto *CS = cast<ConstantStruct>(O);
     if (CS->getOperand(1)->isNullValue())
-      break; // Found a null terminator, skip the rest.
+      break; // Found a null terminator, skip the rest. 
     ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
-    if (!Priority)
-      continue; // Malformed.
+    if (!Priority) 
+      continue; // Malformed. 
     Structors.push_back(Structor());
     Structor &S = Structors.back();
     S.Priority = Priority->getLimitedValue(65535);
     S.Func = CS->getOperand(1);
-    if (!CS->getOperand(2)->isNullValue()) {
-      if (TM.getTargetTriple().isOSAIX())
-        llvm::report_fatal_error(
-            "associated data of XXStructor list is not yet supported on AIX");
+    if (!CS->getOperand(2)->isNullValue()) { 
+      if (TM.getTargetTriple().isOSAIX()) 
+        llvm::report_fatal_error( 
+            "associated data of XXStructor list is not yet supported on AIX"); 
       S.ComdatKey =
           dyn_cast<GlobalValue>(CS->getOperand(2)->stripPointerCasts());
-    }
+    } 
   }
 
   // Emit the function pointers in the target-specific order
   llvm::stable_sort(Structors, [](const Structor &L, const Structor &R) {
     return L.Priority < R.Priority;
   });
-}
-
-/// EmitXXStructorList - Emit the ctor or dtor list taking into account the init
-/// priority.
-void AsmPrinter::emitXXStructorList(const DataLayout &DL, const Constant *List,
-                                    bool IsCtor) {
-  SmallVector<Structor, 8> Structors;
-  preprocessXXStructorList(DL, List, Structors);
-  if (Structors.empty())
-    return;
-
+} 
+ 
+/// EmitXXStructorList - Emit the ctor or dtor list taking into account the init 
+/// priority. 
+void AsmPrinter::emitXXStructorList(const DataLayout &DL, const Constant *List, 
+                                    bool IsCtor) { 
+  SmallVector<Structor, 8> Structors; 
+  preprocessXXStructorList(DL, List, Structors); 
+  if (Structors.empty()) 
+    return; 
+ 
   const Align Align = DL.getPointerPrefAlignment();
   for (Structor &S : Structors) {
     const TargetLoweringObjectFile &Obj = getObjFileLowering();
@@ -2240,9 +2240,9 @@ void AsmPrinter::emitXXStructorList(const DataLayout &DL, const Constant *List,
 
       KeySym = getSymbol(GV);
     }
-
+ 
     MCSection *OutputSection =
-        (IsCtor ? Obj.getStaticCtorSection(S.Priority, KeySym)
+        (IsCtor ? Obj.getStaticCtorSection(S.Priority, KeySym) 
                 : Obj.getStaticDtorSection(S.Priority, KeySym));
     OutStreamer->SwitchSection(OutputSection);
     if (OutStreamer->getCurrentSection() != OutStreamer->getPreviousSection())
@@ -2376,25 +2376,25 @@ const MCExpr *AsmPrinter::lowerConstant(const Constant *CV) {
   if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV))
     return MCSymbolRefExpr::create(GetBlockAddressSymbol(BA), Ctx);
 
-  if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV))
-    return getObjFileLowering().lowerDSOLocalEquivalent(Equiv, TM);
-
+  if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV)) 
+    return getObjFileLowering().lowerDSOLocalEquivalent(Equiv, TM); 
+ 
   const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV);
   if (!CE) {
     llvm_unreachable("Unknown constant value to lower!");
   }
 
   switch (CE->getOpcode()) {
-  case Instruction::AddrSpaceCast: {
-    const Constant *Op = CE->getOperand(0);
-    unsigned DstAS = CE->getType()->getPointerAddressSpace();
-    unsigned SrcAS = Op->getType()->getPointerAddressSpace();
-    if (TM.isNoopAddrSpaceCast(SrcAS, DstAS))
-      return lowerConstant(Op);
-
-    // Fallthrough to error.
-    LLVM_FALLTHROUGH;
-  }
+  case Instruction::AddrSpaceCast: { 
+    const Constant *Op = CE->getOperand(0); 
+    unsigned DstAS = CE->getType()->getPointerAddressSpace(); 
+    unsigned SrcAS = Op->getType()->getPointerAddressSpace(); 
+    if (TM.isNoopAddrSpaceCast(SrcAS, DstAS)) 
+      return lowerConstant(Op); 
+ 
+    // Fallthrough to error. 
+    LLVM_FALLTHROUGH; 
+  } 
   default: {
     // If the code isn't optimized, there may be outstanding folding
     // opportunities. Attempt to fold the expression using DataLayout as a
@@ -2460,8 +2460,8 @@ const MCExpr *AsmPrinter::lowerConstant(const Constant *CV) {
     //
     // If the pointer is larger than the resultant integer, then
     // as with Trunc just depend on the assembler to truncate it.
-    if (DL.getTypeAllocSize(Ty).getFixedSize() <=
-        DL.getTypeAllocSize(Op->getType()).getFixedSize())
+    if (DL.getTypeAllocSize(Ty).getFixedSize() <= 
+        DL.getTypeAllocSize(Op->getType()).getFixedSize()) 
       return OpExpr;
 
     // Otherwise the pointer is smaller than the resultant integer, mask off
@@ -2475,25 +2475,25 @@ const MCExpr *AsmPrinter::lowerConstant(const Constant *CV) {
   case Instruction::Sub: {
     GlobalValue *LHSGV;
     APInt LHSOffset;
-    DSOLocalEquivalent *DSOEquiv;
+    DSOLocalEquivalent *DSOEquiv; 
     if (IsConstantOffsetFromGlobal(CE->getOperand(0), LHSGV, LHSOffset,
-                                   getDataLayout(), &DSOEquiv)) {
+                                   getDataLayout(), &DSOEquiv)) { 
       GlobalValue *RHSGV;
       APInt RHSOffset;
       if (IsConstantOffsetFromGlobal(CE->getOperand(1), RHSGV, RHSOffset,
                                      getDataLayout())) {
         const MCExpr *RelocExpr =
             getObjFileLowering().lowerRelativeReference(LHSGV, RHSGV, TM);
-        if (!RelocExpr) {
-          const MCExpr *LHSExpr =
-              MCSymbolRefExpr::create(getSymbol(LHSGV), Ctx);
-          if (DSOEquiv &&
-              getObjFileLowering().supportDSOLocalEquivalentLowering())
-            LHSExpr =
-                getObjFileLowering().lowerDSOLocalEquivalent(DSOEquiv, TM);
+        if (!RelocExpr) { 
+          const MCExpr *LHSExpr = 
+              MCSymbolRefExpr::create(getSymbol(LHSGV), Ctx); 
+          if (DSOEquiv && 
+              getObjFileLowering().supportDSOLocalEquivalentLowering()) 
+            LHSExpr = 
+                getObjFileLowering().lowerDSOLocalEquivalent(DSOEquiv, TM); 
           RelocExpr = MCBinaryExpr::createSub(
-              LHSExpr, MCSymbolRefExpr::create(getSymbol(RHSGV), Ctx), Ctx);
-        }
+              LHSExpr, MCSymbolRefExpr::create(getSymbol(RHSGV), Ctx), Ctx); 
+        } 
         int64_t Addend = (LHSOffset - RHSOffset).getSExtValue();
         if (Addend != 0)
           RelocExpr = MCBinaryExpr::createAdd(
@@ -3124,7 +3124,7 @@ static void emitBasicBlockLoopComments(const MachineBasicBlock &MBB,
   OS.indent(Loop->getLoopDepth()*2-2);
 
   OS << "This ";
-  if (Loop->isInnermost())
+  if (Loop->isInnermost()) 
     OS << "Inner ";
   OS << "Loop Header: Depth=" + Twine(Loop->getLoopDepth()) << '\n';
 
@@ -3148,16 +3148,16 @@ void AsmPrinter::emitBasicBlockStart(const MachineBasicBlock &MBB) {
   if (Alignment != Align(1))
     emitAlignment(Alignment);
 
-  // Switch to a new section if this basic block must begin a section. The
-  // entry block is always placed in the function section and is handled
-  // separately.
-  if (MBB.isBeginSection() && !MBB.isEntryBlock()) {
-    OutStreamer->SwitchSection(
-        getObjFileLowering().getSectionForMachineBasicBlock(MF->getFunction(),
-                                                            MBB, TM));
-    CurrentSectionBeginSym = MBB.getSymbol();
-  }
-
+  // Switch to a new section if this basic block must begin a section. The 
+  // entry block is always placed in the function section and is handled 
+  // separately. 
+  if (MBB.isBeginSection() && !MBB.isEntryBlock()) { 
+    OutStreamer->SwitchSection( 
+        getObjFileLowering().getSectionForMachineBasicBlock(MF->getFunction(), 
+                                                            MBB, TM)); 
+    CurrentSectionBeginSym = MBB.getSymbol(); 
+  } 
+ 
   // If the block has its address taken, emit any labels that were used to
   // reference the block.  It is possible that there is more than one label
   // here, because multiple LLVM BB's may have been RAUW'd to this block after
@@ -3188,25 +3188,25 @@ void AsmPrinter::emitBasicBlockStart(const MachineBasicBlock &MBB) {
     emitBasicBlockLoopComments(MBB, MLI, *this);
   }
 
-  // Print the main label for the block.
-  if (shouldEmitLabelForBasicBlock(MBB)) {
-    if (isVerbose() && MBB.hasLabelMustBeEmitted())
-      OutStreamer->AddComment("Label of block must be emitted");
-    OutStreamer->emitLabel(MBB.getSymbol());
-  } else {
+  // Print the main label for the block. 
+  if (shouldEmitLabelForBasicBlock(MBB)) { 
+    if (isVerbose() && MBB.hasLabelMustBeEmitted()) 
+      OutStreamer->AddComment("Label of block must be emitted"); 
+    OutStreamer->emitLabel(MBB.getSymbol()); 
+  } else { 
     if (isVerbose()) {
       // NOTE: Want this comment at start of line, don't emit with AddComment.
       OutStreamer->emitRawComment(" %bb." + Twine(MBB.getNumber()) + ":",
                                   false);
     }
   }
-
-  // With BB sections, each basic block must handle CFI information on its own
-  // if it begins a section (Entry block is handled separately by
-  // AsmPrinterHandler::beginFunction).
-  if (MBB.isBeginSection() && !MBB.isEntryBlock())
-    for (const HandlerInfo &HI : Handlers)
-      HI.Handler->beginBasicBlock(MBB);
+ 
+  // With BB sections, each basic block must handle CFI information on its own 
+  // if it begins a section (Entry block is handled separately by 
+  // AsmPrinterHandler::beginFunction). 
+  if (MBB.isBeginSection() && !MBB.isEntryBlock()) 
+    for (const HandlerInfo &HI : Handlers) 
+      HI.Handler->beginBasicBlock(MBB); 
 }
 
 void AsmPrinter::emitBasicBlockEnd(const MachineBasicBlock &MBB) {
@@ -3238,21 +3238,21 @@ void AsmPrinter::emitVisibility(MCSymbol *Sym, unsigned Visibility,
     OutStreamer->emitSymbolAttribute(Sym, Attr);
 }
 
-bool AsmPrinter::shouldEmitLabelForBasicBlock(
-    const MachineBasicBlock &MBB) const {
-  // With `-fbasic-block-sections=`, a label is needed for every non-entry block
-  // in the labels mode (option `=labels`) and every section beginning in the
-  // sections mode (`=all` and `=list=`).
-  if ((MF->hasBBLabels() || MBB.isBeginSection()) && !MBB.isEntryBlock())
-    return true;
-  // A label is needed for any block with at least one predecessor (when that
-  // predecessor is not the fallthrough predecessor, or if it is an EH funclet
-  // entry, or if a label is forced).
-  return !MBB.pred_empty() &&
-         (!isBlockOnlyReachableByFallthrough(&MBB) || MBB.isEHFuncletEntry() ||
-          MBB.hasLabelMustBeEmitted());
-}
-
+bool AsmPrinter::shouldEmitLabelForBasicBlock( 
+    const MachineBasicBlock &MBB) const { 
+  // With `-fbasic-block-sections=`, a label is needed for every non-entry block 
+  // in the labels mode (option `=labels`) and every section beginning in the 
+  // sections mode (`=all` and `=list=`). 
+  if ((MF->hasBBLabels() || MBB.isBeginSection()) && !MBB.isEntryBlock()) 
+    return true; 
+  // A label is needed for any block with at least one predecessor (when that 
+  // predecessor is not the fallthrough predecessor, or if it is an EH funclet 
+  // entry, or if a label is forced). 
+  return !MBB.pred_empty() && 
+         (!isBlockOnlyReachableByFallthrough(&MBB) || MBB.isEHFuncletEntry() || 
+          MBB.hasLabelMustBeEmitted()); 
+} 
+ 
 /// isBlockOnlyReachableByFallthough - Return true if the basic block has
 /// exactly one predecessor and the control transfer mechanism between
 /// the predecessor and this block is a fall-through.
@@ -3368,7 +3368,7 @@ void AsmPrinter::emitXRayTable() {
   MCSection *InstMap = nullptr;
   MCSection *FnSledIndex = nullptr;
   const Triple &TT = TM.getTargetTriple();
-  // Use PC-relative addresses on all targets.
+  // Use PC-relative addresses on all targets. 
   if (TT.isOSBinFormatELF()) {
     auto LinkedToSym = cast<MCSymbolELF>(CurrentFnSym);
     auto Flags = ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER;
@@ -3405,20 +3405,20 @@ void AsmPrinter::emitXRayTable() {
   OutStreamer->SwitchSection(InstMap);
   OutStreamer->emitLabel(SledsStart);
   for (const auto &Sled : Sleds) {
-    MCSymbol *Dot = Ctx.createTempSymbol();
-    OutStreamer->emitLabel(Dot);
-    OutStreamer->emitValueImpl(
-        MCBinaryExpr::createSub(MCSymbolRefExpr::create(Sled.Sled, Ctx),
-                                MCSymbolRefExpr::create(Dot, Ctx), Ctx),
-        WordSizeBytes);
-    OutStreamer->emitValueImpl(
-        MCBinaryExpr::createSub(
-            MCSymbolRefExpr::create(CurrentFnBegin, Ctx),
-            MCBinaryExpr::createAdd(MCSymbolRefExpr::create(Dot, Ctx),
-                                    MCConstantExpr::create(WordSizeBytes, Ctx),
-                                    Ctx),
-            Ctx),
-        WordSizeBytes);
+    MCSymbol *Dot = Ctx.createTempSymbol(); 
+    OutStreamer->emitLabel(Dot); 
+    OutStreamer->emitValueImpl( 
+        MCBinaryExpr::createSub(MCSymbolRefExpr::create(Sled.Sled, Ctx), 
+                                MCSymbolRefExpr::create(Dot, Ctx), Ctx), 
+        WordSizeBytes); 
+    OutStreamer->emitValueImpl( 
+        MCBinaryExpr::createSub( 
+            MCSymbolRefExpr::create(CurrentFnBegin, Ctx), 
+            MCBinaryExpr::createAdd(MCSymbolRefExpr::create(Dot, Ctx), 
+                                    MCConstantExpr::create(WordSizeBytes, Ctx), 
+                                    Ctx), 
+            Ctx), 
+        WordSizeBytes); 
     Sled.emit(WordSizeBytes, OutStreamer.get());
   }
   MCSymbol *SledsEnd = OutContext.createTempSymbol("xray_sleds_end", true);
@@ -3493,17 +3493,17 @@ uint16_t AsmPrinter::getDwarfVersion() const {
 void AsmPrinter::setDwarfVersion(uint16_t Version) {
   OutStreamer->getContext().setDwarfVersion(Version);
 }
-
-bool AsmPrinter::isDwarf64() const {
-  return OutStreamer->getContext().getDwarfFormat() == dwarf::DWARF64;
-}
-
-unsigned int AsmPrinter::getDwarfOffsetByteSize() const {
-  return dwarf::getDwarfOffsetByteSize(
-      OutStreamer->getContext().getDwarfFormat());
-}
-
-unsigned int AsmPrinter::getUnitLengthFieldByteSize() const {
-  return dwarf::getUnitLengthFieldByteSize(
-      OutStreamer->getContext().getDwarfFormat());
-}
+ 
+bool AsmPrinter::isDwarf64() const { 
+  return OutStreamer->getContext().getDwarfFormat() == dwarf::DWARF64; 
+} 
+ 
+unsigned int AsmPrinter::getDwarfOffsetByteSize() const { 
+  return dwarf::getDwarfOffsetByteSize( 
+      OutStreamer->getContext().getDwarfFormat()); 
+} 
+ 
+unsigned int AsmPrinter::getUnitLengthFieldByteSize() const { 
+  return dwarf::getUnitLengthFieldByteSize( 
+      OutStreamer->getContext().getDwarfFormat()); 
+} 
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
index c6e43445e7..3ab8869c2c 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
@@ -27,7 +27,7 @@
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
-#include <cstdint>
+#include <cstdint> 
 using namespace llvm;
 
 #define DEBUG_TYPE "asm-printer"
@@ -98,12 +98,12 @@ static const char *DecodeDWARFEncoding(unsigned Encoding) {
   case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8
       :
     return "indirect pcrel sdata8";
-  case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel |
-      dwarf::DW_EH_PE_sdata4:
-    return "indirect datarel sdata4";
-  case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel |
-      dwarf::DW_EH_PE_sdata8:
-    return "indirect datarel sdata8";
+  case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel | 
+      dwarf::DW_EH_PE_sdata4: 
+    return "indirect datarel sdata4"; 
+  case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel | 
+      dwarf::DW_EH_PE_sdata8: 
+    return "indirect datarel sdata8"; 
   }
 
   return "<unknown encoding>";
@@ -144,7 +144,7 @@ unsigned AsmPrinter::GetSizeOfEncodedValue(unsigned Encoding) const {
   }
 }
 
-void AsmPrinter::emitTTypeReference(const GlobalValue *GV, unsigned Encoding) {
+void AsmPrinter::emitTTypeReference(const GlobalValue *GV, unsigned Encoding) { 
   if (GV) {
     const TargetLoweringObjectFile &TLOF = getObjFileLowering();
 
@@ -160,22 +160,22 @@ void AsmPrinter::emitDwarfSymbolReference(const MCSymbol *Label,
   if (!ForceOffset) {
     // On COFF targets, we have to emit the special .secrel32 directive.
     if (MAI->needsDwarfSectionOffsetDirective()) {
-      assert(!isDwarf64() &&
-             "emitting DWARF64 is not implemented for COFF targets");
+      assert(!isDwarf64() && 
+             "emitting DWARF64 is not implemented for COFF targets"); 
       OutStreamer->EmitCOFFSecRel32(Label, /*Offset=*/0);
       return;
     }
 
     // If the format uses relocations with dwarf, refer to the symbol directly.
     if (MAI->doesDwarfUseRelocationsAcrossSections()) {
-      OutStreamer->emitSymbolValue(Label, getDwarfOffsetByteSize());
+      OutStreamer->emitSymbolValue(Label, getDwarfOffsetByteSize()); 
       return;
     }
   }
 
   // Otherwise, emit it as a label difference from the start of the section.
-  emitLabelDifference(Label, Label->getSection().getBeginSymbol(),
-                      getDwarfOffsetByteSize());
+  emitLabelDifference(Label, Label->getSection().getBeginSymbol(), 
+                      getDwarfOffsetByteSize()); 
 }
 
 void AsmPrinter::emitDwarfStringOffset(DwarfStringPoolEntry S) const {
@@ -186,40 +186,40 @@ void AsmPrinter::emitDwarfStringOffset(DwarfStringPoolEntry S) const {
   }
 
   // Just emit the offset directly; no need for symbol math.
-  OutStreamer->emitIntValue(S.Offset, getDwarfOffsetByteSize());
+  OutStreamer->emitIntValue(S.Offset, getDwarfOffsetByteSize()); 
 }
 
 void AsmPrinter::emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const {
-  emitLabelPlusOffset(Label, Offset, getDwarfOffsetByteSize());
-}
-
-void AsmPrinter::emitDwarfLengthOrOffset(uint64_t Value) const {
-  assert(isDwarf64() || Value <= UINT32_MAX);
-  OutStreamer->emitIntValue(Value, getDwarfOffsetByteSize());
-}
-
-void AsmPrinter::maybeEmitDwarf64Mark() const {
-  if (!isDwarf64())
-    return;
-  OutStreamer->AddComment("DWARF64 Mark");
-  OutStreamer->emitInt32(dwarf::DW_LENGTH_DWARF64);
-}
-
-void AsmPrinter::emitDwarfUnitLength(uint64_t Length,
-                                     const Twine &Comment) const {
-  assert(isDwarf64() || Length <= dwarf::DW_LENGTH_lo_reserved);
-  maybeEmitDwarf64Mark();
-  OutStreamer->AddComment(Comment);
-  OutStreamer->emitIntValue(Length, getDwarfOffsetByteSize());
-}
-
-void AsmPrinter::emitDwarfUnitLength(const MCSymbol *Hi, const MCSymbol *Lo,
-                                     const Twine &Comment) const {
-  maybeEmitDwarf64Mark();
-  OutStreamer->AddComment(Comment);
-  OutStreamer->emitAbsoluteSymbolDiff(Hi, Lo, getDwarfOffsetByteSize());
+  emitLabelPlusOffset(Label, Offset, getDwarfOffsetByteSize()); 
 }
 
+void AsmPrinter::emitDwarfLengthOrOffset(uint64_t Value) const { 
+  assert(isDwarf64() || Value <= UINT32_MAX); 
+  OutStreamer->emitIntValue(Value, getDwarfOffsetByteSize()); 
+} 
+ 
+void AsmPrinter::maybeEmitDwarf64Mark() const { 
+  if (!isDwarf64()) 
+    return; 
+  OutStreamer->AddComment("DWARF64 Mark"); 
+  OutStreamer->emitInt32(dwarf::DW_LENGTH_DWARF64); 
+} 
+ 
+void AsmPrinter::emitDwarfUnitLength(uint64_t Length, 
+                                     const Twine &Comment) const { 
+  assert(isDwarf64() || Length <= dwarf::DW_LENGTH_lo_reserved); 
+  maybeEmitDwarf64Mark(); 
+  OutStreamer->AddComment(Comment); 
+  OutStreamer->emitIntValue(Length, getDwarfOffsetByteSize()); 
+} 
+ 
+void AsmPrinter::emitDwarfUnitLength(const MCSymbol *Hi, const MCSymbol *Lo, 
+                                     const Twine &Comment) const { 
+  maybeEmitDwarf64Mark(); 
+  OutStreamer->AddComment(Comment); 
+  OutStreamer->emitAbsoluteSymbolDiff(Hi, Lo, getDwarfOffsetByteSize()); 
+} 
+ 
 void AsmPrinter::emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo,
                                     unsigned Encoding) const {
   // The least significant 3 bits specify the width of the encoding
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
index 4a67b0bc2c..c30e7651ba 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp
@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/SmallVector.h" 
 #include "llvm/ADT/Twine.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
@@ -147,7 +147,7 @@ void AsmPrinter::emitInlineAsm(StringRef Str, const MCSubtargetInfo &STI,
   // we only need MCInstrInfo for asm parsing. We create one unconditionally
   // because it's not subtarget dependent.
   std::unique_ptr<MCInstrInfo> MII(TM.getTarget().createMCInstrInfo());
-  assert(MII && "Failed to create instruction info");
+  assert(MII && "Failed to create instruction info"); 
   std::unique_ptr<MCTargetAsmParser> TAP(TM.getTarget().createMCAsmParser(
       STI, *Parser, *MII, MCOptions));
   if (!TAP)
@@ -234,8 +234,8 @@ static void EmitMSInlineAsmStr(const char *AsmStr, const MachineInstr *MI,
 
       const char *IDStart = LastEmitted;
       const char *IDEnd = IDStart;
-      while (isDigit(*IDEnd))
-        ++IDEnd;
+      while (isDigit(*IDEnd)) 
+        ++IDEnd; 
 
       unsigned Val;
       if (StringRef(IDStart, IDEnd-IDStart).getAsInteger(10, Val))
@@ -400,8 +400,8 @@ static void EmitGCCInlineAsmStr(const char *AsmStr, const MachineInstr *MI,
 
       const char *IDStart = LastEmitted;
       const char *IDEnd = IDStart;
-      while (isDigit(*IDEnd))
-        ++IDEnd;
+      while (isDigit(*IDEnd)) 
+        ++IDEnd; 
 
       unsigned Val;
       if (StringRef(IDStart, IDEnd-IDStart).getAsInteger(10, Val))
@@ -551,23 +551,23 @@ void AsmPrinter::emitInlineAsm(const MachineInstr *MI) const {
     EmitMSInlineAsmStr(AsmStr, MI, MMI, AP, LocCookie, OS);
 
   // Emit warnings if we use reserved registers on the clobber list, as
-  // that might lead to undefined behaviour.
-  SmallVector<Register, 8> RestrRegs;
-  const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo();
+  // that might lead to undefined behaviour. 
+  SmallVector<Register, 8> RestrRegs; 
+  const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo(); 
   // Start with the first operand descriptor, and iterate over them.
   for (unsigned I = InlineAsm::MIOp_FirstOperand, NumOps = MI->getNumOperands();
        I < NumOps; ++I) {
     const MachineOperand &MO = MI->getOperand(I);
-    if (!MO.isImm())
-      continue;
-    unsigned Flags = MO.getImm();
-    if (InlineAsm::getKind(Flags) == InlineAsm::Kind_Clobber) {
-      Register Reg = MI->getOperand(I + 1).getReg();
-      if (!TRI->isAsmClobberable(*MF, Reg))
-        RestrRegs.push_back(Reg);
+    if (!MO.isImm()) 
+      continue; 
+    unsigned Flags = MO.getImm(); 
+    if (InlineAsm::getKind(Flags) == InlineAsm::Kind_Clobber) { 
+      Register Reg = MI->getOperand(I + 1).getReg(); 
+      if (!TRI->isAsmClobberable(*MF, Reg)) 
+        RestrRegs.push_back(Reg); 
     }
-    // Skip to one before the next operand descriptor, if it exists.
-    I += InlineAsm::getNumOperandRegisters(Flags);
+    // Skip to one before the next operand descriptor, if it exists. 
+    I += InlineAsm::getNumOperandRegisters(Flags); 
   }
 
   if (!RestrRegs.empty()) {
@@ -577,15 +577,15 @@ void AsmPrinter::emitInlineAsm(const MachineInstr *MI) const {
         SrcMgr.getMemoryBuffer(BufNum)->getBuffer().begin());
 
     std::string Msg = "inline asm clobber list contains reserved registers: ";
-    for (auto I = RestrRegs.begin(), E = RestrRegs.end(); I != E; ++I) {
+    for (auto I = RestrRegs.begin(), E = RestrRegs.end(); I != E; ++I) { 
       if(I != RestrRegs.begin())
         Msg += ", ";
-      Msg += TRI->getName(*I);
+      Msg += TRI->getName(*I); 
     }
-    const char *Note =
-        "Reserved registers on the clobber list may not be "
-        "preserved across the asm statement, and clobbering them may "
-        "lead to undefined behaviour.";
+    const char *Note = 
+        "Reserved registers on the clobber list may not be " 
+        "preserved across the asm statement, and clobbering them may " 
+        "lead to undefined behaviour."; 
     SrcMgr.PrintMessage(Loc, SourceMgr::DK_Warning, Msg);
     SrcMgr.PrintMessage(Loc, SourceMgr::DK_Note, Note);
   }
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/ByteStreamer.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/ByteStreamer.h
index 5e7db1f2f7..6aa6045307 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/ByteStreamer.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/ByteStreamer.h
@@ -29,7 +29,7 @@ class ByteStreamer {
 
  public:
   // For now we're just handling the calls we need for dwarf emission/hashing.
-  virtual void emitInt8(uint8_t Byte, const Twine &Comment = "") = 0;
+  virtual void emitInt8(uint8_t Byte, const Twine &Comment = "") = 0; 
   virtual void emitSLEB128(uint64_t DWord, const Twine &Comment = "") = 0;
   virtual void emitULEB128(uint64_t DWord, const Twine &Comment = "",
                            unsigned PadTo = 0) = 0;
@@ -41,7 +41,7 @@ private:
 
 public:
   APByteStreamer(AsmPrinter &Asm) : AP(Asm) {}
-  void emitInt8(uint8_t Byte, const Twine &Comment) override {
+  void emitInt8(uint8_t Byte, const Twine &Comment) override { 
     AP.OutStreamer->AddComment(Comment);
     AP.emitInt8(Byte);
   }
@@ -61,7 +61,7 @@ class HashingByteStreamer final : public ByteStreamer {
   DIEHash &Hash;
  public:
  HashingByteStreamer(DIEHash &H) : Hash(H) {}
-  void emitInt8(uint8_t Byte, const Twine &Comment) override {
+  void emitInt8(uint8_t Byte, const Twine &Comment) override { 
     Hash.update(Byte);
   }
   void emitSLEB128(uint64_t DWord, const Twine &Comment) override {
@@ -88,7 +88,7 @@ public:
                      std::vector<std::string> &Comments, bool GenerateComments)
       : Buffer(Buffer), Comments(Comments), GenerateComments(GenerateComments) {
   }
-  void emitInt8(uint8_t Byte, const Twine &Comment) override {
+  void emitInt8(uint8_t Byte, const Twine &Comment) override { 
     Buffer.push_back(Byte);
     if (GenerateComments)
       Comments.push_back(Comment.str());
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
index b15e750aaf..639dc6740c 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
@@ -126,9 +126,9 @@ static CPUType mapArchToCVCPUType(Triple::ArchType Type) {
   case Triple::ArchType::x86_64:
     return CPUType::X64;
   case Triple::ArchType::thumb:
-    // LLVM currently doesn't support Windows CE and so thumb
-    // here is indiscriminately mapped to ARMNT specifically.
-    return CPUType::ARMNT;
+    // LLVM currently doesn't support Windows CE and so thumb 
+    // here is indiscriminately mapped to ARMNT specifically. 
+    return CPUType::ARMNT; 
   case Triple::ArchType::aarch64:
     return CPUType::ARM64;
   default:
@@ -137,7 +137,7 @@ static CPUType mapArchToCVCPUType(Triple::ArchType Type) {
 }
 
 CodeViewDebug::CodeViewDebug(AsmPrinter *AP)
-    : DebugHandlerBase(AP), OS(*Asm->OutStreamer), TypeTable(Allocator) {}
+    : DebugHandlerBase(AP), OS(*Asm->OutStreamer), TypeTable(Allocator) {} 
 
 StringRef CodeViewDebug::getFullFilepath(const DIFile *File) {
   std::string &Filepath = FileToFilepathMap[File];
@@ -475,7 +475,7 @@ void CodeViewDebug::recordLocalVariable(LocalVariable &&Var,
 
 static void addLocIfNotPresent(SmallVectorImpl<const DILocation *> &Locs,
                                const DILocation *Loc) {
-  if (!llvm::is_contained(Locs, Loc))
+  if (!llvm::is_contained(Locs, Loc)) 
     Locs.push_back(Loc);
 }
 
@@ -541,27 +541,27 @@ void CodeViewDebug::emitCodeViewMagicVersion() {
   OS.emitInt32(COFF::DEBUG_SECTION_MAGIC);
 }
 
-void CodeViewDebug::beginModule(Module *M) {
-  // If module doesn't have named metadata anchors or COFF debug section
-  // is not available, skip any debug info related stuff.
-  if (!M->getNamedMetadata("llvm.dbg.cu") ||
-      !Asm->getObjFileLowering().getCOFFDebugSymbolsSection()) {
-    Asm = nullptr;
-    return;
-  }
-  // Tell MMI that we have and need debug info.
-  MMI->setDebugInfoAvailability(true);
-
-  TheCPU = mapArchToCVCPUType(Triple(M->getTargetTriple()).getArch());
-
-  collectGlobalVariableInfo();
-
-  // Check if we should emit type record hashes.
-  ConstantInt *GH =
-      mdconst::extract_or_null<ConstantInt>(M->getModuleFlag("CodeViewGHash"));
-  EmitDebugGlobalHashes = GH && !GH->isZero();
-}
-
+void CodeViewDebug::beginModule(Module *M) { 
+  // If module doesn't have named metadata anchors or COFF debug section 
+  // is not available, skip any debug info related stuff. 
+  if (!M->getNamedMetadata("llvm.dbg.cu") || 
+      !Asm->getObjFileLowering().getCOFFDebugSymbolsSection()) { 
+    Asm = nullptr; 
+    return; 
+  } 
+  // Tell MMI that we have and need debug info. 
+  MMI->setDebugInfoAvailability(true); 
+ 
+  TheCPU = mapArchToCVCPUType(Triple(M->getTargetTriple()).getArch()); 
+ 
+  collectGlobalVariableInfo(); 
+ 
+  // Check if we should emit type record hashes. 
+  ConstantInt *GH = 
+      mdconst::extract_or_null<ConstantInt>(M->getModuleFlag("CodeViewGHash")); 
+  EmitDebugGlobalHashes = GH && !GH->isZero(); 
+} 
+ 
 void CodeViewDebug::endModule() {
   if (!Asm || !MMI->hasDebugInfo())
     return;
@@ -586,14 +586,14 @@ void CodeViewDebug::endModule() {
     if (!P.first->isDeclarationForLinker())
       emitDebugInfoForFunction(P.first, *P.second);
 
-  // Get types used by globals without emitting anything.
-  // This is meant to collect all static const data members so they can be
-  // emitted as globals.
-  collectDebugInfoForGlobals();
-
-  // Emit retained types.
-  emitDebugInfoForRetainedTypes();
-
+  // Get types used by globals without emitting anything. 
+  // This is meant to collect all static const data members so they can be 
+  // emitted as globals. 
+  collectDebugInfoForGlobals(); 
+ 
+  // Emit retained types. 
+  emitDebugInfoForRetainedTypes(); 
+ 
   // Emit global variable debug information.
   setCurrentSubprogram(nullptr);
   emitDebugInfoForGlobals();
@@ -1186,15 +1186,15 @@ void CodeViewDebug::collectVariableInfoFromMFTable(
 
     // Get the frame register used and the offset.
     Register FrameReg;
-    StackOffset FrameOffset = TFI->getFrameIndexReference(*Asm->MF, VI.Slot, FrameReg);
+    StackOffset FrameOffset = TFI->getFrameIndexReference(*Asm->MF, VI.Slot, FrameReg); 
     uint16_t CVReg = TRI->getCodeViewRegNum(FrameReg);
 
-    assert(!FrameOffset.getScalable() &&
-           "Frame offsets with a scalable component are not supported");
-
+    assert(!FrameOffset.getScalable() && 
+           "Frame offsets with a scalable component are not supported"); 
+ 
     // Calculate the label ranges.
     LocalVarDefRange DefRange =
-        createDefRangeMem(CVReg, FrameOffset.getFixed() + ExprOffset);
+        createDefRangeMem(CVReg, FrameOffset.getFixed() + ExprOffset); 
 
     for (const InsnRange &Range : Scope->getRanges()) {
       const MCSymbol *Begin = getLabelBeforeInsn(Range.first);
@@ -2149,15 +2149,15 @@ void CodeViewDebug::collectMemberInfo(ClassInfo &Info,
                                       const DIDerivedType *DDTy) {
   if (!DDTy->getName().empty()) {
     Info.Members.push_back({DDTy, 0});
-
-    // Collect static const data members with values.
-    if ((DDTy->getFlags() & DINode::FlagStaticMember) ==
-        DINode::FlagStaticMember) {
-      if (DDTy->getConstant() && (isa<ConstantInt>(DDTy->getConstant()) ||
-                                  isa<ConstantFP>(DDTy->getConstant())))
-        StaticConstMembers.push_back(DDTy);
-    }
-
+ 
+    // Collect static const data members with values. 
+    if ((DDTy->getFlags() & DINode::FlagStaticMember) == 
+        DINode::FlagStaticMember) { 
+      if (DDTy->getConstant() && (isa<ConstantInt>(DDTy->getConstant()) || 
+                                  isa<ConstantFP>(DDTy->getConstant()))) 
+        StaticConstMembers.push_back(DDTy); 
+    } 
+ 
     return;
   }
 
@@ -3060,32 +3060,32 @@ void CodeViewDebug::collectGlobalVariableInfo() {
   }
 }
 
-void CodeViewDebug::collectDebugInfoForGlobals() {
-  for (const CVGlobalVariable &CVGV : GlobalVariables) {
-    const DIGlobalVariable *DIGV = CVGV.DIGV;
-    const DIScope *Scope = DIGV->getScope();
-    getCompleteTypeIndex(DIGV->getType());
-    getFullyQualifiedName(Scope, DIGV->getName());
-  }
-
-  for (const CVGlobalVariable &CVGV : ComdatVariables) {
-    const DIGlobalVariable *DIGV = CVGV.DIGV;
-    const DIScope *Scope = DIGV->getScope();
-    getCompleteTypeIndex(DIGV->getType());
-    getFullyQualifiedName(Scope, DIGV->getName());
-  }
-}
-
+void CodeViewDebug::collectDebugInfoForGlobals() { 
+  for (const CVGlobalVariable &CVGV : GlobalVariables) { 
+    const DIGlobalVariable *DIGV = CVGV.DIGV; 
+    const DIScope *Scope = DIGV->getScope(); 
+    getCompleteTypeIndex(DIGV->getType()); 
+    getFullyQualifiedName(Scope, DIGV->getName()); 
+  } 
+ 
+  for (const CVGlobalVariable &CVGV : ComdatVariables) { 
+    const DIGlobalVariable *DIGV = CVGV.DIGV; 
+    const DIScope *Scope = DIGV->getScope(); 
+    getCompleteTypeIndex(DIGV->getType()); 
+    getFullyQualifiedName(Scope, DIGV->getName()); 
+  } 
+} 
+ 
 void CodeViewDebug::emitDebugInfoForGlobals() {
   // First, emit all globals that are not in a comdat in a single symbol
   // substream. MSVC doesn't like it if the substream is empty, so only open
   // it if we have at least one global to emit.
   switchToDebugSectionForSymbol(nullptr);
-  if (!GlobalVariables.empty() || !StaticConstMembers.empty()) {
+  if (!GlobalVariables.empty() || !StaticConstMembers.empty()) { 
     OS.AddComment("Symbol subsection for globals");
     MCSymbol *EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols);
     emitGlobalVariableList(GlobalVariables);
-    emitStaticConstMemberList();
+    emitStaticConstMemberList(); 
     endCVSubsection(EndLabel);
   }
 
@@ -3124,61 +3124,61 @@ void CodeViewDebug::emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals) {
   }
 }
 
-void CodeViewDebug::emitStaticConstMemberList() {
-  for (const DIDerivedType *DTy : StaticConstMembers) {
-    const DIScope *Scope = DTy->getScope();
-
-    APSInt Value;
-    if (const ConstantInt *CI =
-            dyn_cast_or_null<ConstantInt>(DTy->getConstant()))
-      Value = APSInt(CI->getValue(),
-                     DebugHandlerBase::isUnsignedDIType(DTy->getBaseType()));
-    else if (const ConstantFP *CFP =
-                 dyn_cast_or_null<ConstantFP>(DTy->getConstant()))
-      Value = APSInt(CFP->getValueAPF().bitcastToAPInt(), true);
-    else
-      llvm_unreachable("cannot emit a constant without a value");
-
-    std::string QualifiedName = getFullyQualifiedName(Scope, DTy->getName());
-
-    MCSymbol *SConstantEnd = beginSymbolRecord(SymbolKind::S_CONSTANT);
-    OS.AddComment("Type");
-    OS.emitInt32(getTypeIndex(DTy->getBaseType()).getIndex());
-    OS.AddComment("Value");
-
-    // Encoded integers shouldn't need more than 10 bytes.
-    uint8_t Data[10];
-    BinaryStreamWriter Writer(Data, llvm::support::endianness::little);
-    CodeViewRecordIO IO(Writer);
-    cantFail(IO.mapEncodedInteger(Value));
-    StringRef SRef((char *)Data, Writer.getOffset());
-    OS.emitBinaryData(SRef);
-
-    OS.AddComment("Name");
-    emitNullTerminatedSymbolName(OS, QualifiedName);
-    endSymbolRecord(SConstantEnd);
-  }
-}
-
-static bool isFloatDIType(const DIType *Ty) {
-  if (isa<DICompositeType>(Ty))
-    return false;
-
-  if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
-    dwarf::Tag T = (dwarf::Tag)Ty->getTag();
-    if (T == dwarf::DW_TAG_pointer_type ||
-        T == dwarf::DW_TAG_ptr_to_member_type ||
-        T == dwarf::DW_TAG_reference_type ||
-        T == dwarf::DW_TAG_rvalue_reference_type)
-      return false;
-    assert(DTy->getBaseType() && "Expected valid base type");
-    return isFloatDIType(DTy->getBaseType());
-  }
-
-  auto *BTy = cast<DIBasicType>(Ty);
-  return (BTy->getEncoding() == dwarf::DW_ATE_float);
-}
-
+void CodeViewDebug::emitStaticConstMemberList() { 
+  for (const DIDerivedType *DTy : StaticConstMembers) { 
+    const DIScope *Scope = DTy->getScope(); 
+ 
+    APSInt Value; 
+    if (const ConstantInt *CI = 
+            dyn_cast_or_null<ConstantInt>(DTy->getConstant())) 
+      Value = APSInt(CI->getValue(), 
+                     DebugHandlerBase::isUnsignedDIType(DTy->getBaseType())); 
+    else if (const ConstantFP *CFP = 
+                 dyn_cast_or_null<ConstantFP>(DTy->getConstant())) 
+      Value = APSInt(CFP->getValueAPF().bitcastToAPInt(), true); 
+    else 
+      llvm_unreachable("cannot emit a constant without a value"); 
+ 
+    std::string QualifiedName = getFullyQualifiedName(Scope, DTy->getName()); 
+ 
+    MCSymbol *SConstantEnd = beginSymbolRecord(SymbolKind::S_CONSTANT); 
+    OS.AddComment("Type"); 
+    OS.emitInt32(getTypeIndex(DTy->getBaseType()).getIndex()); 
+    OS.AddComment("Value"); 
+ 
+    // Encoded integers shouldn't need more than 10 bytes. 
+    uint8_t Data[10]; 
+    BinaryStreamWriter Writer(Data, llvm::support::endianness::little); 
+    CodeViewRecordIO IO(Writer); 
+    cantFail(IO.mapEncodedInteger(Value)); 
+    StringRef SRef((char *)Data, Writer.getOffset()); 
+    OS.emitBinaryData(SRef); 
+ 
+    OS.AddComment("Name"); 
+    emitNullTerminatedSymbolName(OS, QualifiedName); 
+    endSymbolRecord(SConstantEnd); 
+  } 
+} 
+ 
+static bool isFloatDIType(const DIType *Ty) { 
+  if (isa<DICompositeType>(Ty)) 
+    return false; 
+ 
+  if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) { 
+    dwarf::Tag T = (dwarf::Tag)Ty->getTag(); 
+    if (T == dwarf::DW_TAG_pointer_type || 
+        T == dwarf::DW_TAG_ptr_to_member_type || 
+        T == dwarf::DW_TAG_reference_type || 
+        T == dwarf::DW_TAG_rvalue_reference_type) 
+      return false; 
+    assert(DTy->getBaseType() && "Expected valid base type"); 
+    return isFloatDIType(DTy->getBaseType()); 
+  } 
+ 
+  auto *BTy = cast<DIBasicType>(Ty); 
+  return (BTy->getEncoding() == dwarf::DW_ATE_float); 
+} 
+ 
 void CodeViewDebug::emitDebugInfoForGlobal(const CVGlobalVariable &CVGV) {
   const DIGlobalVariable *DIGV = CVGV.DIGV;
 
@@ -3215,12 +3215,12 @@ void CodeViewDebug::emitDebugInfoForGlobal(const CVGlobalVariable &CVGV) {
     assert(DIE->isConstant() &&
            "Global constant variables must contain a constant expression.");
 
-    // Use unsigned for floats.
-    bool isUnsigned = isFloatDIType(DIGV->getType())
-                          ? true
-                          : DebugHandlerBase::isUnsignedDIType(DIGV->getType());
-    APSInt Value(APInt(/*BitWidth=*/64, DIE->getElement(1)), isUnsigned);
-
+    // Use unsigned for floats. 
+    bool isUnsigned = isFloatDIType(DIGV->getType()) 
+                          ? true 
+                          : DebugHandlerBase::isUnsignedDIType(DIGV->getType()); 
+    APSInt Value(APInt(/*BitWidth=*/64, DIE->getElement(1)), isUnsigned); 
+ 
     MCSymbol *SConstantEnd = beginSymbolRecord(SymbolKind::S_CONSTANT);
     OS.AddComment("Type");
     OS.emitInt32(getTypeIndex(DIGV->getType()).getIndex());
@@ -3230,7 +3230,7 @@ void CodeViewDebug::emitDebugInfoForGlobal(const CVGlobalVariable &CVGV) {
     uint8_t data[10];
     BinaryStreamWriter Writer(data, llvm::support::endianness::little);
     CodeViewRecordIO IO(Writer);
-    cantFail(IO.mapEncodedInteger(Value));
+    cantFail(IO.mapEncodedInteger(Value)); 
     StringRef SRef((char *)data, Writer.getOffset());
     OS.emitBinaryData(SRef);
 
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/CodeViewDebug.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/CodeViewDebug.h
index 9eee5492bc..4dd58dbb42 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/CodeViewDebug.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/CodeViewDebug.h
@@ -203,9 +203,9 @@ class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   // Array of non-COMDAT global variables.
   SmallVector<CVGlobalVariable, 1> GlobalVariables;
 
-  /// List of static const data members to be emitted as S_CONSTANTs.
-  SmallVector<const DIDerivedType *, 4> StaticConstMembers;
-
+  /// List of static const data members to be emitted as S_CONSTANTs. 
+  SmallVector<const DIDerivedType *, 4> StaticConstMembers; 
+ 
   /// The set of comdat .debug$S sections that we've seen so far. Each section
   /// must start with a magic version number that must only be emitted once.
   /// This set tracks which sections we've already opened.
@@ -312,11 +312,11 @@ class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   void emitDebugInfoForUDTs(
       const std::vector<std::pair<std::string, const DIType *>> &UDTs);
 
-  void collectDebugInfoForGlobals();
+  void collectDebugInfoForGlobals(); 
   void emitDebugInfoForGlobals();
   void emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals);
   void emitDebugInfoForGlobal(const CVGlobalVariable &CVGV);
-  void emitStaticConstMemberList();
+  void emitStaticConstMemberList(); 
 
   /// Opens a subsection of the given kind in a .debug$S codeview section.
   /// Returns an end label for use with endCVSubsection when the subsection is
@@ -465,8 +465,8 @@ protected:
 public:
   CodeViewDebug(AsmPrinter *AP);
 
-  void beginModule(Module *M) override;
-
+  void beginModule(Module *M) override; 
+ 
   void setSymbolSize(const MCSymbol *, uint64_t) override {}
 
   /// Emit the COFF section that holds the line table information.
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DIE.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DIE.cpp
index 39b0b027c7..651797b728 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DIE.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DIE.cpp
@@ -194,7 +194,7 @@ DIEAbbrev DIE::generateAbbrev() const {
   return Abbrev;
 }
 
-uint64_t DIE::getDebugSectionOffset() const {
+uint64_t DIE::getDebugSectionOffset() const { 
   const DIEUnit *Unit = getUnit();
   assert(Unit && "DIE must be owned by a DIEUnit to get its absolute offset");
   return Unit->getDebugSectionOffset() + getOffset();
@@ -313,8 +313,8 @@ unsigned DIE::computeOffsetsAndAbbrevs(const AsmPrinter *AP,
 //===----------------------------------------------------------------------===//
 // DIEUnit Implementation
 //===----------------------------------------------------------------------===//
-DIEUnit::DIEUnit(dwarf::Tag UnitTag)
-    : Die(UnitTag), Section(nullptr), Offset(0) {
+DIEUnit::DIEUnit(dwarf::Tag UnitTag) 
+    : Die(UnitTag), Section(nullptr), Offset(0) { 
   Die.Owner = this;
   assert((UnitTag == dwarf::DW_TAG_compile_unit ||
           UnitTag == dwarf::DW_TAG_skeleton_unit ||
@@ -428,10 +428,10 @@ void DIEInteger::emitValue(const AsmPrinter *Asm, dwarf::Form Form) const {
 /// SizeOf - Determine size of integer value in bytes.
 ///
 unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
-  assert(AP && "AsmPrinter is required to set FormParams");
-  dwarf::FormParams Params = {AP->getDwarfVersion(),
-                              uint8_t(AP->getPointerSize()),
-                              AP->OutStreamer->getContext().getDwarfFormat()};
+  assert(AP && "AsmPrinter is required to set FormParams"); 
+  dwarf::FormParams Params = {AP->getDwarfVersion(), 
+                              uint8_t(AP->getPointerSize()), 
+                              AP->OutStreamer->getContext().getDwarfFormat()}; 
 
   if (Optional<uint8_t> FixedSize = dwarf::getFixedFormByteSize(Form, Params))
     return *FixedSize;
@@ -470,16 +470,16 @@ void DIEExpr::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 /// SizeOf - Determine size of expression value in bytes.
 ///
 unsigned DIEExpr::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
-  switch (Form) {
-  case dwarf::DW_FORM_data4:
-    return 4;
-  case dwarf::DW_FORM_data8:
-    return 8;
-  case dwarf::DW_FORM_sec_offset:
-    return AP->getDwarfOffsetByteSize();
-  default:
-    llvm_unreachable("DIE Value form not supported yet");
-  }
+  switch (Form) { 
+  case dwarf::DW_FORM_data4: 
+    return 4; 
+  case dwarf::DW_FORM_data8: 
+    return 8; 
+  case dwarf::DW_FORM_sec_offset: 
+    return AP->getDwarfOffsetByteSize(); 
+  default: 
+    llvm_unreachable("DIE Value form not supported yet"); 
+  } 
 }
 
 LLVM_DUMP_METHOD
@@ -492,26 +492,26 @@ void DIEExpr::print(raw_ostream &O) const { O << "Expr: " << *Expr; }
 /// EmitValue - Emit label value.
 ///
 void DIELabel::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
-  bool IsSectionRelative = Form != dwarf::DW_FORM_addr;
-  AP->emitLabelReference(Label, SizeOf(AP, Form), IsSectionRelative);
+  bool IsSectionRelative = Form != dwarf::DW_FORM_addr; 
+  AP->emitLabelReference(Label, SizeOf(AP, Form), IsSectionRelative); 
 }
 
 /// SizeOf - Determine size of label value in bytes.
 ///
 unsigned DIELabel::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
-  switch (Form) {
-  case dwarf::DW_FORM_data4:
-    return 4;
-  case dwarf::DW_FORM_data8:
-    return 8;
-  case dwarf::DW_FORM_sec_offset:
-  case dwarf::DW_FORM_strp:
-    return AP->getDwarfOffsetByteSize();
-  case dwarf::DW_FORM_addr:
-    return AP->MAI->getCodePointerSize();
-  default:
-    llvm_unreachable("DIE Value form not supported yet");
-  }
+  switch (Form) { 
+  case dwarf::DW_FORM_data4: 
+    return 4; 
+  case dwarf::DW_FORM_data8: 
+    return 8; 
+  case dwarf::DW_FORM_sec_offset: 
+  case dwarf::DW_FORM_strp: 
+    return AP->getDwarfOffsetByteSize(); 
+  case dwarf::DW_FORM_addr: 
+    return AP->MAI->getCodePointerSize(); 
+  default: 
+    llvm_unreachable("DIE Value form not supported yet"); 
+  } 
 }
 
 LLVM_DUMP_METHOD
@@ -547,16 +547,16 @@ void DIEDelta::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 /// SizeOf - Determine size of delta value in bytes.
 ///
 unsigned DIEDelta::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
-  switch (Form) {
-  case dwarf::DW_FORM_data4:
-    return 4;
-  case dwarf::DW_FORM_data8:
-    return 8;
-  case dwarf::DW_FORM_sec_offset:
-    return AP->getDwarfOffsetByteSize();
-  default:
-    llvm_unreachable("DIE Value form not supported yet");
-  }
+  switch (Form) { 
+  case dwarf::DW_FORM_data4: 
+    return 4; 
+  case dwarf::DW_FORM_data8: 
+    return 8; 
+  case dwarf::DW_FORM_sec_offset: 
+    return AP->getDwarfOffsetByteSize(); 
+  default: 
+    llvm_unreachable("DIE Value form not supported yet"); 
+  } 
 }
 
 LLVM_DUMP_METHOD
@@ -662,7 +662,7 @@ void DIEEntry::emitValue(const AsmPrinter *AP, dwarf::Form Form) const {
 
   case dwarf::DW_FORM_ref_addr: {
     // Get the absolute offset for this DIE within the debug info/types section.
-    uint64_t Addr = Entry->getDebugSectionOffset();
+    uint64_t Addr = Entry->getDebugSectionOffset(); 
     if (const MCSymbol *SectionSym =
             Entry->getUnit()->getCrossSectionRelativeBaseAddress()) {
       AP->emitLabelPlusOffset(SectionSym, Addr, SizeOf(AP, Form), true);
@@ -819,24 +819,24 @@ void DIEBlock::print(raw_ostream &O) const {
 //===----------------------------------------------------------------------===//
 
 unsigned DIELocList::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
-  switch (Form) {
-  case dwarf::DW_FORM_loclistx:
+  switch (Form) { 
+  case dwarf::DW_FORM_loclistx: 
     return getULEB128Size(Index);
-  case dwarf::DW_FORM_data4:
-    assert(!AP->isDwarf64() &&
-           "DW_FORM_data4 is not suitable to emit a pointer to a location list "
-           "in the 64-bit DWARF format");
+  case dwarf::DW_FORM_data4: 
+    assert(!AP->isDwarf64() && 
+           "DW_FORM_data4 is not suitable to emit a pointer to a location list " 
+           "in the 64-bit DWARF format"); 
     return 4;
-  case dwarf::DW_FORM_data8:
-    assert(AP->isDwarf64() &&
-           "DW_FORM_data8 is not suitable to emit a pointer to a location list "
-           "in the 32-bit DWARF format");
-    return 8;
-  case dwarf::DW_FORM_sec_offset:
-    return AP->getDwarfOffsetByteSize();
-  default:
-    llvm_unreachable("DIE Value form not supported yet");
-  }
+  case dwarf::DW_FORM_data8: 
+    assert(AP->isDwarf64() && 
+           "DW_FORM_data8 is not suitable to emit a pointer to a location list " 
+           "in the 32-bit DWARF format"); 
+    return 8; 
+  case dwarf::DW_FORM_sec_offset: 
+    return AP->getDwarfOffsetByteSize(); 
+  default: 
+    llvm_unreachable("DIE Value form not supported yet"); 
+  } 
 }
 
 /// EmitValue - Emit label value.
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DIEHash.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DIEHash.cpp
index da9997efc0..01c5c4a01d 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DIEHash.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DIEHash.cpp
@@ -12,7 +12,7 @@
 
 #include "DIEHash.h"
 #include "ByteStreamer.h"
-#include "DwarfCompileUnit.h"
+#include "DwarfCompileUnit.h" 
 #include "DwarfDebug.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
@@ -215,15 +215,15 @@ void DIEHash::hashDIEEntry(dwarf::Attribute Attribute, dwarf::Tag Tag,
 // all of the data is going to be added as integers.
 void DIEHash::hashBlockData(const DIE::const_value_range &Values) {
   for (const auto &V : Values)
-    if (V.getType() == DIEValue::isBaseTypeRef) {
-      const DIE &C =
-          *CU->ExprRefedBaseTypes[V.getDIEBaseTypeRef().getIndex()].Die;
-      StringRef Name = getDIEStringAttr(C, dwarf::DW_AT_name);
-      assert(!Name.empty() &&
-             "Base types referenced from DW_OP_convert should have a name");
-      hashNestedType(C, Name);
-    } else
-      Hash.update((uint64_t)V.getDIEInteger().getValue());
+    if (V.getType() == DIEValue::isBaseTypeRef) { 
+      const DIE &C = 
+          *CU->ExprRefedBaseTypes[V.getDIEBaseTypeRef().getIndex()].Die; 
+      StringRef Name = getDIEStringAttr(C, dwarf::DW_AT_name); 
+      assert(!Name.empty() && 
+             "Base types referenced from DW_OP_convert should have a name"); 
+      hashNestedType(C, Name); 
+    } else 
+      Hash.update((uint64_t)V.getDIEInteger().getValue()); 
 }
 
 // Hash the contents of a loclistptr class.
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DIEHash.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DIEHash.h
index 29e1da4c5d..0a1ab02ee7 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DIEHash.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DIEHash.h
@@ -31,8 +31,8 @@ class DIEHash {
   };
 
 public:
-  DIEHash(AsmPrinter *A = nullptr, DwarfCompileUnit *CU = nullptr)
-      : AP(A), CU(CU) {}
+  DIEHash(AsmPrinter *A = nullptr, DwarfCompileUnit *CU = nullptr) 
+      : AP(A), CU(CU) {} 
 
   /// Computes the CU signature.
   uint64_t computeCUSignature(StringRef DWOName, const DIE &Die);
@@ -102,7 +102,7 @@ private:
 private:
   MD5 Hash;
   AsmPrinter *AP;
-  DwarfCompileUnit *CU;
+  DwarfCompileUnit *CU; 
   DenseMap<const DIE *, unsigned> Numbering;
 };
 }
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp
index 1c9131edab..6139139e36 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp
@@ -8,11 +8,11 @@
 
 #include "llvm/CodeGen/DbgEntityHistoryCalculator.h"
 #include "llvm/ADT/BitVector.h"
-#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/Optional.h" 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/CodeGen/LexicalScopes.h"
+#include "llvm/CodeGen/LexicalScopes.h" 
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"
@@ -53,37 +53,37 @@ static Register isDescribedByReg(const MachineInstr &MI) {
                                        : Register();
 }
 
-void InstructionOrdering::initialize(const MachineFunction &MF) {
-  // We give meta instructions the same ordinal as the preceding instruction
-  // because this class is written for the task of comparing positions of
-  // variable location ranges against scope ranges. To reflect what we'll see
-  // in the binary, when we look at location ranges we must consider all
-  // DBG_VALUEs between two real instructions at the same position. And a
-  // scope range which ends on a meta instruction should be considered to end
-  // at the last seen real instruction. E.g.
-  //
-  //  1 instruction p      Both the variable location for x and for y start
-  //  1 DBG_VALUE for "x"  after instruction p so we give them all the same
-  //  1 DBG_VALUE for "y"  number. If a scope range ends at DBG_VALUE for "y",
-  //  2 instruction q      we should treat it as ending after instruction p
-  //                       because it will be the last real instruction in the
-  //                       range. DBG_VALUEs at or after this position for
-  //                       variables declared in the scope will have no effect.
-  clear();
-  unsigned Position = 0;
-  for (const MachineBasicBlock &MBB : MF)
-    for (const MachineInstr &MI : MBB)
-      InstNumberMap[&MI] = MI.isMetaInstruction() ? Position : ++Position;
-}
-
-bool InstructionOrdering::isBefore(const MachineInstr *A,
-                                   const MachineInstr *B) const {
-  assert(A->getParent() && B->getParent() && "Operands must have a parent");
-  assert(A->getMF() == B->getMF() &&
-         "Operands must be in the same MachineFunction");
-  return InstNumberMap.lookup(A) < InstNumberMap.lookup(B);
-}
-
+void InstructionOrdering::initialize(const MachineFunction &MF) { 
+  // We give meta instructions the same ordinal as the preceding instruction 
+  // because this class is written for the task of comparing positions of 
+  // variable location ranges against scope ranges. To reflect what we'll see 
+  // in the binary, when we look at location ranges we must consider all 
+  // DBG_VALUEs between two real instructions at the same position. And a 
+  // scope range which ends on a meta instruction should be considered to end 
+  // at the last seen real instruction. E.g. 
+  // 
+  //  1 instruction p      Both the variable location for x and for y start 
+  //  1 DBG_VALUE for "x"  after instruction p so we give them all the same 
+  //  1 DBG_VALUE for "y"  number. If a scope range ends at DBG_VALUE for "y", 
+  //  2 instruction q      we should treat it as ending after instruction p 
+  //                       because it will be the last real instruction in the 
+  //                       range. DBG_VALUEs at or after this position for 
+  //                       variables declared in the scope will have no effect. 
+  clear(); 
+  unsigned Position = 0; 
+  for (const MachineBasicBlock &MBB : MF) 
+    for (const MachineInstr &MI : MBB) 
+      InstNumberMap[&MI] = MI.isMetaInstruction() ? Position : ++Position; 
+} 
+ 
+bool InstructionOrdering::isBefore(const MachineInstr *A, 
+                                   const MachineInstr *B) const { 
+  assert(A->getParent() && B->getParent() && "Operands must have a parent"); 
+  assert(A->getMF() == B->getMF() && 
+         "Operands must be in the same MachineFunction"); 
+  return InstNumberMap.lookup(A) < InstNumberMap.lookup(B); 
+} 
+ 
 bool DbgValueHistoryMap::startDbgValue(InlinedEntity Var,
                                        const MachineInstr &MI,
                                        EntryIndex &NewIndex) {
@@ -123,156 +123,156 @@ void DbgValueHistoryMap::Entry::endEntry(EntryIndex Index) {
   EndIndex = Index;
 }
 
-/// Check if the instruction range [StartMI, EndMI] intersects any instruction
-/// range in Ranges. EndMI can be nullptr to indicate that the range is
-/// unbounded. Assumes Ranges is ordered and disjoint. Returns true and points
-/// to the first intersecting scope range if one exists.
-static Optional<ArrayRef<InsnRange>::iterator>
-intersects(const MachineInstr *StartMI, const MachineInstr *EndMI,
-           const ArrayRef<InsnRange> &Ranges,
-           const InstructionOrdering &Ordering) {
-  for (auto RangesI = Ranges.begin(), RangesE = Ranges.end();
-       RangesI != RangesE; ++RangesI) {
-    if (EndMI && Ordering.isBefore(EndMI, RangesI->first))
-      return None;
-    if (EndMI && !Ordering.isBefore(RangesI->second, EndMI))
-      return RangesI;
-    if (Ordering.isBefore(StartMI, RangesI->second))
-      return RangesI;
-  }
-  return None;
-}
-
-void DbgValueHistoryMap::trimLocationRanges(
-    const MachineFunction &MF, LexicalScopes &LScopes,
-    const InstructionOrdering &Ordering) {
-  // The indices of the entries we're going to remove for each variable.
-  SmallVector<EntryIndex, 4> ToRemove;
-  // Entry reference count for each variable. Clobbers left with no references
-  // will be removed.
-  SmallVector<int, 4> ReferenceCount;
-  // Entries reference other entries by index. Offsets is used to remap these
-  // references if any entries are removed.
-  SmallVector<size_t, 4> Offsets;
-
-  for (auto &Record : VarEntries) {
-    auto &HistoryMapEntries = Record.second;
-    if (HistoryMapEntries.empty())
-      continue;
-
-    InlinedEntity Entity = Record.first;
-    const DILocalVariable *LocalVar = cast<DILocalVariable>(Entity.first);
-
-    LexicalScope *Scope = nullptr;
-    if (const DILocation *InlinedAt = Entity.second) {
-      Scope = LScopes.findInlinedScope(LocalVar->getScope(), InlinedAt);
-    } else {
-      Scope = LScopes.findLexicalScope(LocalVar->getScope());
-      // Ignore variables for non-inlined function level scopes. The scope
-      // ranges (from scope->getRanges()) will not include any instructions
-      // before the first one with a debug-location, which could cause us to
-      // incorrectly drop a location. We could introduce special casing for
-      // these variables, but it doesn't seem worth it because no out-of-scope
-      // locations have been observed for variables declared in function level
-      // scopes.
-      if (Scope &&
-          (Scope->getScopeNode() == Scope->getScopeNode()->getSubprogram()) &&
-          (Scope->getScopeNode() == LocalVar->getScope()))
-        continue;
-    }
-
-    // If there is no scope for the variable then something has probably gone
-    // wrong.
-    if (!Scope)
-      continue;
-
-    ToRemove.clear();
-    // Zero the reference counts.
-    ReferenceCount.assign(HistoryMapEntries.size(), 0);
-    // Index of the DBG_VALUE which marks the start of the current location
-    // range.
-    EntryIndex StartIndex = 0;
-    ArrayRef<InsnRange> ScopeRanges(Scope->getRanges());
-    for (auto EI = HistoryMapEntries.begin(), EE = HistoryMapEntries.end();
-         EI != EE; ++EI, ++StartIndex) {
-      // Only DBG_VALUEs can open location ranges so skip anything else.
-      if (!EI->isDbgValue())
-        continue;
-
-      // Index of the entry which closes this range.
-      EntryIndex EndIndex = EI->getEndIndex();
-      // If this range is closed bump the reference count of the closing entry.
-      if (EndIndex != NoEntry)
-        ReferenceCount[EndIndex] += 1;
-      // Skip this location range if the opening entry is still referenced. It
-      // may close a location range which intersects a scope range.
-      // TODO: We could be 'smarter' and trim these kinds of ranges such that
-      // they do not leak out of the scope ranges if they partially overlap.
-      if (ReferenceCount[StartIndex] > 0)
-        continue;
-
-      const MachineInstr *StartMI = EI->getInstr();
-      const MachineInstr *EndMI = EndIndex != NoEntry
-                                      ? HistoryMapEntries[EndIndex].getInstr()
-                                      : nullptr;
-      // Check if the location range [StartMI, EndMI] intersects with any scope
-      // range for the variable.
-      if (auto R = intersects(StartMI, EndMI, ScopeRanges, Ordering)) {
-        // Adjust ScopeRanges to exclude ranges which subsequent location ranges
-        // cannot possibly intersect.
-        ScopeRanges = ArrayRef<InsnRange>(R.getValue(), ScopeRanges.end());
-      } else {
-        // If the location range does not intersect any scope range then the
-        // DBG_VALUE which opened this location range is usless, mark it for
-        // removal.
-        ToRemove.push_back(StartIndex);
-        // Because we'll be removing this entry we need to update the reference
-        // count of the closing entry, if one exists.
-        if (EndIndex != NoEntry)
-          ReferenceCount[EndIndex] -= 1;
-      }
-    }
-
-    // If there is nothing to remove then jump to next variable.
-    if (ToRemove.empty())
-      continue;
-
-    // Mark clobbers that will no longer close any location ranges for removal.
-    for (size_t i = 0; i < HistoryMapEntries.size(); ++i)
-      if (ReferenceCount[i] <= 0 && HistoryMapEntries[i].isClobber())
-        ToRemove.push_back(i);
-
-    llvm::sort(ToRemove);
-
-    // Build an offset map so we can update the EndIndex of the remaining
-    // entries.
-    // Zero the offsets.
-    Offsets.assign(HistoryMapEntries.size(), 0);
-    size_t CurOffset = 0;
-    auto ToRemoveItr = ToRemove.begin();
-    for (size_t EntryIdx = *ToRemoveItr; EntryIdx < HistoryMapEntries.size();
-         ++EntryIdx) {
-      // Check if this is an entry which will be removed.
-      if (ToRemoveItr != ToRemove.end() && *ToRemoveItr == EntryIdx) {
-        ++ToRemoveItr;
-        ++CurOffset;
-      }
-      Offsets[EntryIdx] = CurOffset;
-    }
-
-    // Update the EndIndex of the entries to account for those which will be
-    // removed.
-    for (auto &Entry : HistoryMapEntries)
-      if (Entry.isClosed())
-        Entry.EndIndex -= Offsets[Entry.EndIndex];
-
-    // Now actually remove the entries. Iterate backwards so that our remaining
-    // ToRemove indices are valid after each erase.
-    for (auto Itr = ToRemove.rbegin(), End = ToRemove.rend(); Itr != End; ++Itr)
-      HistoryMapEntries.erase(HistoryMapEntries.begin() + *Itr);
-  }
-}
-
+/// Check if the instruction range [StartMI, EndMI] intersects any instruction 
+/// range in Ranges. EndMI can be nullptr to indicate that the range is 
+/// unbounded. Assumes Ranges is ordered and disjoint. Returns true and points 
+/// to the first intersecting scope range if one exists. 
+static Optional<ArrayRef<InsnRange>::iterator> 
+intersects(const MachineInstr *StartMI, const MachineInstr *EndMI, 
+           const ArrayRef<InsnRange> &Ranges, 
+           const InstructionOrdering &Ordering) { 
+  for (auto RangesI = Ranges.begin(), RangesE = Ranges.end(); 
+       RangesI != RangesE; ++RangesI) { 
+    if (EndMI && Ordering.isBefore(EndMI, RangesI->first)) 
+      return None; 
+    if (EndMI && !Ordering.isBefore(RangesI->second, EndMI)) 
+      return RangesI; 
+    if (Ordering.isBefore(StartMI, RangesI->second)) 
+      return RangesI; 
+  } 
+  return None; 
+} 
+ 
+void DbgValueHistoryMap::trimLocationRanges( 
+    const MachineFunction &MF, LexicalScopes &LScopes, 
+    const InstructionOrdering &Ordering) { 
+  // The indices of the entries we're going to remove for each variable. 
+  SmallVector<EntryIndex, 4> ToRemove; 
+  // Entry reference count for each variable. Clobbers left with no references 
+  // will be removed. 
+  SmallVector<int, 4> ReferenceCount; 
+  // Entries reference other entries by index. Offsets is used to remap these 
+  // references if any entries are removed. 
+  SmallVector<size_t, 4> Offsets; 
+ 
+  for (auto &Record : VarEntries) { 
+    auto &HistoryMapEntries = Record.second; 
+    if (HistoryMapEntries.empty()) 
+      continue; 
+ 
+    InlinedEntity Entity = Record.first; 
+    const DILocalVariable *LocalVar = cast<DILocalVariable>(Entity.first); 
+ 
+    LexicalScope *Scope = nullptr; 
+    if (const DILocation *InlinedAt = Entity.second) { 
+      Scope = LScopes.findInlinedScope(LocalVar->getScope(), InlinedAt); 
+    } else { 
+      Scope = LScopes.findLexicalScope(LocalVar->getScope()); 
+      // Ignore variables for non-inlined function level scopes. The scope 
+      // ranges (from scope->getRanges()) will not include any instructions 
+      // before the first one with a debug-location, which could cause us to 
+      // incorrectly drop a location. We could introduce special casing for 
+      // these variables, but it doesn't seem worth it because no out-of-scope 
+      // locations have been observed for variables declared in function level 
+      // scopes. 
+      if (Scope && 
+          (Scope->getScopeNode() == Scope->getScopeNode()->getSubprogram()) && 
+          (Scope->getScopeNode() == LocalVar->getScope())) 
+        continue; 
+    } 
+ 
+    // If there is no scope for the variable then something has probably gone 
+    // wrong. 
+    if (!Scope) 
+      continue; 
+ 
+    ToRemove.clear(); 
+    // Zero the reference counts. 
+    ReferenceCount.assign(HistoryMapEntries.size(), 0); 
+    // Index of the DBG_VALUE which marks the start of the current location 
+    // range. 
+    EntryIndex StartIndex = 0; 
+    ArrayRef<InsnRange> ScopeRanges(Scope->getRanges()); 
+    for (auto EI = HistoryMapEntries.begin(), EE = HistoryMapEntries.end(); 
+         EI != EE; ++EI, ++StartIndex) { 
+      // Only DBG_VALUEs can open location ranges so skip anything else. 
+      if (!EI->isDbgValue()) 
+        continue; 
+ 
+      // Index of the entry which closes this range. 
+      EntryIndex EndIndex = EI->getEndIndex(); 
+      // If this range is closed bump the reference count of the closing entry. 
+      if (EndIndex != NoEntry) 
+        ReferenceCount[EndIndex] += 1; 
+      // Skip this location range if the opening entry is still referenced. It 
+      // may close a location range which intersects a scope range. 
+      // TODO: We could be 'smarter' and trim these kinds of ranges such that 
+      // they do not leak out of the scope ranges if they partially overlap. 
+      if (ReferenceCount[StartIndex] > 0) 
+        continue; 
+ 
+      const MachineInstr *StartMI = EI->getInstr(); 
+      const MachineInstr *EndMI = EndIndex != NoEntry 
+                                      ? HistoryMapEntries[EndIndex].getInstr() 
+                                      : nullptr; 
+      // Check if the location range [StartMI, EndMI] intersects with any scope 
+      // range for the variable. 
+      if (auto R = intersects(StartMI, EndMI, ScopeRanges, Ordering)) { 
+        // Adjust ScopeRanges to exclude ranges which subsequent location ranges 
+        // cannot possibly intersect. 
+        ScopeRanges = ArrayRef<InsnRange>(R.getValue(), ScopeRanges.end()); 
+      } else { 
+        // If the location range does not intersect any scope range then the 
+        // DBG_VALUE which opened this location range is usless, mark it for 
+        // removal. 
+        ToRemove.push_back(StartIndex); 
+        // Because we'll be removing this entry we need to update the reference 
+        // count of the closing entry, if one exists. 
+        if (EndIndex != NoEntry) 
+          ReferenceCount[EndIndex] -= 1; 
+      } 
+    } 
+ 
+    // If there is nothing to remove then jump to next variable. 
+    if (ToRemove.empty()) 
+      continue; 
+ 
+    // Mark clobbers that will no longer close any location ranges for removal. 
+    for (size_t i = 0; i < HistoryMapEntries.size(); ++i) 
+      if (ReferenceCount[i] <= 0 && HistoryMapEntries[i].isClobber()) 
+        ToRemove.push_back(i); 
+ 
+    llvm::sort(ToRemove); 
+ 
+    // Build an offset map so we can update the EndIndex of the remaining 
+    // entries. 
+    // Zero the offsets. 
+    Offsets.assign(HistoryMapEntries.size(), 0); 
+    size_t CurOffset = 0; 
+    auto ToRemoveItr = ToRemove.begin(); 
+    for (size_t EntryIdx = *ToRemoveItr; EntryIdx < HistoryMapEntries.size(); 
+         ++EntryIdx) { 
+      // Check if this is an entry which will be removed. 
+      if (ToRemoveItr != ToRemove.end() && *ToRemoveItr == EntryIdx) { 
+        ++ToRemoveItr; 
+        ++CurOffset; 
+      } 
+      Offsets[EntryIdx] = CurOffset; 
+    } 
+ 
+    // Update the EndIndex of the entries to account for those which will be 
+    // removed. 
+    for (auto &Entry : HistoryMapEntries) 
+      if (Entry.isClosed()) 
+        Entry.EndIndex -= Offsets[Entry.EndIndex]; 
+ 
+    // Now actually remove the entries. Iterate backwards so that our remaining 
+    // ToRemove indices are valid after each erase. 
+    for (auto Itr = ToRemove.rbegin(), End = ToRemove.rend(); Itr != End; ++Itr) 
+      HistoryMapEntries.erase(HistoryMapEntries.begin() + *Itr); 
+  } 
+} 
+ 
 void DbgLabelInstrMap::addInstr(InlinedEntity Label, const MachineInstr &MI) {
   assert(MI.isDebugLabel() && "not a DBG_LABEL");
   LabelInstr[Label] = &MI;
@@ -417,7 +417,7 @@ void llvm::calculateDbgEntityHistory(const MachineFunction *MF,
                                      DbgValueHistoryMap &DbgValues,
                                      DbgLabelInstrMap &DbgLabels) {
   const TargetLowering *TLI = MF->getSubtarget().getTargetLowering();
-  Register SP = TLI->getStackPointerRegisterToSaveRestore();
+  Register SP = TLI->getStackPointerRegisterToSaveRestore(); 
   Register FrameReg = TRI->getFrameRegister(*MF);
   RegDescribedVarsMap RegVars;
   DbgValueEntriesMap LiveEntries;
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp
index 68a4bfba42..01bcdd9be2 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp
@@ -21,16 +21,16 @@
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/MC/MCStreamer.h"
-#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/CommandLine.h" 
 
 using namespace llvm;
 
 #define DEBUG_TYPE "dwarfdebug"
 
-/// If true, we drop variable location ranges which exist entirely outside the
-/// variable's lexical scope instruction ranges.
-static cl::opt<bool> TrimVarLocs("trim-var-locs", cl::Hidden, cl::init(true));
-
+/// If true, we drop variable location ranges which exist entirely outside the 
+/// variable's lexical scope instruction ranges. 
+static cl::opt<bool> TrimVarLocs("trim-var-locs", cl::Hidden, cl::init(true)); 
+ 
 Optional<DbgVariableLocation>
 DbgVariableLocation::extractFromMachineInstruction(
     const MachineInstr &Instruction) {
@@ -91,11 +91,11 @@ DbgVariableLocation::extractFromMachineInstruction(
 
 DebugHandlerBase::DebugHandlerBase(AsmPrinter *A) : Asm(A), MMI(Asm->MMI) {}
 
-void DebugHandlerBase::beginModule(Module *M) {
-  if (M->debug_compile_units().empty())
-    Asm = nullptr;
-}
-
+void DebugHandlerBase::beginModule(Module *M) { 
+  if (M->debug_compile_units().empty()) 
+    Asm = nullptr; 
+} 
+ 
 // Each LexicalScope has first instruction and last instruction to mark
 // beginning and end of a scope respectively. Create an inverse map that list
 // scopes starts (and ends) with an instruction. One instruction may start (or
@@ -163,54 +163,54 @@ uint64_t DebugHandlerBase::getBaseTypeSize(const DIType *Ty) {
   return getBaseTypeSize(BaseType);
 }
 
-bool DebugHandlerBase::isUnsignedDIType(const DIType *Ty) {
-  if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
-    // FIXME: Enums without a fixed underlying type have unknown signedness
-    // here, leading to incorrectly emitted constants.
-    if (CTy->getTag() == dwarf::DW_TAG_enumeration_type)
-      return false;
-
-    // (Pieces of) aggregate types that get hacked apart by SROA may be
-    // represented by a constant. Encode them as unsigned bytes.
-    return true;
-  }
-
-  if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
-    dwarf::Tag T = (dwarf::Tag)Ty->getTag();
-    // Encode pointer constants as unsigned bytes. This is used at least for
-    // null pointer constant emission.
-    // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
-    // here, but accept them for now due to a bug in SROA producing bogus
-    // dbg.values.
-    if (T == dwarf::DW_TAG_pointer_type ||
-        T == dwarf::DW_TAG_ptr_to_member_type ||
-        T == dwarf::DW_TAG_reference_type ||
-        T == dwarf::DW_TAG_rvalue_reference_type)
-      return true;
-    assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
-           T == dwarf::DW_TAG_volatile_type ||
-           T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type);
-    assert(DTy->getBaseType() && "Expected valid base type");
-    return isUnsignedDIType(DTy->getBaseType());
-  }
-
-  auto *BTy = cast<DIBasicType>(Ty);
-  unsigned Encoding = BTy->getEncoding();
-  assert((Encoding == dwarf::DW_ATE_unsigned ||
-          Encoding == dwarf::DW_ATE_unsigned_char ||
-          Encoding == dwarf::DW_ATE_signed ||
-          Encoding == dwarf::DW_ATE_signed_char ||
-          Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
-          Encoding == dwarf::DW_ATE_boolean ||
-          (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
-           Ty->getName() == "decltype(nullptr)")) &&
-         "Unsupported encoding");
-  return Encoding == dwarf::DW_ATE_unsigned ||
-         Encoding == dwarf::DW_ATE_unsigned_char ||
-         Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
-         Ty->getTag() == dwarf::DW_TAG_unspecified_type;
-}
-
+bool DebugHandlerBase::isUnsignedDIType(const DIType *Ty) { 
+  if (auto *CTy = dyn_cast<DICompositeType>(Ty)) { 
+    // FIXME: Enums without a fixed underlying type have unknown signedness 
+    // here, leading to incorrectly emitted constants. 
+    if (CTy->getTag() == dwarf::DW_TAG_enumeration_type) 
+      return false; 
+ 
+    // (Pieces of) aggregate types that get hacked apart by SROA may be 
+    // represented by a constant. Encode them as unsigned bytes. 
+    return true; 
+  } 
+ 
+  if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) { 
+    dwarf::Tag T = (dwarf::Tag)Ty->getTag(); 
+    // Encode pointer constants as unsigned bytes. This is used at least for 
+    // null pointer constant emission. 
+    // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed 
+    // here, but accept them for now due to a bug in SROA producing bogus 
+    // dbg.values. 
+    if (T == dwarf::DW_TAG_pointer_type || 
+        T == dwarf::DW_TAG_ptr_to_member_type || 
+        T == dwarf::DW_TAG_reference_type || 
+        T == dwarf::DW_TAG_rvalue_reference_type) 
+      return true; 
+    assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type || 
+           T == dwarf::DW_TAG_volatile_type || 
+           T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type); 
+    assert(DTy->getBaseType() && "Expected valid base type"); 
+    return isUnsignedDIType(DTy->getBaseType()); 
+  } 
+ 
+  auto *BTy = cast<DIBasicType>(Ty); 
+  unsigned Encoding = BTy->getEncoding(); 
+  assert((Encoding == dwarf::DW_ATE_unsigned || 
+          Encoding == dwarf::DW_ATE_unsigned_char || 
+          Encoding == dwarf::DW_ATE_signed || 
+          Encoding == dwarf::DW_ATE_signed_char || 
+          Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || 
+          Encoding == dwarf::DW_ATE_boolean || 
+          (Ty->getTag() == dwarf::DW_TAG_unspecified_type && 
+           Ty->getName() == "decltype(nullptr)")) && 
+         "Unsupported encoding"); 
+  return Encoding == dwarf::DW_ATE_unsigned || 
+         Encoding == dwarf::DW_ATE_unsigned_char || 
+         Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean || 
+         Ty->getTag() == dwarf::DW_TAG_unspecified_type; 
+} 
+ 
 static bool hasDebugInfo(const MachineModuleInfo *MMI,
                          const MachineFunction *MF) {
   if (!MMI->hasDebugInfo())
@@ -249,9 +249,9 @@ void DebugHandlerBase::beginFunction(const MachineFunction *MF) {
   assert(DbgLabels.empty() && "DbgLabels map wasn't cleaned!");
   calculateDbgEntityHistory(MF, Asm->MF->getSubtarget().getRegisterInfo(),
                             DbgValues, DbgLabels);
-  InstOrdering.initialize(*MF);
-  if (TrimVarLocs)
-    DbgValues.trimLocationRanges(*MF, LScopes, InstOrdering);
+  InstOrdering.initialize(*MF); 
+  if (TrimVarLocs) 
+    DbgValues.trimLocationRanges(*MF, LScopes, InstOrdering); 
   LLVM_DEBUG(DbgValues.dump());
 
   // Request labels for the full history.
@@ -273,16 +273,16 @@ void DebugHandlerBase::beginFunction(const MachineFunction *MF) {
     // doing that violates the ranges that are calculated in the history map.
     // However, we currently do not emit debug values for constant arguments
     // directly at the start of the function, so this code is still useful.
-    // FIXME: If the first mention of an argument is in a unique section basic
-    // block, we cannot always assign the CurrentFnBeginLabel as it lies in a
-    // different section.  Temporarily, we disable generating loc list
-    // information or DW_AT_const_value when the block is in a different
-    // section.
+    // FIXME: If the first mention of an argument is in a unique section basic 
+    // block, we cannot always assign the CurrentFnBeginLabel as it lies in a 
+    // different section.  Temporarily, we disable generating loc list 
+    // information or DW_AT_const_value when the block is in a different 
+    // section. 
     const DILocalVariable *DIVar =
         Entries.front().getInstr()->getDebugVariable();
     if (DIVar->isParameter() &&
-        getDISubprogram(DIVar->getScope())->describes(&MF->getFunction()) &&
-        Entries.front().getInstr()->getParent()->sameSection(&MF->front())) {
+        getDISubprogram(DIVar->getScope())->describes(&MF->getFunction()) && 
+        Entries.front().getInstr()->getParent()->sameSection(&MF->front())) { 
       if (!IsDescribedByReg(Entries.front().getInstr()))
         LabelsBeforeInsn[Entries.front().getInstr()] = Asm->getFunctionBegin();
       if (Entries.front().getInstr()->getDebugExpression()->isFragment()) {
@@ -329,7 +329,7 @@ void DebugHandlerBase::beginFunction(const MachineFunction *MF) {
 }
 
 void DebugHandlerBase::beginInstruction(const MachineInstr *MI) {
-  if (!Asm || !MMI->hasDebugInfo())
+  if (!Asm || !MMI->hasDebugInfo()) 
     return;
 
   assert(CurMI == nullptr);
@@ -355,7 +355,7 @@ void DebugHandlerBase::beginInstruction(const MachineInstr *MI) {
 }
 
 void DebugHandlerBase::endInstruction() {
-  if (!Asm || !MMI->hasDebugInfo())
+  if (!Asm || !MMI->hasDebugInfo()) 
     return;
 
   assert(CurMI != nullptr);
@@ -387,13 +387,13 @@ void DebugHandlerBase::endInstruction() {
 }
 
 void DebugHandlerBase::endFunction(const MachineFunction *MF) {
-  if (Asm && hasDebugInfo(MMI, MF))
+  if (Asm && hasDebugInfo(MMI, MF)) 
     endFunctionImpl(MF);
   DbgValues.clear();
   DbgLabels.clear();
   LabelsBeforeInsn.clear();
   LabelsAfterInsn.clear();
-  InstOrdering.clear();
+  InstOrdering.clear(); 
 }
 
 void DebugHandlerBase::beginBasicBlock(const MachineBasicBlock &MBB) {
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfCFIException.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfCFIException.cpp
index c20ac6040a..747ccf79eb 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfCFIException.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfCFIException.cpp
@@ -81,9 +81,9 @@ void DwarfCFIException::endModule() {
   }
 }
 
-static MCSymbol *getExceptionSym(AsmPrinter *Asm,
-                                 const MachineBasicBlock *MBB) {
-  return Asm->getMBBExceptionSym(*MBB);
+static MCSymbol *getExceptionSym(AsmPrinter *Asm, 
+                                 const MachineBasicBlock *MBB) { 
+  return Asm->getMBBExceptionSym(*MBB); 
 }
 
 void DwarfCFIException::beginFunction(const MachineFunction *MF) {
@@ -162,7 +162,7 @@ void DwarfCFIException::beginFragment(const MachineBasicBlock *MBB,
 
   // Provide LSDA information.
   if (shouldEmitLSDA)
-    Asm->OutStreamer->emitCFILsda(ESP(Asm, MBB), TLOF.getLSDAEncoding());
+    Asm->OutStreamer->emitCFILsda(ESP(Asm, MBB), TLOF.getLSDAEncoding()); 
 }
 
 /// endFunction - Gather and emit post-function exception information.
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
index befc4bba19..c07f0569ec 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
@@ -105,7 +105,7 @@ unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
     return Asm->OutStreamer->emitDwarfFileDirective(0, "", "", None, None,
                                                     CUID);
   return Asm->OutStreamer->emitDwarfFileDirective(
-      0, File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File),
+      0, File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File), 
       File->getSource(), CUID);
 }
 
@@ -248,9 +248,9 @@ void DwarfCompileUnit::addLocationAttribute(
                                      : dwarf::DW_OP_const8u);
             // 2) containing the (relocated) offset of the TLS variable
             //    within the module's TLS block.
-            addExpr(*Loc,
-                    PointerSize == 4 ? dwarf::DW_FORM_data4
-                                     : dwarf::DW_FORM_data8,
+            addExpr(*Loc, 
+                    PointerSize == 4 ? dwarf::DW_FORM_data4 
+                                     : dwarf::DW_FORM_data8, 
                     Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
           } else {
             addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
@@ -422,10 +422,10 @@ DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
       // FIXME: duplicated from Target/WebAssembly/WebAssembly.h
       // don't want to depend on target specific headers in this code?
       const unsigned TI_GLOBAL_RELOC = 3;
-      // FIXME: when writing dwo, we need to avoid relocations. Probably
-      // the "right" solution is to treat globals the way func and data symbols
-      // are (with entries in .debug_addr).
-      if (FrameBase.Location.WasmLoc.Kind == TI_GLOBAL_RELOC && !isDwoUnit()) {
+      // FIXME: when writing dwo, we need to avoid relocations. Probably 
+      // the "right" solution is to treat globals the way func and data symbols 
+      // are (with entries in .debug_addr). 
+      if (FrameBase.Location.WasmLoc.Kind == TI_GLOBAL_RELOC && !isDwoUnit()) { 
         // These need to be relocatable.
         assert(FrameBase.Location.WasmLoc.Index == 0);  // Only SP so far.
         auto SPSym = cast<MCSymbolWasm>(
@@ -442,8 +442,8 @@ DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
             true});
         DIELoc *Loc = new (DIEValueAllocator) DIELoc;
         addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_WASM_location);
-        addSInt(*Loc, dwarf::DW_FORM_sdata, TI_GLOBAL_RELOC);
-        addLabel(*Loc, dwarf::DW_FORM_data4, SPSym);
+        addSInt(*Loc, dwarf::DW_FORM_sdata, TI_GLOBAL_RELOC); 
+        addLabel(*Loc, dwarf::DW_FORM_data4, SPSym); 
         DD->addArangeLabel(SymbolCU(this, SPSym));
         addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
         addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc);
@@ -558,12 +558,12 @@ void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
 
 void DwarfCompileUnit::attachRangesOrLowHighPC(
     DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
-  assert(!Ranges.empty());
-  if (!DD->useRangesSection() ||
-      (Ranges.size() == 1 &&
-       (!DD->alwaysUseRanges() ||
-        DD->getSectionLabel(&Ranges.front().Begin->getSection()) ==
-            Ranges.front().Begin))) {
+  assert(!Ranges.empty()); 
+  if (!DD->useRangesSection() || 
+      (Ranges.size() == 1 && 
+       (!DD->alwaysUseRanges() || 
+        DD->getSectionLabel(&Ranges.front().Begin->getSection()) == 
+            Ranges.front().Begin))) { 
     const RangeSpan &Front = Ranges.front();
     const RangeSpan &Back = Ranges.back();
     attachLowHighPC(Die, Front.Begin, Back.End);
@@ -686,9 +686,9 @@ DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
 
   // Add variable address.
 
-  unsigned Index = DV.getDebugLocListIndex();
-  if (Index != ~0U) {
-    addLocationList(*VariableDie, dwarf::DW_AT_location, Index);
+  unsigned Index = DV.getDebugLocListIndex(); 
+  if (Index != ~0U) { 
+    addLocationList(*VariableDie, dwarf::DW_AT_location, Index); 
     auto TagOffset = DV.getDebugLocListTagOffset();
     if (TagOffset)
       addUInt(*VariableDie, dwarf::DW_AT_LLVM_tag_offset, dwarf::DW_FORM_data1,
@@ -720,13 +720,13 @@ DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
       addConstantFPValue(*VariableDie, DVal->getConstantFP());
     } else if (DVal->isConstantInt()) {
       addConstantValue(*VariableDie, DVal->getConstantInt(), DV.getType());
-    } else if (DVal->isTargetIndexLocation()) {
-      DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-      DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
-      const DIBasicType *BT = dyn_cast<DIBasicType>(
-          static_cast<const Metadata *>(DV.getVariable()->getType()));
-      DwarfDebug::emitDebugLocValue(*Asm, BT, *DVal, DwarfExpr);
-      addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
+    } else if (DVal->isTargetIndexLocation()) { 
+      DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+      DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc); 
+      const DIBasicType *BT = dyn_cast<DIBasicType>( 
+          static_cast<const Metadata *>(DV.getVariable()->getType())); 
+      DwarfDebug::emitDebugLocValue(*Asm, BT, *DVal, DwarfExpr); 
+      addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize()); 
     }
     return VariableDie;
   }
@@ -742,14 +742,14 @@ DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
     Register FrameReg;
     const DIExpression *Expr = Fragment.Expr;
     const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
-    StackOffset Offset =
-        TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg);
+    StackOffset Offset = 
+        TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg); 
     DwarfExpr.addFragmentOffset(Expr);
-
-    auto *TRI = Asm->MF->getSubtarget().getRegisterInfo();
+ 
+    auto *TRI = Asm->MF->getSubtarget().getRegisterInfo(); 
     SmallVector<uint64_t, 8> Ops;
-    TRI->getOffsetOpcodes(Offset, Ops);
-
+    TRI->getOffsetOpcodes(Offset, Ops); 
+ 
     // According to
     // https://docs.nvidia.com/cuda/archive/10.0/ptx-writers-guide-to-interoperability/index.html#cuda-specific-dwarf
     // cuda-gdb requires DW_AT_address_class for all variables to be able to
@@ -810,10 +810,10 @@ static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) {
     return Result;
   if (auto *DLVar = Array->getDataLocation())
     Result.push_back(DLVar);
-  if (auto *AsVar = Array->getAssociated())
-    Result.push_back(AsVar);
-  if (auto *AlVar = Array->getAllocated())
-    Result.push_back(AlVar);
+  if (auto *AsVar = Array->getAssociated()) 
+    Result.push_back(AsVar); 
+  if (auto *AlVar = Array->getAllocated()) 
+    Result.push_back(AlVar); 
   for (auto *El : Array->getElements()) {
     if (auto *Subrange = dyn_cast<DISubrange>(El)) {
       if (auto Count = Subrange->getCount())
@@ -828,19 +828,19 @@ static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) {
       if (auto ST = Subrange->getStride())
         if (auto *Dependency = ST.dyn_cast<DIVariable *>())
           Result.push_back(Dependency);
-    } else if (auto *GenericSubrange = dyn_cast<DIGenericSubrange>(El)) {
-      if (auto Count = GenericSubrange->getCount())
-        if (auto *Dependency = Count.dyn_cast<DIVariable *>())
-          Result.push_back(Dependency);
-      if (auto LB = GenericSubrange->getLowerBound())
-        if (auto *Dependency = LB.dyn_cast<DIVariable *>())
-          Result.push_back(Dependency);
-      if (auto UB = GenericSubrange->getUpperBound())
-        if (auto *Dependency = UB.dyn_cast<DIVariable *>())
-          Result.push_back(Dependency);
-      if (auto ST = GenericSubrange->getStride())
-        if (auto *Dependency = ST.dyn_cast<DIVariable *>())
-          Result.push_back(Dependency);
+    } else if (auto *GenericSubrange = dyn_cast<DIGenericSubrange>(El)) { 
+      if (auto Count = GenericSubrange->getCount()) 
+        if (auto *Dependency = Count.dyn_cast<DIVariable *>()) 
+          Result.push_back(Dependency); 
+      if (auto LB = GenericSubrange->getLowerBound()) 
+        if (auto *Dependency = LB.dyn_cast<DIVariable *>()) 
+          Result.push_back(Dependency); 
+      if (auto UB = GenericSubrange->getUpperBound()) 
+        if (auto *Dependency = UB.dyn_cast<DIVariable *>()) 
+          Result.push_back(Dependency); 
+      if (auto ST = GenericSubrange->getStride()) 
+        if (auto *Dependency = ST.dyn_cast<DIVariable *>()) 
+          Result.push_back(Dependency); 
     }
   }
   return Result;
@@ -1022,7 +1022,7 @@ void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
 }
 
 bool DwarfCompileUnit::useGNUAnalogForDwarf5Feature() const {
-  return DD->getDwarfVersion() == 4 && !DD->tuneForLLDB();
+  return DD->getDwarfVersion() == 4 && !DD->tuneForLLDB(); 
 }
 
 dwarf::Tag DwarfCompileUnit::getDwarf5OrGNUTag(dwarf::Tag Tag) const {
@@ -1378,9 +1378,9 @@ void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
 /// Add a Dwarf loclistptr attribute data and value.
 void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
                                        unsigned Index) {
-  dwarf::Form Form = (DD->getDwarfVersion() >= 5)
-                         ? dwarf::DW_FORM_loclistx
-                         : DD->getDwarfSectionOffsetForm();
+  dwarf::Form Form = (DD->getDwarfVersion() >= 5) 
+                         ? dwarf::DW_FORM_loclistx 
+                         : DD->getDwarfSectionOffsetForm(); 
   Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index));
 }
 
@@ -1441,8 +1441,8 @@ void DwarfCompileUnit::addAddrTableBase() {
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
   MCSymbol *Label = DD->getAddressPool().getLabel();
   addSectionLabel(getUnitDie(),
-                  DD->getDwarfVersion() >= 5 ? dwarf::DW_AT_addr_base
-                                             : dwarf::DW_AT_GNU_addr_base,
+                  DD->getDwarfVersion() >= 5 ? dwarf::DW_AT_addr_base 
+                                             : dwarf::DW_AT_GNU_addr_base, 
                   Label, TLOF.getDwarfAddrSection()->getBeginSymbol());
 }
 
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
index 6d8186a5ee..c9f33672ca 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
@@ -33,9 +33,9 @@
 namespace llvm {
 
 class AsmPrinter;
-class DIE;
-class DIELoc;
-class DIEValueList;
+class DIE; 
+class DIELoc; 
+class DIEValueList; 
 class DwarfFile;
 class GlobalVariable;
 class MCExpr;
@@ -57,7 +57,7 @@ class DwarfCompileUnit final : public DwarfUnit {
   DwarfCompileUnit *Skeleton = nullptr;
 
   /// The start of the unit within its section.
-  MCSymbol *LabelBegin = nullptr;
+  MCSymbol *LabelBegin = nullptr; 
 
   /// The start of the unit macro info within macro section.
   MCSymbol *MacroLabelBegin;
@@ -289,8 +289,8 @@ public:
     return DwarfUnit::getHeaderSize() + DWOIdSize;
   }
   unsigned getLength() {
-    return Asm->getUnitLengthFieldByteSize() + // Length field
-           getHeaderSize() + getUnitDie().getSize();
+    return Asm->getUnitLengthFieldByteSize() + // Length field 
+           getHeaderSize() + getUnitDie().getSize(); 
   }
 
   void emitHeader(bool UseOffsets) override;
@@ -299,7 +299,7 @@ public:
   void addAddrTableBase();
 
   MCSymbol *getLabelBegin() const {
-    assert(LabelBegin && "LabelBegin is not initialized");
+    assert(LabelBegin && "LabelBegin is not initialized"); 
     return LabelBegin;
   }
 
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfDebug.cpp
index 462682743c..b48ea8547b 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfDebug.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfDebug.cpp
@@ -123,18 +123,18 @@ static cl::opt<DefaultOnOff> DwarfSectionsAsReferences(
                clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")),
     cl::init(Default));
 
-static cl::opt<bool>
-    UseGNUDebugMacro("use-gnu-debug-macro", cl::Hidden,
-                     cl::desc("Emit the GNU .debug_macro format with DWARF <5"),
-                     cl::init(false));
-
-static cl::opt<DefaultOnOff> DwarfOpConvert(
-    "dwarf-op-convert", cl::Hidden,
-    cl::desc("Enable use of the DWARFv5 DW_OP_convert operator"),
-    cl::values(clEnumVal(Default, "Default for platform"),
-               clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")),
-    cl::init(Default));
-
+static cl::opt<bool> 
+    UseGNUDebugMacro("use-gnu-debug-macro", cl::Hidden, 
+                     cl::desc("Emit the GNU .debug_macro format with DWARF <5"), 
+                     cl::init(false)); 
+ 
+static cl::opt<DefaultOnOff> DwarfOpConvert( 
+    "dwarf-op-convert", cl::Hidden, 
+    cl::desc("Enable use of the DWARFv5 DW_OP_convert operator"), 
+    cl::values(clEnumVal(Default, "Default for platform"), 
+               clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")), 
+    cl::init(Default)); 
+ 
 enum LinkageNameOption {
   DefaultLinkageNames,
   AllLinkageNames,
@@ -151,23 +151,23 @@ static cl::opt<LinkageNameOption>
                                             "Abstract subprograms")),
                       cl::init(DefaultLinkageNames));
 
-static cl::opt<DwarfDebug::MinimizeAddrInV5> MinimizeAddrInV5Option(
-    "minimize-addr-in-v5", cl::Hidden,
-    cl::desc("Always use DW_AT_ranges in DWARFv5 whenever it could allow more "
-             "address pool entry sharing to reduce relocations/object size"),
-    cl::values(clEnumValN(DwarfDebug::MinimizeAddrInV5::Default, "Default",
-                          "Default address minimization strategy"),
-               clEnumValN(DwarfDebug::MinimizeAddrInV5::Ranges, "Ranges",
-                          "Use rnglists for contiguous ranges if that allows "
-                          "using a pre-existing base address"),
-               clEnumValN(DwarfDebug::MinimizeAddrInV5::Disabled, "Disabled",
-                          "Stuff")),
-    cl::init(DwarfDebug::MinimizeAddrInV5::Default));
+static cl::opt<DwarfDebug::MinimizeAddrInV5> MinimizeAddrInV5Option( 
+    "minimize-addr-in-v5", cl::Hidden, 
+    cl::desc("Always use DW_AT_ranges in DWARFv5 whenever it could allow more " 
+             "address pool entry sharing to reduce relocations/object size"), 
+    cl::values(clEnumValN(DwarfDebug::MinimizeAddrInV5::Default, "Default", 
+                          "Default address minimization strategy"), 
+               clEnumValN(DwarfDebug::MinimizeAddrInV5::Ranges, "Ranges", 
+                          "Use rnglists for contiguous ranges if that allows " 
+                          "using a pre-existing base address"), 
+               clEnumValN(DwarfDebug::MinimizeAddrInV5::Disabled, "Disabled", 
+                          "Stuff")), 
+    cl::init(DwarfDebug::MinimizeAddrInV5::Default)); 
 
 static constexpr unsigned ULEB128PadSize = 4;
 
 void DebugLocDwarfExpression::emitOp(uint8_t Op, const char *Comment) {
-  getActiveStreamer().emitInt8(
+  getActiveStreamer().emitInt8( 
       Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
                   : dwarf::OperationEncodingString(Op));
 }
@@ -181,7 +181,7 @@ void DebugLocDwarfExpression::emitUnsigned(uint64_t Value) {
 }
 
 void DebugLocDwarfExpression::emitData1(uint8_t Value) {
-  getActiveStreamer().emitInt8(Value, Twine(Value));
+  getActiveStreamer().emitInt8(Value, Twine(Value)); 
 }
 
 void DebugLocDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
@@ -190,7 +190,7 @@ void DebugLocDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
 }
 
 bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
-                                              llvm::Register MachineReg) {
+                                              llvm::Register MachineReg) { 
   // This information is not available while emitting .debug_loc entries.
   return false;
 }
@@ -215,7 +215,7 @@ void DebugLocDwarfExpression::commitTemporaryBuffer() {
     const char *Comment = (Byte.index() < TmpBuf->Comments.size())
                               ? TmpBuf->Comments[Byte.index()].c_str()
                               : "";
-    OutBS.emitInt8(Byte.value(), Comment);
+    OutBS.emitInt8(Byte.value(), Comment); 
   }
   TmpBuf->Bytes.clear();
   TmpBuf->Comments.clear();
@@ -230,8 +230,8 @@ static DbgValueLoc getDebugLocValue(const MachineInstr *MI) {
   const DIExpression *Expr = MI->getDebugExpression();
   assert(MI->getNumOperands() == 4);
   if (MI->getDebugOperand(0).isReg()) {
-    const auto &RegOp = MI->getDebugOperand(0);
-    const auto &Op1 = MI->getDebugOffset();
+    const auto &RegOp = MI->getDebugOperand(0); 
+    const auto &Op1 = MI->getDebugOffset(); 
     // If the second operand is an immediate, this is a
     // register-indirect address.
     assert((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset");
@@ -239,7 +239,7 @@ static DbgValueLoc getDebugLocValue(const MachineInstr *MI) {
     return DbgValueLoc(Expr, MLoc);
   }
   if (MI->getDebugOperand(0).isTargetIndex()) {
-    const auto &Op = MI->getDebugOperand(0);
+    const auto &Op = MI->getDebugOperand(0); 
     return DbgValueLoc(Expr,
                        TargetIndexLocation(Op.getIndex(), Op.getOffset()));
   }
@@ -342,7 +342,7 @@ static AccelTableKind computeAccelTableKind(unsigned DwarfVersion,
   return AccelTableKind::None;
 }
 
-DwarfDebug::DwarfDebug(AsmPrinter *A)
+DwarfDebug::DwarfDebug(AsmPrinter *A) 
     : DebugHandlerBase(A), DebugLocs(A->OutStreamer->isVerboseAsm()),
       InfoHolder(A, "info_string", DIEValueAllocator),
       SkeletonHolder(A, "skel_string", DIEValueAllocator),
@@ -385,11 +385,11 @@ DwarfDebug::DwarfDebug(AsmPrinter *A)
   DwarfVersion =
       TT.isNVPTX() ? 2 : (DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION);
 
-  bool Dwarf64 = Asm->TM.Options.MCOptions.Dwarf64 &&
-                 DwarfVersion >= 3 &&   // DWARF64 was introduced in DWARFv3.
-                 TT.isArch64Bit() &&    // DWARF64 requires 64-bit relocations.
-                 TT.isOSBinFormatELF(); // Support only ELF for now.
-
+  bool Dwarf64 = Asm->TM.Options.MCOptions.Dwarf64 && 
+                 DwarfVersion >= 3 &&   // DWARF64 was introduced in DWARFv3. 
+                 TT.isArch64Bit() &&    // DWARF64 requires 64-bit relocations. 
+                 TT.isOSBinFormatELF(); // Support only ELF for now. 
+ 
   UseRangesSection = !NoDwarfRangesSection && !TT.isNVPTX();
 
   // Use sections as references. Force for NVPTX.
@@ -399,9 +399,9 @@ DwarfDebug::DwarfDebug(AsmPrinter *A)
     UseSectionsAsReferences = DwarfSectionsAsReferences == Enable;
 
   // Don't generate type units for unsupported object file formats.
-  GenerateTypeUnits = (A->TM.getTargetTriple().isOSBinFormatELF() ||
-                       A->TM.getTargetTriple().isOSBinFormatWasm()) &&
-                      GenerateDwarfTypeUnits;
+  GenerateTypeUnits = (A->TM.getTargetTriple().isOSBinFormatELF() || 
+                       A->TM.getTargetTriple().isOSBinFormatWasm()) && 
+                      GenerateDwarfTypeUnits; 
 
   TheAccelTableKind = computeAccelTableKind(
       DwarfVersion, GenerateTypeUnits, DebuggerTuning, A->TM.getTargetTriple());
@@ -424,31 +424,31 @@ DwarfDebug::DwarfDebug(AsmPrinter *A)
 
   // Emit call-site-param debug info for GDB and LLDB, if the target supports
   // the debug entry values feature. It can also be enabled explicitly.
-  EmitDebugEntryValues = Asm->TM.Options.ShouldEmitDebugEntryValues();
-
-  // It is unclear if the GCC .debug_macro extension is well-specified
-  // for split DWARF. For now, do not allow LLVM to emit it.
-  UseDebugMacroSection =
-      DwarfVersion >= 5 || (UseGNUDebugMacro && !useSplitDwarf());
-  if (DwarfOpConvert == Default)
-    EnableOpConvert = !((tuneForGDB() && useSplitDwarf()) || (tuneForLLDB() && !TT.isOSBinFormatMachO()));
-  else
-    EnableOpConvert = (DwarfOpConvert == Enable);
-
-  // Split DWARF would benefit object size significantly by trading reductions
-  // in address pool usage for slightly increased range list encodings.
-  if (DwarfVersion >= 5) {
-    MinimizeAddr = MinimizeAddrInV5Option;
-    // FIXME: In the future, enable this by default for Split DWARF where the
-    // tradeoff is more pronounced due to being able to offload the range
-    // lists to the dwo file and shrink object files/reduce relocations there.
-    if (MinimizeAddr == MinimizeAddrInV5::Default)
-      MinimizeAddr = MinimizeAddrInV5::Disabled;
-  }
-
+  EmitDebugEntryValues = Asm->TM.Options.ShouldEmitDebugEntryValues(); 
+
+  // It is unclear if the GCC .debug_macro extension is well-specified 
+  // for split DWARF. For now, do not allow LLVM to emit it. 
+  UseDebugMacroSection = 
+      DwarfVersion >= 5 || (UseGNUDebugMacro && !useSplitDwarf()); 
+  if (DwarfOpConvert == Default) 
+    EnableOpConvert = !((tuneForGDB() && useSplitDwarf()) || (tuneForLLDB() && !TT.isOSBinFormatMachO())); 
+  else 
+    EnableOpConvert = (DwarfOpConvert == Enable); 
+ 
+  // Split DWARF would benefit object size significantly by trading reductions 
+  // in address pool usage for slightly increased range list encodings. 
+  if (DwarfVersion >= 5) { 
+    MinimizeAddr = MinimizeAddrInV5Option; 
+    // FIXME: In the future, enable this by default for Split DWARF where the 
+    // tradeoff is more pronounced due to being able to offload the range 
+    // lists to the dwo file and shrink object files/reduce relocations there. 
+    if (MinimizeAddr == MinimizeAddrInV5::Default) 
+      MinimizeAddr = MinimizeAddrInV5::Disabled; 
+  } 
+ 
   Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
-  Asm->OutStreamer->getContext().setDwarfFormat(Dwarf64 ? dwarf::DWARF64
-                                                        : dwarf::DWARF32);
+  Asm->OutStreamer->getContext().setDwarfFormat(Dwarf64 ? dwarf::DWARF64 
+                                                        : dwarf::DWARF32); 
 }
 
 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
@@ -597,7 +597,7 @@ static const DIExpression *combineDIExpressions(const DIExpression *Original,
   std::vector<uint64_t> Elts = Addition->getElements().vec();
   // Avoid multiple DW_OP_stack_values.
   if (Original->isImplicit() && Addition->isImplicit())
-    erase_value(Elts, dwarf::DW_OP_stack_value);
+    erase_value(Elts, dwarf::DW_OP_stack_value); 
   const DIExpression *CombinedExpr =
       (Elts.size() > 0) ? DIExpression::append(Original, Elts) : Original;
   return CombinedExpr;
@@ -723,11 +723,11 @@ static void interpretValues(const MachineInstr *CurMI,
                              ForwardedRegWorklist[ParamFwdReg], Params);
       } else if (ParamValue->first.isReg()) {
         Register RegLoc = ParamValue->first.getReg();
-        Register SP = TLI.getStackPointerRegisterToSaveRestore();
+        Register SP = TLI.getStackPointerRegisterToSaveRestore(); 
         Register FP = TRI.getFrameRegister(*MF);
         bool IsSPorFP = (RegLoc == SP) || (RegLoc == FP);
         if (TRI.isCalleeSavedPhysReg(RegLoc, *MF) || IsSPorFP) {
-          MachineLocation MLoc(RegLoc, /*Indirect=*/IsSPorFP);
+          MachineLocation MLoc(RegLoc, /*Indirect=*/IsSPorFP); 
           finishCallSiteParams(MLoc, ParamValue->second,
                                ForwardedRegWorklist[ParamFwdReg], Params);
         } else {
@@ -811,11 +811,11 @@ static void collectCallSiteParameters(const MachineInstr *CallMI,
     (void)InsertedReg;
   }
 
-  // Do not emit CSInfo for undef forwarding registers.
-  for (auto &MO : CallMI->uses())
-    if (MO.isReg() && MO.isUndef())
-      ForwardedRegWorklist.erase(MO.getReg());
-
+  // Do not emit CSInfo for undef forwarding registers. 
+  for (auto &MO : CallMI->uses()) 
+    if (MO.isReg() && MO.isUndef()) 
+      ForwardedRegWorklist.erase(MO.getReg()); 
+ 
   // We erase, from the ForwardedRegWorklist, those forwarding registers for
   // which we successfully describe a loaded value (by using
   // the describeLoadedValue()). For those remaining arguments in the working
@@ -1090,8 +1090,8 @@ DwarfDebug::getOrCreateDwarfCompileUnit(const DICompileUnit *DIUnit) {
   // compilation directory.
   if (!Asm->OutStreamer->hasRawTextSupport() || SingleCU)
     Asm->OutStreamer->emitDwarfFile0Directive(
-        CompilationDir, DIUnit->getFilename(), getMD5AsBytes(DIUnit->getFile()),
-        DIUnit->getSource(), NewCU.getUniqueID());
+        CompilationDir, DIUnit->getFilename(), getMD5AsBytes(DIUnit->getFile()), 
+        DIUnit->getSource(), NewCU.getUniqueID()); 
 
   if (useSplitDwarf()) {
     NewCU.setSkeleton(constructSkeletonCU(NewCU));
@@ -1144,17 +1144,17 @@ sortGlobalExprs(SmallVectorImpl<DwarfCompileUnit::GlobalExpr> &GVEs) {
 // Emit all Dwarf sections that should come prior to the content. Create
 // global DIEs and emit initial debug info sections. This is invoked by
 // the target AsmPrinter.
-void DwarfDebug::beginModule(Module *M) {
-  DebugHandlerBase::beginModule(M);
-
-  if (!Asm || !MMI->hasDebugInfo())
+void DwarfDebug::beginModule(Module *M) { 
+  DebugHandlerBase::beginModule(M); 
+ 
+  if (!Asm || !MMI->hasDebugInfo()) 
     return;
 
   unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
                                        M->debug_compile_units_end());
-  assert(NumDebugCUs > 0 && "Asm unexpectedly initialized");
-  assert(MMI->hasDebugInfo() &&
-         "DebugInfoAvailabilty unexpectedly not initialized");
+  assert(NumDebugCUs > 0 && "Asm unexpectedly initialized"); 
+  assert(MMI->hasDebugInfo() && 
+         "DebugInfoAvailabilty unexpectedly not initialized"); 
   SingleCU = NumDebugCUs == 1;
   DenseMap<DIGlobalVariable *, SmallVector<DwarfCompileUnit::GlobalExpr, 1>>
       GVMap;
@@ -1306,7 +1306,7 @@ void DwarfDebug::finalizeModuleInfo() {
                       Asm->TM.Options.MCOptions.SplitDwarfFile);
       // Emit a unique identifier for this CU.
       uint64_t ID =
-          DIEHash(Asm, &TheCU).computeCUSignature(DWOName, TheCU.getUnitDie());
+          DIEHash(Asm, &TheCU).computeCUSignature(DWOName, TheCU.getUnitDie()); 
       if (getDwarfVersion() >= 5) {
         TheCU.setDWOId(ID);
         SkCU->setDWOId(ID);
@@ -1367,18 +1367,18 @@ void DwarfDebug::finalizeModuleInfo() {
     // If compile Unit has macros, emit "DW_AT_macro_info/DW_AT_macros"
     // attribute.
     if (CUNode->getMacros()) {
-      if (UseDebugMacroSection) {
+      if (UseDebugMacroSection) { 
         if (useSplitDwarf())
           TheCU.addSectionDelta(
               TheCU.getUnitDie(), dwarf::DW_AT_macros, U.getMacroLabelBegin(),
               TLOF.getDwarfMacroDWOSection()->getBeginSymbol());
-        else {
-          dwarf::Attribute MacrosAttr = getDwarfVersion() >= 5
-                                            ? dwarf::DW_AT_macros
-                                            : dwarf::DW_AT_GNU_macros;
-          U.addSectionLabel(U.getUnitDie(), MacrosAttr, U.getMacroLabelBegin(),
+        else { 
+          dwarf::Attribute MacrosAttr = getDwarfVersion() >= 5 
+                                            ? dwarf::DW_AT_macros 
+                                            : dwarf::DW_AT_GNU_macros; 
+          U.addSectionLabel(U.getUnitDie(), MacrosAttr, U.getMacroLabelBegin(), 
                             TLOF.getDwarfMacroSection()->getBeginSymbol());
-        }
+        } 
       } else {
         if (useSplitDwarf())
           TheCU.addSectionDelta(
@@ -1415,8 +1415,8 @@ void DwarfDebug::endModule() {
   }
 
   // If we aren't actually generating debug info (check beginModule -
-  // conditionalized on the presence of the llvm.dbg.cu metadata node)
-  if (!Asm || !MMI->hasDebugInfo())
+  // conditionalized on the presence of the llvm.dbg.cu metadata node) 
+  if (!Asm || !MMI->hasDebugInfo()) 
     return;
 
   // Finalize the debug info for the module.
@@ -1548,8 +1548,8 @@ void DwarfDebug::collectVariableInfoFromMFTable(
 /// either open or otherwise rolls off the end of the scope.
 static bool validThroughout(LexicalScopes &LScopes,
                             const MachineInstr *DbgValue,
-                            const MachineInstr *RangeEnd,
-                            const InstructionOrdering &Ordering) {
+                            const MachineInstr *RangeEnd, 
+                            const InstructionOrdering &Ordering) { 
   assert(DbgValue->getDebugLoc() && "DBG_VALUE without a debug location");
   auto MBB = DbgValue->getParent();
   auto DL = DbgValue->getDebugLoc();
@@ -1562,29 +1562,29 @@ static bool validThroughout(LexicalScopes &LScopes,
     return false;
 
   const MachineInstr *LScopeBegin = LSRange.front().first;
-  // If the scope starts before the DBG_VALUE then we may have a negative
-  // result. Otherwise the location is live coming into the scope and we
-  // can skip the following checks.
-  if (!Ordering.isBefore(DbgValue, LScopeBegin)) {
-    // Exit if the lexical scope begins outside of the current block.
-    if (LScopeBegin->getParent() != MBB)
-      return false;
-
-    MachineBasicBlock::const_reverse_iterator Pred(DbgValue);
-    for (++Pred; Pred != MBB->rend(); ++Pred) {
-      if (Pred->getFlag(MachineInstr::FrameSetup))
-        break;
-      auto PredDL = Pred->getDebugLoc();
-      if (!PredDL || Pred->isMetaInstruction())
-        continue;
-      // Check whether the instruction preceding the DBG_VALUE is in the same
-      // (sub)scope as the DBG_VALUE.
-      if (DL->getScope() == PredDL->getScope())
-        return false;
-      auto *PredScope = LScopes.findLexicalScope(PredDL);
-      if (!PredScope || LScope->dominates(PredScope))
-        return false;
-    }
+  // If the scope starts before the DBG_VALUE then we may have a negative 
+  // result. Otherwise the location is live coming into the scope and we 
+  // can skip the following checks. 
+  if (!Ordering.isBefore(DbgValue, LScopeBegin)) { 
+    // Exit if the lexical scope begins outside of the current block. 
+    if (LScopeBegin->getParent() != MBB) 
+      return false; 
+
+    MachineBasicBlock::const_reverse_iterator Pred(DbgValue); 
+    for (++Pred; Pred != MBB->rend(); ++Pred) { 
+      if (Pred->getFlag(MachineInstr::FrameSetup)) 
+        break; 
+      auto PredDL = Pred->getDebugLoc(); 
+      if (!PredDL || Pred->isMetaInstruction()) 
+        continue; 
+      // Check whether the instruction preceding the DBG_VALUE is in the same 
+      // (sub)scope as the DBG_VALUE. 
+      if (DL->getScope() == PredDL->getScope()) 
+        return false; 
+      auto *PredScope = LScopes.findLexicalScope(PredDL); 
+      if (!PredScope || LScope->dominates(PredScope)) 
+        return false; 
+    } 
   }
 
   // If the range of the DBG_VALUE is open-ended, report success.
@@ -1598,10 +1598,10 @@ static bool validThroughout(LexicalScopes &LScopes,
   if (DbgValue->getDebugOperand(0).isImm() && MBB->pred_empty())
     return true;
 
-  // Test if the location terminates before the end of the scope.
-  const MachineInstr *LScopeEnd = LSRange.back().second;
-  if (Ordering.isBefore(RangeEnd, LScopeEnd))
-    return false;
+  // Test if the location terminates before the end of the scope. 
+  const MachineInstr *LScopeEnd = LSRange.back().second; 
+  if (Ordering.isBefore(RangeEnd, LScopeEnd)) 
+    return false; 
 
   // There's a single location which starts at the scope start, and ends at or
   // after the scope end.
@@ -1641,8 +1641,8 @@ static bool validThroughout(LexicalScopes &LScopes,
 // [1-3)    [(reg0, fragment 0, 32), (reg1, fragment 32, 32)]
 // [3-4)    [(reg1, fragment 32, 32), (123, fragment 64, 32)]
 // [4-)     [(@g, fragment 0, 96)]
-bool DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
-                                   const DbgValueHistoryMap::Entries &Entries) {
+bool DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc, 
+                                   const DbgValueHistoryMap::Entries &Entries) { 
   using OpenRange =
       std::pair<DbgValueHistoryMap::EntryIndex, DbgValueLoc>;
   SmallVector<OpenRange, 4> OpenRanges;
@@ -1655,7 +1655,7 @@ bool DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
 
     // Remove all values that are no longer live.
     size_t Index = std::distance(EB, EI);
-    erase_if(OpenRanges, [&](OpenRange &R) { return R.first <= Index; });
+    erase_if(OpenRanges, [&](OpenRange &R) { return R.first <= Index; }); 
 
     // If we are dealing with a clobbering entry, this iteration will result in
     // a location list entry starting after the clobbering instruction.
@@ -1736,8 +1736,8 @@ bool DwarfDebug::buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
       DebugLoc.pop_back();
   }
 
-  return DebugLoc.size() == 1 && isSafeForSingleLocation &&
-         validThroughout(LScopes, StartDebugMI, EndMI, getInstOrdering());
+  return DebugLoc.size() == 1 && isSafeForSingleLocation && 
+         validThroughout(LScopes, StartDebugMI, EndMI, getInstOrdering()); 
 }
 
 DbgEntity *DwarfDebug::createConcreteEntity(DwarfCompileUnit &TheCU,
@@ -1805,7 +1805,7 @@ void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU,
     if (HistSize == 1 || SingleValueWithClobber) {
       const auto *End =
           SingleValueWithClobber ? HistoryMapEntries[1].getInstr() : nullptr;
-      if (validThroughout(LScopes, MInsn, End, getInstOrdering())) {
+      if (validThroughout(LScopes, MInsn, End, getInstOrdering())) { 
         RegVar->initializeDbgValue(MInsn);
         continue;
       }
@@ -1820,7 +1820,7 @@ void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU,
 
     // Build the location list for this variable.
     SmallVector<DebugLocEntry, 8> Entries;
-    bool isValidSingleLocation = buildLocationList(Entries, HistoryMapEntries);
+    bool isValidSingleLocation = buildLocationList(Entries, HistoryMapEntries); 
 
     // Check whether buildLocationList managed to merge all locations to one
     // that is valid throughout the variable's scope. If so, produce single
@@ -1925,8 +1925,8 @@ void DwarfDebug::beginInstruction(const MachineInstr *MI) {
   }
 
   DebugHandlerBase::beginInstruction(MI);
-  if (!CurMI)
-    return;
+  if (!CurMI) 
+    return; 
 
   if (NoDebug)
     return;
@@ -2365,8 +2365,8 @@ void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name,
   // Emit the header.
   MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + Name + "_begin");
   MCSymbol *EndLabel = Asm->createTempSymbol("pub" + Name + "_end");
-  Asm->emitDwarfUnitLength(EndLabel, BeginLabel,
-                           "Length of Public " + Name + " Info");
+  Asm->emitDwarfUnitLength(EndLabel, BeginLabel, 
+                           "Length of Public " + Name + " Info"); 
 
   Asm->OutStreamer->emitLabel(BeginLabel);
 
@@ -2377,7 +2377,7 @@ void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name,
   emitSectionReference(*TheU);
 
   Asm->OutStreamer->AddComment("Compilation Unit Length");
-  Asm->emitDwarfLengthOrOffset(TheU->getLength());
+  Asm->emitDwarfLengthOrOffset(TheU->getLength()); 
 
   // Emit the pubnames for this compilation unit.
   for (const auto &GI : Globals) {
@@ -2385,7 +2385,7 @@ void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name,
     const DIE *Entity = GI.second;
 
     Asm->OutStreamer->AddComment("DIE offset");
-    Asm->emitDwarfLengthOrOffset(Entity->getOffset());
+    Asm->emitDwarfLengthOrOffset(Entity->getOffset()); 
 
     if (GnuStyle) {
       dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
@@ -2400,7 +2400,7 @@ void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name,
   }
 
   Asm->OutStreamer->AddComment("End Mark");
-  Asm->emitDwarfLengthOrOffset(0);
+  Asm->emitDwarfLengthOrOffset(0); 
   Asm->OutStreamer->emitLabel(EndLabel);
 }
 
@@ -2439,7 +2439,7 @@ void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
   for (auto &Op : Expr) {
     assert(Op.getCode() != dwarf::DW_OP_const_type &&
            "3 operand ops not yet supported");
-    Streamer.emitInt8(Op.getCode(), Comment != End ? *(Comment++) : "");
+    Streamer.emitInt8(Op.getCode(), Comment != End ? *(Comment++) : ""); 
     Offset++;
     for (unsigned I = 0; I < 2; ++I) {
       if (Op.getDescription().Op[I] == Encoding::SizeNA)
@@ -2455,7 +2455,7 @@ void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
             Comment++;
       } else {
         for (uint64_t J = Offset; J < Op.getOperandEndOffset(I); ++J)
-          Streamer.emitInt8(Data.getData()[J], Comment != End ? *(Comment++) : "");
+          Streamer.emitInt8(Data.getData()[J], Comment != End ? *(Comment++) : ""); 
       }
       Offset = Op.getOperandEndOffset(I);
     }
@@ -2492,26 +2492,26 @@ void DwarfDebug::emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
     TargetIndexLocation Loc = Value.getTargetIndexLocation();
     // TODO TargetIndexLocation is a target-independent. Currently only the WebAssembly-specific
     // encoding is supported.
-    assert(AP.TM.getTargetTriple().isWasm());
+    assert(AP.TM.getTargetTriple().isWasm()); 
     DwarfExpr.addWasmLocation(Loc.Index, static_cast<uint64_t>(Loc.Offset));
-      DwarfExpr.addExpression(std::move(ExprCursor));
-      return;
+      DwarfExpr.addExpression(std::move(ExprCursor)); 
+      return; 
   } else if (Value.isConstantFP()) {
-    if (AP.getDwarfVersion() >= 4 && !AP.getDwarfDebug()->tuneForSCE() &&
-        !ExprCursor) {
-      DwarfExpr.addConstantFP(Value.getConstantFP()->getValueAPF(), AP);
-      return;
-    }
-    if (Value.getConstantFP()->getValueAPF().bitcastToAPInt().getBitWidth() <=
-        64 /*bits*/)
-      DwarfExpr.addUnsignedConstant(
-          Value.getConstantFP()->getValueAPF().bitcastToAPInt());
-    else
-      LLVM_DEBUG(
-          dbgs()
-          << "Skipped DwarfExpression creation for ConstantFP of size"
-          << Value.getConstantFP()->getValueAPF().bitcastToAPInt().getBitWidth()
-          << " bits\n");
+    if (AP.getDwarfVersion() >= 4 && !AP.getDwarfDebug()->tuneForSCE() && 
+        !ExprCursor) { 
+      DwarfExpr.addConstantFP(Value.getConstantFP()->getValueAPF(), AP); 
+      return; 
+    } 
+    if (Value.getConstantFP()->getValueAPF().bitcastToAPInt().getBitWidth() <= 
+        64 /*bits*/) 
+      DwarfExpr.addUnsignedConstant( 
+          Value.getConstantFP()->getValueAPF().bitcastToAPInt()); 
+    else 
+      LLVM_DEBUG( 
+          dbgs() 
+          << "Skipped DwarfExpression creation for ConstantFP of size" 
+          << Value.getConstantFP()->getValueAPF().bitcastToAPInt().getBitWidth() 
+          << " bits\n"); 
   }
   DwarfExpr.addExpression(std::move(ExprCursor));
 }
@@ -2534,7 +2534,7 @@ void DebugLocEntry::finalize(const AsmPrinter &AP,
         }) && "all values are expected to be fragments");
     assert(llvm::is_sorted(Values) && "fragments are expected to be sorted");
 
-    for (const auto &Fragment : Values)
+    for (const auto &Fragment : Values) 
       DwarfDebug::emitDebugLocValue(AP, BT, Fragment, DwarfExpr);
 
   } else {
@@ -2577,8 +2577,8 @@ static MCSymbol *emitRnglistsTableHeader(AsmPrinter *Asm,
   Asm->OutStreamer->emitLabel(Holder.getRnglistsTableBaseSym());
 
   for (const RangeSpanList &List : Holder.getRangeLists())
-    Asm->emitLabelDifference(List.Label, Holder.getRnglistsTableBaseSym(),
-                             Asm->getDwarfOffsetByteSize());
+    Asm->emitLabelDifference(List.Label, Holder.getRnglistsTableBaseSym(), 
+                             Asm->getDwarfOffsetByteSize()); 
 
   return TableEnd;
 }
@@ -2597,8 +2597,8 @@ static MCSymbol *emitLoclistsTableHeader(AsmPrinter *Asm,
   Asm->OutStreamer->emitLabel(DebugLocs.getSym());
 
   for (const auto &List : DebugLocs.getLists())
-    Asm->emitLabelDifference(List.Label, DebugLocs.getSym(),
-                             Asm->getDwarfOffsetByteSize());
+    Asm->emitLabelDifference(List.Label, DebugLocs.getSym(), 
+                             Asm->getDwarfOffsetByteSize()); 
 
   return TableEnd;
 }
@@ -2880,23 +2880,23 @@ void DwarfDebug::emitDebugARanges() {
 
     // Emit size of content not including length itself.
     unsigned ContentSize =
-        sizeof(int16_t) +               // DWARF ARange version number
-        Asm->getDwarfOffsetByteSize() + // Offset of CU in the .debug_info
-                                        // section
-        sizeof(int8_t) +                // Pointer Size (in bytes)
-        sizeof(int8_t);                 // Segment Size (in bytes)
+        sizeof(int16_t) +               // DWARF ARange version number 
+        Asm->getDwarfOffsetByteSize() + // Offset of CU in the .debug_info 
+                                        // section 
+        sizeof(int8_t) +                // Pointer Size (in bytes) 
+        sizeof(int8_t);                 // Segment Size (in bytes) 
 
     unsigned TupleSize = PtrSize * 2;
 
     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
-    unsigned Padding = offsetToAlignment(
-        Asm->getUnitLengthFieldByteSize() + ContentSize, Align(TupleSize));
+    unsigned Padding = offsetToAlignment( 
+        Asm->getUnitLengthFieldByteSize() + ContentSize, Align(TupleSize)); 
 
     ContentSize += Padding;
     ContentSize += (List.size() + 1) * TupleSize;
 
     // For each compile unit, write the list of spans it covers.
-    Asm->emitDwarfUnitLength(ContentSize, "Length of ARange Set");
+    Asm->emitDwarfUnitLength(ContentSize, "Length of ARange Set"); 
     Asm->OutStreamer->AddComment("DWARF Arange version number");
     Asm->emitInt16(dwarf::DW_ARANGES_VERSION);
     Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
@@ -2982,30 +2982,30 @@ void DwarfDebug::emitDebugRangesDWO() {
                       Asm->getObjFileLowering().getDwarfRnglistsDWOSection());
 }
 
-/// Emit the header of a DWARF 5 macro section, or the GNU extension for
-/// DWARF 4.
+/// Emit the header of a DWARF 5 macro section, or the GNU extension for 
+/// DWARF 4. 
 static void emitMacroHeader(AsmPrinter *Asm, const DwarfDebug &DD,
-                            const DwarfCompileUnit &CU, uint16_t DwarfVersion) {
+                            const DwarfCompileUnit &CU, uint16_t DwarfVersion) { 
   enum HeaderFlagMask {
 #define HANDLE_MACRO_FLAG(ID, NAME) MACRO_FLAG_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   };
   Asm->OutStreamer->AddComment("Macro information version");
-  Asm->emitInt16(DwarfVersion >= 5 ? DwarfVersion : 4);
-  // We emit the line offset flag unconditionally here, since line offset should
-  // be mostly present.
-  if (Asm->isDwarf64()) {
-    Asm->OutStreamer->AddComment("Flags: 64 bit, debug_line_offset present");
-    Asm->emitInt8(MACRO_FLAG_OFFSET_SIZE | MACRO_FLAG_DEBUG_LINE_OFFSET);
-  } else {
-    Asm->OutStreamer->AddComment("Flags: 32 bit, debug_line_offset present");
-    Asm->emitInt8(MACRO_FLAG_DEBUG_LINE_OFFSET);
-  }
+  Asm->emitInt16(DwarfVersion >= 5 ? DwarfVersion : 4); 
+  // We emit the line offset flag unconditionally here, since line offset should 
+  // be mostly present. 
+  if (Asm->isDwarf64()) { 
+    Asm->OutStreamer->AddComment("Flags: 64 bit, debug_line_offset present"); 
+    Asm->emitInt8(MACRO_FLAG_OFFSET_SIZE | MACRO_FLAG_DEBUG_LINE_OFFSET); 
+  } else { 
+    Asm->OutStreamer->AddComment("Flags: 32 bit, debug_line_offset present"); 
+    Asm->emitInt8(MACRO_FLAG_DEBUG_LINE_OFFSET); 
+  } 
   Asm->OutStreamer->AddComment("debug_line_offset");
-  if (DD.useSplitDwarf())
-    Asm->emitDwarfLengthOrOffset(0);
-  else
-    Asm->emitDwarfSymbolReference(CU.getLineTableStartSym());
+  if (DD.useSplitDwarf()) 
+    Asm->emitDwarfLengthOrOffset(0); 
+  else 
+    Asm->emitDwarfSymbolReference(CU.getLineTableStartSym()); 
 }
 
 void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) {
@@ -3023,62 +3023,62 @@ void DwarfDebug::emitMacro(DIMacro &M) {
   StringRef Name = M.getName();
   StringRef Value = M.getValue();
 
-  // There should be one space between the macro name and the macro value in
-  // define entries. In undef entries, only the macro name is emitted.
-  std::string Str = Value.empty() ? Name.str() : (Name + " " + Value).str();
-
-  if (UseDebugMacroSection) {
-    if (getDwarfVersion() >= 5) {
-      unsigned Type = M.getMacinfoType() == dwarf::DW_MACINFO_define
-                          ? dwarf::DW_MACRO_define_strx
-                          : dwarf::DW_MACRO_undef_strx;
-      Asm->OutStreamer->AddComment(dwarf::MacroString(Type));
-      Asm->emitULEB128(Type);
-      Asm->OutStreamer->AddComment("Line Number");
-      Asm->emitULEB128(M.getLine());
-      Asm->OutStreamer->AddComment("Macro String");
-      Asm->emitULEB128(
-          InfoHolder.getStringPool().getIndexedEntry(*Asm, Str).getIndex());
-    } else {
-      unsigned Type = M.getMacinfoType() == dwarf::DW_MACINFO_define
-                          ? dwarf::DW_MACRO_GNU_define_indirect
-                          : dwarf::DW_MACRO_GNU_undef_indirect;
-      Asm->OutStreamer->AddComment(dwarf::GnuMacroString(Type));
-      Asm->emitULEB128(Type);
-      Asm->OutStreamer->AddComment("Line Number");
-      Asm->emitULEB128(M.getLine());
-      Asm->OutStreamer->AddComment("Macro String");
-      Asm->emitDwarfSymbolReference(
-          InfoHolder.getStringPool().getEntry(*Asm, Str).getSymbol());
-    }
+  // There should be one space between the macro name and the macro value in 
+  // define entries. In undef entries, only the macro name is emitted. 
+  std::string Str = Value.empty() ? Name.str() : (Name + " " + Value).str(); 
+ 
+  if (UseDebugMacroSection) { 
+    if (getDwarfVersion() >= 5) { 
+      unsigned Type = M.getMacinfoType() == dwarf::DW_MACINFO_define 
+                          ? dwarf::DW_MACRO_define_strx 
+                          : dwarf::DW_MACRO_undef_strx; 
+      Asm->OutStreamer->AddComment(dwarf::MacroString(Type)); 
+      Asm->emitULEB128(Type); 
+      Asm->OutStreamer->AddComment("Line Number"); 
+      Asm->emitULEB128(M.getLine()); 
+      Asm->OutStreamer->AddComment("Macro String"); 
+      Asm->emitULEB128( 
+          InfoHolder.getStringPool().getIndexedEntry(*Asm, Str).getIndex()); 
+    } else { 
+      unsigned Type = M.getMacinfoType() == dwarf::DW_MACINFO_define 
+                          ? dwarf::DW_MACRO_GNU_define_indirect 
+                          : dwarf::DW_MACRO_GNU_undef_indirect; 
+      Asm->OutStreamer->AddComment(dwarf::GnuMacroString(Type)); 
+      Asm->emitULEB128(Type); 
+      Asm->OutStreamer->AddComment("Line Number"); 
+      Asm->emitULEB128(M.getLine()); 
+      Asm->OutStreamer->AddComment("Macro String"); 
+      Asm->emitDwarfSymbolReference( 
+          InfoHolder.getStringPool().getEntry(*Asm, Str).getSymbol()); 
+    } 
   } else {
     Asm->OutStreamer->AddComment(dwarf::MacinfoString(M.getMacinfoType()));
     Asm->emitULEB128(M.getMacinfoType());
     Asm->OutStreamer->AddComment("Line Number");
     Asm->emitULEB128(M.getLine());
     Asm->OutStreamer->AddComment("Macro String");
-    Asm->OutStreamer->emitBytes(Str);
+    Asm->OutStreamer->emitBytes(Str); 
     Asm->emitInt8('\0');
   }
 }
 
 void DwarfDebug::emitMacroFileImpl(
-    DIMacroFile &MF, DwarfCompileUnit &U, unsigned StartFile, unsigned EndFile,
+    DIMacroFile &MF, DwarfCompileUnit &U, unsigned StartFile, unsigned EndFile, 
     StringRef (*MacroFormToString)(unsigned Form)) {
 
   Asm->OutStreamer->AddComment(MacroFormToString(StartFile));
   Asm->emitULEB128(StartFile);
   Asm->OutStreamer->AddComment("Line Number");
-  Asm->emitULEB128(MF.getLine());
+  Asm->emitULEB128(MF.getLine()); 
   Asm->OutStreamer->AddComment("File Number");
-  DIFile &F = *MF.getFile();
-  if (useSplitDwarf())
-    Asm->emitULEB128(getDwoLineTable(U)->getFile(
-        F.getDirectory(), F.getFilename(), getMD5AsBytes(&F),
-        Asm->OutContext.getDwarfVersion(), F.getSource()));
-  else
-    Asm->emitULEB128(U.getOrCreateSourceID(&F));
-  handleMacroNodes(MF.getElements(), U);
+  DIFile &F = *MF.getFile(); 
+  if (useSplitDwarf()) 
+    Asm->emitULEB128(getDwoLineTable(U)->getFile( 
+        F.getDirectory(), F.getFilename(), getMD5AsBytes(&F), 
+        Asm->OutContext.getDwarfVersion(), F.getSource())); 
+  else 
+    Asm->emitULEB128(U.getOrCreateSourceID(&F)); 
+  handleMacroNodes(MF.getElements(), U); 
   Asm->OutStreamer->AddComment(MacroFormToString(EndFile));
   Asm->emitULEB128(EndFile);
 }
@@ -3087,10 +3087,10 @@ void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
   // DWARFv5 macro and DWARFv4 macinfo share some common encodings,
   // so for readibility/uniformity, We are explicitly emitting those.
   assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
-  if (UseDebugMacroSection)
-    emitMacroFileImpl(
-        F, U, dwarf::DW_MACRO_start_file, dwarf::DW_MACRO_end_file,
-        (getDwarfVersion() >= 5) ? dwarf::MacroString : dwarf::GnuMacroString);
+  if (UseDebugMacroSection) 
+    emitMacroFileImpl( 
+        F, U, dwarf::DW_MACRO_start_file, dwarf::DW_MACRO_end_file, 
+        (getDwarfVersion() >= 5) ? dwarf::MacroString : dwarf::GnuMacroString); 
   else
     emitMacroFileImpl(F, U, dwarf::DW_MACINFO_start_file,
                       dwarf::DW_MACINFO_end_file, dwarf::MacinfoString);
@@ -3107,8 +3107,8 @@ void DwarfDebug::emitDebugMacinfoImpl(MCSection *Section) {
       continue;
     Asm->OutStreamer->SwitchSection(Section);
     Asm->OutStreamer->emitLabel(U.getMacroLabelBegin());
-    if (UseDebugMacroSection)
-      emitMacroHeader(Asm, *this, U, getDwarfVersion());
+    if (UseDebugMacroSection) 
+      emitMacroHeader(Asm, *this, U, getDwarfVersion()); 
     handleMacroNodes(Macros, U);
     Asm->OutStreamer->AddComment("End Of Macro List Mark");
     Asm->emitInt8(0);
@@ -3118,14 +3118,14 @@ void DwarfDebug::emitDebugMacinfoImpl(MCSection *Section) {
 /// Emit macros into a debug macinfo/macro section.
 void DwarfDebug::emitDebugMacinfo() {
   auto &ObjLower = Asm->getObjFileLowering();
-  emitDebugMacinfoImpl(UseDebugMacroSection
+  emitDebugMacinfoImpl(UseDebugMacroSection 
                            ? ObjLower.getDwarfMacroSection()
                            : ObjLower.getDwarfMacinfoSection());
 }
 
 void DwarfDebug::emitDebugMacinfoDWO() {
   auto &ObjLower = Asm->getObjFileLowering();
-  emitDebugMacinfoImpl(UseDebugMacroSection
+  emitDebugMacinfoImpl(UseDebugMacroSection 
                            ? ObjLower.getDwarfMacroDWOSection()
                            : ObjLower.getDwarfMacinfoDWOSection());
 }
@@ -3212,7 +3212,7 @@ MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
   const DICompileUnit *DIUnit = CU.getCUNode();
   SplitTypeUnitFileTable.maybeSetRootFile(
       DIUnit->getDirectory(), DIUnit->getFilename(),
-      getMD5AsBytes(DIUnit->getFile()), DIUnit->getSource());
+      getMD5AsBytes(DIUnit->getFile()), DIUnit->getSource()); 
   return &SplitTypeUnitFileTable;
 }
 
@@ -3315,14 +3315,14 @@ void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
 
 DwarfDebug::NonTypeUnitContext::NonTypeUnitContext(DwarfDebug *DD)
     : DD(DD),
-      TypeUnitsUnderConstruction(std::move(DD->TypeUnitsUnderConstruction)), AddrPoolUsed(DD->AddrPool.hasBeenUsed()) {
+      TypeUnitsUnderConstruction(std::move(DD->TypeUnitsUnderConstruction)), AddrPoolUsed(DD->AddrPool.hasBeenUsed()) { 
   DD->TypeUnitsUnderConstruction.clear();
-  DD->AddrPool.resetUsedFlag();
+  DD->AddrPool.resetUsedFlag(); 
 }
 
 DwarfDebug::NonTypeUnitContext::~NonTypeUnitContext() {
   DD->TypeUnitsUnderConstruction = std::move(TypeUnitsUnderConstruction);
-  DD->AddrPool.resetUsedFlag(AddrPoolUsed);
+  DD->AddrPool.resetUsedFlag(AddrPoolUsed); 
 }
 
 DwarfDebug::NonTypeUnitContext DwarfDebug::enterNonTypeUnitContext() {
@@ -3387,15 +3387,15 @@ uint16_t DwarfDebug::getDwarfVersion() const {
   return Asm->OutStreamer->getContext().getDwarfVersion();
 }
 
-dwarf::Form DwarfDebug::getDwarfSectionOffsetForm() const {
-  if (Asm->getDwarfVersion() >= 4)
-    return dwarf::Form::DW_FORM_sec_offset;
-  assert((!Asm->isDwarf64() || (Asm->getDwarfVersion() == 3)) &&
-         "DWARF64 is not defined prior DWARFv3");
-  return Asm->isDwarf64() ? dwarf::Form::DW_FORM_data8
-                          : dwarf::Form::DW_FORM_data4;
-}
-
+dwarf::Form DwarfDebug::getDwarfSectionOffsetForm() const { 
+  if (Asm->getDwarfVersion() >= 4) 
+    return dwarf::Form::DW_FORM_sec_offset; 
+  assert((!Asm->isDwarf64() || (Asm->getDwarfVersion() == 3)) && 
+         "DWARF64 is not defined prior DWARFv3"); 
+  return Asm->isDwarf64() ? dwarf::Form::DW_FORM_data8 
+                          : dwarf::Form::DW_FORM_data4; 
+} 
+ 
 const MCSymbol *DwarfDebug::getSectionLabel(const MCSection *S) {
   return SectionLabels.find(S)->second;
 }
@@ -3404,20 +3404,20 @@ void DwarfDebug::insertSectionLabel(const MCSymbol *S) {
     if (useSplitDwarf() || getDwarfVersion() >= 5)
       AddrPool.getIndex(S);
 }
-
-Optional<MD5::MD5Result> DwarfDebug::getMD5AsBytes(const DIFile *File) const {
-  assert(File);
-  if (getDwarfVersion() < 5)
-    return None;
-  Optional<DIFile::ChecksumInfo<StringRef>> Checksum = File->getChecksum();
-  if (!Checksum || Checksum->Kind != DIFile::CSK_MD5)
-    return None;
-
-  // Convert the string checksum to an MD5Result for the streamer.
-  // The verifier validates the checksum so we assume it's okay.
-  // An MD5 checksum is 16 bytes.
-  std::string ChecksumString = fromHex(Checksum->Value);
-  MD5::MD5Result CKMem;
-  std::copy(ChecksumString.begin(), ChecksumString.end(), CKMem.Bytes.data());
-  return CKMem;
-}
+ 
+Optional<MD5::MD5Result> DwarfDebug::getMD5AsBytes(const DIFile *File) const { 
+  assert(File); 
+  if (getDwarfVersion() < 5) 
+    return None; 
+  Optional<DIFile::ChecksumInfo<StringRef>> Checksum = File->getChecksum(); 
+  if (!Checksum || Checksum->Kind != DIFile::CSK_MD5) 
+    return None; 
+ 
+  // Convert the string checksum to an MD5Result for the streamer. 
+  // The verifier validates the checksum so we assume it's okay. 
+  // An MD5 checksum is 16 bytes. 
+  std::string ChecksumString = fromHex(Checksum->Value); 
+  MD5::MD5Result CKMem; 
+  std::copy(ChecksumString.begin(), ChecksumString.end(), CKMem.Bytes.data()); 
+  return CKMem; 
+} 
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfDebug.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfDebug.h
index df19ef4588..a5380addbb 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfDebug.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfDebug.h
@@ -114,7 +114,7 @@ public:
 ///
 /// Variables that have been optimized out use none of these fields.
 class DbgVariable : public DbgEntity {
-  /// Index of the entry list in DebugLocs.
+  /// Index of the entry list in DebugLocs. 
   unsigned DebugLocListIndex = ~0u;
   /// DW_OP_LLVM_tag_offset value from DebugLocs.
   Optional<uint8_t> DebugLocListTagOffset;
@@ -372,23 +372,23 @@ class DwarfDebug : public DebugHandlerBase {
   /// Generate DWARF v4 type units.
   bool GenerateTypeUnits;
 
-  /// Emit a .debug_macro section instead of .debug_macinfo.
-  bool UseDebugMacroSection;
-
-  /// Avoid using DW_OP_convert due to consumer incompatibilities.
-  bool EnableOpConvert;
-
-public:
-  enum class MinimizeAddrInV5 {
-    Default,
-    Disabled,
-    Ranges,
-  };
-
-private:
-  /// Force the use of DW_AT_ranges even for single-entry range lists.
-  MinimizeAddrInV5 MinimizeAddr = MinimizeAddrInV5::Disabled;
-
+  /// Emit a .debug_macro section instead of .debug_macinfo. 
+  bool UseDebugMacroSection; 
+ 
+  /// Avoid using DW_OP_convert due to consumer incompatibilities. 
+  bool EnableOpConvert; 
+ 
+public: 
+  enum class MinimizeAddrInV5 { 
+    Default, 
+    Disabled, 
+    Ranges, 
+  }; 
+ 
+private: 
+  /// Force the use of DW_AT_ranges even for single-entry range lists. 
+  MinimizeAddrInV5 MinimizeAddr = MinimizeAddrInV5::Disabled; 
+ 
   /// DWARF5 Experimental Options
   /// @{
   AccelTableKind TheAccelTableKind;
@@ -426,9 +426,9 @@ private:
   bool SingleCU;
   bool IsDarwin;
 
-  /// Map for tracking Fortran deferred CHARACTER lengths.
-  DenseMap<const DIStringType *, unsigned> StringTypeLocMap;
-
+  /// Map for tracking Fortran deferred CHARACTER lengths. 
+  DenseMap<const DIStringType *, unsigned> StringTypeLocMap; 
+ 
   AddressPool AddrPool;
 
   /// Accelerator tables.
@@ -612,8 +612,8 @@ private:
   /// function that describe the same variable. If the resulting 
   /// list has only one entry that is valid for entire variable's
   /// scope return true.
-  bool buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
-                         const DbgValueHistoryMap::Entries &Entries);
+  bool buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc, 
+                         const DbgValueHistoryMap::Entries &Entries); 
 
   /// Collect variable information from the side table maintained by MF.
   void collectVariableInfoFromMFTable(DwarfCompileUnit &TheCU,
@@ -635,13 +635,13 @@ public:
   //===--------------------------------------------------------------------===//
   // Main entry points.
   //
-  DwarfDebug(AsmPrinter *A);
+  DwarfDebug(AsmPrinter *A); 
 
   ~DwarfDebug() override;
 
   /// Emit all Dwarf sections that should come prior to the
   /// content.
-  void beginModule(Module *M) override;
+  void beginModule(Module *M) override; 
 
   /// Emit all Dwarf sections that should come after the content.
   void endModule() override;
@@ -663,7 +663,7 @@ public:
   class NonTypeUnitContext {
     DwarfDebug *DD;
     decltype(DwarfDebug::TypeUnitsUnderConstruction) TypeUnitsUnderConstruction;
-    bool AddrPoolUsed;
+    bool AddrPoolUsed; 
     friend class DwarfDebug;
     NonTypeUnitContext(DwarfDebug *DD);
   public:
@@ -700,12 +700,12 @@ public:
   /// Returns whether ranges section should be emitted.
   bool useRangesSection() const { return UseRangesSection; }
 
-  /// Returns whether range encodings should be used for single entry range
-  /// lists.
-  bool alwaysUseRanges() const {
-    return MinimizeAddr == MinimizeAddrInV5::Ranges;
-  }
-
+  /// Returns whether range encodings should be used for single entry range 
+  /// lists. 
+  bool alwaysUseRanges() const { 
+    return MinimizeAddr == MinimizeAddrInV5::Ranges; 
+  } 
+ 
   /// Returns whether to use sections as labels rather than temp symbols.
   bool useSectionsAsReferences() const {
     return UseSectionsAsReferences;
@@ -744,21 +744,21 @@ public:
     return EmitDebugEntryValues;
   }
 
-  bool useOpConvert() const {
-    return EnableOpConvert;
-  }
-
+  bool useOpConvert() const { 
+    return EnableOpConvert; 
+  } 
+ 
   bool shareAcrossDWOCUs() const;
 
   /// Returns the Dwarf Version.
   uint16_t getDwarfVersion() const;
 
-  /// Returns a suitable DWARF form to represent a section offset, i.e.
-  /// * DW_FORM_sec_offset for DWARF version >= 4;
-  /// * DW_FORM_data8 for 64-bit DWARFv3;
-  /// * DW_FORM_data4 for 32-bit DWARFv3 and DWARFv2.
-  dwarf::Form getDwarfSectionOffsetForm() const;
-
+  /// Returns a suitable DWARF form to represent a section offset, i.e. 
+  /// * DW_FORM_sec_offset for DWARF version >= 4; 
+  /// * DW_FORM_data8 for 64-bit DWARFv3; 
+  /// * DW_FORM_data4 for 32-bit DWARFv3 and DWARFv2. 
+  dwarf::Form getDwarfSectionOffsetForm() const; 
+ 
   /// Returns the previous CU that was being updated
   const DwarfCompileUnit *getPrevCU() const { return PrevCU; }
   void setPrevCU(const DwarfCompileUnit *PrevCU) { this->PrevCU = PrevCU; }
@@ -803,16 +803,16 @@ public:
     return CUDieMap.lookup(Die);
   }
 
-  unsigned getStringTypeLoc(const DIStringType *ST) const {
-    return StringTypeLocMap.lookup(ST);
-  }
-
-  void addStringTypeLoc(const DIStringType *ST, unsigned Loc) {
-    assert(ST);
-    if (Loc)
-      StringTypeLocMap[ST] = Loc;
-  }
-
+  unsigned getStringTypeLoc(const DIStringType *ST) const { 
+    return StringTypeLocMap.lookup(ST); 
+  } 
+ 
+  void addStringTypeLoc(const DIStringType *ST, unsigned Loc) { 
+    assert(ST); 
+    if (Loc) 
+      StringTypeLocMap[ST] = Loc; 
+  } 
+ 
   /// \defgroup DebuggerTuning Predicates to tune DWARF for a given debugger.
   ///
   /// Returns whether we are "tuning" for a given debugger.
@@ -828,10 +828,10 @@ public:
   static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
                                 const DbgValueLoc &Value,
                                 DwarfExpression &DwarfExpr);
-
-  /// If the \p File has an MD5 checksum, return it as an MD5Result
-  /// allocated in the MCContext.
-  Optional<MD5::MD5Result> getMD5AsBytes(const DIFile *File) const;
+ 
+  /// If the \p File has an MD5 checksum, return it as an MD5Result 
+  /// allocated in the MCContext. 
+  Optional<MD5::MD5Result> getMD5AsBytes(const DIFile *File) const; 
 };
 
 } // end namespace llvm
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfException.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfException.h
index b19b436538..4ff07151ab 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfException.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfException.h
@@ -92,20 +92,20 @@ public:
   /// Gather and emit post-function exception information.
   void endFunction(const MachineFunction *) override;
 };
-
-class LLVM_LIBRARY_VISIBILITY AIXException : public DwarfCFIExceptionBase {
-  /// This is AIX's compat unwind section, which unwinder would use
-  /// to find the location of LSDA area and personality rountine.
-  void emitExceptionInfoTable(const MCSymbol *LSDA, const MCSymbol *PerSym);
-
-public:
-  AIXException(AsmPrinter *A);
-
-  void endModule() override {}
-  void beginFunction(const MachineFunction *MF) override {}
-
-  void endFunction(const MachineFunction *MF) override;
-};
+ 
+class LLVM_LIBRARY_VISIBILITY AIXException : public DwarfCFIExceptionBase { 
+  /// This is AIX's compat unwind section, which unwinder would use 
+  /// to find the location of LSDA area and personality rountine. 
+  void emitExceptionInfoTable(const MCSymbol *LSDA, const MCSymbol *PerSym); 
+ 
+public: 
+  AIXException(AsmPrinter *A); 
+ 
+  void endModule() override {} 
+  void beginFunction(const MachineFunction *MF) override {} 
+ 
+  void endFunction(const MachineFunction *MF) override; 
+}; 
 } // End of namespace llvm
 
 #endif
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfExpression.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfExpression.cpp
index 59ad7646ce..83d4169397 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfExpression.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfExpression.cpp
@@ -17,14 +17,14 @@
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/CodeGen/Register.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
-#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DataLayout.h" 
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 
 using namespace llvm;
 
-#define DEBUG_TYPE "dwarfdebug"
-
+#define DEBUG_TYPE "dwarfdebug" 
+ 
 void DwarfExpression::emitConstu(uint64_t Value) {
   if (Value < 32)
     emitOp(dwarf::DW_OP_lit0 + Value);
@@ -97,8 +97,8 @@ void DwarfExpression::addAnd(unsigned Mask) {
 }
 
 bool DwarfExpression::addMachineReg(const TargetRegisterInfo &TRI,
-                                    llvm::Register MachineReg,
-                                    unsigned MaxSize) {
+                                    llvm::Register MachineReg, 
+                                    unsigned MaxSize) { 
   if (!llvm::Register::isPhysicalRegister(MachineReg)) {
     if (isFrameRegister(TRI, MachineReg)) {
       DwarfRegs.push_back(Register::createRegister(-1, nullptr));
@@ -220,36 +220,36 @@ void DwarfExpression::addUnsignedConstant(const APInt &Value) {
   }
 }
 
-void DwarfExpression::addConstantFP(const APFloat &APF, const AsmPrinter &AP) {
-  assert(isImplicitLocation() || isUnknownLocation());
-  APInt API = APF.bitcastToAPInt();
-  int NumBytes = API.getBitWidth() / 8;
-  if (NumBytes == 4 /*float*/ || NumBytes == 8 /*double*/) {
-    // FIXME: Add support for `long double`.
-    emitOp(dwarf::DW_OP_implicit_value);
-    emitUnsigned(NumBytes /*Size of the block in bytes*/);
-
-    // The loop below is emitting the value starting at least significant byte,
-    // so we need to perform a byte-swap to get the byte order correct in case
-    // of a big-endian target.
-    if (AP.getDataLayout().isBigEndian())
-      API = API.byteSwap();
-
-    for (int i = 0; i < NumBytes; ++i) {
-      emitData1(API.getZExtValue() & 0xFF);
-      API = API.lshr(8);
-    }
-
-    return;
-  }
-  LLVM_DEBUG(
-      dbgs() << "Skipped DW_OP_implicit_value creation for ConstantFP of size: "
-             << API.getBitWidth() << " bits\n");
-}
-
+void DwarfExpression::addConstantFP(const APFloat &APF, const AsmPrinter &AP) { 
+  assert(isImplicitLocation() || isUnknownLocation()); 
+  APInt API = APF.bitcastToAPInt(); 
+  int NumBytes = API.getBitWidth() / 8; 
+  if (NumBytes == 4 /*float*/ || NumBytes == 8 /*double*/) { 
+    // FIXME: Add support for `long double`. 
+    emitOp(dwarf::DW_OP_implicit_value); 
+    emitUnsigned(NumBytes /*Size of the block in bytes*/); 
+ 
+    // The loop below is emitting the value starting at least significant byte, 
+    // so we need to perform a byte-swap to get the byte order correct in case 
+    // of a big-endian target. 
+    if (AP.getDataLayout().isBigEndian()) 
+      API = API.byteSwap(); 
+ 
+    for (int i = 0; i < NumBytes; ++i) { 
+      emitData1(API.getZExtValue() & 0xFF); 
+      API = API.lshr(8); 
+    } 
+ 
+    return; 
+  } 
+  LLVM_DEBUG( 
+      dbgs() << "Skipped DW_OP_implicit_value creation for ConstantFP of size: " 
+             << API.getBitWidth() << " bits\n"); 
+} 
+ 
 bool DwarfExpression::addMachineRegExpression(const TargetRegisterInfo &TRI,
                                               DIExpressionCursor &ExprCursor,
-                                              llvm::Register MachineReg,
+                                              llvm::Register MachineReg, 
                                               unsigned FragmentOffsetInBits) {
   auto Fragment = ExprCursor.getFragmentInfo();
   if (!addMachineReg(TRI, MachineReg, Fragment ? Fragment->SizeInBits : ~1U)) {
@@ -526,7 +526,7 @@ void DwarfExpression::addExpression(DIExpressionCursor &&ExprCursor,
     case dwarf::DW_OP_not:
     case dwarf::DW_OP_dup:
     case dwarf::DW_OP_push_object_address:
-    case dwarf::DW_OP_over:
+    case dwarf::DW_OP_over: 
       emitOp(OpNum);
       break;
     case dwarf::DW_OP_deref:
@@ -542,15 +542,15 @@ void DwarfExpression::addExpression(DIExpressionCursor &&ExprCursor,
       assert(!isRegisterLocation());
       emitConstu(Op->getArg(0));
       break;
-    case dwarf::DW_OP_consts:
-      assert(!isRegisterLocation());
-      emitOp(dwarf::DW_OP_consts);
-      emitSigned(Op->getArg(0));
-      break;
+    case dwarf::DW_OP_consts: 
+      assert(!isRegisterLocation()); 
+      emitOp(dwarf::DW_OP_consts); 
+      emitSigned(Op->getArg(0)); 
+      break; 
     case dwarf::DW_OP_LLVM_convert: {
       unsigned BitSize = Op->getArg(0);
       dwarf::TypeKind Encoding = static_cast<dwarf::TypeKind>(Op->getArg(1));
-      if (DwarfVersion >= 5 && CU.getDwarfDebug().useOpConvert()) {
+      if (DwarfVersion >= 5 && CU.getDwarfDebug().useOpConvert()) { 
         emitOp(dwarf::DW_OP_convert);
         // If targeting a location-list; simply emit the index into the raw
         // byte stream as ULEB128, DwarfDebug::emitDebugLocEntry has been
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfExpression.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfExpression.h
index 8fca9f5a63..6d73207168 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfExpression.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfExpression.h
@@ -218,7 +218,7 @@ protected:
   /// Return whether the given machine register is the frame register in the
   /// current function.
   virtual bool isFrameRegister(const TargetRegisterInfo &TRI,
-                               llvm::Register MachineReg) = 0;
+                               llvm::Register MachineReg) = 0; 
 
   /// Emit a DW_OP_reg operation. Note that this is only legal inside a DWARF
   /// register location description.
@@ -245,7 +245,7 @@ protected:
   /// multiple subregisters that alias the register.
   ///
   /// \return false if no DWARF register exists for MachineReg.
-  bool addMachineReg(const TargetRegisterInfo &TRI, llvm::Register MachineReg,
+  bool addMachineReg(const TargetRegisterInfo &TRI, llvm::Register MachineReg, 
                      unsigned MaxSize = ~1U);
 
   /// Emit a DW_OP_piece or DW_OP_bit_piece operation for a variable fragment.
@@ -299,9 +299,9 @@ public:
   /// Emit an unsigned constant.
   void addUnsignedConstant(const APInt &Value);
 
-  /// Emit an floating point constant.
-  void addConstantFP(const APFloat &Value, const AsmPrinter &AP);
-
+  /// Emit an floating point constant. 
+  void addConstantFP(const APFloat &Value, const AsmPrinter &AP); 
+ 
   /// Lock this down to become a memory location description.
   void setMemoryLocationKind() {
     assert(isUnknownLocation());
@@ -325,8 +325,8 @@ public:
   /// \return                         false if no DWARF register exists
   ///                                 for MachineReg.
   bool addMachineRegExpression(const TargetRegisterInfo &TRI,
-                               DIExpressionCursor &Expr,
-                               llvm::Register MachineReg,
+                               DIExpressionCursor &Expr, 
+                               llvm::Register MachineReg, 
                                unsigned FragmentOffsetInBits = 0);
 
   /// Begin emission of an entry value dwarf operation. The entry value's
@@ -389,7 +389,7 @@ class DebugLocDwarfExpression final : public DwarfExpression {
   void commitTemporaryBuffer() override;
 
   bool isFrameRegister(const TargetRegisterInfo &TRI,
-                       llvm::Register MachineReg) override;
+                       llvm::Register MachineReg) override; 
 
 public:
   DebugLocDwarfExpression(unsigned DwarfVersion, BufferByteStreamer &BS,
@@ -419,7 +419,7 @@ class DIEDwarfExpression final : public DwarfExpression {
   void commitTemporaryBuffer() override;
 
   bool isFrameRegister(const TargetRegisterInfo &TRI,
-                       llvm::Register MachineReg) override;
+                       llvm::Register MachineReg) override; 
 
 public:
   DIEDwarfExpression(const AsmPrinter &AP, DwarfCompileUnit &CU, DIELoc &DIE);
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfFile.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfFile.cpp
index 838e1c9a10..b21ac54386 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfFile.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfFile.cpp
@@ -12,7 +12,7 @@
 #include "DwarfUnit.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/IR/DebugInfoMetadata.h"
-#include "llvm/IR/Metadata.h"
+#include "llvm/IR/Metadata.h" 
 #include "llvm/MC/MCStreamer.h"
 #include <algorithm>
 #include <cstdint>
@@ -58,7 +58,7 @@ void DwarfFile::emitUnit(DwarfUnit *TheU, bool UseOffsets) {
 // Compute the size and offset for each DIE.
 void DwarfFile::computeSizeAndOffsets() {
   // Offset from the first CU in the debug info section is 0 initially.
-  uint64_t SecOffset = 0;
+  uint64_t SecOffset = 0; 
 
   // Iterate over each compile unit and set the size and offsets for each
   // DIE within each compile unit. All offsets are CU relative.
@@ -74,15 +74,15 @@ void DwarfFile::computeSizeAndOffsets() {
     TheU->setDebugSectionOffset(SecOffset);
     SecOffset += computeSizeAndOffsetsForUnit(TheU.get());
   }
-  if (SecOffset > UINT32_MAX && !Asm->isDwarf64())
-    report_fatal_error("The generated debug information is too large "
-                       "for the 32-bit DWARF format.");
+  if (SecOffset > UINT32_MAX && !Asm->isDwarf64()) 
+    report_fatal_error("The generated debug information is too large " 
+                       "for the 32-bit DWARF format."); 
 }
 
 unsigned DwarfFile::computeSizeAndOffsetsForUnit(DwarfUnit *TheU) {
   // CU-relative offset is reset to 0 here.
-  unsigned Offset = Asm->getUnitLengthFieldByteSize() + // Length of Unit Info
-                    TheU->getHeaderSize();              // Unit-specific headers
+  unsigned Offset = Asm->getUnitLengthFieldByteSize() + // Length of Unit Info 
+                    TheU->getHeaderSize();              // Unit-specific headers 
 
   // The return value here is CU-relative, after laying out
   // all of the CU DIE.
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfFile.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfFile.h
index 79a6ce7801..4120e4d668 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfFile.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfFile.h
@@ -25,12 +25,12 @@ class AsmPrinter;
 class DbgEntity;
 class DbgVariable;
 class DbgLabel;
-class DINode;
+class DINode; 
 class DwarfCompileUnit;
 class DwarfUnit;
 class LexicalScope;
 class MCSection;
-class MDNode;
+class MDNode; 
 
 // Data structure to hold a range for range lists.
 struct RangeSpan {
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp
index a876f8ccac..899fdade48 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp
@@ -56,13 +56,13 @@ void DwarfStringPool::emitStringOffsetsTableHeader(AsmPrinter &Asm,
   if (getNumIndexedStrings() == 0)
     return;
   Asm.OutStreamer->SwitchSection(Section);
-  unsigned EntrySize = Asm.getDwarfOffsetByteSize();
+  unsigned EntrySize = Asm.getDwarfOffsetByteSize(); 
   // We are emitting the header for a contribution to the string offsets
   // table. The header consists of an entry with the contribution's
   // size (not including the size of the length field), the DWARF version and
   // 2 bytes of padding.
-  Asm.emitDwarfUnitLength(getNumIndexedStrings() * EntrySize + 4,
-                          "Length of String Offsets Set");
+  Asm.emitDwarfUnitLength(getNumIndexedStrings() * EntrySize + 4, 
+                          "Length of String Offsets Set"); 
   Asm.emitInt16(Asm.getDwarfVersion());
   Asm.emitInt16(0);
   // Define the symbol that marks the start of the contribution. It is
@@ -118,7 +118,7 @@ void DwarfStringPool::emit(AsmPrinter &Asm, MCSection *StrSection,
     }
 
     Asm.OutStreamer->SwitchSection(OffsetSection);
-    unsigned size = Asm.getDwarfOffsetByteSize();
+    unsigned size = Asm.getDwarfOffsetByteSize(); 
     for (const auto &Entry : Entries)
       if (UseRelativeOffsets)
         Asm.emitDwarfStringOffset(Entry->getValue());
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfStringPool.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfStringPool.h
index 79b5df89e3..0759123d0d 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfStringPool.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfStringPool.h
@@ -28,7 +28,7 @@ class DwarfStringPool {
 
   StringMap<EntryTy, BumpPtrAllocator &> Pool;
   StringRef Prefix;
-  uint64_t NumBytes = 0;
+  uint64_t NumBytes = 0; 
   unsigned NumIndexedStrings = 0;
   bool ShouldCreateSymbols;
 
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
index 118b5fcc3b..61f2eafa87 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
@@ -83,14 +83,14 @@ unsigned DIEDwarfExpression::getTemporaryBufferSize() {
 void DIEDwarfExpression::commitTemporaryBuffer() { OutDIE.takeValues(TmpDIE); }
 
 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
-                                         llvm::Register MachineReg) {
+                                         llvm::Register MachineReg) { 
   return MachineReg == TRI.getFrameRegister(*AP.MF);
 }
 
 DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node,
                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
-    : DIEUnit(UnitTag), CUNode(Node), Asm(A), DD(DW), DU(DWU),
-      IndexTyDie(nullptr) {}
+    : DIEUnit(UnitTag), CUNode(Node), Asm(A), DD(DW), DU(DWU), 
+      IndexTyDie(nullptr) {} 
 
 DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
                              DwarfDebug *DW, DwarfFile *DWU,
@@ -299,7 +299,7 @@ void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
 
 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
                                  uint64_t Integer) {
-  addUInt(Die, Attribute, DD->getDwarfSectionOffsetForm(), Integer);
+  addUInt(Die, Attribute, DD->getDwarfSectionOffsetForm(), Integer); 
 }
 
 unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
@@ -310,9 +310,9 @@ unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
     // This is a split type unit that needs a line table.
     addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
   }
-  return SplitLineTable->getFile(
-      File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File),
-      Asm->OutContext.getDwarfVersion(), File->getSource());
+  return SplitLineTable->getFile( 
+      File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File), 
+      Asm->OutContext.getDwarfVersion(), File->getSource()); 
 }
 
 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
@@ -330,7 +330,7 @@ void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
   }
 
   addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
-  addLabel(Die, dwarf::DW_FORM_addr, Sym);
+  addLabel(Die, dwarf::DW_FORM_addr, Sym); 
 }
 
 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
@@ -445,7 +445,7 @@ void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty) {
-  addConstantValue(Die, DD->isUnsignedDIType(Ty), Val);
+  addConstantValue(Die, DD->isUnsignedDIType(Ty), Val); 
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
@@ -456,7 +456,7 @@ void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
-  addConstantValue(Die, Val, DD->isUnsignedDIType(Ty));
+  addConstantValue(Die, Val, DD->isUnsignedDIType(Ty)); 
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
@@ -553,8 +553,8 @@ DIE *DwarfUnit::createTypeDIE(const DIScope *Context, DIE &ContextDIE,
 
   if (auto *BT = dyn_cast<DIBasicType>(Ty))
     constructTypeDIE(TyDIE, BT);
-  else if (auto *ST = dyn_cast<DIStringType>(Ty))
-    constructTypeDIE(TyDIE, ST);
+  else if (auto *ST = dyn_cast<DIStringType>(Ty)) 
+    constructTypeDIE(TyDIE, ST); 
   else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
     constructTypeDIE(TyDIE, STy);
   else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
@@ -673,9 +673,9 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
   if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
     return;
 
-  if (BTy->getTag() != dwarf::DW_TAG_string_type)
-    addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
-            BTy->getEncoding());
+  if (BTy->getTag() != dwarf::DW_TAG_string_type) 
+    addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 
+            BTy->getEncoding()); 
 
   uint64_t Size = BTy->getSizeInBits() >> 3;
   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
@@ -686,37 +686,37 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
     addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_little);
 }
 
-void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIStringType *STy) {
-  // Get core information.
-  StringRef Name = STy->getName();
-  // Add name if not anonymous or intermediate type.
-  if (!Name.empty())
-    addString(Buffer, dwarf::DW_AT_name, Name);
-
-  if (DIVariable *Var = STy->getStringLength()) {
-    if (auto *VarDIE = getDIE(Var))
-      addDIEEntry(Buffer, dwarf::DW_AT_string_length, *VarDIE);
-  } else if (DIExpression *Expr = STy->getStringLengthExp()) {
-    DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
-    // This is to describe the memory location of the
-    // length of a Fortran deferred length string, so
-    // lock it down as such.
-    DwarfExpr.setMemoryLocationKind();
-    DwarfExpr.addExpression(Expr);
-    addBlock(Buffer, dwarf::DW_AT_string_length, DwarfExpr.finalize());
-  } else {
-    uint64_t Size = STy->getSizeInBits() >> 3;
-    addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
-  }
-
-  if (STy->getEncoding()) {
-    // For eventual Unicode support.
-    addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
-            STy->getEncoding());
-  }
-}
-
+void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIStringType *STy) { 
+  // Get core information. 
+  StringRef Name = STy->getName(); 
+  // Add name if not anonymous or intermediate type. 
+  if (!Name.empty()) 
+    addString(Buffer, dwarf::DW_AT_name, Name); 
+ 
+  if (DIVariable *Var = STy->getStringLength()) { 
+    if (auto *VarDIE = getDIE(Var)) 
+      addDIEEntry(Buffer, dwarf::DW_AT_string_length, *VarDIE); 
+  } else if (DIExpression *Expr = STy->getStringLengthExp()) { 
+    DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); 
+    // This is to describe the memory location of the 
+    // length of a Fortran deferred length string, so 
+    // lock it down as such. 
+    DwarfExpr.setMemoryLocationKind(); 
+    DwarfExpr.addExpression(Expr); 
+    addBlock(Buffer, dwarf::DW_AT_string_length, DwarfExpr.finalize()); 
+  } else { 
+    uint64_t Size = STy->getSizeInBits() >> 3; 
+    addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 
+  } 
+ 
+  if (STy->getEncoding()) { 
+    // For eventual Unicode support. 
+    addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 
+            STy->getEncoding()); 
+  } 
+} 
+ 
 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
   // Get core information.
   StringRef Name = DTy->getName();
@@ -843,11 +843,11 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
       }
     }
 
-    // Add template parameters to a class, structure or union types.
-    if (Tag == dwarf::DW_TAG_class_type ||
-        Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
-      addTemplateParams(Buffer, CTy->getTemplateParams());
-
+    // Add template parameters to a class, structure or union types. 
+    if (Tag == dwarf::DW_TAG_class_type || 
+        Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) 
+      addTemplateParams(Buffer, CTy->getTemplateParams()); 
+ 
     // Add elements to structure type.
     DINodeArray Elements = CTy->getElements();
     for (const auto *Element : Elements) {
@@ -867,7 +867,7 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
           DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
           if (const ConstantInt *CI =
               dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
-            if (DD->isUnsignedDIType(Discriminator->getBaseType()))
+            if (DD->isUnsignedDIType(Discriminator->getBaseType())) 
               addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue());
             else
               addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue());
@@ -940,10 +940,10 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
       Tag == dwarf::DW_TAG_union_type) {
     // Add size if non-zero (derived types might be zero-sized.)
-    // Ignore the size if it's a non-enum forward decl.
+    // Ignore the size if it's a non-enum forward decl. 
     // TODO: Do we care about size for enum forward declarations?
-    if (Size &&
-        (!CTy->isForwardDecl() || Tag == dwarf::DW_TAG_enumeration_type))
+    if (Size && 
+        (!CTy->isForwardDecl() || Tag == dwarf::DW_TAG_enumeration_type)) 
       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
     else if (!CTy->isForwardDecl())
       // Add zero size if it is not a forward declaration.
@@ -1067,8 +1067,8 @@ DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
             getOrCreateSourceID(M->getFile()));
   if (M->getLineNo())
     addUInt(MDie, dwarf::DW_AT_decl_line, None, M->getLineNo());
-  if (M->getIsDecl())
-    addFlag(MDie, dwarf::DW_AT_declaration);
+  if (M->getIsDecl()) 
+    addFlag(MDie, dwarf::DW_AT_declaration); 
 
   return &MDie;
 }
@@ -1290,7 +1290,7 @@ void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
   if (auto *CI = SR->getCount().dyn_cast<ConstantInt*>())
     Count = CI->getSExtValue();
 
-  auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
+  auto AddBoundTypeEntry = [&](dwarf::Attribute Attr, 
                                DISubrange::BoundType Bound) -> void {
     if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
       if (auto *VarDIE = getDIE(BV))
@@ -1308,7 +1308,7 @@ void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
     }
   };
 
-  AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->getLowerBound());
+  AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->getLowerBound()); 
 
   if (auto *CV = SR->getCount().dyn_cast<DIVariable*>()) {
     if (auto *CountVarDIE = getDIE(CV))
@@ -1316,47 +1316,47 @@ void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
   } else if (Count != -1)
     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
 
-  AddBoundTypeEntry(dwarf::DW_AT_upper_bound, SR->getUpperBound());
-
-  AddBoundTypeEntry(dwarf::DW_AT_byte_stride, SR->getStride());
-}
-
-void DwarfUnit::constructGenericSubrangeDIE(DIE &Buffer,
-                                            const DIGenericSubrange *GSR,
-                                            DIE *IndexTy) {
-  DIE &DwGenericSubrange =
-      createAndAddDIE(dwarf::DW_TAG_generic_subrange, Buffer);
-  addDIEEntry(DwGenericSubrange, dwarf::DW_AT_type, *IndexTy);
-
-  int64_t DefaultLowerBound = getDefaultLowerBound();
-
-  auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
-                               DIGenericSubrange::BoundType Bound) -> void {
-    if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
-      if (auto *VarDIE = getDIE(BV))
-        addDIEEntry(DwGenericSubrange, Attr, *VarDIE);
-    } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) {
-      if (BE->isSignedConstant()) {
-        if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
-            static_cast<int64_t>(BE->getElement(1)) != DefaultLowerBound)
-          addSInt(DwGenericSubrange, Attr, dwarf::DW_FORM_sdata,
-                  BE->getElement(1));
-      } else {
-        DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-        DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
-        DwarfExpr.setMemoryLocationKind();
-        DwarfExpr.addExpression(BE);
-        addBlock(DwGenericSubrange, Attr, DwarfExpr.finalize());
-      }
-    }
-  };
-
-  AddBoundTypeEntry(dwarf::DW_AT_lower_bound, GSR->getLowerBound());
-  AddBoundTypeEntry(dwarf::DW_AT_count, GSR->getCount());
-  AddBoundTypeEntry(dwarf::DW_AT_upper_bound, GSR->getUpperBound());
-  AddBoundTypeEntry(dwarf::DW_AT_byte_stride, GSR->getStride());
-}
-
+  AddBoundTypeEntry(dwarf::DW_AT_upper_bound, SR->getUpperBound()); 
+
+  AddBoundTypeEntry(dwarf::DW_AT_byte_stride, SR->getStride()); 
+}
+
+void DwarfUnit::constructGenericSubrangeDIE(DIE &Buffer, 
+                                            const DIGenericSubrange *GSR, 
+                                            DIE *IndexTy) { 
+  DIE &DwGenericSubrange = 
+      createAndAddDIE(dwarf::DW_TAG_generic_subrange, Buffer); 
+  addDIEEntry(DwGenericSubrange, dwarf::DW_AT_type, *IndexTy); 
+ 
+  int64_t DefaultLowerBound = getDefaultLowerBound(); 
+ 
+  auto AddBoundTypeEntry = [&](dwarf::Attribute Attr, 
+                               DIGenericSubrange::BoundType Bound) -> void { 
+    if (auto *BV = Bound.dyn_cast<DIVariable *>()) { 
+      if (auto *VarDIE = getDIE(BV)) 
+        addDIEEntry(DwGenericSubrange, Attr, *VarDIE); 
+    } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) { 
+      if (BE->isSignedConstant()) { 
+        if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 || 
+            static_cast<int64_t>(BE->getElement(1)) != DefaultLowerBound) 
+          addSInt(DwGenericSubrange, Attr, dwarf::DW_FORM_sdata, 
+                  BE->getElement(1)); 
+      } else { 
+        DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+        DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); 
+        DwarfExpr.setMemoryLocationKind(); 
+        DwarfExpr.addExpression(BE); 
+        addBlock(DwGenericSubrange, Attr, DwarfExpr.finalize()); 
+      } 
+    } 
+  }; 
+ 
+  AddBoundTypeEntry(dwarf::DW_AT_lower_bound, GSR->getLowerBound()); 
+  AddBoundTypeEntry(dwarf::DW_AT_count, GSR->getCount()); 
+  AddBoundTypeEntry(dwarf::DW_AT_upper_bound, GSR->getUpperBound()); 
+  AddBoundTypeEntry(dwarf::DW_AT_byte_stride, GSR->getStride()); 
+} 
+ 
 DIE *DwarfUnit::getIndexTyDie() {
   if (IndexTyDie)
     return IndexTyDie;
@@ -1419,39 +1419,39 @@ void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
     addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize());
   }
 
-  if (DIVariable *Var = CTy->getAssociated()) {
-    if (auto *VarDIE = getDIE(Var))
-      addDIEEntry(Buffer, dwarf::DW_AT_associated, *VarDIE);
-  } else if (DIExpression *Expr = CTy->getAssociatedExp()) {
-    DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
-    DwarfExpr.setMemoryLocationKind();
-    DwarfExpr.addExpression(Expr);
-    addBlock(Buffer, dwarf::DW_AT_associated, DwarfExpr.finalize());
-  }
-
-  if (DIVariable *Var = CTy->getAllocated()) {
-    if (auto *VarDIE = getDIE(Var))
-      addDIEEntry(Buffer, dwarf::DW_AT_allocated, *VarDIE);
-  } else if (DIExpression *Expr = CTy->getAllocatedExp()) {
-    DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
-    DwarfExpr.setMemoryLocationKind();
-    DwarfExpr.addExpression(Expr);
-    addBlock(Buffer, dwarf::DW_AT_allocated, DwarfExpr.finalize());
-  }
-
-  if (auto *RankConst = CTy->getRankConst()) {
-    addSInt(Buffer, dwarf::DW_AT_rank, dwarf::DW_FORM_sdata,
-            RankConst->getSExtValue());
-  } else if (auto *RankExpr = CTy->getRankExp()) {
-    DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
-    DwarfExpr.setMemoryLocationKind();
-    DwarfExpr.addExpression(RankExpr);
-    addBlock(Buffer, dwarf::DW_AT_rank, DwarfExpr.finalize());
-  }
-
+  if (DIVariable *Var = CTy->getAssociated()) { 
+    if (auto *VarDIE = getDIE(Var)) 
+      addDIEEntry(Buffer, dwarf::DW_AT_associated, *VarDIE); 
+  } else if (DIExpression *Expr = CTy->getAssociatedExp()) { 
+    DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); 
+    DwarfExpr.setMemoryLocationKind(); 
+    DwarfExpr.addExpression(Expr); 
+    addBlock(Buffer, dwarf::DW_AT_associated, DwarfExpr.finalize()); 
+  } 
+ 
+  if (DIVariable *Var = CTy->getAllocated()) { 
+    if (auto *VarDIE = getDIE(Var)) 
+      addDIEEntry(Buffer, dwarf::DW_AT_allocated, *VarDIE); 
+  } else if (DIExpression *Expr = CTy->getAllocatedExp()) { 
+    DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); 
+    DwarfExpr.setMemoryLocationKind(); 
+    DwarfExpr.addExpression(Expr); 
+    addBlock(Buffer, dwarf::DW_AT_allocated, DwarfExpr.finalize()); 
+  } 
+ 
+  if (auto *RankConst = CTy->getRankConst()) { 
+    addSInt(Buffer, dwarf::DW_AT_rank, dwarf::DW_FORM_sdata, 
+            RankConst->getSExtValue()); 
+  } else if (auto *RankExpr = CTy->getRankExp()) { 
+    DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); 
+    DwarfExpr.setMemoryLocationKind(); 
+    DwarfExpr.addExpression(RankExpr); 
+    addBlock(Buffer, dwarf::DW_AT_rank, DwarfExpr.finalize()); 
+  } 
+ 
   // Emit the element type.
   addType(Buffer, CTy->getBaseType());
 
@@ -1464,19 +1464,19 @@ void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
   DINodeArray Elements = CTy->getElements();
   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
     // FIXME: Should this really be such a loose cast?
-    if (auto *Element = dyn_cast_or_null<DINode>(Elements[i])) {
+    if (auto *Element = dyn_cast_or_null<DINode>(Elements[i])) { 
       if (Element->getTag() == dwarf::DW_TAG_subrange_type)
         constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
-      else if (Element->getTag() == dwarf::DW_TAG_generic_subrange)
-        constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element),
-                                    IdxTy);
-    }
+      else if (Element->getTag() == dwarf::DW_TAG_generic_subrange) 
+        constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element), 
+                                    IdxTy); 
+    } 
   }
 }
 
 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
   const DIType *DTy = CTy->getBaseType();
-  bool IsUnsigned = DTy && DD->isUnsignedDIType(DTy);
+  bool IsUnsigned = DTy && DD->isUnsignedDIType(DTy); 
   if (DTy) {
     if (DD->getDwarfVersion() >= 3)
       addType(Buffer, DTy);
@@ -1679,11 +1679,11 @@ void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) {
     StringRef Prefix = isDwoUnit() ? "debug_info_dwo_" : "debug_info_";
     MCSymbol *BeginLabel = Asm->createTempSymbol(Prefix + "start");
     EndLabel = Asm->createTempSymbol(Prefix + "end");
-    Asm->emitDwarfUnitLength(EndLabel, BeginLabel, "Length of Unit");
+    Asm->emitDwarfUnitLength(EndLabel, BeginLabel, "Length of Unit"); 
     Asm->OutStreamer->emitLabel(BeginLabel);
   } else
-    Asm->emitDwarfUnitLength(getHeaderSize() + getUnitDie().getSize(),
-                             "Length of Unit");
+    Asm->emitDwarfUnitLength(getHeaderSize() + getUnitDie().getSize(), 
+                             "Length of Unit"); 
 
   Asm->OutStreamer->AddComment("DWARF version number");
   unsigned Version = DD->getDwarfVersion();
@@ -1703,7 +1703,7 @@ void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) {
   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
   if (UseOffsets)
-    Asm->emitDwarfLengthOrOffset(0);
+    Asm->emitDwarfLengthOrOffset(0); 
   else
     Asm->emitDwarfSymbolReference(
         TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
@@ -1722,14 +1722,14 @@ void DwarfTypeUnit::emitHeader(bool UseOffsets) {
   Asm->OutStreamer->emitIntValue(TypeSignature, sizeof(TypeSignature));
   Asm->OutStreamer->AddComment("Type DIE Offset");
   // In a skeleton type unit there is no type DIE so emit a zero offset.
-  Asm->emitDwarfLengthOrOffset(Ty ? Ty->getOffset() : 0);
+  Asm->emitDwarfLengthOrOffset(Ty ? Ty->getOffset() : 0); 
 }
 
 DIE::value_iterator
 DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
                            const MCSymbol *Hi, const MCSymbol *Lo) {
   return Die.addValue(DIEValueAllocator, Attribute,
-                      DD->getDwarfSectionOffsetForm(),
+                      DD->getDwarfSectionOffsetForm(), 
                       new (DIEValueAllocator) DIEDelta(Hi, Lo));
 }
 
@@ -1737,7 +1737,7 @@ DIE::value_iterator
 DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
                            const MCSymbol *Label, const MCSymbol *Sec) {
   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
-    return addLabel(Die, Attribute, DD->getDwarfSectionOffsetForm(), Label);
+    return addLabel(Die, Attribute, DD->getDwarfSectionOffsetForm(), Label); 
   return addSectionDelta(Die, Attribute, Label, Sec);
 }
 
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.h
index 5c643760fd..13c60ed220 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.h
@@ -18,17 +18,17 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/DIE.h"
-#include <string>
+#include <string> 
 
 namespace llvm {
 
-class ConstantFP;
+class ConstantFP; 
 class ConstantInt;
 class DbgVariable;
 class DwarfCompileUnit;
-class MachineOperand;
-class MCDwarfDwoLineTable;
-class MCSymbol;
+class MachineOperand; 
+class MCDwarfDwoLineTable; 
+class MCSymbol; 
 
 //===----------------------------------------------------------------------===//
 /// This dwarf writer support class manages information associated with a
@@ -82,7 +82,7 @@ public:
   MCSymbol *getEndLabel() const { return EndLabel; }
   uint16_t getLanguage() const { return CUNode->getSourceLanguage(); }
   const DICompileUnit *getCUNode() const { return CUNode; }
-  DwarfDebug &getDwarfDebug() const { return *DD; }
+  DwarfDebug &getDwarfDebug() const { return *DD; } 
 
   /// Return true if this compile unit has something to write out.
   bool hasContent() const { return getUnitDie().hasChildren(); }
@@ -248,9 +248,9 @@ public:
   /// Compute the size of a header for this unit, not including the initial
   /// length field.
   virtual unsigned getHeaderSize() const {
-    return sizeof(int16_t) +               // DWARF version number
-           Asm->getDwarfOffsetByteSize() + // Offset Into Abbrev. Section
-           sizeof(int8_t) +                // Pointer Size (in bytes)
+    return sizeof(int16_t) +               // DWARF version number 
+           Asm->getDwarfOffsetByteSize() + // Offset Into Abbrev. Section 
+           sizeof(int8_t) +                // Pointer Size (in bytes) 
            (DD->getDwarfVersion() >= 5 ? sizeof(int8_t)
                                        : 0); // DWARF v5 unit type
   }
@@ -295,12 +295,12 @@ protected:
 
 private:
   void constructTypeDIE(DIE &Buffer, const DIBasicType *BTy);
-  void constructTypeDIE(DIE &Buffer, const DIStringType *BTy);
+  void constructTypeDIE(DIE &Buffer, const DIStringType *BTy); 
   void constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy);
   void constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy);
   void constructSubrangeDIE(DIE &Buffer, const DISubrange *SR, DIE *IndexTy);
-  void constructGenericSubrangeDIE(DIE &Buffer, const DIGenericSubrange *SR,
-                                   DIE *IndexTy);
+  void constructGenericSubrangeDIE(DIE &Buffer, const DIGenericSubrange *SR, 
+                                   DIE *IndexTy); 
   void constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy);
   void constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy);
   DIE &constructMemberDIE(DIE &Buffer, const DIDerivedType *DT);
@@ -353,7 +353,7 @@ public:
   void emitHeader(bool UseOffsets) override;
   unsigned getHeaderSize() const override {
     return DwarfUnit::getHeaderSize() + sizeof(uint64_t) + // Type Signature
-           Asm->getDwarfOffsetByteSize();                  // Type DIE Offset
+           Asm->getDwarfOffsetByteSize();                  // Type DIE Offset 
   }
   void addGlobalName(StringRef Name, const DIE &Die,
                      const DIScope *Context) override;
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/EHStreamer.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/EHStreamer.cpp
index 2ffe8a7b04..76b737c3d4 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/EHStreamer.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/EHStreamer.cpp
@@ -44,9 +44,9 @@ EHStreamer::~EHStreamer() = default;
 unsigned EHStreamer::sharedTypeIDs(const LandingPadInfo *L,
                                    const LandingPadInfo *R) {
   const std::vector<int> &LIds = L->TypeIds, &RIds = R->TypeIds;
-  return std::mismatch(LIds.begin(), LIds.end(), RIds.begin(), RIds.end())
-             .first -
-         LIds.begin();
+  return std::mismatch(LIds.begin(), LIds.end(), RIds.begin(), RIds.end()) 
+             .first - 
+         LIds.begin(); 
 }
 
 /// Compute the actions table and gather the first action index for each landing
@@ -214,30 +214,30 @@ void EHStreamer::computePadMap(
 /// the landing pad and the action.  Calls marked 'nounwind' have no entry and
 /// must not be contained in the try-range of any entry - they form gaps in the
 /// table.  Entries must be ordered by try-range address.
-///
-/// Call-sites are split into one or more call-site ranges associated with
-/// different sections of the function.
-///
-///   - Without -basic-block-sections, all call-sites are grouped into one
-///     call-site-range corresponding to the function section.
-///
-///   - With -basic-block-sections, one call-site range is created for each
-///     section, with its FragmentBeginLabel and FragmentEndLabel respectively
-//      set to the beginning and ending of the corresponding section and its
-//      ExceptionLabel set to the exception symbol dedicated for this section.
-//      Later, one LSDA header will be emitted for each call-site range with its
-//      call-sites following. The action table and type info table will be
-//      shared across all ranges.
-void EHStreamer::computeCallSiteTable(
-    SmallVectorImpl<CallSiteEntry> &CallSites,
-    SmallVectorImpl<CallSiteRange> &CallSiteRanges,
-    const SmallVectorImpl<const LandingPadInfo *> &LandingPads,
-    const SmallVectorImpl<unsigned> &FirstActions) {
+/// 
+/// Call-sites are split into one or more call-site ranges associated with 
+/// different sections of the function. 
+/// 
+///   - Without -basic-block-sections, all call-sites are grouped into one 
+///     call-site-range corresponding to the function section. 
+/// 
+///   - With -basic-block-sections, one call-site range is created for each 
+///     section, with its FragmentBeginLabel and FragmentEndLabel respectively 
+//      set to the beginning and ending of the corresponding section and its 
+//      ExceptionLabel set to the exception symbol dedicated for this section. 
+//      Later, one LSDA header will be emitted for each call-site range with its 
+//      call-sites following. The action table and type info table will be 
+//      shared across all ranges. 
+void EHStreamer::computeCallSiteTable( 
+    SmallVectorImpl<CallSiteEntry> &CallSites, 
+    SmallVectorImpl<CallSiteRange> &CallSiteRanges, 
+    const SmallVectorImpl<const LandingPadInfo *> &LandingPads, 
+    const SmallVectorImpl<unsigned> &FirstActions) { 
   RangeMapType PadMap;
   computePadMap(LandingPads, PadMap);
 
   // The end label of the previous invoke or nounwind try-range.
-  MCSymbol *LastLabel = Asm->getFunctionBegin();
+  MCSymbol *LastLabel = Asm->getFunctionBegin(); 
 
   // Whether there is a potentially throwing instruction (currently this means
   // an ordinary call) between the end of the previous try-range and now.
@@ -250,21 +250,21 @@ void EHStreamer::computeCallSiteTable(
 
   // Visit all instructions in order of address.
   for (const auto &MBB : *Asm->MF) {
-    if (&MBB == &Asm->MF->front() || MBB.isBeginSection()) {
-      // We start a call-site range upon function entry and at the beginning of
-      // every basic block section.
-      CallSiteRanges.push_back(
-          {Asm->MBBSectionRanges[MBB.getSectionIDNum()].BeginLabel,
-           Asm->MBBSectionRanges[MBB.getSectionIDNum()].EndLabel,
-           Asm->getMBBExceptionSym(MBB), CallSites.size()});
-      PreviousIsInvoke = false;
-      SawPotentiallyThrowing = false;
-      LastLabel = nullptr;
-    }
-
-    if (MBB.isEHPad())
-      CallSiteRanges.back().IsLPRange = true;
-
+    if (&MBB == &Asm->MF->front() || MBB.isBeginSection()) { 
+      // We start a call-site range upon function entry and at the beginning of 
+      // every basic block section. 
+      CallSiteRanges.push_back( 
+          {Asm->MBBSectionRanges[MBB.getSectionIDNum()].BeginLabel, 
+           Asm->MBBSectionRanges[MBB.getSectionIDNum()].EndLabel, 
+           Asm->getMBBExceptionSym(MBB), CallSites.size()}); 
+      PreviousIsInvoke = false; 
+      SawPotentiallyThrowing = false; 
+      LastLabel = nullptr; 
+    } 
+ 
+    if (MBB.isEHPad()) 
+      CallSiteRanges.back().IsLPRange = true; 
+ 
     for (const auto &MI : MBB) {
       if (!MI.isEHLabel()) {
         if (MI.isCall())
@@ -288,14 +288,14 @@ void EHStreamer::computeCallSiteTable(
       assert(BeginLabel == LandingPad->BeginLabels[P.RangeIndex] &&
              "Inconsistent landing pad map!");
 
-      // For Dwarf and AIX exception handling (SjLj handling doesn't use this).
-      // If some instruction between the previous try-range and this one may
-      // throw, create a call-site entry with no landing pad for the region
-      // between the try-ranges.
-      if (SawPotentiallyThrowing &&
-          (Asm->MAI->usesCFIForEH() ||
-           Asm->MAI->getExceptionHandlingType() == ExceptionHandling::AIX)) {
-        CallSites.push_back({LastLabel, BeginLabel, nullptr, 0});
+      // For Dwarf and AIX exception handling (SjLj handling doesn't use this). 
+      // If some instruction between the previous try-range and this one may 
+      // throw, create a call-site entry with no landing pad for the region 
+      // between the try-ranges. 
+      if (SawPotentiallyThrowing && 
+          (Asm->MAI->usesCFIForEH() || 
+           Asm->MAI->getExceptionHandlingType() == ExceptionHandling::AIX)) { 
+        CallSites.push_back({LastLabel, BeginLabel, nullptr, 0}); 
         PreviousIsInvoke = false;
       }
 
@@ -339,20 +339,20 @@ void EHStreamer::computeCallSiteTable(
       }
     }
 
-    // We end the call-site range upon function exit and at the end of every
-    // basic block section.
-    if (&MBB == &Asm->MF->back() || MBB.isEndSection()) {
-      // If some instruction between the previous try-range and the end of the
-      // function may throw, create a call-site entry with no landing pad for
-      // the region following the try-range.
-      if (SawPotentiallyThrowing && !IsSJLJ) {
-        CallSiteEntry Site = {LastLabel, CallSiteRanges.back().FragmentEndLabel,
-                              nullptr, 0};
-        CallSites.push_back(Site);
-        SawPotentiallyThrowing = false;
-      }
-      CallSiteRanges.back().CallSiteEndIdx = CallSites.size();
-    }
+    // We end the call-site range upon function exit and at the end of every 
+    // basic block section. 
+    if (&MBB == &Asm->MF->back() || MBB.isEndSection()) { 
+      // If some instruction between the previous try-range and the end of the 
+      // function may throw, create a call-site entry with no landing pad for 
+      // the region following the try-range. 
+      if (SawPotentiallyThrowing && !IsSJLJ) { 
+        CallSiteEntry Site = {LastLabel, CallSiteRanges.back().FragmentEndLabel, 
+                              nullptr, 0}; 
+        CallSites.push_back(Site); 
+        SawPotentiallyThrowing = false; 
+      } 
+      CallSiteRanges.back().CallSiteEndIdx = CallSites.size(); 
+    } 
   }
 }
 
@@ -403,25 +403,25 @@ MCSymbol *EHStreamer::emitExceptionTable() {
   SmallVector<unsigned, 64> FirstActions;
   computeActionsTable(LandingPads, Actions, FirstActions);
 
-  // Compute the call-site table and call-site ranges. Normally, there is only
-  // one call-site-range which covers the whole funciton. With
-  // -basic-block-sections, there is one call-site-range per basic block
-  // section.
+  // Compute the call-site table and call-site ranges. Normally, there is only 
+  // one call-site-range which covers the whole funciton. With 
+  // -basic-block-sections, there is one call-site-range per basic block 
+  // section. 
   SmallVector<CallSiteEntry, 64> CallSites;
-  SmallVector<CallSiteRange, 4> CallSiteRanges;
-  computeCallSiteTable(CallSites, CallSiteRanges, LandingPads, FirstActions);
+  SmallVector<CallSiteRange, 4> CallSiteRanges; 
+  computeCallSiteTable(CallSites, CallSiteRanges, LandingPads, FirstActions); 
 
   bool IsSJLJ = Asm->MAI->getExceptionHandlingType() == ExceptionHandling::SjLj;
   bool IsWasm = Asm->MAI->getExceptionHandlingType() == ExceptionHandling::Wasm;
-  bool HasLEB128Directives = Asm->MAI->hasLEB128Directives();
+  bool HasLEB128Directives = Asm->MAI->hasLEB128Directives(); 
   unsigned CallSiteEncoding =
       IsSJLJ ? static_cast<unsigned>(dwarf::DW_EH_PE_udata4) :
                Asm->getObjFileLowering().getCallSiteEncoding();
   bool HaveTTData = !TypeInfos.empty() || !FilterIds.empty();
 
   // Type infos.
-  MCSection *LSDASection =
-      Asm->getObjFileLowering().getSectionForLSDA(MF->getFunction(), Asm->TM);
+  MCSection *LSDASection = 
+      Asm->getObjFileLowering().getSectionForLSDA(MF->getFunction(), Asm->TM); 
   unsigned TTypeEncoding;
 
   if (!HaveTTData) {
@@ -471,122 +471,122 @@ MCSymbol *EHStreamer::emitExceptionTable() {
     Asm->OutContext.getOrCreateSymbol(Twine("GCC_except_table")+
                                       Twine(Asm->getFunctionNumber()));
   Asm->OutStreamer->emitLabel(GCCETSym);
-  MCSymbol *CstEndLabel = Asm->createTempSymbol(
-      CallSiteRanges.size() > 1 ? "action_table_base" : "cst_end");
+  MCSymbol *CstEndLabel = Asm->createTempSymbol( 
+      CallSiteRanges.size() > 1 ? "action_table_base" : "cst_end"); 
 
   MCSymbol *TTBaseLabel = nullptr;
-  if (HaveTTData)
+  if (HaveTTData) 
     TTBaseLabel = Asm->createTempSymbol("ttbase");
 
-  const bool VerboseAsm = Asm->OutStreamer->isVerboseAsm();
-
-  // Helper for emitting references (offsets) for type table and the end of the
-  // call-site table (which marks the beginning of the action table).
-  //  * For Itanium, these references will be emitted for every callsite range.
-  //  * For SJLJ and Wasm, they will be emitted only once in the LSDA header.
-  auto EmitTypeTableRefAndCallSiteTableEndRef = [&]() {
-    Asm->emitEncodingByte(TTypeEncoding, "@TType");
-    if (HaveTTData) {
-      // N.B.: There is a dependency loop between the size of the TTBase uleb128
-      // here and the amount of padding before the aligned type table. The
-      // assembler must sometimes pad this uleb128 or insert extra padding
-      // before the type table. See PR35809 or GNU as bug 4029.
-      MCSymbol *TTBaseRefLabel = Asm->createTempSymbol("ttbaseref");
-      Asm->emitLabelDifferenceAsULEB128(TTBaseLabel, TTBaseRefLabel);
-      Asm->OutStreamer->emitLabel(TTBaseRefLabel);
-    }
-
-    // The Action table follows the call-site table. So we emit the
-    // label difference from here (start of the call-site table for SJLJ and
-    // Wasm, and start of a call-site range for Itanium) to the end of the
-    // whole call-site table (end of the last call-site range for Itanium).
-    MCSymbol *CstBeginLabel = Asm->createTempSymbol("cst_begin");
-    Asm->emitEncodingByte(CallSiteEncoding, "Call site");
-    Asm->emitLabelDifferenceAsULEB128(CstEndLabel, CstBeginLabel);
-    Asm->OutStreamer->emitLabel(CstBeginLabel);
-  };
-
-  // An alternative path to EmitTypeTableRefAndCallSiteTableEndRef.
-  // For some platforms, the system assembler does not accept the form of
-  // `.uleb128 label2 - label1`. In those situations, we would need to calculate
-  // the size between label1 and label2 manually.
-  // In this case, we would need to calculate the LSDA size and the call
-  // site table size.
-  auto EmitTypeTableOffsetAndCallSiteTableOffset = [&]() {
-    assert(CallSiteEncoding == dwarf::DW_EH_PE_udata4 && !HasLEB128Directives &&
-           "Targets supporting .uleb128 do not need to take this path.");
-    if (CallSiteRanges.size() > 1)
-      report_fatal_error(
-          "-fbasic-block-sections is not yet supported on "
-          "platforms that do not have general LEB128 directive support.");
-
-    uint64_t CallSiteTableSize = 0;
-    const CallSiteRange &CSRange = CallSiteRanges.back();
-    for (size_t CallSiteIdx = CSRange.CallSiteBeginIdx;
-         CallSiteIdx < CSRange.CallSiteEndIdx; ++CallSiteIdx) {
-      const CallSiteEntry &S = CallSites[CallSiteIdx];
-      // Each call site entry consists of 3 udata4 fields (12 bytes) and
-      // 1 ULEB128 field.
-      CallSiteTableSize += 12 + getULEB128Size(S.Action);
-      assert(isUInt<32>(CallSiteTableSize) && "CallSiteTableSize overflows.");
-    }
-
-    Asm->emitEncodingByte(TTypeEncoding, "@TType");
-    if (HaveTTData) {
-      const unsigned ByteSizeOfCallSiteOffset =
-          getULEB128Size(CallSiteTableSize);
-      uint64_t ActionTableSize = 0;
-      for (const ActionEntry &Action : Actions) {
-        // Each action entry consists of two SLEB128 fields.
-        ActionTableSize += getSLEB128Size(Action.ValueForTypeID) +
-                           getSLEB128Size(Action.NextAction);
-        assert(isUInt<32>(ActionTableSize) && "ActionTableSize overflows.");
-      }
-
-      const unsigned TypeInfoSize =
-          Asm->GetSizeOfEncodedValue(TTypeEncoding) * MF->getTypeInfos().size();
-
-      const uint64_t LSDASizeBeforeAlign =
-          1                          // Call site encoding byte.
-          + ByteSizeOfCallSiteOffset // ULEB128 encoding of CallSiteTableSize.
-          + CallSiteTableSize        // Call site table content.
-          + ActionTableSize;         // Action table content.
-
-      const uint64_t LSDASizeWithoutAlign = LSDASizeBeforeAlign + TypeInfoSize;
-      const unsigned ByteSizeOfLSDAWithoutAlign =
-          getULEB128Size(LSDASizeWithoutAlign);
-      const uint64_t DisplacementBeforeAlign =
-          2 // LPStartEncoding and TypeTableEncoding.
-          + ByteSizeOfLSDAWithoutAlign + LSDASizeBeforeAlign;
-
-      // The type info area starts with 4 byte alignment.
-      const unsigned NeedAlignVal = (4 - DisplacementBeforeAlign % 4) % 4;
-      uint64_t LSDASizeWithAlign = LSDASizeWithoutAlign + NeedAlignVal;
-      const unsigned ByteSizeOfLSDAWithAlign =
-          getULEB128Size(LSDASizeWithAlign);
-
-      // The LSDASizeWithAlign could use 1 byte less padding for alignment
-      // when the data we use to represent the LSDA Size "needs" to be 1 byte
-      // larger than the one previously calculated without alignment.
-      if (ByteSizeOfLSDAWithAlign > ByteSizeOfLSDAWithoutAlign)
-        LSDASizeWithAlign -= 1;
-
-      Asm->OutStreamer->emitULEB128IntValue(LSDASizeWithAlign,
-                                            ByteSizeOfLSDAWithAlign);
-    }
-
-    Asm->emitEncodingByte(CallSiteEncoding, "Call site");
-    Asm->OutStreamer->emitULEB128IntValue(CallSiteTableSize);
-  };
-
+  const bool VerboseAsm = Asm->OutStreamer->isVerboseAsm(); 
+
+  // Helper for emitting references (offsets) for type table and the end of the 
+  // call-site table (which marks the beginning of the action table). 
+  //  * For Itanium, these references will be emitted for every callsite range. 
+  //  * For SJLJ and Wasm, they will be emitted only once in the LSDA header. 
+  auto EmitTypeTableRefAndCallSiteTableEndRef = [&]() { 
+    Asm->emitEncodingByte(TTypeEncoding, "@TType"); 
+    if (HaveTTData) { 
+      // N.B.: There is a dependency loop between the size of the TTBase uleb128 
+      // here and the amount of padding before the aligned type table. The 
+      // assembler must sometimes pad this uleb128 or insert extra padding 
+      // before the type table. See PR35809 or GNU as bug 4029. 
+      MCSymbol *TTBaseRefLabel = Asm->createTempSymbol("ttbaseref"); 
+      Asm->emitLabelDifferenceAsULEB128(TTBaseLabel, TTBaseRefLabel); 
+      Asm->OutStreamer->emitLabel(TTBaseRefLabel); 
+    } 
+
+    // The Action table follows the call-site table. So we emit the 
+    // label difference from here (start of the call-site table for SJLJ and 
+    // Wasm, and start of a call-site range for Itanium) to the end of the 
+    // whole call-site table (end of the last call-site range for Itanium). 
+    MCSymbol *CstBeginLabel = Asm->createTempSymbol("cst_begin"); 
+    Asm->emitEncodingByte(CallSiteEncoding, "Call site"); 
+    Asm->emitLabelDifferenceAsULEB128(CstEndLabel, CstBeginLabel); 
+    Asm->OutStreamer->emitLabel(CstBeginLabel); 
+  }; 
+ 
+  // An alternative path to EmitTypeTableRefAndCallSiteTableEndRef. 
+  // For some platforms, the system assembler does not accept the form of 
+  // `.uleb128 label2 - label1`. In those situations, we would need to calculate 
+  // the size between label1 and label2 manually. 
+  // In this case, we would need to calculate the LSDA size and the call 
+  // site table size. 
+  auto EmitTypeTableOffsetAndCallSiteTableOffset = [&]() { 
+    assert(CallSiteEncoding == dwarf::DW_EH_PE_udata4 && !HasLEB128Directives && 
+           "Targets supporting .uleb128 do not need to take this path."); 
+    if (CallSiteRanges.size() > 1) 
+      report_fatal_error( 
+          "-fbasic-block-sections is not yet supported on " 
+          "platforms that do not have general LEB128 directive support."); 
+ 
+    uint64_t CallSiteTableSize = 0; 
+    const CallSiteRange &CSRange = CallSiteRanges.back(); 
+    for (size_t CallSiteIdx = CSRange.CallSiteBeginIdx; 
+         CallSiteIdx < CSRange.CallSiteEndIdx; ++CallSiteIdx) { 
+      const CallSiteEntry &S = CallSites[CallSiteIdx]; 
+      // Each call site entry consists of 3 udata4 fields (12 bytes) and 
+      // 1 ULEB128 field. 
+      CallSiteTableSize += 12 + getULEB128Size(S.Action); 
+      assert(isUInt<32>(CallSiteTableSize) && "CallSiteTableSize overflows."); 
+    } 
+ 
+    Asm->emitEncodingByte(TTypeEncoding, "@TType"); 
+    if (HaveTTData) { 
+      const unsigned ByteSizeOfCallSiteOffset = 
+          getULEB128Size(CallSiteTableSize); 
+      uint64_t ActionTableSize = 0; 
+      for (const ActionEntry &Action : Actions) { 
+        // Each action entry consists of two SLEB128 fields. 
+        ActionTableSize += getSLEB128Size(Action.ValueForTypeID) + 
+                           getSLEB128Size(Action.NextAction); 
+        assert(isUInt<32>(ActionTableSize) && "ActionTableSize overflows."); 
+      } 
+ 
+      const unsigned TypeInfoSize = 
+          Asm->GetSizeOfEncodedValue(TTypeEncoding) * MF->getTypeInfos().size(); 
+ 
+      const uint64_t LSDASizeBeforeAlign = 
+          1                          // Call site encoding byte. 
+          + ByteSizeOfCallSiteOffset // ULEB128 encoding of CallSiteTableSize. 
+          + CallSiteTableSize        // Call site table content. 
+          + ActionTableSize;         // Action table content. 
+ 
+      const uint64_t LSDASizeWithoutAlign = LSDASizeBeforeAlign + TypeInfoSize; 
+      const unsigned ByteSizeOfLSDAWithoutAlign = 
+          getULEB128Size(LSDASizeWithoutAlign); 
+      const uint64_t DisplacementBeforeAlign = 
+          2 // LPStartEncoding and TypeTableEncoding. 
+          + ByteSizeOfLSDAWithoutAlign + LSDASizeBeforeAlign; 
+ 
+      // The type info area starts with 4 byte alignment. 
+      const unsigned NeedAlignVal = (4 - DisplacementBeforeAlign % 4) % 4; 
+      uint64_t LSDASizeWithAlign = LSDASizeWithoutAlign + NeedAlignVal; 
+      const unsigned ByteSizeOfLSDAWithAlign = 
+          getULEB128Size(LSDASizeWithAlign); 
+ 
+      // The LSDASizeWithAlign could use 1 byte less padding for alignment 
+      // when the data we use to represent the LSDA Size "needs" to be 1 byte 
+      // larger than the one previously calculated without alignment. 
+      if (ByteSizeOfLSDAWithAlign > ByteSizeOfLSDAWithoutAlign) 
+        LSDASizeWithAlign -= 1; 
+ 
+      Asm->OutStreamer->emitULEB128IntValue(LSDASizeWithAlign, 
+                                            ByteSizeOfLSDAWithAlign); 
+    } 
+ 
+    Asm->emitEncodingByte(CallSiteEncoding, "Call site"); 
+    Asm->OutStreamer->emitULEB128IntValue(CallSiteTableSize); 
+  }; 
+ 
   // SjLj / Wasm Exception handling
   if (IsSJLJ || IsWasm) {
-    Asm->OutStreamer->emitLabel(Asm->getMBBExceptionSym(Asm->MF->front()));
-
-    // emit the LSDA header.
-    Asm->emitEncodingByte(dwarf::DW_EH_PE_omit, "@LPStart");
-    EmitTypeTableRefAndCallSiteTableEndRef();
-
+    Asm->OutStreamer->emitLabel(Asm->getMBBExceptionSym(Asm->MF->front())); 
+ 
+    // emit the LSDA header. 
+    Asm->emitEncodingByte(dwarf::DW_EH_PE_omit, "@LPStart"); 
+    EmitTypeTableRefAndCallSiteTableEndRef(); 
+ 
     unsigned idx = 0;
     for (SmallVectorImpl<CallSiteEntry>::const_iterator
          I = CallSites.begin(), E = CallSites.end(); I != E; ++I, ++idx) {
@@ -611,7 +611,7 @@ MCSymbol *EHStreamer::emitExceptionTable() {
       }
       Asm->emitULEB128(S.Action);
     }
-    Asm->OutStreamer->emitLabel(CstEndLabel);
+    Asm->OutStreamer->emitLabel(CstEndLabel); 
   } else {
     // Itanium LSDA exception handling
 
@@ -633,126 +633,126 @@ MCSymbol *EHStreamer::emitExceptionTable() {
     // A missing entry in the call-site table indicates that a call is not
     // supposed to throw.
 
-    assert(CallSiteRanges.size() != 0 && "No call-site ranges!");
-
-    // There should be only one call-site range which includes all the landing
-    // pads. Find that call-site range here.
-    const CallSiteRange *LandingPadRange = nullptr;
-    for (const CallSiteRange &CSRange : CallSiteRanges) {
-      if (CSRange.IsLPRange) {
-        assert(LandingPadRange == nullptr &&
-               "All landing pads must be in a single callsite range.");
-        LandingPadRange = &CSRange;
-      }
-    }
-
-    // The call-site table is split into its call-site ranges, each being
-    // emitted as:
-    //              [ LPStartEncoding | LPStart ]
-    //              [ TypeTableEncoding | TypeTableOffset ]
-    //              [ CallSiteEncoding | CallSiteTableEndOffset ]
-    // cst_begin -> { call-site entries contained in this range }
-    //
-    // and is followed by the next call-site range.
-    //
-    // For each call-site range, CallSiteTableEndOffset is computed as the
-    // difference between cst_begin of that range and the last call-site-table's
-    // end label. This offset is used to find the action table.
-
+    assert(CallSiteRanges.size() != 0 && "No call-site ranges!"); 
+ 
+    // There should be only one call-site range which includes all the landing 
+    // pads. Find that call-site range here. 
+    const CallSiteRange *LandingPadRange = nullptr; 
+    for (const CallSiteRange &CSRange : CallSiteRanges) { 
+      if (CSRange.IsLPRange) { 
+        assert(LandingPadRange == nullptr && 
+               "All landing pads must be in a single callsite range."); 
+        LandingPadRange = &CSRange; 
+      } 
+    } 
+ 
+    // The call-site table is split into its call-site ranges, each being 
+    // emitted as: 
+    //              [ LPStartEncoding | LPStart ] 
+    //              [ TypeTableEncoding | TypeTableOffset ] 
+    //              [ CallSiteEncoding | CallSiteTableEndOffset ] 
+    // cst_begin -> { call-site entries contained in this range } 
+    // 
+    // and is followed by the next call-site range. 
+    // 
+    // For each call-site range, CallSiteTableEndOffset is computed as the 
+    // difference between cst_begin of that range and the last call-site-table's 
+    // end label. This offset is used to find the action table. 
+ 
     unsigned Entry = 0;
-    for (const CallSiteRange &CSRange : CallSiteRanges) {
-      if (CSRange.CallSiteBeginIdx != 0) {
-        // Align the call-site range for all ranges except the first. The
-        // first range is already aligned due to the exception table alignment.
-        Asm->emitAlignment(Align(4));
-      }
-      Asm->OutStreamer->emitLabel(CSRange.ExceptionLabel);
-
-      // Emit the LSDA header.
-      // If only one call-site range exists, LPStart is omitted as it is the
-      // same as the function entry.
-      if (CallSiteRanges.size() == 1) {
-        Asm->emitEncodingByte(dwarf::DW_EH_PE_omit, "@LPStart");
-      } else if (!Asm->isPositionIndependent()) {
-        // For more than one call-site ranges, LPStart must be explicitly
-        // specified.
-        // For non-PIC we can simply use the absolute value.
-        Asm->emitEncodingByte(dwarf::DW_EH_PE_absptr, "@LPStart");
-        Asm->OutStreamer->emitSymbolValue(LandingPadRange->FragmentBeginLabel,
-                                          Asm->MAI->getCodePointerSize());
-      } else {
-        // For PIC mode, we Emit a PC-relative address for LPStart.
-        Asm->emitEncodingByte(dwarf::DW_EH_PE_pcrel, "@LPStart");
-        MCContext &Context = Asm->OutStreamer->getContext();
-        MCSymbol *Dot = Context.createTempSymbol();
-        Asm->OutStreamer->emitLabel(Dot);
-        Asm->OutStreamer->emitValue(
-            MCBinaryExpr::createSub(
-                MCSymbolRefExpr::create(LandingPadRange->FragmentBeginLabel,
-                                        Context),
-                MCSymbolRefExpr::create(Dot, Context), Context),
-            Asm->MAI->getCodePointerSize());
-      }
-
-      if (HasLEB128Directives)
-        EmitTypeTableRefAndCallSiteTableEndRef();
-      else
-        EmitTypeTableOffsetAndCallSiteTableOffset();
-
-      for (size_t CallSiteIdx = CSRange.CallSiteBeginIdx;
-           CallSiteIdx != CSRange.CallSiteEndIdx; ++CallSiteIdx) {
-        const CallSiteEntry &S = CallSites[CallSiteIdx];
-
-        MCSymbol *EHFuncBeginSym = CSRange.FragmentBeginLabel;
-        MCSymbol *EHFuncEndSym = CSRange.FragmentEndLabel;
-
-        MCSymbol *BeginLabel = S.BeginLabel;
-        if (!BeginLabel)
-          BeginLabel = EHFuncBeginSym;
-        MCSymbol *EndLabel = S.EndLabel;
-        if (!EndLabel)
-          EndLabel = EHFuncEndSym;
-
-        // Offset of the call site relative to the start of the procedure.
+    for (const CallSiteRange &CSRange : CallSiteRanges) { 
+      if (CSRange.CallSiteBeginIdx != 0) { 
+        // Align the call-site range for all ranges except the first. The 
+        // first range is already aligned due to the exception table alignment. 
+        Asm->emitAlignment(Align(4)); 
+      } 
+      Asm->OutStreamer->emitLabel(CSRange.ExceptionLabel); 
+
+      // Emit the LSDA header. 
+      // If only one call-site range exists, LPStart is omitted as it is the 
+      // same as the function entry. 
+      if (CallSiteRanges.size() == 1) { 
+        Asm->emitEncodingByte(dwarf::DW_EH_PE_omit, "@LPStart"); 
+      } else if (!Asm->isPositionIndependent()) { 
+        // For more than one call-site ranges, LPStart must be explicitly 
+        // specified. 
+        // For non-PIC we can simply use the absolute value. 
+        Asm->emitEncodingByte(dwarf::DW_EH_PE_absptr, "@LPStart"); 
+        Asm->OutStreamer->emitSymbolValue(LandingPadRange->FragmentBeginLabel, 
+                                          Asm->MAI->getCodePointerSize()); 
+      } else { 
+        // For PIC mode, we Emit a PC-relative address for LPStart. 
+        Asm->emitEncodingByte(dwarf::DW_EH_PE_pcrel, "@LPStart"); 
+        MCContext &Context = Asm->OutStreamer->getContext(); 
+        MCSymbol *Dot = Context.createTempSymbol(); 
+        Asm->OutStreamer->emitLabel(Dot); 
+        Asm->OutStreamer->emitValue( 
+            MCBinaryExpr::createSub( 
+                MCSymbolRefExpr::create(LandingPadRange->FragmentBeginLabel, 
+                                        Context), 
+                MCSymbolRefExpr::create(Dot, Context), Context), 
+            Asm->MAI->getCodePointerSize()); 
+      } 
+
+      if (HasLEB128Directives) 
+        EmitTypeTableRefAndCallSiteTableEndRef(); 
+      else 
+        EmitTypeTableOffsetAndCallSiteTableOffset(); 
+
+      for (size_t CallSiteIdx = CSRange.CallSiteBeginIdx; 
+           CallSiteIdx != CSRange.CallSiteEndIdx; ++CallSiteIdx) { 
+        const CallSiteEntry &S = CallSites[CallSiteIdx]; 
+
+        MCSymbol *EHFuncBeginSym = CSRange.FragmentBeginLabel; 
+        MCSymbol *EHFuncEndSym = CSRange.FragmentEndLabel; 
+ 
+        MCSymbol *BeginLabel = S.BeginLabel; 
+        if (!BeginLabel) 
+          BeginLabel = EHFuncBeginSym; 
+        MCSymbol *EndLabel = S.EndLabel; 
+        if (!EndLabel) 
+          EndLabel = EHFuncEndSym; 
+ 
+        // Offset of the call site relative to the start of the procedure. 
         if (VerboseAsm)
-          Asm->OutStreamer->AddComment(">> Call Site " + Twine(++Entry) +
-                                       " <<");
-        Asm->emitCallSiteOffset(BeginLabel, EHFuncBeginSym, CallSiteEncoding);
+          Asm->OutStreamer->AddComment(">> Call Site " + Twine(++Entry) + 
+                                       " <<"); 
+        Asm->emitCallSiteOffset(BeginLabel, EHFuncBeginSym, CallSiteEncoding); 
         if (VerboseAsm)
-          Asm->OutStreamer->AddComment(Twine("  Call between ") +
-                                       BeginLabel->getName() + " and " +
-                                       EndLabel->getName());
-        Asm->emitCallSiteOffset(EndLabel, BeginLabel, CallSiteEncoding);
-
-        // Offset of the landing pad relative to the start of the landing pad
-        // fragment.
-        if (!S.LPad) {
-          if (VerboseAsm)
-            Asm->OutStreamer->AddComment("    has no landing pad");
-          Asm->emitCallSiteValue(0, CallSiteEncoding);
-        } else {
-          if (VerboseAsm)
-            Asm->OutStreamer->AddComment(Twine("    jumps to ") +
-                                         S.LPad->LandingPadLabel->getName());
-          Asm->emitCallSiteOffset(S.LPad->LandingPadLabel,
-                                  LandingPadRange->FragmentBeginLabel,
-                                  CallSiteEncoding);
-        }
-
-        // Offset of the first associated action record, relative to the start
-        // of the action table. This value is biased by 1 (1 indicates the start
-        // of the action table), and 0 indicates that there are no actions.
-        if (VerboseAsm) {
-          if (S.Action == 0)
-            Asm->OutStreamer->AddComment("  On action: cleanup");
-          else
-            Asm->OutStreamer->AddComment("  On action: " +
-                                         Twine((S.Action - 1) / 2 + 1));
-        }
-        Asm->emitULEB128(S.Action);
+          Asm->OutStreamer->AddComment(Twine("  Call between ") + 
+                                       BeginLabel->getName() + " and " + 
+                                       EndLabel->getName()); 
+        Asm->emitCallSiteOffset(EndLabel, BeginLabel, CallSiteEncoding); 
+
+        // Offset of the landing pad relative to the start of the landing pad 
+        // fragment. 
+        if (!S.LPad) { 
+          if (VerboseAsm) 
+            Asm->OutStreamer->AddComment("    has no landing pad"); 
+          Asm->emitCallSiteValue(0, CallSiteEncoding); 
+        } else { 
+          if (VerboseAsm) 
+            Asm->OutStreamer->AddComment(Twine("    jumps to ") + 
+                                         S.LPad->LandingPadLabel->getName()); 
+          Asm->emitCallSiteOffset(S.LPad->LandingPadLabel, 
+                                  LandingPadRange->FragmentBeginLabel, 
+                                  CallSiteEncoding); 
+        } 
+ 
+        // Offset of the first associated action record, relative to the start 
+        // of the action table. This value is biased by 1 (1 indicates the start 
+        // of the action table), and 0 indicates that there are no actions. 
+        if (VerboseAsm) { 
+          if (S.Action == 0) 
+            Asm->OutStreamer->AddComment("  On action: cleanup"); 
+          else 
+            Asm->OutStreamer->AddComment("  On action: " + 
+                                         Twine((S.Action - 1) / 2 + 1)); 
+        } 
+        Asm->emitULEB128(S.Action); 
       }
     }
-    Asm->OutStreamer->emitLabel(CstEndLabel);
+    Asm->OutStreamer->emitLabel(CstEndLabel); 
   }
 
   // Emit the Action Table.
@@ -784,11 +784,11 @@ MCSymbol *EHStreamer::emitExceptionTable() {
 
     // Action Record
     if (VerboseAsm) {
-      if (Action.Previous == unsigned(-1)) {
+      if (Action.Previous == unsigned(-1)) { 
         Asm->OutStreamer->AddComment("  No further actions");
       } else {
-        Asm->OutStreamer->AddComment("  Continue to action " +
-                                     Twine(Action.Previous + 1));
+        Asm->OutStreamer->AddComment("  Continue to action " + 
+                                     Twine(Action.Previous + 1)); 
       }
     }
     Asm->emitSLEB128(Action.NextAction);
@@ -808,7 +808,7 @@ void EHStreamer::emitTypeInfos(unsigned TTypeEncoding, MCSymbol *TTBaseLabel) {
   const std::vector<const GlobalValue *> &TypeInfos = MF->getTypeInfos();
   const std::vector<unsigned> &FilterIds = MF->getFilterIds();
 
-  const bool VerboseAsm = Asm->OutStreamer->isVerboseAsm();
+  const bool VerboseAsm = Asm->OutStreamer->isVerboseAsm(); 
 
   int Entry = 0;
   // Emit the Catch TypeInfos.
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/EHStreamer.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/EHStreamer.h
index 234e62506a..5f9f6d3381 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/EHStreamer.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/EHStreamer.h
@@ -69,48 +69,48 @@ protected:
     unsigned Action;
   };
 
-  /// Structure describing a contiguous range of call-sites which reside
-  /// in the same procedure fragment. With -fbasic-block-sections, there will
-  /// be one call site range per basic block section. Otherwise, we will have
-  /// one call site range containing all the call sites in the function.
-  struct CallSiteRange {
-    // Symbol marking the beginning of the precedure fragment.
-    MCSymbol *FragmentBeginLabel = nullptr;
-    // Symbol marking the end of the procedure fragment.
-    MCSymbol *FragmentEndLabel = nullptr;
-    // LSDA symbol for this call-site range.
-    MCSymbol *ExceptionLabel = nullptr;
-    // Index of the first call-site entry in the call-site table which
-    // belongs to this range.
-    size_t CallSiteBeginIdx = 0;
-    // Index just after the last call-site entry in the call-site table which
-    // belongs to this range.
-    size_t CallSiteEndIdx = 0;
-    // Whether this is the call-site range containing all the landing pads.
-    bool IsLPRange = false;
-  };
-
+  /// Structure describing a contiguous range of call-sites which reside 
+  /// in the same procedure fragment. With -fbasic-block-sections, there will 
+  /// be one call site range per basic block section. Otherwise, we will have 
+  /// one call site range containing all the call sites in the function. 
+  struct CallSiteRange { 
+    // Symbol marking the beginning of the precedure fragment. 
+    MCSymbol *FragmentBeginLabel = nullptr; 
+    // Symbol marking the end of the procedure fragment. 
+    MCSymbol *FragmentEndLabel = nullptr; 
+    // LSDA symbol for this call-site range. 
+    MCSymbol *ExceptionLabel = nullptr; 
+    // Index of the first call-site entry in the call-site table which 
+    // belongs to this range. 
+    size_t CallSiteBeginIdx = 0; 
+    // Index just after the last call-site entry in the call-site table which 
+    // belongs to this range. 
+    size_t CallSiteEndIdx = 0; 
+    // Whether this is the call-site range containing all the landing pads. 
+    bool IsLPRange = false; 
+  }; 
+ 
   /// Compute the actions table and gather the first action index for each
   /// landing pad site.
-  void computeActionsTable(
-      const SmallVectorImpl<const LandingPadInfo *> &LandingPads,
-      SmallVectorImpl<ActionEntry> &Actions,
-      SmallVectorImpl<unsigned> &FirstActions);
+  void computeActionsTable( 
+      const SmallVectorImpl<const LandingPadInfo *> &LandingPads, 
+      SmallVectorImpl<ActionEntry> &Actions, 
+      SmallVectorImpl<unsigned> &FirstActions); 
 
   void computePadMap(const SmallVectorImpl<const LandingPadInfo *> &LandingPads,
                      RangeMapType &PadMap);
 
-  /// Compute the call-site table and the call-site ranges. The entry for an
-  /// invoke has a try-range containing the call, a non-zero landing pad and an
-  /// appropriate action. The entry for an ordinary call has a try-range
-  /// containing the call and zero for the landing pad and the action.  Calls
-  /// marked 'nounwind' have no entry and must not be contained in the try-range
-  /// of any entry - they form gaps in the table.  Entries must be ordered by
-  /// try-range address. CallSiteRanges vector is only populated for Itanium
-  /// exception handling.
+  /// Compute the call-site table and the call-site ranges. The entry for an 
+  /// invoke has a try-range containing the call, a non-zero landing pad and an 
+  /// appropriate action. The entry for an ordinary call has a try-range 
+  /// containing the call and zero for the landing pad and the action.  Calls 
+  /// marked 'nounwind' have no entry and must not be contained in the try-range 
+  /// of any entry - they form gaps in the table.  Entries must be ordered by 
+  /// try-range address. CallSiteRanges vector is only populated for Itanium 
+  /// exception handling. 
   virtual void computeCallSiteTable(
       SmallVectorImpl<CallSiteEntry> &CallSites,
-      SmallVectorImpl<CallSiteRange> &CallSiteRanges,
+      SmallVectorImpl<CallSiteRange> &CallSiteRanges, 
       const SmallVectorImpl<const LandingPadInfo *> &LandingPads,
       const SmallVectorImpl<unsigned> &FirstActions);
 
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp
index 354b638b47..b31268b896 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp
@@ -145,10 +145,10 @@ void OcamlGCMetadataPrinter::finishAssembly(Module &M, GCModuleInfo &Info,
       report_fatal_error("Function '" + FI.getFunction().getName() +
                          "' is too large for the ocaml GC! "
                          "Frame size " +
-                         Twine(FrameSize) +
-                         ">= 65536.\n"
-                         "(" +
-                         Twine(reinterpret_cast<uintptr_t>(&FI)) + ")");
+                         Twine(FrameSize) + 
+                         ">= 65536.\n" 
+                         "(" + 
+                         Twine(reinterpret_cast<uintptr_t>(&FI)) + ")"); 
     }
 
     AP.OutStreamer->AddComment("live roots for " +
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/PseudoProbePrinter.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/PseudoProbePrinter.cpp
index e8636052c5..1dc107041e 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/PseudoProbePrinter.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/PseudoProbePrinter.cpp
@@ -1,84 +1,84 @@
-//===- llvm/CodeGen/PseudoProbePrinter.cpp - Pseudo Probe Emission -------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains support for writing pseudo probe info into asm files.
-//
-//===----------------------------------------------------------------------===//
-
-#include "PseudoProbePrinter.h"
-#include "llvm/CodeGen/AsmPrinter.h"
-#include "llvm/IR/DebugInfoMetadata.h"
-#include "llvm/IR/Module.h"
-#include "llvm/IR/PseudoProbe.h"
-#include "llvm/MC/MCPseudoProbe.h"
-#include "llvm/MC/MCStreamer.h"
-
-using namespace llvm;
-
-#define DEBUG_TYPE "pseudoprobe"
-
-PseudoProbeHandler::~PseudoProbeHandler() = default;
-
-PseudoProbeHandler::PseudoProbeHandler(AsmPrinter *A, Module *M) : Asm(A) {
-  NamedMDNode *FuncInfo = M->getNamedMetadata(PseudoProbeDescMetadataName);
-  assert(FuncInfo && "Pseudo probe descriptors are missing");
-  for (const auto *Operand : FuncInfo->operands()) {
-    const auto *MD = cast<MDNode>(Operand);
-    auto GUID =
-        mdconst::dyn_extract<ConstantInt>(MD->getOperand(0))->getZExtValue();
-    auto Name = cast<MDString>(MD->getOperand(2))->getString();
-    // We may see pairs with same name but different GUIDs here in LTO mode, due
-    // to static same-named functions inlined from other modules into this
-    // module. Function profiles with the same name will be merged no matter
-    // whether they are collected on the same function. Therefore we just pick
-    // up the last <Name, GUID> pair here to represent the same-named function
-    // collection and all probes from the collection will be merged into a
-    // single profile eventually.
-    Names[Name] = GUID;
-  }
-
-  LLVM_DEBUG(dump());
-}
-
-void PseudoProbeHandler::emitPseudoProbe(uint64_t Guid, uint64_t Index,
-                                         uint64_t Type, uint64_t Attr,
-                                         const DILocation *DebugLoc) {
-  // Gather all the inlined-at nodes.
-  // When it's done ReversedInlineStack looks like ([66, B], [88, A])
-  // which means, Function A inlines function B at calliste with a probe id 88,
-  // and B inlines C at probe 66 where C is represented by Guid.
-  SmallVector<InlineSite, 8> ReversedInlineStack;
-  auto *InlinedAt = DebugLoc ? DebugLoc->getInlinedAt() : nullptr;
-  while (InlinedAt) {
-    const DISubprogram *SP = InlinedAt->getScope()->getSubprogram();
-    // Use linkage name for C++ if possible.
-    auto Name = SP->getLinkageName();
-    if (Name.empty())
-      Name = SP->getName();
-    assert(Names.count(Name) && "Pseudo probe descriptor missing for function");
-    uint64_t CallerGuid = Names[Name];
-    uint64_t CallerProbeId = PseudoProbeDwarfDiscriminator::extractProbeIndex(
-        InlinedAt->getDiscriminator());
-    ReversedInlineStack.emplace_back(CallerGuid, CallerProbeId);
-    InlinedAt = InlinedAt->getInlinedAt();
-  }
-
-  SmallVector<InlineSite, 8> InlineStack(ReversedInlineStack.rbegin(),
-                                         ReversedInlineStack.rend());
-  Asm->OutStreamer->emitPseudoProbe(Guid, Index, Type, Attr, InlineStack);
-}
-
-#ifndef NDEBUG
-void PseudoProbeHandler::dump() const {
-  dbgs() << "\n=============================\n";
-  dbgs() << "\nFunction Name to GUID map:\n";
-  dbgs() << "\n=============================\n";
-  for (const auto &Item : Names)
-    dbgs() << "Func: " << Item.first << "   GUID: " << Item.second << "\n";
-}
-#endif
+//===- llvm/CodeGen/PseudoProbePrinter.cpp - Pseudo Probe Emission -------===// 
+// 
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
+// See https://llvm.org/LICENSE.txt for license information. 
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
+// 
+//===----------------------------------------------------------------------===// 
+// 
+// This file contains support for writing pseudo probe info into asm files. 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include "PseudoProbePrinter.h" 
+#include "llvm/CodeGen/AsmPrinter.h" 
+#include "llvm/IR/DebugInfoMetadata.h" 
+#include "llvm/IR/Module.h" 
+#include "llvm/IR/PseudoProbe.h" 
+#include "llvm/MC/MCPseudoProbe.h" 
+#include "llvm/MC/MCStreamer.h" 
+ 
+using namespace llvm; 
+ 
+#define DEBUG_TYPE "pseudoprobe" 
+ 
+PseudoProbeHandler::~PseudoProbeHandler() = default; 
+ 
+PseudoProbeHandler::PseudoProbeHandler(AsmPrinter *A, Module *M) : Asm(A) { 
+  NamedMDNode *FuncInfo = M->getNamedMetadata(PseudoProbeDescMetadataName); 
+  assert(FuncInfo && "Pseudo probe descriptors are missing"); 
+  for (const auto *Operand : FuncInfo->operands()) { 
+    const auto *MD = cast<MDNode>(Operand); 
+    auto GUID = 
+        mdconst::dyn_extract<ConstantInt>(MD->getOperand(0))->getZExtValue(); 
+    auto Name = cast<MDString>(MD->getOperand(2))->getString(); 
+    // We may see pairs with same name but different GUIDs here in LTO mode, due 
+    // to static same-named functions inlined from other modules into this 
+    // module. Function profiles with the same name will be merged no matter 
+    // whether they are collected on the same function. Therefore we just pick 
+    // up the last <Name, GUID> pair here to represent the same-named function 
+    // collection and all probes from the collection will be merged into a 
+    // single profile eventually. 
+    Names[Name] = GUID; 
+  } 
+ 
+  LLVM_DEBUG(dump()); 
+} 
+ 
+void PseudoProbeHandler::emitPseudoProbe(uint64_t Guid, uint64_t Index, 
+                                         uint64_t Type, uint64_t Attr, 
+                                         const DILocation *DebugLoc) { 
+  // Gather all the inlined-at nodes. 
+  // When it's done ReversedInlineStack looks like ([66, B], [88, A]) 
+  // which means, Function A inlines function B at calliste with a probe id 88, 
+  // and B inlines C at probe 66 where C is represented by Guid. 
+  SmallVector<InlineSite, 8> ReversedInlineStack; 
+  auto *InlinedAt = DebugLoc ? DebugLoc->getInlinedAt() : nullptr; 
+  while (InlinedAt) { 
+    const DISubprogram *SP = InlinedAt->getScope()->getSubprogram(); 
+    // Use linkage name for C++ if possible. 
+    auto Name = SP->getLinkageName(); 
+    if (Name.empty()) 
+      Name = SP->getName(); 
+    assert(Names.count(Name) && "Pseudo probe descriptor missing for function"); 
+    uint64_t CallerGuid = Names[Name]; 
+    uint64_t CallerProbeId = PseudoProbeDwarfDiscriminator::extractProbeIndex( 
+        InlinedAt->getDiscriminator()); 
+    ReversedInlineStack.emplace_back(CallerGuid, CallerProbeId); 
+    InlinedAt = InlinedAt->getInlinedAt(); 
+  } 
+ 
+  SmallVector<InlineSite, 8> InlineStack(ReversedInlineStack.rbegin(), 
+                                         ReversedInlineStack.rend()); 
+  Asm->OutStreamer->emitPseudoProbe(Guid, Index, Type, Attr, InlineStack); 
+} 
+ 
+#ifndef NDEBUG 
+void PseudoProbeHandler::dump() const { 
+  dbgs() << "\n=============================\n"; 
+  dbgs() << "\nFunction Name to GUID map:\n"; 
+  dbgs() << "\n=============================\n"; 
+  for (const auto &Item : Names) 
+    dbgs() << "Func: " << Item.first << "   GUID: " << Item.second << "\n"; 
+} 
+#endif 
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/PseudoProbePrinter.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/PseudoProbePrinter.h
index bea07ceae9..627b497936 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/PseudoProbePrinter.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/PseudoProbePrinter.h
@@ -1,53 +1,53 @@
-//===- PseudoProbePrinter.h - Pseudo probe encoding support -----*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains support for writing pseudo probe info into asm files.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_PSEUDOPROBEPRINTER_H
-#define LLVM_LIB_CODEGEN_ASMPRINTER_PSEUDOPROBEPRINTER_H
-
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/CodeGen/AsmPrinterHandler.h"
-
-namespace llvm {
-
-class AsmPrinter;
-class MCStreamer;
-class Module;
-class DILocation;
-
-class PseudoProbeHandler : public AsmPrinterHandler {
-  // Target of pseudo probe emission.
-  AsmPrinter *Asm;
-  // Name to GUID map
-  DenseMap<StringRef, uint64_t> Names;
-
-public:
-  PseudoProbeHandler(AsmPrinter *A, Module *M);
-  ~PseudoProbeHandler() override;
-
-  void emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type,
-                       uint64_t Attr, const DILocation *DebugLoc);
-
-  // Unused.
-  void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {}
-  void endModule() override {}
-  void beginFunction(const MachineFunction *MF) override {}
-  void endFunction(const MachineFunction *MF) override {}
-  void beginInstruction(const MachineInstr *MI) override {}
-  void endInstruction() override {}
-  
-#ifndef NDEBUG
-  void dump() const;
-#endif
-};
-
-} // namespace llvm
-#endif // LLVM_LIB_CODEGEN_ASMPRINTER_PSEUDOPROBEPRINTER_H
+//===- PseudoProbePrinter.h - Pseudo probe encoding support -----*- C++ -*-===// 
+// 
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
+// See https://llvm.org/LICENSE.txt for license information. 
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
+// 
+//===----------------------------------------------------------------------===// 
+// 
+// This file contains support for writing pseudo probe info into asm files. 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_PSEUDOPROBEPRINTER_H 
+#define LLVM_LIB_CODEGEN_ASMPRINTER_PSEUDOPROBEPRINTER_H 
+ 
+#include "llvm/ADT/DenseMap.h" 
+#include "llvm/CodeGen/AsmPrinterHandler.h" 
+ 
+namespace llvm { 
+ 
+class AsmPrinter; 
+class MCStreamer; 
+class Module; 
+class DILocation; 
+ 
+class PseudoProbeHandler : public AsmPrinterHandler { 
+  // Target of pseudo probe emission. 
+  AsmPrinter *Asm; 
+  // Name to GUID map 
+  DenseMap<StringRef, uint64_t> Names; 
+ 
+public: 
+  PseudoProbeHandler(AsmPrinter *A, Module *M); 
+  ~PseudoProbeHandler() override; 
+ 
+  void emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type, 
+                       uint64_t Attr, const DILocation *DebugLoc); 
+ 
+  // Unused. 
+  void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {} 
+  void endModule() override {} 
+  void beginFunction(const MachineFunction *MF) override {} 
+  void endFunction(const MachineFunction *MF) override {} 
+  void beginInstruction(const MachineInstr *MI) override {} 
+  void endInstruction() override {} 
+   
+#ifndef NDEBUG 
+  void dump() const; 
+#endif 
+}; 
+ 
+} // namespace llvm 
+#endif // LLVM_LIB_CODEGEN_ASMPRINTER_PSEUDOPROBEPRINTER_H 
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WasmException.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WasmException.cpp
index 352a33e863..c40a8b3c85 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WasmException.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WasmException.cpp
@@ -18,11 +18,11 @@
 using namespace llvm;
 
 void WasmException::endModule() {
-  // This is the symbol used in 'throw' and 'catch' instruction to denote this
-  // is a C++ exception. This symbol has to be emitted somewhere once in the
-  // module.  Check if the symbol has already been created, i.e., we have at
-  // least one 'throw' or 'catch' instruction in the module, and emit the symbol
-  // only if so.
+  // This is the symbol used in 'throw' and 'catch' instruction to denote this 
+  // is a C++ exception. This symbol has to be emitted somewhere once in the 
+  // module.  Check if the symbol has already been created, i.e., we have at 
+  // least one 'throw' or 'catch' instruction in the module, and emit the symbol 
+  // only if so. 
   SmallString<60> NameStr;
   Mangler::getNameWithPrefix(NameStr, "__cpp_exception", Asm->getDataLayout());
   if (Asm->OutContext.lookupSymbol(NameStr)) {
@@ -76,7 +76,7 @@ void WasmException::endFunction(const MachineFunction *MF) {
 // information.
 void WasmException::computeCallSiteTable(
     SmallVectorImpl<CallSiteEntry> &CallSites,
-    SmallVectorImpl<CallSiteRange> &CallSiteRanges,
+    SmallVectorImpl<CallSiteRange> &CallSiteRanges, 
     const SmallVectorImpl<const LandingPadInfo *> &LandingPads,
     const SmallVectorImpl<unsigned> &FirstActions) {
   MachineFunction &MF = *Asm->MF;
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WasmException.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WasmException.h
index f06de786bd..40c5013539 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WasmException.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WasmException.h
@@ -32,7 +32,7 @@ protected:
   // Compute the call site table for wasm EH.
   void computeCallSiteTable(
       SmallVectorImpl<CallSiteEntry> &CallSites,
-      SmallVectorImpl<CallSiteRange> &CallSiteRanges,
+      SmallVectorImpl<CallSiteRange> &CallSiteRanges, 
       const SmallVectorImpl<const LandingPadInfo *> &LandingPads,
       const SmallVectorImpl<unsigned> &FirstActions) override;
 };
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WinCFGuard.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WinCFGuard.cpp
index 1e3f33e707..1486c9e868 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WinCFGuard.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WinCFGuard.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for writing the metadata for Windows Control Flow
-// Guard, including address-taken functions and valid longjmp targets.
+// Guard, including address-taken functions and valid longjmp targets. 
 //
 //===----------------------------------------------------------------------===//
 
@@ -17,7 +17,7 @@
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/IR/Constants.h"
-#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Instructions.h" 
 #include "llvm/IR/Metadata.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
@@ -38,7 +38,7 @@ void WinCFGuard::endFunction(const MachineFunction *MF) {
     return;
 
   // Copy the function's longjmp targets to a module-level list.
-  llvm::append_range(LongjmpTargets, MF->getLongjmpTargets());
+  llvm::append_range(LongjmpTargets, MF->getLongjmpTargets()); 
 }
 
 /// Returns true if this function's address is escaped in a way that might make
@@ -77,50 +77,50 @@ static bool isPossibleIndirectCallTarget(const Function *F) {
   return false;
 }
 
-MCSymbol *WinCFGuard::lookupImpSymbol(const MCSymbol *Sym) {
-  if (Sym->getName().startswith("__imp_"))
-    return nullptr;
-  return Asm->OutContext.lookupSymbol(Twine("__imp_") + Sym->getName());
-}
-
+MCSymbol *WinCFGuard::lookupImpSymbol(const MCSymbol *Sym) { 
+  if (Sym->getName().startswith("__imp_")) 
+    return nullptr; 
+  return Asm->OutContext.lookupSymbol(Twine("__imp_") + Sym->getName()); 
+} 
+ 
 void WinCFGuard::endModule() {
   const Module *M = Asm->MMI->getModule();
-  std::vector<const MCSymbol *> GFIDsEntries;
-  std::vector<const MCSymbol *> GIATsEntries;
-  for (const Function &F : *M) {
-    if (isPossibleIndirectCallTarget(&F)) {
-      // If F is a dllimport and has an "__imp_" symbol already defined, add the
-      // "__imp_" symbol to the .giats section.
-      if (F.hasDLLImportStorageClass()) {
-        if (MCSymbol *impSym = lookupImpSymbol(Asm->getSymbol(&F))) {
-          GIATsEntries.push_back(impSym);
-        }
-      }
-      // Add the function's symbol to the .gfids section.
-      // Note: For dllimport functions, MSVC sometimes does not add this symbol
-      // to the .gfids section, but only adds the corresponding "__imp_" symbol
-      // to the .giats section. Here we always add the symbol to the .gfids
-      // section, since this does not introduce security risks.
-      GFIDsEntries.push_back(Asm->getSymbol(&F));
-    }
-  }
-
-  if (GFIDsEntries.empty() && GIATsEntries.empty() && LongjmpTargets.empty())
+  std::vector<const MCSymbol *> GFIDsEntries; 
+  std::vector<const MCSymbol *> GIATsEntries; 
+  for (const Function &F : *M) { 
+    if (isPossibleIndirectCallTarget(&F)) { 
+      // If F is a dllimport and has an "__imp_" symbol already defined, add the 
+      // "__imp_" symbol to the .giats section. 
+      if (F.hasDLLImportStorageClass()) { 
+        if (MCSymbol *impSym = lookupImpSymbol(Asm->getSymbol(&F))) { 
+          GIATsEntries.push_back(impSym); 
+        } 
+      } 
+      // Add the function's symbol to the .gfids section. 
+      // Note: For dllimport functions, MSVC sometimes does not add this symbol 
+      // to the .gfids section, but only adds the corresponding "__imp_" symbol 
+      // to the .giats section. Here we always add the symbol to the .gfids 
+      // section, since this does not introduce security risks. 
+      GFIDsEntries.push_back(Asm->getSymbol(&F)); 
+    } 
+  } 
+ 
+  if (GFIDsEntries.empty() && GIATsEntries.empty() && LongjmpTargets.empty()) 
     return;
-
-  // Emit the symbol index of each GFIDs entry to form the .gfids section.
+ 
+  // Emit the symbol index of each GFIDs entry to form the .gfids section. 
   auto &OS = *Asm->OutStreamer;
   OS.SwitchSection(Asm->OutContext.getObjectFileInfo()->getGFIDsSection());
-  for (const MCSymbol *S : GFIDsEntries)
-    OS.EmitCOFFSymbolIndex(S);
-
-  // Emit the symbol index of each GIATs entry to form the .giats section.
-  OS.SwitchSection(Asm->OutContext.getObjectFileInfo()->getGIATsSection());
-  for (const MCSymbol *S : GIATsEntries) {
-    OS.EmitCOFFSymbolIndex(S);
-  }
+  for (const MCSymbol *S : GFIDsEntries) 
+    OS.EmitCOFFSymbolIndex(S); 
 
-  // Emit the symbol index of each longjmp target to form the .gljmp section.
+  // Emit the symbol index of each GIATs entry to form the .giats section. 
+  OS.SwitchSection(Asm->OutContext.getObjectFileInfo()->getGIATsSection()); 
+  for (const MCSymbol *S : GIATsEntries) { 
+    OS.EmitCOFFSymbolIndex(S); 
+  } 
+ 
+  // Emit the symbol index of each longjmp target to form the .gljmp section. 
   OS.SwitchSection(Asm->OutContext.getObjectFileInfo()->getGLJMPSection());
   for (const MCSymbol *S : LongjmpTargets) {
     OS.EmitCOFFSymbolIndex(S);
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WinCFGuard.h b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WinCFGuard.h
index 0e472af52c..870345f1eb 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WinCFGuard.h
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WinCFGuard.h
@@ -24,7 +24,7 @@ class LLVM_LIBRARY_VISIBILITY WinCFGuard : public AsmPrinterHandler {
   /// Target of directive emission.
   AsmPrinter *Asm;
   std::vector<const MCSymbol *> LongjmpTargets;
-  MCSymbol *lookupImpSymbol(const MCSymbol *Sym);
+  MCSymbol *lookupImpSymbol(const MCSymbol *Sym); 
 
 public:
   WinCFGuard(AsmPrinter *A);
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WinException.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WinException.cpp
index 3a9c9df797..e981bd0d96 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WinException.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/WinException.cpp
@@ -137,8 +137,8 @@ void WinException::endFunction(const MachineFunction *MF) {
 
   endFuncletImpl();
 
-  // endFunclet will emit the necessary .xdata tables for table-based SEH.
-  if (Per == EHPersonality::MSVC_TableSEH && MF->hasEHFunclets())
+  // endFunclet will emit the necessary .xdata tables for table-based SEH. 
+  if (Per == EHPersonality::MSVC_TableSEH && MF->hasEHFunclets()) 
     return;
 
   if (shouldEmitPersonality || shouldEmitLSDA) {
@@ -151,7 +151,7 @@ void WinException::endFunction(const MachineFunction *MF) {
 
     // Emit the tables appropriate to the personality function in use. If we
     // don't recognize the personality, assume it uses an Itanium-style LSDA.
-    if (Per == EHPersonality::MSVC_TableSEH)
+    if (Per == EHPersonality::MSVC_TableSEH) 
       emitCSpecificHandlerTable(MF);
     else if (Per == EHPersonality::MSVC_X86SEH)
       emitExceptHandlerTable(MF);
@@ -260,33 +260,33 @@ void WinException::endFuncletImpl() {
 
     if (Per == EHPersonality::MSVC_CXX && shouldEmitPersonality &&
         !CurrentFuncletEntry->isCleanupFuncletEntry()) {
-      // Emit an UNWIND_INFO struct describing the prologue.
-      Asm->OutStreamer->EmitWinEHHandlerData();
-
+      // Emit an UNWIND_INFO struct describing the prologue. 
+      Asm->OutStreamer->EmitWinEHHandlerData(); 
+ 
       // If this is a C++ catch funclet (or the parent function),
       // emit a reference to the LSDA for the parent function.
       StringRef FuncLinkageName = GlobalValue::dropLLVMManglingEscape(F.getName());
       MCSymbol *FuncInfoXData = Asm->OutContext.getOrCreateSymbol(
           Twine("$cppxdata$", FuncLinkageName));
       Asm->OutStreamer->emitValue(create32bitRef(FuncInfoXData), 4);
-    } else if (Per == EHPersonality::MSVC_TableSEH && MF->hasEHFunclets() &&
+    } else if (Per == EHPersonality::MSVC_TableSEH && MF->hasEHFunclets() && 
                !CurrentFuncletEntry->isEHFuncletEntry()) {
-      // Emit an UNWIND_INFO struct describing the prologue.
-      Asm->OutStreamer->EmitWinEHHandlerData();
-
+      // Emit an UNWIND_INFO struct describing the prologue. 
+      Asm->OutStreamer->EmitWinEHHandlerData(); 
+ 
       // If this is the parent function in Win64 SEH, emit the LSDA immediately
       // following .seh_handlerdata.
       emitCSpecificHandlerTable(MF);
-    } else if (shouldEmitPersonality || shouldEmitLSDA) {
-      // Emit an UNWIND_INFO struct describing the prologue.
-      Asm->OutStreamer->EmitWinEHHandlerData();
-      // In these cases, no further info is written to the .xdata section
-      // right here, but is written by e.g. emitExceptionTable in endFunction()
-      // above.
-    } else {
-      // No need to emit the EH handler data right here if nothing needs
-      // writing to the .xdata section; it will be emitted for all
-      // functions that need it in the end anyway.
+    } else if (shouldEmitPersonality || shouldEmitLSDA) { 
+      // Emit an UNWIND_INFO struct describing the prologue. 
+      Asm->OutStreamer->EmitWinEHHandlerData(); 
+      // In these cases, no further info is written to the .xdata section 
+      // right here, but is written by e.g. emitExceptionTable in endFunction() 
+      // above. 
+    } else { 
+      // No need to emit the EH handler data right here if nothing needs 
+      // writing to the .xdata section; it will be emitted for all 
+      // functions that need it in the end anyway. 
     }
 
     // Switch back to the funclet start .text section now that we are done
@@ -343,24 +343,24 @@ int WinException::getFrameIndexOffset(int FrameIndex,
   const TargetFrameLowering &TFI = *Asm->MF->getSubtarget().getFrameLowering();
   Register UnusedReg;
   if (Asm->MAI->usesWindowsCFI()) {
-    StackOffset Offset =
+    StackOffset Offset = 
         TFI.getFrameIndexReferencePreferSP(*Asm->MF, FrameIndex, UnusedReg,
                                            /*IgnoreSPUpdates*/ true);
     assert(UnusedReg ==
            Asm->MF->getSubtarget()
                .getTargetLowering()
                ->getStackPointerRegisterToSaveRestore());
-    return Offset.getFixed();
+    return Offset.getFixed(); 
   }
 
   // For 32-bit, offsets should be relative to the end of the EH registration
   // node. For 64-bit, it's relative to SP at the end of the prologue.
   assert(FuncInfo.EHRegNodeEndOffset != INT_MAX);
-  StackOffset Offset = TFI.getFrameIndexReference(*Asm->MF, FrameIndex, UnusedReg);
-  Offset += StackOffset::getFixed(FuncInfo.EHRegNodeEndOffset);
-  assert(!Offset.getScalable() &&
-         "Frame offsets with a scalable component are not supported");
-  return Offset.getFixed();
+  StackOffset Offset = TFI.getFrameIndexReference(*Asm->MF, FrameIndex, UnusedReg); 
+  Offset += StackOffset::getFixed(FuncInfo.EHRegNodeEndOffset); 
+  assert(!Offset.getScalable() && 
+         "Frame offsets with a scalable component are not supported"); 
+  return Offset.getFixed(); 
 }
 
 namespace {
@@ -957,7 +957,7 @@ void WinException::emitEHRegistrationOffsetLabel(const WinEHFuncInfo &FuncInfo,
   int FI = FuncInfo.EHRegNodeFrameIndex;
   if (FI != INT_MAX) {
     const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
-    Offset = TFI->getNonLocalFrameIndexReference(*Asm->MF, FI).getFixed();
+    Offset = TFI->getNonLocalFrameIndexReference(*Asm->MF, FI).getFixed(); 
   }
 
   MCContext &Ctx = Asm->OutContext;
@@ -1021,8 +1021,8 @@ void WinException::emitExceptHandlerTable(const MachineFunction *MF) {
       Register UnusedReg;
       const TargetFrameLowering *TFI = MF->getSubtarget().getFrameLowering();
       int SSPIdx = MFI.getStackProtectorIndex();
-      GSCookieOffset =
-          TFI->getFrameIndexReference(*MF, SSPIdx, UnusedReg).getFixed();
+      GSCookieOffset = 
+          TFI->getFrameIndexReference(*MF, SSPIdx, UnusedReg).getFixed(); 
     }
 
     // Retrieve the EH Guard slot.
@@ -1032,8 +1032,8 @@ void WinException::emitExceptHandlerTable(const MachineFunction *MF) {
       Register UnusedReg;
       const TargetFrameLowering *TFI = MF->getSubtarget().getFrameLowering();
       int EHGuardIdx = FuncInfo.EHGuardFrameIndex;
-      EHCookieOffset =
-          TFI->getFrameIndexReference(*MF, EHGuardIdx, UnusedReg).getFixed();
+      EHCookieOffset = 
+          TFI->getFrameIndexReference(*MF, EHGuardIdx, UnusedReg).getFixed(); 
     }
 
     AddComment("GSCookieOffset");
diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/ya.make b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/ya.make
index 47d6139b3d..47a05ac91e 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/ya.make
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/ya.make
@@ -12,25 +12,25 @@ LICENSE(Apache-2.0 WITH LLVM-exception)
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
 PEERDIR(
-    contrib/libs/llvm12
-    contrib/libs/llvm12/include
-    contrib/libs/llvm12/lib/Analysis
-    contrib/libs/llvm12/lib/BinaryFormat
-    contrib/libs/llvm12/lib/CodeGen
-    contrib/libs/llvm12/lib/DebugInfo/CodeView
-    contrib/libs/llvm12/lib/DebugInfo/DWARF
-    contrib/libs/llvm12/lib/DebugInfo/MSF
-    contrib/libs/llvm12/lib/IR
-    contrib/libs/llvm12/lib/MC
-    contrib/libs/llvm12/lib/MC/MCParser
-    contrib/libs/llvm12/lib/Remarks
-    contrib/libs/llvm12/lib/Support
-    contrib/libs/llvm12/lib/Target
+    contrib/libs/llvm12 
+    contrib/libs/llvm12/include 
+    contrib/libs/llvm12/lib/Analysis 
+    contrib/libs/llvm12/lib/BinaryFormat 
+    contrib/libs/llvm12/lib/CodeGen 
+    contrib/libs/llvm12/lib/DebugInfo/CodeView 
+    contrib/libs/llvm12/lib/DebugInfo/DWARF 
+    contrib/libs/llvm12/lib/DebugInfo/MSF 
+    contrib/libs/llvm12/lib/IR 
+    contrib/libs/llvm12/lib/MC 
+    contrib/libs/llvm12/lib/MC/MCParser 
+    contrib/libs/llvm12/lib/Remarks 
+    contrib/libs/llvm12/lib/Support 
+    contrib/libs/llvm12/lib/Target 
 )
 
 IF (SANITIZER_TYPE == "undefined")
     PEERDIR(
-        contrib/libs/llvm12/lib/Target/ARM/MCTargetDesc
+        contrib/libs/llvm12/lib/Target/ARM/MCTargetDesc 
     )
 ENDIF()
 
@@ -43,7 +43,7 @@ NO_COMPILER_WARNINGS()
 NO_UTIL()
 
 SRCS(
-    AIXException.cpp
+    AIXException.cpp 
     ARMException.cpp
     AccelTable.cpp
     AddressPool.cpp
@@ -66,7 +66,7 @@ SRCS(
     EHStreamer.cpp
     ErlangGCPrinter.cpp
     OcamlGCPrinter.cpp
-    PseudoProbePrinter.cpp
+    PseudoProbePrinter.cpp 
     WasmException.cpp
     WinCFGuard.cpp
     WinException.cpp