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

1 files changed, 257 insertions, 257 deletions

diff --git a/contrib/libs/llvm12/lib/Remarks/YAMLRemarkSerializer.cpp b/contrib/libs/llvm12/lib/Remarks/YAMLRemarkSerializer.cpp
index 3a42fe0678..4a34d898d3 100644
--- a/contrib/libs/llvm12/lib/Remarks/YAMLRemarkSerializer.cpp
+++ b/contrib/libs/llvm12/lib/Remarks/YAMLRemarkSerializer.cpp
@@ -1,257 +1,257 @@
-//===- YAMLRemarkSerializer.cpp -------------------------------------------===//
-//
-// 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 provides the implementation of the YAML remark serializer using
-// LLVM's YAMLTraits.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Remarks/YAMLRemarkSerializer.h"
-#include "llvm/Support/CommandLine.h"
-
-using namespace llvm;
-using namespace llvm::remarks;
-
-// Use the same keys whether we use a string table or not (respectively, T is an
-// unsigned or a StringRef).
-template <typename T>
-static void mapRemarkHeader(yaml::IO &io, T PassName, T RemarkName,
-                            Optional<RemarkLocation> RL, T FunctionName,
-                            Optional<uint64_t> Hotness,
-                            ArrayRef<Argument> Args) {
-  io.mapRequired("Pass", PassName);
-  io.mapRequired("Name", RemarkName);
-  io.mapOptional("DebugLoc", RL);
-  io.mapRequired("Function", FunctionName);
-  io.mapOptional("Hotness", Hotness);
-  io.mapOptional("Args", Args);
-}
-
-namespace llvm {
-namespace yaml {
-
-template <> struct MappingTraits<remarks::Remark *> {
-  static void mapping(IO &io, remarks::Remark *&Remark) {
-    assert(io.outputting() && "input not yet implemented");
-
-    if (io.mapTag("!Passed", (Remark->RemarkType == Type::Passed)))
-      ;
-    else if (io.mapTag("!Missed", (Remark->RemarkType == Type::Missed)))
-      ;
-    else if (io.mapTag("!Analysis", (Remark->RemarkType == Type::Analysis)))
-      ;
-    else if (io.mapTag("!AnalysisFPCommute",
-                       (Remark->RemarkType == Type::AnalysisFPCommute)))
-      ;
-    else if (io.mapTag("!AnalysisAliasing",
-                       (Remark->RemarkType == Type::AnalysisAliasing)))
-      ;
-    else if (io.mapTag("!Failure", (Remark->RemarkType == Type::Failure)))
-      ;
-    else
-      llvm_unreachable("Unknown remark type");
-
-    if (auto *Serializer = dyn_cast<YAMLStrTabRemarkSerializer>(
-            reinterpret_cast<RemarkSerializer *>(io.getContext()))) {
-      assert(Serializer->StrTab.hasValue() &&
-             "YAMLStrTabSerializer with no StrTab.");
-      StringTable &StrTab = *Serializer->StrTab;
-      unsigned PassID = StrTab.add(Remark->PassName).first;
-      unsigned NameID = StrTab.add(Remark->RemarkName).first;
-      unsigned FunctionID = StrTab.add(Remark->FunctionName).first;
-      mapRemarkHeader(io, PassID, NameID, Remark->Loc, FunctionID,
-                      Remark->Hotness, Remark->Args);
-    } else {
-      mapRemarkHeader(io, Remark->PassName, Remark->RemarkName, Remark->Loc,
-                      Remark->FunctionName, Remark->Hotness, Remark->Args);
-    }
-  }
-};
-
-template <> struct MappingTraits<RemarkLocation> {
-  static void mapping(IO &io, RemarkLocation &RL) {
-    assert(io.outputting() && "input not yet implemented");
-
-    StringRef File = RL.SourceFilePath;
-    unsigned Line = RL.SourceLine;
-    unsigned Col = RL.SourceColumn;
-
-    if (auto *Serializer = dyn_cast<YAMLStrTabRemarkSerializer>(
-            reinterpret_cast<RemarkSerializer *>(io.getContext()))) {
-      assert(Serializer->StrTab.hasValue() &&
-             "YAMLStrTabSerializer with no StrTab.");
-      StringTable &StrTab = *Serializer->StrTab;
-      unsigned FileID = StrTab.add(File).first;
-      io.mapRequired("File", FileID);
-    } else {
-      io.mapRequired("File", File);
-    }
-
-    io.mapRequired("Line", Line);
-    io.mapRequired("Column", Col);
-  }
-
-  static const bool flow = true;
-};
-
-/// Helper struct for multiline string block literals. Use this type to preserve
-/// newlines in strings.
-struct StringBlockVal {
-  StringRef Value;
-  StringBlockVal(StringRef R) : Value(R) {}
-};
-
-template <> struct BlockScalarTraits<StringBlockVal> {
-  static void output(const StringBlockVal &S, void *Ctx, raw_ostream &OS) {
-    return ScalarTraits<StringRef>::output(S.Value, Ctx, OS);
-  }
-
-  static StringRef input(StringRef Scalar, void *Ctx, StringBlockVal &S) {
-    return ScalarTraits<StringRef>::input(Scalar, Ctx, S.Value);
-  }
-};
-
-/// ArrayRef is not really compatible with the YAMLTraits. Everything should be
-/// immutable in an ArrayRef, while the SequenceTraits expect a mutable version
-/// for inputting, but we're only using the outputting capabilities here.
-/// This is a hack, but still nicer than having to manually call the YAMLIO
-/// internal methods.
-/// Keep this in this file so that it doesn't get misused from YAMLTraits.h.
-template <typename T> struct SequenceTraits<ArrayRef<T>> {
-  static size_t size(IO &io, ArrayRef<T> &seq) { return seq.size(); }
-  static Argument &element(IO &io, ArrayRef<T> &seq, size_t index) {
-    assert(io.outputting() && "input not yet implemented");
-    // The assert above should make this "safer" to satisfy the YAMLTraits.
-    return const_cast<T &>(seq[index]);
-  }
-};
-
-/// Implement this as a mapping for now to get proper quotation for the value.
-template <> struct MappingTraits<Argument> {
-  static void mapping(IO &io, Argument &A) {
-    assert(io.outputting() && "input not yet implemented");
-
-    if (auto *Serializer = dyn_cast<YAMLStrTabRemarkSerializer>(
-            reinterpret_cast<RemarkSerializer *>(io.getContext()))) {
-      assert(Serializer->StrTab.hasValue() &&
-             "YAMLStrTabSerializer with no StrTab.");
-      StringTable &StrTab = *Serializer->StrTab;
-      auto ValueID = StrTab.add(A.Val).first;
-      io.mapRequired(A.Key.data(), ValueID);
-    } else if (StringRef(A.Val).count('\n') > 1) {
-      StringBlockVal S(A.Val);
-      io.mapRequired(A.Key.data(), S);
-    } else {
-      io.mapRequired(A.Key.data(), A.Val);
-    }
-    io.mapOptional("DebugLoc", A.Loc);
-  }
-};
-
-} // end namespace yaml
-} // end namespace llvm
-
-LLVM_YAML_IS_SEQUENCE_VECTOR(Argument)
-
-YAMLRemarkSerializer::YAMLRemarkSerializer(raw_ostream &OS, SerializerMode Mode,
-                                           Optional<StringTable> StrTabIn)
-    : YAMLRemarkSerializer(Format::YAML, OS, Mode, std::move(StrTabIn)) {}
-
-YAMLRemarkSerializer::YAMLRemarkSerializer(Format SerializerFormat,
-                                           raw_ostream &OS, SerializerMode Mode,
-                                           Optional<StringTable> StrTabIn)
-    : RemarkSerializer(SerializerFormat, OS, Mode),
-      YAMLOutput(OS, reinterpret_cast<void *>(this)) {
-  StrTab = std::move(StrTabIn);
-}
-
-void YAMLRemarkSerializer::emit(const Remark &Remark) {
-  // Again, YAMLTraits expect a non-const object for inputting, but we're not
-  // using that here.
-  auto R = const_cast<remarks::Remark *>(&Remark);
-  YAMLOutput << R;
-}
-
-std::unique_ptr<MetaSerializer>
-YAMLRemarkSerializer::metaSerializer(raw_ostream &OS,
-                                     Optional<StringRef> ExternalFilename) {
-  return std::make_unique<YAMLMetaSerializer>(OS, ExternalFilename);
-}
-
-void YAMLStrTabRemarkSerializer::emit(const Remark &Remark) {
-  // In standalone mode, for the serializer with a string table, emit the
-  // metadata first and set DidEmitMeta to avoid emitting it again.
-  if (Mode == SerializerMode::Standalone && !DidEmitMeta) {
-    std::unique_ptr<MetaSerializer> MetaSerializer =
-        metaSerializer(OS, /*ExternalFilename=*/None);
-    MetaSerializer->emit();
-    DidEmitMeta = true;
-  }
-
-  // Then do the usual remark emission.
-  YAMLRemarkSerializer::emit(Remark);
-}
-
-std::unique_ptr<MetaSerializer> YAMLStrTabRemarkSerializer::metaSerializer(
-    raw_ostream &OS, Optional<StringRef> ExternalFilename) {
-  assert(StrTab);
-  return std::make_unique<YAMLStrTabMetaSerializer>(OS, ExternalFilename,
-                                                    *StrTab);
-}
-
-static void emitMagic(raw_ostream &OS) {
-  // Emit the magic number.
-  OS << remarks::Magic;
-  // Explicitly emit a '\0'.
-  OS.write('\0');
-}
-
-static void emitVersion(raw_ostream &OS) {
-  // Emit the version number: little-endian uint64_t.
-  std::array<char, 8> Version;
-  support::endian::write64le(Version.data(), remarks::CurrentRemarkVersion);
-  OS.write(Version.data(), Version.size());
-}
-
-static void emitStrTab(raw_ostream &OS, Optional<const StringTable *> StrTab) {
-  // Emit the string table in the section.
-  uint64_t StrTabSize = StrTab ? (*StrTab)->SerializedSize : 0;
-  // Emit the total size of the string table (the size itself excluded):
-  // little-endian uint64_t.
-  // Note: even if no string table is used, emit 0.
-  std::array<char, 8> StrTabSizeBuf;
-  support::endian::write64le(StrTabSizeBuf.data(), StrTabSize);
-  OS.write(StrTabSizeBuf.data(), StrTabSizeBuf.size());
-  if (StrTab)
-    (*StrTab)->serialize(OS);
-}
-
-static void emitExternalFile(raw_ostream &OS, StringRef Filename) {
-  // Emit the null-terminated absolute path to the remark file.
-  SmallString<128> FilenameBuf = Filename;
-  sys::fs::make_absolute(FilenameBuf);
-  assert(!FilenameBuf.empty() && "The filename can't be empty.");
-  OS.write(FilenameBuf.data(), FilenameBuf.size());
-  OS.write('\0');
-}
-
-void YAMLMetaSerializer::emit() {
-  emitMagic(OS);
-  emitVersion(OS);
-  emitStrTab(OS, None);
-  if (ExternalFilename)
-    emitExternalFile(OS, *ExternalFilename);
-}
-
-void YAMLStrTabMetaSerializer::emit() {
-  emitMagic(OS);
-  emitVersion(OS);
-  emitStrTab(OS, &StrTab);
-  if (ExternalFilename)
-    emitExternalFile(OS, *ExternalFilename);
-}
+//===- YAMLRemarkSerializer.cpp -------------------------------------------===// 
+// 
+// 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 provides the implementation of the YAML remark serializer using 
+// LLVM's YAMLTraits. 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include "llvm/Remarks/YAMLRemarkSerializer.h" 
+#include "llvm/Support/CommandLine.h" 
+ 
+using namespace llvm; 
+using namespace llvm::remarks; 
+ 
+// Use the same keys whether we use a string table or not (respectively, T is an 
+// unsigned or a StringRef). 
+template <typename T> 
+static void mapRemarkHeader(yaml::IO &io, T PassName, T RemarkName, 
+                            Optional<RemarkLocation> RL, T FunctionName, 
+                            Optional<uint64_t> Hotness, 
+                            ArrayRef<Argument> Args) { 
+  io.mapRequired("Pass", PassName); 
+  io.mapRequired("Name", RemarkName); 
+  io.mapOptional("DebugLoc", RL); 
+  io.mapRequired("Function", FunctionName); 
+  io.mapOptional("Hotness", Hotness); 
+  io.mapOptional("Args", Args); 
+} 
+ 
+namespace llvm { 
+namespace yaml { 
+ 
+template <> struct MappingTraits<remarks::Remark *> { 
+  static void mapping(IO &io, remarks::Remark *&Remark) { 
+    assert(io.outputting() && "input not yet implemented"); 
+ 
+    if (io.mapTag("!Passed", (Remark->RemarkType == Type::Passed))) 
+      ; 
+    else if (io.mapTag("!Missed", (Remark->RemarkType == Type::Missed))) 
+      ; 
+    else if (io.mapTag("!Analysis", (Remark->RemarkType == Type::Analysis))) 
+      ; 
+    else if (io.mapTag("!AnalysisFPCommute", 
+                       (Remark->RemarkType == Type::AnalysisFPCommute))) 
+      ; 
+    else if (io.mapTag("!AnalysisAliasing", 
+                       (Remark->RemarkType == Type::AnalysisAliasing))) 
+      ; 
+    else if (io.mapTag("!Failure", (Remark->RemarkType == Type::Failure))) 
+      ; 
+    else 
+      llvm_unreachable("Unknown remark type"); 
+ 
+    if (auto *Serializer = dyn_cast<YAMLStrTabRemarkSerializer>( 
+            reinterpret_cast<RemarkSerializer *>(io.getContext()))) { 
+      assert(Serializer->StrTab.hasValue() && 
+             "YAMLStrTabSerializer with no StrTab."); 
+      StringTable &StrTab = *Serializer->StrTab; 
+      unsigned PassID = StrTab.add(Remark->PassName).first; 
+      unsigned NameID = StrTab.add(Remark->RemarkName).first; 
+      unsigned FunctionID = StrTab.add(Remark->FunctionName).first; 
+      mapRemarkHeader(io, PassID, NameID, Remark->Loc, FunctionID, 
+                      Remark->Hotness, Remark->Args); 
+    } else { 
+      mapRemarkHeader(io, Remark->PassName, Remark->RemarkName, Remark->Loc, 
+                      Remark->FunctionName, Remark->Hotness, Remark->Args); 
+    } 
+  } 
+}; 
+ 
+template <> struct MappingTraits<RemarkLocation> { 
+  static void mapping(IO &io, RemarkLocation &RL) { 
+    assert(io.outputting() && "input not yet implemented"); 
+ 
+    StringRef File = RL.SourceFilePath; 
+    unsigned Line = RL.SourceLine; 
+    unsigned Col = RL.SourceColumn; 
+ 
+    if (auto *Serializer = dyn_cast<YAMLStrTabRemarkSerializer>( 
+            reinterpret_cast<RemarkSerializer *>(io.getContext()))) { 
+      assert(Serializer->StrTab.hasValue() && 
+             "YAMLStrTabSerializer with no StrTab."); 
+      StringTable &StrTab = *Serializer->StrTab; 
+      unsigned FileID = StrTab.add(File).first; 
+      io.mapRequired("File", FileID); 
+    } else { 
+      io.mapRequired("File", File); 
+    } 
+ 
+    io.mapRequired("Line", Line); 
+    io.mapRequired("Column", Col); 
+  } 
+ 
+  static const bool flow = true; 
+}; 
+ 
+/// Helper struct for multiline string block literals. Use this type to preserve 
+/// newlines in strings. 
+struct StringBlockVal { 
+  StringRef Value; 
+  StringBlockVal(StringRef R) : Value(R) {} 
+}; 
+ 
+template <> struct BlockScalarTraits<StringBlockVal> { 
+  static void output(const StringBlockVal &S, void *Ctx, raw_ostream &OS) { 
+    return ScalarTraits<StringRef>::output(S.Value, Ctx, OS); 
+  } 
+ 
+  static StringRef input(StringRef Scalar, void *Ctx, StringBlockVal &S) { 
+    return ScalarTraits<StringRef>::input(Scalar, Ctx, S.Value); 
+  } 
+}; 
+ 
+/// ArrayRef is not really compatible with the YAMLTraits. Everything should be 
+/// immutable in an ArrayRef, while the SequenceTraits expect a mutable version 
+/// for inputting, but we're only using the outputting capabilities here. 
+/// This is a hack, but still nicer than having to manually call the YAMLIO 
+/// internal methods. 
+/// Keep this in this file so that it doesn't get misused from YAMLTraits.h. 
+template <typename T> struct SequenceTraits<ArrayRef<T>> { 
+  static size_t size(IO &io, ArrayRef<T> &seq) { return seq.size(); } 
+  static Argument &element(IO &io, ArrayRef<T> &seq, size_t index) { 
+    assert(io.outputting() && "input not yet implemented"); 
+    // The assert above should make this "safer" to satisfy the YAMLTraits. 
+    return const_cast<T &>(seq[index]); 
+  } 
+}; 
+ 
+/// Implement this as a mapping for now to get proper quotation for the value. 
+template <> struct MappingTraits<Argument> { 
+  static void mapping(IO &io, Argument &A) { 
+    assert(io.outputting() && "input not yet implemented"); 
+ 
+    if (auto *Serializer = dyn_cast<YAMLStrTabRemarkSerializer>( 
+            reinterpret_cast<RemarkSerializer *>(io.getContext()))) { 
+      assert(Serializer->StrTab.hasValue() && 
+             "YAMLStrTabSerializer with no StrTab."); 
+      StringTable &StrTab = *Serializer->StrTab; 
+      auto ValueID = StrTab.add(A.Val).first; 
+      io.mapRequired(A.Key.data(), ValueID); 
+    } else if (StringRef(A.Val).count('\n') > 1) { 
+      StringBlockVal S(A.Val); 
+      io.mapRequired(A.Key.data(), S); 
+    } else { 
+      io.mapRequired(A.Key.data(), A.Val); 
+    } 
+    io.mapOptional("DebugLoc", A.Loc); 
+  } 
+}; 
+ 
+} // end namespace yaml 
+} // end namespace llvm 
+ 
+LLVM_YAML_IS_SEQUENCE_VECTOR(Argument) 
+ 
+YAMLRemarkSerializer::YAMLRemarkSerializer(raw_ostream &OS, SerializerMode Mode, 
+                                           Optional<StringTable> StrTabIn) 
+    : YAMLRemarkSerializer(Format::YAML, OS, Mode, std::move(StrTabIn)) {} 
+ 
+YAMLRemarkSerializer::YAMLRemarkSerializer(Format SerializerFormat, 
+                                           raw_ostream &OS, SerializerMode Mode, 
+                                           Optional<StringTable> StrTabIn) 
+    : RemarkSerializer(SerializerFormat, OS, Mode), 
+      YAMLOutput(OS, reinterpret_cast<void *>(this)) { 
+  StrTab = std::move(StrTabIn); 
+} 
+ 
+void YAMLRemarkSerializer::emit(const Remark &Remark) { 
+  // Again, YAMLTraits expect a non-const object for inputting, but we're not 
+  // using that here. 
+  auto R = const_cast<remarks::Remark *>(&Remark); 
+  YAMLOutput << R; 
+} 
+ 
+std::unique_ptr<MetaSerializer> 
+YAMLRemarkSerializer::metaSerializer(raw_ostream &OS, 
+                                     Optional<StringRef> ExternalFilename) { 
+  return std::make_unique<YAMLMetaSerializer>(OS, ExternalFilename); 
+} 
+ 
+void YAMLStrTabRemarkSerializer::emit(const Remark &Remark) { 
+  // In standalone mode, for the serializer with a string table, emit the 
+  // metadata first and set DidEmitMeta to avoid emitting it again. 
+  if (Mode == SerializerMode::Standalone && !DidEmitMeta) { 
+    std::unique_ptr<MetaSerializer> MetaSerializer = 
+        metaSerializer(OS, /*ExternalFilename=*/None); 
+    MetaSerializer->emit(); 
+    DidEmitMeta = true; 
+  } 
+ 
+  // Then do the usual remark emission. 
+  YAMLRemarkSerializer::emit(Remark); 
+} 
+ 
+std::unique_ptr<MetaSerializer> YAMLStrTabRemarkSerializer::metaSerializer( 
+    raw_ostream &OS, Optional<StringRef> ExternalFilename) { 
+  assert(StrTab); 
+  return std::make_unique<YAMLStrTabMetaSerializer>(OS, ExternalFilename, 
+                                                    *StrTab); 
+} 
+ 
+static void emitMagic(raw_ostream &OS) { 
+  // Emit the magic number. 
+  OS << remarks::Magic; 
+  // Explicitly emit a '\0'. 
+  OS.write('\0'); 
+} 
+ 
+static void emitVersion(raw_ostream &OS) { 
+  // Emit the version number: little-endian uint64_t. 
+  std::array<char, 8> Version; 
+  support::endian::write64le(Version.data(), remarks::CurrentRemarkVersion); 
+  OS.write(Version.data(), Version.size()); 
+} 
+ 
+static void emitStrTab(raw_ostream &OS, Optional<const StringTable *> StrTab) { 
+  // Emit the string table in the section. 
+  uint64_t StrTabSize = StrTab ? (*StrTab)->SerializedSize : 0; 
+  // Emit the total size of the string table (the size itself excluded): 
+  // little-endian uint64_t. 
+  // Note: even if no string table is used, emit 0. 
+  std::array<char, 8> StrTabSizeBuf; 
+  support::endian::write64le(StrTabSizeBuf.data(), StrTabSize); 
+  OS.write(StrTabSizeBuf.data(), StrTabSizeBuf.size()); 
+  if (StrTab) 
+    (*StrTab)->serialize(OS); 
+} 
+ 
+static void emitExternalFile(raw_ostream &OS, StringRef Filename) { 
+  // Emit the null-terminated absolute path to the remark file. 
+  SmallString<128> FilenameBuf = Filename; 
+  sys::fs::make_absolute(FilenameBuf); 
+  assert(!FilenameBuf.empty() && "The filename can't be empty."); 
+  OS.write(FilenameBuf.data(), FilenameBuf.size()); 
+  OS.write('\0'); 
+} 
+ 
+void YAMLMetaSerializer::emit() { 
+  emitMagic(OS); 
+  emitVersion(OS); 
+  emitStrTab(OS, None); 
+  if (ExternalFilename) 
+    emitExternalFile(OS, *ExternalFilename); 
+} 
+ 
+void YAMLStrTabMetaSerializer::emit() { 
+  emitMagic(OS); 
+  emitVersion(OS); 
+  emitStrTab(OS, &StrTab); 
+  if (ExternalFilename) 
+    emitExternalFile(OS, *ExternalFilename); 
+}