Restoring authorship annotation for <[email protected]>. Commit 1 of 2.

1 files changed, 321 insertions, 321 deletions

diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc
index 8936f8ca70c..b0f9a9c5c8b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc
@@ -1,264 +1,264 @@
-// Copyright 2017 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.
-//
-// Produce stack trace
-
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
-
-#if defined(__linux__) && (defined(__i386__) || defined(__x86_64__))
-#include <ucontext.h>  // for ucontext_t
-#endif
-
-#if !defined(_WIN32)
-#include <unistd.h>
-#endif
-
-#include <cassert>
-#include <cstdint>
+// Copyright 2017 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. 
+// 
+// Produce stack trace 
+ 
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_ 
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_ 
+ 
+#if defined(__linux__) && (defined(__i386__) || defined(__x86_64__)) 
+#include <ucontext.h>  // for ucontext_t 
+#endif 
+ 
+#if !defined(_WIN32) 
+#include <unistd.h> 
+#endif 
+ 
+#include <cassert> 
+#include <cstdint> 
 #include <limits>
-
+ 
 #include "y_absl/base/macros.h"
 #include "y_absl/base/port.h"
 #include "y_absl/debugging/internal/address_is_readable.h"
 #include "y_absl/debugging/internal/vdso_support.h"  // a no-op on non-elf or non-glibc systems
 #include "y_absl/debugging/stacktrace.h"
-
+ 
 #include "y_absl/base/internal/raw_logging.h"
-
+ 
 using y_absl::debugging_internal::AddressIsReadable;
-
-#if defined(__linux__) && defined(__i386__)
-// Count "push %reg" instructions in VDSO __kernel_vsyscall(),
-// preceeding "syscall" or "sysenter".
-// If __kernel_vsyscall uses frame pointer, answer 0.
-//
-// kMaxBytes tells how many instruction bytes of __kernel_vsyscall
-// to analyze before giving up. Up to kMaxBytes+1 bytes of
-// instructions could be accessed.
-//
-// Here are known __kernel_vsyscall instruction sequences:
-//
-// SYSENTER (linux-2.6.26/arch/x86/vdso/vdso32/sysenter.S).
-// Used on Intel.
-//  0xffffe400 <__kernel_vsyscall+0>:       push   %ecx
-//  0xffffe401 <__kernel_vsyscall+1>:       push   %edx
-//  0xffffe402 <__kernel_vsyscall+2>:       push   %ebp
-//  0xffffe403 <__kernel_vsyscall+3>:       mov    %esp,%ebp
-//  0xffffe405 <__kernel_vsyscall+5>:       sysenter
-//
-// SYSCALL (see linux-2.6.26/arch/x86/vdso/vdso32/syscall.S).
-// Used on AMD.
-//  0xffffe400 <__kernel_vsyscall+0>:       push   %ebp
-//  0xffffe401 <__kernel_vsyscall+1>:       mov    %ecx,%ebp
-//  0xffffe403 <__kernel_vsyscall+3>:       syscall
-//
-
-// The sequence below isn't actually expected in Google fleet,
-// here only for completeness. Remove this comment from OSS release.
-
-// i386 (see linux-2.6.26/arch/x86/vdso/vdso32/int80.S)
-//  0xffffe400 <__kernel_vsyscall+0>:       int $0x80
-//  0xffffe401 <__kernel_vsyscall+1>:       ret
-//
-static const int kMaxBytes = 10;
-
-// We use assert()s instead of DCHECK()s -- this is too low level
-// for DCHECK().
-
-static int CountPushInstructions(const unsigned char *const addr) {
-  int result = 0;
-  for (int i = 0; i < kMaxBytes; ++i) {
-    if (addr[i] == 0x89) {
-      // "mov reg,reg"
-      if (addr[i + 1] == 0xE5) {
-        // Found "mov %esp,%ebp".
-        return 0;
-      }
-      ++i;  // Skip register encoding byte.
-    } else if (addr[i] == 0x0F &&
-               (addr[i + 1] == 0x34 || addr[i + 1] == 0x05)) {
-      // Found "sysenter" or "syscall".
-      return result;
-    } else if ((addr[i] & 0xF0) == 0x50) {
-      // Found "push %reg".
-      ++result;
-    } else if (addr[i] == 0xCD && addr[i + 1] == 0x80) {
-      // Found "int $0x80"
-      assert(result == 0);
-      return 0;
-    } else {
-      // Unexpected instruction.
-      assert(false && "unexpected instruction in __kernel_vsyscall");
-      return 0;
-    }
-  }
-  // Unexpected: didn't find SYSENTER or SYSCALL in
-  // [__kernel_vsyscall, __kernel_vsyscall + kMaxBytes) interval.
-  assert(false && "did not find SYSENTER or SYSCALL in __kernel_vsyscall");
-  return 0;
-}
-#endif
-
-// Assume stack frames larger than 100,000 bytes are bogus.
-static const int kMaxFrameBytes = 100000;
-
-// Returns the stack frame pointer from signal context, 0 if unknown.
-// vuc is a ucontext_t *.  We use void* to avoid the use
-// of ucontext_t on non-POSIX systems.
-static uintptr_t GetFP(const void *vuc) {
-#if !defined(__linux__)
-  static_cast<void>(vuc);  // Avoid an unused argument compiler warning.
-#else
-  if (vuc != nullptr) {
-    auto *uc = reinterpret_cast<const ucontext_t *>(vuc);
-#if defined(__i386__)
-    const auto bp = uc->uc_mcontext.gregs[REG_EBP];
-    const auto sp = uc->uc_mcontext.gregs[REG_ESP];
-#elif defined(__x86_64__)
-    const auto bp = uc->uc_mcontext.gregs[REG_RBP];
-    const auto sp = uc->uc_mcontext.gregs[REG_RSP];
-#else
-    const uintptr_t bp = 0;
-    const uintptr_t sp = 0;
-#endif
+ 
+#if defined(__linux__) && defined(__i386__) 
+// Count "push %reg" instructions in VDSO __kernel_vsyscall(), 
+// preceeding "syscall" or "sysenter". 
+// If __kernel_vsyscall uses frame pointer, answer 0. 
+// 
+// kMaxBytes tells how many instruction bytes of __kernel_vsyscall 
+// to analyze before giving up. Up to kMaxBytes+1 bytes of 
+// instructions could be accessed. 
+// 
+// Here are known __kernel_vsyscall instruction sequences: 
+// 
+// SYSENTER (linux-2.6.26/arch/x86/vdso/vdso32/sysenter.S). 
+// Used on Intel. 
+//  0xffffe400 <__kernel_vsyscall+0>:       push   %ecx 
+//  0xffffe401 <__kernel_vsyscall+1>:       push   %edx 
+//  0xffffe402 <__kernel_vsyscall+2>:       push   %ebp 
+//  0xffffe403 <__kernel_vsyscall+3>:       mov    %esp,%ebp 
+//  0xffffe405 <__kernel_vsyscall+5>:       sysenter 
+// 
+// SYSCALL (see linux-2.6.26/arch/x86/vdso/vdso32/syscall.S). 
+// Used on AMD. 
+//  0xffffe400 <__kernel_vsyscall+0>:       push   %ebp 
+//  0xffffe401 <__kernel_vsyscall+1>:       mov    %ecx,%ebp 
+//  0xffffe403 <__kernel_vsyscall+3>:       syscall 
+// 
+ 
+// The sequence below isn't actually expected in Google fleet, 
+// here only for completeness. Remove this comment from OSS release. 
+ 
+// i386 (see linux-2.6.26/arch/x86/vdso/vdso32/int80.S) 
+//  0xffffe400 <__kernel_vsyscall+0>:       int $0x80 
+//  0xffffe401 <__kernel_vsyscall+1>:       ret 
+// 
+static const int kMaxBytes = 10; 
+ 
+// We use assert()s instead of DCHECK()s -- this is too low level 
+// for DCHECK(). 
+ 
+static int CountPushInstructions(const unsigned char *const addr) { 
+  int result = 0; 
+  for (int i = 0; i < kMaxBytes; ++i) { 
+    if (addr[i] == 0x89) { 
+      // "mov reg,reg" 
+      if (addr[i + 1] == 0xE5) { 
+        // Found "mov %esp,%ebp". 
+        return 0; 
+      } 
+      ++i;  // Skip register encoding byte. 
+    } else if (addr[i] == 0x0F && 
+               (addr[i + 1] == 0x34 || addr[i + 1] == 0x05)) { 
+      // Found "sysenter" or "syscall". 
+      return result; 
+    } else if ((addr[i] & 0xF0) == 0x50) { 
+      // Found "push %reg". 
+      ++result; 
+    } else if (addr[i] == 0xCD && addr[i + 1] == 0x80) { 
+      // Found "int $0x80" 
+      assert(result == 0); 
+      return 0; 
+    } else { 
+      // Unexpected instruction. 
+      assert(false && "unexpected instruction in __kernel_vsyscall"); 
+      return 0; 
+    } 
+  } 
+  // Unexpected: didn't find SYSENTER or SYSCALL in 
+  // [__kernel_vsyscall, __kernel_vsyscall + kMaxBytes) interval. 
+  assert(false && "did not find SYSENTER or SYSCALL in __kernel_vsyscall"); 
+  return 0; 
+} 
+#endif 
+ 
+// Assume stack frames larger than 100,000 bytes are bogus. 
+static const int kMaxFrameBytes = 100000; 
+ 
+// Returns the stack frame pointer from signal context, 0 if unknown. 
+// vuc is a ucontext_t *.  We use void* to avoid the use 
+// of ucontext_t on non-POSIX systems. 
+static uintptr_t GetFP(const void *vuc) { 
+#if !defined(__linux__) 
+  static_cast<void>(vuc);  // Avoid an unused argument compiler warning. 
+#else 
+  if (vuc != nullptr) { 
+    auto *uc = reinterpret_cast<const ucontext_t *>(vuc); 
+#if defined(__i386__) 
+    const auto bp = uc->uc_mcontext.gregs[REG_EBP]; 
+    const auto sp = uc->uc_mcontext.gregs[REG_ESP]; 
+#elif defined(__x86_64__) 
+    const auto bp = uc->uc_mcontext.gregs[REG_RBP]; 
+    const auto sp = uc->uc_mcontext.gregs[REG_RSP]; 
+#else 
+    const uintptr_t bp = 0; 
+    const uintptr_t sp = 0; 
+#endif 
     // Sanity-check that the base pointer is valid. It's possible that some
     // code in the process is compiled with --copt=-fomit-frame-pointer or
-    // --copt=-momit-leaf-frame-pointer.
-    //
-    // TODO(bcmills): -momit-leaf-frame-pointer is currently the default
-    // behavior when building with clang.  Talk to the C++ toolchain team about
-    // fixing that.
-    if (bp >= sp && bp - sp <= kMaxFrameBytes) return bp;
-
-    // If bp isn't a plausible frame pointer, return the stack pointer instead.
-    // If we're lucky, it points to the start of a stack frame; otherwise, we'll
-    // get one frame of garbage in the stack trace and fail the sanity check on
-    // the next iteration.
-    return sp;
-  }
-#endif
-  return 0;
-}
-
-// 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.
+    // --copt=-momit-leaf-frame-pointer. 
+    // 
+    // TODO(bcmills): -momit-leaf-frame-pointer is currently the default 
+    // behavior when building with clang.  Talk to the C++ toolchain team about 
+    // fixing that. 
+    if (bp >= sp && bp - sp <= kMaxFrameBytes) return bp; 
+ 
+    // If bp isn't a plausible frame pointer, return the stack pointer instead. 
+    // If we're lucky, it points to the start of a stack frame; otherwise, we'll 
+    // get one frame of garbage in the stack trace and fail the sanity check on 
+    // the next iteration. 
+    return sp; 
+  } 
+#endif 
+  return 0; 
+} 
+ 
+// 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_fp, const void *uc,
                              size_t stack_low, size_t stack_high) {
-  void **new_fp = (void **)*old_fp;
-
-#if defined(__linux__) && defined(__i386__)
-  if (WITH_CONTEXT && uc != nullptr) {
-    // How many "push %reg" instructions are there at __kernel_vsyscall?
-    // This is constant for a given kernel and processor, so compute
-    // it only once.
-    static int num_push_instructions = -1;  // Sentinel: not computed yet.
-    // Initialize with sentinel value: __kernel_rt_sigreturn can not possibly
-    // be there.
-    static const unsigned char *kernel_rt_sigreturn_address = nullptr;
-    static const unsigned char *kernel_vsyscall_address = nullptr;
-    if (num_push_instructions == -1) {
+  void **new_fp = (void **)*old_fp; 
+ 
+#if defined(__linux__) && defined(__i386__) 
+  if (WITH_CONTEXT && uc != nullptr) { 
+    // How many "push %reg" instructions are there at __kernel_vsyscall? 
+    // This is constant for a given kernel and processor, so compute 
+    // it only once. 
+    static int num_push_instructions = -1;  // Sentinel: not computed yet. 
+    // Initialize with sentinel value: __kernel_rt_sigreturn can not possibly 
+    // be there. 
+    static const unsigned char *kernel_rt_sigreturn_address = nullptr; 
+    static const unsigned char *kernel_vsyscall_address = nullptr; 
+    if (num_push_instructions == -1) { 
 #ifdef ABSL_HAVE_VDSO_SUPPORT
       y_absl::debugging_internal::VDSOSupport vdso;
-      if (vdso.IsPresent()) {
+      if (vdso.IsPresent()) { 
         y_absl::debugging_internal::VDSOSupport::SymbolInfo
-            rt_sigreturn_symbol_info;
+            rt_sigreturn_symbol_info; 
         y_absl::debugging_internal::VDSOSupport::SymbolInfo vsyscall_symbol_info;
-        if (!vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_2.5", STT_FUNC,
-                               &rt_sigreturn_symbol_info) ||
-            !vdso.LookupSymbol("__kernel_vsyscall", "LINUX_2.5", STT_FUNC,
-                               &vsyscall_symbol_info) ||
-            rt_sigreturn_symbol_info.address == nullptr ||
-            vsyscall_symbol_info.address == nullptr) {
-          // Unexpected: 32-bit VDSO is present, yet one of the expected
-          // symbols is missing or null.
-          assert(false && "VDSO is present, but doesn't have expected symbols");
-          num_push_instructions = 0;
-        } else {
-          kernel_rt_sigreturn_address =
-              reinterpret_cast<const unsigned char *>(
-                  rt_sigreturn_symbol_info.address);
-          kernel_vsyscall_address =
-              reinterpret_cast<const unsigned char *>(
-                  vsyscall_symbol_info.address);
-          num_push_instructions =
-              CountPushInstructions(kernel_vsyscall_address);
-        }
-      } else {
-        num_push_instructions = 0;
-      }
+        if (!vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_2.5", STT_FUNC, 
+                               &rt_sigreturn_symbol_info) || 
+            !vdso.LookupSymbol("__kernel_vsyscall", "LINUX_2.5", STT_FUNC, 
+                               &vsyscall_symbol_info) || 
+            rt_sigreturn_symbol_info.address == nullptr || 
+            vsyscall_symbol_info.address == nullptr) { 
+          // Unexpected: 32-bit VDSO is present, yet one of the expected 
+          // symbols is missing or null. 
+          assert(false && "VDSO is present, but doesn't have expected symbols"); 
+          num_push_instructions = 0; 
+        } else { 
+          kernel_rt_sigreturn_address = 
+              reinterpret_cast<const unsigned char *>( 
+                  rt_sigreturn_symbol_info.address); 
+          kernel_vsyscall_address = 
+              reinterpret_cast<const unsigned char *>( 
+                  vsyscall_symbol_info.address); 
+          num_push_instructions = 
+              CountPushInstructions(kernel_vsyscall_address); 
+        } 
+      } else { 
+        num_push_instructions = 0; 
+      } 
 #else  // ABSL_HAVE_VDSO_SUPPORT
       num_push_instructions = 0;
 #endif  // ABSL_HAVE_VDSO_SUPPORT
-    }
-    if (num_push_instructions != 0 && kernel_rt_sigreturn_address != nullptr &&
-        old_fp[1] == kernel_rt_sigreturn_address) {
-      const ucontext_t *ucv = static_cast<const ucontext_t *>(uc);
-      // This kernel does not use frame pointer in its VDSO code,
-      // and so %ebp is not suitable for unwinding.
-      void **const reg_ebp =
-          reinterpret_cast<void **>(ucv->uc_mcontext.gregs[REG_EBP]);
-      const unsigned char *const reg_eip =
-          reinterpret_cast<unsigned char *>(ucv->uc_mcontext.gregs[REG_EIP]);
-      if (new_fp == reg_ebp && kernel_vsyscall_address <= reg_eip &&
-          reg_eip - kernel_vsyscall_address < kMaxBytes) {
-        // We "stepped up" to __kernel_vsyscall, but %ebp is not usable.
-        // Restore from 'ucv' instead.
-        void **const reg_esp =
-            reinterpret_cast<void **>(ucv->uc_mcontext.gregs[REG_ESP]);
-        // Check that alleged %esp is not null and is reasonably aligned.
-        if (reg_esp &&
-            ((uintptr_t)reg_esp & (sizeof(reg_esp) - 1)) == 0) {
-          // Check that alleged %esp is actually readable. This is to prevent
-          // "double fault" in case we hit the first fault due to e.g. stack
-          // corruption.
-          void *const reg_esp2 = reg_esp[num_push_instructions - 1];
-          if (AddressIsReadable(reg_esp2)) {
-            // Alleged %esp is readable, use it for further unwinding.
-            new_fp = reinterpret_cast<void **>(reg_esp2);
-          }
-        }
-      }
-    }
-  }
-#endif
-
-  const uintptr_t old_fp_u = reinterpret_cast<uintptr_t>(old_fp);
-  const uintptr_t new_fp_u = reinterpret_cast<uintptr_t>(new_fp);
-
-  // Check that the transition from frame pointer old_fp to frame
-  // pointer new_fp isn't clearly bogus.  Skip the checks if new_fp
-  // matches the signal context, so that we don't skip out early when
-  // using an alternate signal stack.
-  //
-  // TODO(bcmills): The GetFP call should be completely unnecessary when
+    } 
+    if (num_push_instructions != 0 && kernel_rt_sigreturn_address != nullptr && 
+        old_fp[1] == kernel_rt_sigreturn_address) { 
+      const ucontext_t *ucv = static_cast<const ucontext_t *>(uc); 
+      // This kernel does not use frame pointer in its VDSO code, 
+      // and so %ebp is not suitable for unwinding. 
+      void **const reg_ebp = 
+          reinterpret_cast<void **>(ucv->uc_mcontext.gregs[REG_EBP]); 
+      const unsigned char *const reg_eip = 
+          reinterpret_cast<unsigned char *>(ucv->uc_mcontext.gregs[REG_EIP]); 
+      if (new_fp == reg_ebp && kernel_vsyscall_address <= reg_eip && 
+          reg_eip - kernel_vsyscall_address < kMaxBytes) { 
+        // We "stepped up" to __kernel_vsyscall, but %ebp is not usable. 
+        // Restore from 'ucv' instead. 
+        void **const reg_esp = 
+            reinterpret_cast<void **>(ucv->uc_mcontext.gregs[REG_ESP]); 
+        // Check that alleged %esp is not null and is reasonably aligned. 
+        if (reg_esp && 
+            ((uintptr_t)reg_esp & (sizeof(reg_esp) - 1)) == 0) { 
+          // Check that alleged %esp is actually readable. This is to prevent 
+          // "double fault" in case we hit the first fault due to e.g. stack 
+          // corruption. 
+          void *const reg_esp2 = reg_esp[num_push_instructions - 1]; 
+          if (AddressIsReadable(reg_esp2)) { 
+            // Alleged %esp is readable, use it for further unwinding. 
+            new_fp = reinterpret_cast<void **>(reg_esp2); 
+          } 
+        } 
+      } 
+    } 
+  } 
+#endif 
+ 
+  const uintptr_t old_fp_u = reinterpret_cast<uintptr_t>(old_fp); 
+  const uintptr_t new_fp_u = reinterpret_cast<uintptr_t>(new_fp); 
+ 
+  // Check that the transition from frame pointer old_fp to frame 
+  // pointer new_fp isn't clearly bogus.  Skip the checks if new_fp 
+  // matches the signal context, so that we don't skip out early when 
+  // using an alternate signal stack. 
+  // 
+  // TODO(bcmills): The GetFP call should be completely unnecessary when 
   // ENABLE_COMBINED_UNWINDER is set (because we should be back in the thread's
-  // stack by this point), but it is empirically still needed (e.g. when the
-  // stack includes a call to abort).  unw_get_reg returns UNW_EBADREG for some
-  // frames.  Figure out why GetValidFrameAddr and/or libunwind isn't doing what
-  // it's supposed to.
-  if (STRICT_UNWINDING &&
-      (!WITH_CONTEXT || uc == nullptr || new_fp_u != GetFP(uc))) {
-    // With the stack growing downwards, older stack frame must be
-    // at a greater address that the current one.
-    if (new_fp_u <= old_fp_u) return nullptr;
-    if (new_fp_u - old_fp_u > kMaxFrameBytes) return nullptr;
+  // stack by this point), but it is empirically still needed (e.g. when the 
+  // stack includes a call to abort).  unw_get_reg returns UNW_EBADREG for some 
+  // frames.  Figure out why GetValidFrameAddr and/or libunwind isn't doing what 
+  // it's supposed to. 
+  if (STRICT_UNWINDING && 
+      (!WITH_CONTEXT || uc == nullptr || new_fp_u != GetFP(uc))) { 
+    // With the stack growing downwards, older stack frame must be 
+    // at a greater address that the current one. 
+    if (new_fp_u <= old_fp_u) return nullptr; 
+    if (new_fp_u - old_fp_u > kMaxFrameBytes) return nullptr; 
 
     if (stack_low < old_fp_u && old_fp_u <= stack_high) {
       // Old BP was in the expected stack region...
@@ -271,94 +271,94 @@ static void **NextStackFrame(void **old_fp, const void *uc,
       // We may be here if we are executing in a co-routine with a
       // separate stack. We can't do safety checks in this case.
     }
-  } else {
-    if (new_fp == nullptr) return nullptr;  // skip AddressIsReadable() below
-    // In the non-strict mode, allow discontiguous stack frames.
-    // (alternate-signal-stacks for example).
-    if (new_fp == old_fp) return nullptr;
-  }
-
-  if (new_fp_u & (sizeof(void *) - 1)) return nullptr;
-#ifdef __i386__
-  // On 32-bit machines, the stack pointer can be very close to
-  // 0xffffffff, so we explicitly check for a pointer into the
-  // last two pages in the address space
-  if (new_fp_u >= 0xffffe000) return nullptr;
-#endif
-#if !defined(_WIN32)
-  if (!STRICT_UNWINDING) {
-    // Lax sanity checks cause a crash in 32-bit tcmalloc/crash_reason_test
-    // on AMD-based machines with VDSO-enabled kernels.
-    // Make an extra sanity check to insure new_fp is readable.
-    // Note: NextStackFrame<false>() is only called while the program
-    //       is already on its last leg, so it's ok to be slow here.
-
-    if (!AddressIsReadable(new_fp)) {
-      return nullptr;
-    }
-  }
-#endif
-  return new_fp;
-}
-
-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.
-ABSL_ATTRIBUTE_NOINLINE
-static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
-                      const void *ucp, int *min_dropped_frames) {
-  int n = 0;
-  void **fp = reinterpret_cast<void **>(__builtin_frame_address(0));
-
+  } else { 
+    if (new_fp == nullptr) return nullptr;  // skip AddressIsReadable() below 
+    // In the non-strict mode, allow discontiguous stack frames. 
+    // (alternate-signal-stacks for example). 
+    if (new_fp == old_fp) return nullptr; 
+  } 
+ 
+  if (new_fp_u & (sizeof(void *) - 1)) return nullptr; 
+#ifdef __i386__ 
+  // On 32-bit machines, the stack pointer can be very close to 
+  // 0xffffffff, so we explicitly check for a pointer into the 
+  // last two pages in the address space 
+  if (new_fp_u >= 0xffffe000) return nullptr; 
+#endif 
+#if !defined(_WIN32) 
+  if (!STRICT_UNWINDING) { 
+    // Lax sanity checks cause a crash in 32-bit tcmalloc/crash_reason_test 
+    // on AMD-based machines with VDSO-enabled kernels. 
+    // Make an extra sanity check to insure new_fp is readable. 
+    // Note: NextStackFrame<false>() is only called while the program 
+    //       is already on its last leg, so it's ok to be slow here. 
+ 
+    if (!AddressIsReadable(new_fp)) { 
+      return nullptr; 
+    } 
+  } 
+#endif 
+  return new_fp; 
+} 
+ 
+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. 
+ABSL_ATTRIBUTE_NOINLINE 
+static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count, 
+                      const void *ucp, int *min_dropped_frames) { 
+  int n = 0; 
+  void **fp = reinterpret_cast<void **>(__builtin_frame_address(0)); 
+ 
   size_t stack_low = getpagesize();  // Assume that the first page is not stack.
   size_t stack_high = std::numeric_limits<size_t>::max() - sizeof(void *);
 
-  while (fp && n < max_depth) {
-    if (*(fp + 1) == reinterpret_cast<void *>(0)) {
-      // In 64-bit code, we often see a frame that
-      // points to itself and has a return address of 0.
-      break;
-    }
+  while (fp && n < max_depth) { 
+    if (*(fp + 1) == reinterpret_cast<void *>(0)) { 
+      // In 64-bit code, we often see a frame that 
+      // points to itself and has a return address of 0. 
+      break; 
+    } 
     void **next_fp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(
         fp, ucp, stack_low, stack_high);
-    if (skip_count > 0) {
-      skip_count--;
-    } else {
-      result[n] = *(fp + 1);
-      if (IS_STACK_FRAMES) {
-        if (next_fp > fp) {
-          sizes[n] = (uintptr_t)next_fp - (uintptr_t)fp;
-        } else {
-          // A frame-size of 0 is used to indicate unknown frame size.
-          sizes[n] = 0;
-        }
-      }
-      n++;
-    }
-    fp = next_fp;
-  }
-  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 = 1000;
-    int j = 0;
-    for (; fp != nullptr && j < kMaxUnwind; j++) {
+    if (skip_count > 0) { 
+      skip_count--; 
+    } else { 
+      result[n] = *(fp + 1); 
+      if (IS_STACK_FRAMES) { 
+        if (next_fp > fp) { 
+          sizes[n] = (uintptr_t)next_fp - (uintptr_t)fp; 
+        } else { 
+          // A frame-size of 0 is used to indicate unknown frame size. 
+          sizes[n] = 0; 
+        } 
+      } 
+      n++; 
+    } 
+    fp = next_fp; 
+  } 
+  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 = 1000; 
+    int j = 0; 
+    for (; fp != nullptr && j < kMaxUnwind; j++) { 
       fp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(fp, ucp, stack_low,
                                                              stack_high);
-    }
-    *min_dropped_frames = j;
-  }
-  return n;
-}
-
+    } 
+    *min_dropped_frames = j; 
+  } 
+  return n; 
+} 
+ 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-bool StackTraceWorksForTest() {
-  return true;
-}
-}  // namespace debugging_internal
+namespace debugging_internal { 
+bool StackTraceWorksForTest() { 
+  return true; 
+} 
+}  // namespace debugging_internal 
 ABSL_NAMESPACE_END
 }  // namespace y_absl
-
-#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
+ 
+#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_