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

1 files changed, 234 insertions, 234 deletions

diff --git a/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_riscv-inl.inc b/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_riscv-inl.inc
index 8cbc78548c..933c2d3015 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_riscv-inl.inc
+++ b/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_riscv-inl.inc
@@ -1,234 +1,234 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_
-
-// Generate stack trace for riscv
-
-#include <sys/ucontext.h>
-
-#include "absl/base/config.h"
-#if defined(__linux__)
-#include <sys/mman.h>
-#include <ucontext.h>
-#include <unistd.h>
-#endif
-
-#include <atomic>
-#include <cassert>
-#include <cstdint>
-#include <iostream>
-
-#include "absl/base/attributes.h"
-#include "absl/debugging/internal/address_is_readable.h"
-#include "absl/debugging/internal/vdso_support.h"
-#include "absl/debugging/stacktrace.h"
-
-static const uintptr_t kUnknownFrameSize = 0;
-
-#if defined(__linux__)
-// Returns the address of the VDSO __kernel_rt_sigreturn function, if present.
-static const unsigned char *GetKernelRtSigreturnAddress() {
-  constexpr uintptr_t kImpossibleAddress = 0;
-  ABSL_CONST_INIT static std::atomic<uintptr_t> memoized(kImpossibleAddress);
-  uintptr_t address = memoized.load(std::memory_order_relaxed);
-  if (address != kImpossibleAddress) {
-    return reinterpret_cast<const unsigned char *>(address);
-  }
-
-  address = reinterpret_cast<uintptr_t>(nullptr);
-
-#if ABSL_HAVE_VDSO_SUPPORT
-  absl::debugging_internal::VDSOSupport vdso;
-  if (vdso.IsPresent()) {
-    absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info;
-    // Symbol versioning pulled from arch/riscv/kernel/vdso/vdso.lds at v5.10.
-    auto lookup = [&](int type) {
-      return vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_4.15", type,
-                               &symbol_info);
-    };
-    if ((!lookup(STT_FUNC) && !lookup(STT_NOTYPE)) ||
-        symbol_info.address == nullptr) {
-      // Unexpected: VDSO is present, yet the expected symbol is missing or
-      // null.
-      assert(false && "VDSO is present, but doesn't have expected symbol");
-    } else {
-      if (reinterpret_cast<uintptr_t>(symbol_info.address) !=
-          kImpossibleAddress) {
-        address = reinterpret_cast<uintptr_t>(symbol_info.address);
-      } else {
-        assert(false && "VDSO returned invalid address");
-      }
-    }
-  }
-#endif
-
-  memoized.store(address, std::memory_order_relaxed);
-  return reinterpret_cast<const unsigned char *>(address);
-}
-#endif  // __linux__
-
-// Compute the size of a stack frame in [low..high).  We assume that low < high.
-// Return size of kUnknownFrameSize.
-template <typename T>
-static inline uintptr_t ComputeStackFrameSize(const T *low, const T *high) {
-  const char *low_char_ptr = reinterpret_cast<const char *>(low);
-  const char *high_char_ptr = reinterpret_cast<const char *>(high);
-  return low < high ? high_char_ptr - low_char_ptr : kUnknownFrameSize;
-}
-
-// Given a pointer to a stack frame, locate and return the calling stackframe,
-// or return null if no stackframe can be found. Perform sanity checks (the
-// strictness of which is controlled by the boolean parameter
-// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
-template <bool STRICT_UNWINDING, bool WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
-static void ** NextStackFrame(void **old_frame_pointer, const void *uc) {
-  //               .
-  //               .
-  //               .
-  //   +-> +----------------+
-  //   |   | return address |
-  //   |   |   previous fp  |
-  //   |   |      ...       |
-  //   |   +----------------+ <-+
-  //   |   | return address |   |
-  //   +---|-  previous fp  |   |
-  //       |      ...       |   |
-  // $fp ->|----------------+   |
-  //       | return address |   |
-  //       |   previous fp -|---+
-  // $sp ->|      ...       |
-  //       +----------------+
-  void **new_frame_pointer = reinterpret_cast<void **>(old_frame_pointer[-2]);
-  bool check_frame_size = true;
-
-#if defined(__linux__)
-  if (WITH_CONTEXT && uc != nullptr) {
-    // Check to see if next frame's return address is __kernel_rt_sigreturn.
-    if (old_frame_pointer[-1] == GetKernelRtSigreturnAddress()) {
-      const ucontext_t *ucv = static_cast<const ucontext_t *>(uc);
-      // old_frame_pointer is not suitable for unwinding, look at ucontext to
-      // discover frame pointer before signal.
-      //
-      // RISCV ELF psABI has the frame pointer at x8/fp/s0.
-      // -- RISCV psABI Table 18.2
-      void **const pre_signal_frame_pointer =
-          reinterpret_cast<void **>(ucv->uc_mcontext.__gregs[8]);
-
-      // Check the alleged frame pointer is actually readable. This is to
-      // prevent "double fault" in case we hit the first fault due to stack
-      // corruption.
-      if (!absl::debugging_internal::AddressIsReadable(
-              pre_signal_frame_pointer))
-        return nullptr;
-
-      // Alleged frame pointer is readable, use it for further unwinding.
-      new_frame_pointer = pre_signal_frame_pointer;
-
-      // Skip frame size check if we return from a signal.  We may be using an
-      // alterate stack for signals.
-      check_frame_size = false;
-    }
-  }
-#endif
-
-  // The RISCV ELF psABI mandates that the stack pointer is always 16-byte
-  // aligned.
-  // FIXME(abdulras) this doesn't hold for ILP32E which only mandates a 4-byte
-  // alignment.
-  if ((reinterpret_cast<uintptr_t>(new_frame_pointer) & 15) != 0)
-    return nullptr;
-
-  // Check frame size.  In strict mode, we assume frames to be under 100,000
-  // bytes.  In non-strict mode, we relax the limit to 1MB.
-  if (check_frame_size) {
-    const uintptr_t max_size = STRICT_UNWINDING ? 100000 : 1000000;
-    const uintptr_t frame_size =
-        ComputeStackFrameSize(old_frame_pointer, new_frame_pointer);
-    if (frame_size == kUnknownFrameSize || frame_size > max_size)
-      return nullptr;
-  }
-
-  return new_frame_pointer;
-}
-
-template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
-static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
-                      const void *ucp, int *min_dropped_frames) {
-#if defined(__GNUC__)
-  void **frame_pointer = reinterpret_cast<void **>(__builtin_frame_address(0));
-#else
-#error reading stack pointer not yet supported on this platform
-#endif
-
-  skip_count++;  // Skip the frame for this function.
-  int n = 0;
-
-  // The `frame_pointer` that is computed here points to the top of the frame.
-  // The two words preceding the address are the return address and the previous
-  // frame pointer.  To find a PC value associated with the current frame, we
-  // need to go down a level in the call chain.  So we remember the return
-  // address of the last frame seen.  This does not work for the first stack
-  // frame, which belongs to `UnwindImp()` but we skip the frame for
-  // `UnwindImp()` anyway.
-  void *prev_return_address = nullptr;
-
-  while (frame_pointer && n < max_depth) {
-    // The absl::GetStackFrames routine si called when we are in some
-    // informational context (the failure signal handler for example).  Use the
-    // non-strict unwinding rules to produce a stack trace that is as complete
-    // as possible (even if it contains a few bogus entries in some rare cases).
-    void **next_frame_pointer =
-        NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp);
-
-    if (skip_count > 0) {
-      skip_count--;
-    } else {
-      result[n] = prev_return_address;
-      if (IS_STACK_FRAMES) {
-        sizes[n] = ComputeStackFrameSize(frame_pointer, next_frame_pointer);
-      }
-      n++;
-    }
-    prev_return_address = frame_pointer[-1];
-    frame_pointer = next_frame_pointer;
-  }
-  if (min_dropped_frames != nullptr) {
-    // Implementation detail: we clamp the max of frames we are willing to
-    // count, so as not to spend too much time in the loop below.
-    const int kMaxUnwind = 200;
-    int j = 0;
-    for (; frame_pointer != nullptr && j < kMaxUnwind; j++) {
-      frame_pointer =
-          NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp);
-    }
-    *min_dropped_frames = j;
-  }
-  return n;
-}
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-bool StackTraceWorksForTest() { return true; }
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif
+// Copyright 2021 The Abseil Authors 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//     https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+ 
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_ 
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_ 
+ 
+// Generate stack trace for riscv 
+ 
+#include <sys/ucontext.h> 
+ 
+#include "absl/base/config.h" 
+#if defined(__linux__) 
+#include <sys/mman.h> 
+#include <ucontext.h> 
+#include <unistd.h> 
+#endif 
+ 
+#include <atomic> 
+#include <cassert> 
+#include <cstdint> 
+#include <iostream> 
+ 
+#include "absl/base/attributes.h" 
+#include "absl/debugging/internal/address_is_readable.h" 
+#include "absl/debugging/internal/vdso_support.h" 
+#include "absl/debugging/stacktrace.h" 
+ 
+static const uintptr_t kUnknownFrameSize = 0; 
+ 
+#if defined(__linux__) 
+// Returns the address of the VDSO __kernel_rt_sigreturn function, if present. 
+static const unsigned char *GetKernelRtSigreturnAddress() { 
+  constexpr uintptr_t kImpossibleAddress = 0; 
+  ABSL_CONST_INIT static std::atomic<uintptr_t> memoized(kImpossibleAddress); 
+  uintptr_t address = memoized.load(std::memory_order_relaxed); 
+  if (address != kImpossibleAddress) { 
+    return reinterpret_cast<const unsigned char *>(address); 
+  } 
+ 
+  address = reinterpret_cast<uintptr_t>(nullptr); 
+ 
+#if ABSL_HAVE_VDSO_SUPPORT 
+  absl::debugging_internal::VDSOSupport vdso; 
+  if (vdso.IsPresent()) { 
+    absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info; 
+    // Symbol versioning pulled from arch/riscv/kernel/vdso/vdso.lds at v5.10. 
+    auto lookup = [&](int type) { 
+      return vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_4.15", type, 
+                               &symbol_info); 
+    }; 
+    if ((!lookup(STT_FUNC) && !lookup(STT_NOTYPE)) || 
+        symbol_info.address == nullptr) { 
+      // Unexpected: VDSO is present, yet the expected symbol is missing or 
+      // null. 
+      assert(false && "VDSO is present, but doesn't have expected symbol"); 
+    } else { 
+      if (reinterpret_cast<uintptr_t>(symbol_info.address) != 
+          kImpossibleAddress) { 
+        address = reinterpret_cast<uintptr_t>(symbol_info.address); 
+      } else { 
+        assert(false && "VDSO returned invalid address"); 
+      } 
+    } 
+  } 
+#endif 
+ 
+  memoized.store(address, std::memory_order_relaxed); 
+  return reinterpret_cast<const unsigned char *>(address); 
+} 
+#endif  // __linux__ 
+ 
+// Compute the size of a stack frame in [low..high).  We assume that low < high. 
+// Return size of kUnknownFrameSize. 
+template <typename T> 
+static inline uintptr_t ComputeStackFrameSize(const T *low, const T *high) { 
+  const char *low_char_ptr = reinterpret_cast<const char *>(low); 
+  const char *high_char_ptr = reinterpret_cast<const char *>(high); 
+  return low < high ? high_char_ptr - low_char_ptr : kUnknownFrameSize; 
+} 
+ 
+// Given a pointer to a stack frame, locate and return the calling stackframe, 
+// or return null if no stackframe can be found. Perform sanity checks (the 
+// strictness of which is controlled by the boolean parameter 
+// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned. 
+template <bool STRICT_UNWINDING, bool WITH_CONTEXT> 
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack. 
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack. 
+static void ** NextStackFrame(void **old_frame_pointer, const void *uc) { 
+  //               . 
+  //               . 
+  //               . 
+  //   +-> +----------------+ 
+  //   |   | return address | 
+  //   |   |   previous fp  | 
+  //   |   |      ...       | 
+  //   |   +----------------+ <-+ 
+  //   |   | return address |   | 
+  //   +---|-  previous fp  |   | 
+  //       |      ...       |   | 
+  // $fp ->|----------------+   | 
+  //       | return address |   | 
+  //       |   previous fp -|---+ 
+  // $sp ->|      ...       | 
+  //       +----------------+ 
+  void **new_frame_pointer = reinterpret_cast<void **>(old_frame_pointer[-2]); 
+  bool check_frame_size = true; 
+ 
+#if defined(__linux__) 
+  if (WITH_CONTEXT && uc != nullptr) { 
+    // Check to see if next frame's return address is __kernel_rt_sigreturn. 
+    if (old_frame_pointer[-1] == GetKernelRtSigreturnAddress()) { 
+      const ucontext_t *ucv = static_cast<const ucontext_t *>(uc); 
+      // old_frame_pointer is not suitable for unwinding, look at ucontext to 
+      // discover frame pointer before signal. 
+      // 
+      // RISCV ELF psABI has the frame pointer at x8/fp/s0. 
+      // -- RISCV psABI Table 18.2 
+      void **const pre_signal_frame_pointer = 
+          reinterpret_cast<void **>(ucv->uc_mcontext.__gregs[8]); 
+ 
+      // Check the alleged frame pointer is actually readable. This is to 
+      // prevent "double fault" in case we hit the first fault due to stack 
+      // corruption. 
+      if (!absl::debugging_internal::AddressIsReadable( 
+              pre_signal_frame_pointer)) 
+        return nullptr; 
+ 
+      // Alleged frame pointer is readable, use it for further unwinding. 
+      new_frame_pointer = pre_signal_frame_pointer; 
+ 
+      // Skip frame size check if we return from a signal.  We may be using an 
+      // alterate stack for signals. 
+      check_frame_size = false; 
+    } 
+  } 
+#endif 
+ 
+  // The RISCV ELF psABI mandates that the stack pointer is always 16-byte 
+  // aligned. 
+  // FIXME(abdulras) this doesn't hold for ILP32E which only mandates a 4-byte 
+  // alignment. 
+  if ((reinterpret_cast<uintptr_t>(new_frame_pointer) & 15) != 0) 
+    return nullptr; 
+ 
+  // Check frame size.  In strict mode, we assume frames to be under 100,000 
+  // bytes.  In non-strict mode, we relax the limit to 1MB. 
+  if (check_frame_size) { 
+    const uintptr_t max_size = STRICT_UNWINDING ? 100000 : 1000000; 
+    const uintptr_t frame_size = 
+        ComputeStackFrameSize(old_frame_pointer, new_frame_pointer); 
+    if (frame_size == kUnknownFrameSize || frame_size > max_size) 
+      return nullptr; 
+  } 
+ 
+  return new_frame_pointer; 
+} 
+ 
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT> 
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack. 
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack. 
+static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count, 
+                      const void *ucp, int *min_dropped_frames) { 
+#if defined(__GNUC__) 
+  void **frame_pointer = reinterpret_cast<void **>(__builtin_frame_address(0)); 
+#else 
+#error reading stack pointer not yet supported on this platform 
+#endif 
+ 
+  skip_count++;  // Skip the frame for this function. 
+  int n = 0; 
+ 
+  // The `frame_pointer` that is computed here points to the top of the frame. 
+  // The two words preceding the address are the return address and the previous 
+  // frame pointer.  To find a PC value associated with the current frame, we 
+  // need to go down a level in the call chain.  So we remember the return 
+  // address of the last frame seen.  This does not work for the first stack 
+  // frame, which belongs to `UnwindImp()` but we skip the frame for 
+  // `UnwindImp()` anyway. 
+  void *prev_return_address = nullptr; 
+ 
+  while (frame_pointer && n < max_depth) { 
+    // The absl::GetStackFrames routine si called when we are in some 
+    // informational context (the failure signal handler for example).  Use the 
+    // non-strict unwinding rules to produce a stack trace that is as complete 
+    // as possible (even if it contains a few bogus entries in some rare cases). 
+    void **next_frame_pointer = 
+        NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp); 
+ 
+    if (skip_count > 0) { 
+      skip_count--; 
+    } else { 
+      result[n] = prev_return_address; 
+      if (IS_STACK_FRAMES) { 
+        sizes[n] = ComputeStackFrameSize(frame_pointer, next_frame_pointer); 
+      } 
+      n++; 
+    } 
+    prev_return_address = frame_pointer[-1]; 
+    frame_pointer = next_frame_pointer; 
+  } 
+  if (min_dropped_frames != nullptr) { 
+    // Implementation detail: we clamp the max of frames we are willing to 
+    // count, so as not to spend too much time in the loop below. 
+    const int kMaxUnwind = 200; 
+    int j = 0; 
+    for (; frame_pointer != nullptr && j < kMaxUnwind; j++) { 
+      frame_pointer = 
+          NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp); 
+    } 
+    *min_dropped_frames = j; 
+  } 
+  return n; 
+} 
+ 
+namespace absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace debugging_internal { 
+bool StackTraceWorksForTest() { return true; } 
+}  // namespace debugging_internal 
+ABSL_NAMESPACE_END 
+}  // namespace absl 
+ 
+#endif