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

1 files changed, 221 insertions, 221 deletions

diff --git a/contrib/libs/llvm12/lib/AsmParser/Parser.cpp b/contrib/libs/llvm12/lib/AsmParser/Parser.cpp
index fb98646201..8147620181 100644
--- a/contrib/libs/llvm12/lib/AsmParser/Parser.cpp
+++ b/contrib/libs/llvm12/lib/AsmParser/Parser.cpp
@@ -1,221 +1,221 @@
-//===- Parser.cpp - Main dispatch module for the Parser library -----------===// 
-// 
-// 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 library implements the functionality defined in llvm/AsmParser/Parser.h 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#include "llvm/AsmParser/Parser.h" 
-#include "LLParser.h" 
-#include "llvm/ADT/STLExtras.h" 
-#include "llvm/IR/Module.h" 
-#include "llvm/IR/ModuleSummaryIndex.h" 
-#include "llvm/Support/MemoryBuffer.h" 
-#include "llvm/Support/SourceMgr.h" 
-#include <cstring> 
-#include <system_error> 
- 
-using namespace llvm; 
- 
-static bool parseAssemblyInto(MemoryBufferRef F, Module *M, 
-                              ModuleSummaryIndex *Index, SMDiagnostic &Err, 
-                              SlotMapping *Slots, bool UpgradeDebugInfo, 
-                              DataLayoutCallbackTy DataLayoutCallback) { 
-  SourceMgr SM; 
-  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(F); 
-  SM.AddNewSourceBuffer(std::move(Buf), SMLoc()); 
- 
-  LLVMContext Context; 
-  return LLParser(F.getBuffer(), SM, Err, M, Index, 
-                  M ? M->getContext() : Context, Slots) 
-      .Run(UpgradeDebugInfo, DataLayoutCallback); 
-} 
- 
-bool llvm::parseAssemblyInto(MemoryBufferRef F, Module *M, 
-                             ModuleSummaryIndex *Index, SMDiagnostic &Err, 
-                             SlotMapping *Slots, 
-                             DataLayoutCallbackTy DataLayoutCallback) { 
-  return ::parseAssemblyInto(F, M, Index, Err, Slots, 
-                             /*UpgradeDebugInfo*/ true, DataLayoutCallback); 
-} 
- 
-std::unique_ptr<Module> 
-llvm::parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context, 
-                    SlotMapping *Slots, 
-                    DataLayoutCallbackTy DataLayoutCallback) { 
-  std::unique_ptr<Module> M = 
-      std::make_unique<Module>(F.getBufferIdentifier(), Context); 
- 
-  if (parseAssemblyInto(F, M.get(), nullptr, Err, Slots, DataLayoutCallback)) 
-    return nullptr; 
- 
-  return M; 
-} 
- 
-std::unique_ptr<Module> llvm::parseAssemblyFile(StringRef Filename, 
-                                                SMDiagnostic &Err, 
-                                                LLVMContext &Context, 
-                                                SlotMapping *Slots) { 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr = 
-      MemoryBuffer::getFileOrSTDIN(Filename); 
-  if (std::error_code EC = FileOrErr.getError()) { 
-    Err = SMDiagnostic(Filename, SourceMgr::DK_Error, 
-                       "Could not open input file: " + EC.message()); 
-    return nullptr; 
-  } 
- 
-  return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context, Slots); 
-} 
- 
-static ParsedModuleAndIndex 
-parseAssemblyWithIndex(MemoryBufferRef F, SMDiagnostic &Err, 
-                       LLVMContext &Context, SlotMapping *Slots, 
-                       bool UpgradeDebugInfo, 
-                       DataLayoutCallbackTy DataLayoutCallback) { 
-  std::unique_ptr<Module> M = 
-      std::make_unique<Module>(F.getBufferIdentifier(), Context); 
-  std::unique_ptr<ModuleSummaryIndex> Index = 
-      std::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/true); 
- 
-  if (parseAssemblyInto(F, M.get(), Index.get(), Err, Slots, UpgradeDebugInfo, 
-                        DataLayoutCallback)) 
-    return {nullptr, nullptr}; 
- 
-  return {std::move(M), std::move(Index)}; 
-} 
- 
-ParsedModuleAndIndex llvm::parseAssemblyWithIndex(MemoryBufferRef F, 
-                                                  SMDiagnostic &Err, 
-                                                  LLVMContext &Context, 
-                                                  SlotMapping *Slots) { 
-  return ::parseAssemblyWithIndex(F, Err, Context, Slots, 
-                                  /*UpgradeDebugInfo*/ true, 
-                                  [](StringRef) { return None; }); 
-} 
- 
-static ParsedModuleAndIndex 
-parseAssemblyFileWithIndex(StringRef Filename, SMDiagnostic &Err, 
-                           LLVMContext &Context, SlotMapping *Slots, 
-                           bool UpgradeDebugInfo, 
-                           DataLayoutCallbackTy DataLayoutCallback) { 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr = 
-      MemoryBuffer::getFileOrSTDIN(Filename); 
-  if (std::error_code EC = FileOrErr.getError()) { 
-    Err = SMDiagnostic(Filename, SourceMgr::DK_Error, 
-                       "Could not open input file: " + EC.message()); 
-    return {nullptr, nullptr}; 
-  } 
- 
-  return parseAssemblyWithIndex(FileOrErr.get()->getMemBufferRef(), Err, 
-                                Context, Slots, UpgradeDebugInfo, 
-                                DataLayoutCallback); 
-} 
- 
-ParsedModuleAndIndex 
-llvm::parseAssemblyFileWithIndex(StringRef Filename, SMDiagnostic &Err, 
-                                 LLVMContext &Context, SlotMapping *Slots, 
-                                 DataLayoutCallbackTy DataLayoutCallback) { 
-  return ::parseAssemblyFileWithIndex(Filename, Err, Context, Slots, 
-                                      /*UpgradeDebugInfo*/ true, 
-                                      DataLayoutCallback); 
-} 
- 
-ParsedModuleAndIndex llvm::parseAssemblyFileWithIndexNoUpgradeDebugInfo( 
-    StringRef Filename, SMDiagnostic &Err, LLVMContext &Context, 
-    SlotMapping *Slots, DataLayoutCallbackTy DataLayoutCallback) { 
-  return ::parseAssemblyFileWithIndex(Filename, Err, Context, Slots, 
-                                      /*UpgradeDebugInfo*/ false, 
-                                      DataLayoutCallback); 
-} 
- 
-std::unique_ptr<Module> llvm::parseAssemblyString(StringRef AsmString, 
-                                                  SMDiagnostic &Err, 
-                                                  LLVMContext &Context, 
-                                                  SlotMapping *Slots) { 
-  MemoryBufferRef F(AsmString, "<string>"); 
-  return parseAssembly(F, Err, Context, Slots); 
-} 
- 
-static bool parseSummaryIndexAssemblyInto(MemoryBufferRef F, 
-                                          ModuleSummaryIndex &Index, 
-                                          SMDiagnostic &Err) { 
-  SourceMgr SM; 
-  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(F); 
-  SM.AddNewSourceBuffer(std::move(Buf), SMLoc()); 
- 
-  // The parser holds a reference to a context that is unused when parsing the 
-  // index, but we need to initialize it. 
-  LLVMContext unusedContext; 
-  return LLParser(F.getBuffer(), SM, Err, nullptr, &Index, unusedContext) 
-      .Run(true, [](StringRef) { return None; }); 
-} 
- 
-std::unique_ptr<ModuleSummaryIndex> 
-llvm::parseSummaryIndexAssembly(MemoryBufferRef F, SMDiagnostic &Err) { 
-  std::unique_ptr<ModuleSummaryIndex> Index = 
-      std::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/false); 
- 
-  if (parseSummaryIndexAssemblyInto(F, *Index, Err)) 
-    return nullptr; 
- 
-  return Index; 
-} 
- 
-std::unique_ptr<ModuleSummaryIndex> 
-llvm::parseSummaryIndexAssemblyFile(StringRef Filename, SMDiagnostic &Err) { 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr = 
-      MemoryBuffer::getFileOrSTDIN(Filename); 
-  if (std::error_code EC = FileOrErr.getError()) { 
-    Err = SMDiagnostic(Filename, SourceMgr::DK_Error, 
-                       "Could not open input file: " + EC.message()); 
-    return nullptr; 
-  } 
- 
-  return parseSummaryIndexAssembly(FileOrErr.get()->getMemBufferRef(), Err); 
-} 
- 
-Constant *llvm::parseConstantValue(StringRef Asm, SMDiagnostic &Err, 
-                                   const Module &M, const SlotMapping *Slots) { 
-  SourceMgr SM; 
-  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm); 
-  SM.AddNewSourceBuffer(std::move(Buf), SMLoc()); 
-  Constant *C; 
-  if (LLParser(Asm, SM, Err, const_cast<Module *>(&M), nullptr, M.getContext()) 
-          .parseStandaloneConstantValue(C, Slots)) 
-    return nullptr; 
-  return C; 
-} 
- 
-Type *llvm::parseType(StringRef Asm, SMDiagnostic &Err, const Module &M, 
-                      const SlotMapping *Slots) { 
-  unsigned Read; 
-  Type *Ty = parseTypeAtBeginning(Asm, Read, Err, M, Slots); 
-  if (!Ty) 
-    return nullptr; 
-  if (Read != Asm.size()) { 
-    SourceMgr SM; 
-    std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm); 
-    SM.AddNewSourceBuffer(std::move(Buf), SMLoc()); 
-    Err = SM.GetMessage(SMLoc::getFromPointer(Asm.begin() + Read), 
-                        SourceMgr::DK_Error, "expected end of string"); 
-    return nullptr; 
-  } 
-  return Ty; 
-} 
-Type *llvm::parseTypeAtBeginning(StringRef Asm, unsigned &Read, 
-                                 SMDiagnostic &Err, const Module &M, 
-                                 const SlotMapping *Slots) { 
-  SourceMgr SM; 
-  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm); 
-  SM.AddNewSourceBuffer(std::move(Buf), SMLoc()); 
-  Type *Ty; 
-  if (LLParser(Asm, SM, Err, const_cast<Module *>(&M), nullptr, M.getContext()) 
-          .parseTypeAtBeginning(Ty, Read, Slots)) 
-    return nullptr; 
-  return Ty; 
-} 
+//===- Parser.cpp - Main dispatch module for the Parser library -----------===//
+//
+// 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 library implements the functionality defined in llvm/AsmParser/Parser.h
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/AsmParser/Parser.h"
+#include "LLParser.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/ModuleSummaryIndex.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/SourceMgr.h"
+#include <cstring>
+#include <system_error>
+
+using namespace llvm;
+
+static bool parseAssemblyInto(MemoryBufferRef F, Module *M,
+                              ModuleSummaryIndex *Index, SMDiagnostic &Err,
+                              SlotMapping *Slots, bool UpgradeDebugInfo,
+                              DataLayoutCallbackTy DataLayoutCallback) {
+  SourceMgr SM;
+  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(F);
+  SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
+
+  LLVMContext Context;
+  return LLParser(F.getBuffer(), SM, Err, M, Index,
+                  M ? M->getContext() : Context, Slots)
+      .Run(UpgradeDebugInfo, DataLayoutCallback);
+}
+
+bool llvm::parseAssemblyInto(MemoryBufferRef F, Module *M,
+                             ModuleSummaryIndex *Index, SMDiagnostic &Err,
+                             SlotMapping *Slots,
+                             DataLayoutCallbackTy DataLayoutCallback) {
+  return ::parseAssemblyInto(F, M, Index, Err, Slots,
+                             /*UpgradeDebugInfo*/ true, DataLayoutCallback);
+}
+
+std::unique_ptr<Module>
+llvm::parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context,
+                    SlotMapping *Slots,
+                    DataLayoutCallbackTy DataLayoutCallback) {
+  std::unique_ptr<Module> M =
+      std::make_unique<Module>(F.getBufferIdentifier(), Context);
+
+  if (parseAssemblyInto(F, M.get(), nullptr, Err, Slots, DataLayoutCallback))
+    return nullptr;
+
+  return M;
+}
+
+std::unique_ptr<Module> llvm::parseAssemblyFile(StringRef Filename,
+                                                SMDiagnostic &Err,
+                                                LLVMContext &Context,
+                                                SlotMapping *Slots) {
+  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+      MemoryBuffer::getFileOrSTDIN(Filename);
+  if (std::error_code EC = FileOrErr.getError()) {
+    Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
+                       "Could not open input file: " + EC.message());
+    return nullptr;
+  }
+
+  return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context, Slots);
+}
+
+static ParsedModuleAndIndex
+parseAssemblyWithIndex(MemoryBufferRef F, SMDiagnostic &Err,
+                       LLVMContext &Context, SlotMapping *Slots,
+                       bool UpgradeDebugInfo,
+                       DataLayoutCallbackTy DataLayoutCallback) {
+  std::unique_ptr<Module> M =
+      std::make_unique<Module>(F.getBufferIdentifier(), Context);
+  std::unique_ptr<ModuleSummaryIndex> Index =
+      std::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/true);
+
+  if (parseAssemblyInto(F, M.get(), Index.get(), Err, Slots, UpgradeDebugInfo,
+                        DataLayoutCallback))
+    return {nullptr, nullptr};
+
+  return {std::move(M), std::move(Index)};
+}
+
+ParsedModuleAndIndex llvm::parseAssemblyWithIndex(MemoryBufferRef F,
+                                                  SMDiagnostic &Err,
+                                                  LLVMContext &Context,
+                                                  SlotMapping *Slots) {
+  return ::parseAssemblyWithIndex(F, Err, Context, Slots,
+                                  /*UpgradeDebugInfo*/ true,
+                                  [](StringRef) { return None; });
+}
+
+static ParsedModuleAndIndex
+parseAssemblyFileWithIndex(StringRef Filename, SMDiagnostic &Err,
+                           LLVMContext &Context, SlotMapping *Slots,
+                           bool UpgradeDebugInfo,
+                           DataLayoutCallbackTy DataLayoutCallback) {
+  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+      MemoryBuffer::getFileOrSTDIN(Filename);
+  if (std::error_code EC = FileOrErr.getError()) {
+    Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
+                       "Could not open input file: " + EC.message());
+    return {nullptr, nullptr};
+  }
+
+  return parseAssemblyWithIndex(FileOrErr.get()->getMemBufferRef(), Err,
+                                Context, Slots, UpgradeDebugInfo,
+                                DataLayoutCallback);
+}
+
+ParsedModuleAndIndex
+llvm::parseAssemblyFileWithIndex(StringRef Filename, SMDiagnostic &Err,
+                                 LLVMContext &Context, SlotMapping *Slots,
+                                 DataLayoutCallbackTy DataLayoutCallback) {
+  return ::parseAssemblyFileWithIndex(Filename, Err, Context, Slots,
+                                      /*UpgradeDebugInfo*/ true,
+                                      DataLayoutCallback);
+}
+
+ParsedModuleAndIndex llvm::parseAssemblyFileWithIndexNoUpgradeDebugInfo(
+    StringRef Filename, SMDiagnostic &Err, LLVMContext &Context,
+    SlotMapping *Slots, DataLayoutCallbackTy DataLayoutCallback) {
+  return ::parseAssemblyFileWithIndex(Filename, Err, Context, Slots,
+                                      /*UpgradeDebugInfo*/ false,
+                                      DataLayoutCallback);
+}
+
+std::unique_ptr<Module> llvm::parseAssemblyString(StringRef AsmString,
+                                                  SMDiagnostic &Err,
+                                                  LLVMContext &Context,
+                                                  SlotMapping *Slots) {
+  MemoryBufferRef F(AsmString, "<string>");
+  return parseAssembly(F, Err, Context, Slots);
+}
+
+static bool parseSummaryIndexAssemblyInto(MemoryBufferRef F,
+                                          ModuleSummaryIndex &Index,
+                                          SMDiagnostic &Err) {
+  SourceMgr SM;
+  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(F);
+  SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
+
+  // The parser holds a reference to a context that is unused when parsing the
+  // index, but we need to initialize it.
+  LLVMContext unusedContext;
+  return LLParser(F.getBuffer(), SM, Err, nullptr, &Index, unusedContext)
+      .Run(true, [](StringRef) { return None; });
+}
+
+std::unique_ptr<ModuleSummaryIndex>
+llvm::parseSummaryIndexAssembly(MemoryBufferRef F, SMDiagnostic &Err) {
+  std::unique_ptr<ModuleSummaryIndex> Index =
+      std::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/false);
+
+  if (parseSummaryIndexAssemblyInto(F, *Index, Err))
+    return nullptr;
+
+  return Index;
+}
+
+std::unique_ptr<ModuleSummaryIndex>
+llvm::parseSummaryIndexAssemblyFile(StringRef Filename, SMDiagnostic &Err) {
+  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+      MemoryBuffer::getFileOrSTDIN(Filename);
+  if (std::error_code EC = FileOrErr.getError()) {
+    Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
+                       "Could not open input file: " + EC.message());
+    return nullptr;
+  }
+
+  return parseSummaryIndexAssembly(FileOrErr.get()->getMemBufferRef(), Err);
+}
+
+Constant *llvm::parseConstantValue(StringRef Asm, SMDiagnostic &Err,
+                                   const Module &M, const SlotMapping *Slots) {
+  SourceMgr SM;
+  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
+  SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
+  Constant *C;
+  if (LLParser(Asm, SM, Err, const_cast<Module *>(&M), nullptr, M.getContext())
+          .parseStandaloneConstantValue(C, Slots))
+    return nullptr;
+  return C;
+}
+
+Type *llvm::parseType(StringRef Asm, SMDiagnostic &Err, const Module &M,
+                      const SlotMapping *Slots) {
+  unsigned Read;
+  Type *Ty = parseTypeAtBeginning(Asm, Read, Err, M, Slots);
+  if (!Ty)
+    return nullptr;
+  if (Read != Asm.size()) {
+    SourceMgr SM;
+    std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
+    SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
+    Err = SM.GetMessage(SMLoc::getFromPointer(Asm.begin() + Read),
+                        SourceMgr::DK_Error, "expected end of string");
+    return nullptr;
+  }
+  return Ty;
+}
+Type *llvm::parseTypeAtBeginning(StringRef Asm, unsigned &Read,
+                                 SMDiagnostic &Err, const Module &M,
+                                 const SlotMapping *Slots) {
+  SourceMgr SM;
+  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
+  SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
+  Type *Ty;
+  if (LLParser(Asm, SM, Err, const_cast<Module *>(&M), nullptr, M.getContext())
+          .parseTypeAtBeginning(Ty, Read, Slots))
+    return nullptr;
+  return Ty;
+}