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

1 files changed, 72 insertions, 72 deletions

diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp
index 01bcdd9be2..68a4bfba42 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) {