grpc 1.84.0.pre1 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/crc/internal/non_temporal_arm_intrinsics.h

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// SKIP_ABSL_INLINE_NAMESPACE_CHECK
+
 #ifndef ABSL_CRC_INTERNAL_NON_TEMPORAL_ARM_INTRINSICS_H_
 #define ABSL_CRC_INTERNAL_NON_TEMPORAL_ARM_INTRINSICS_H_
 
@@ -21,7 +23,7 @@
 #include <arm_neon.h>
 
 typedef int64x2_t __m128i; /* 128-bit vector containing integers */
-#define vreinterpretq_m128i_s32(x) vreinterpretq_s64_s32(x)
+#define vreinterpretq_m128i_s64(x) (x)
 #define vreinterpretq_s64_m128i(x) (x)
 
 // Guarantees that every preceding store is globally visible before any
@@ -44,7 +46,7 @@ static inline __attribute__((always_inline)) void _mm_sfence(void) {
 // https://msdn.microsoft.com/zh-cn/library/f4k12ae8(v=vs.90).aspx
 static inline __attribute__((always_inline)) __m128i _mm_loadu_si128(
     const __m128i *p) {
-  return vreinterpretq_m128i_s32(vld1q_s32((const int32_t *)p));
+  return vreinterpretq_m128i_s64(vld1q_s64((const int64_t*)p));
 }
 
 // Stores the data in a to the address p without polluting the caches.  If the

data/third_party/abseil-cpp/absl/debugging/internal/demangle.cc

@@ -28,7 +28,7 @@
 #include "absl/base/config.h"
 #include "absl/debugging/internal/demangle_rust.h"
 
-#if ABSL_INTERNAL_HAS_CXA_DEMANGLE
+#ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
 #include <cxxabi.h>
 #endif
 
@@ -2941,7 +2941,7 @@ std::string DemangleString(const char* mangled) {
   std::string out;
   int status = 0;
   char* demangled = nullptr;
-#if ABSL_INTERNAL_HAS_CXA_DEMANGLE
+#ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
   demangled = abi::__cxa_demangle(mangled, nullptr, nullptr, &status);
 #endif
   if (status == 0 && demangled != nullptr) {

data/third_party/abseil-cpp/absl/debugging/internal/demangle_rust.h

@@ -32,6 +32,14 @@ namespace debugging_internal {
 // DemangleRustSymbolEncoding is async-signal-safe and runs in bounded C++
 // call-stack space.  It is suitable for symbolizing stack traces in a signal
 // handler.
+//
+// Note that this demangler purposefully omits some details: generic argument
+// lists become `<>`, function types `fn...`, and long tuples `(t, u, v, ...)`.
+// This simplification suits crash backtracing, where the signal handler must
+// not `malloc`, and the human troubleshooter won't want the `file:line` blame
+// drowned in generic arguments.  Applications better served by a freely
+// allocating detailed demangler might prefer to use Rust's own `rustc-demangle`
+// crate.
 bool DemangleRustSymbolEncoding(const char* mangled, char* out,
                                 size_t out_size);
 

data/third_party/abseil-cpp/absl/debugging/internal/elf_mem_image.h

@@ -32,10 +32,10 @@
 #error ABSL_HAVE_ELF_MEM_IMAGE cannot be directly set
 #endif
 
-#if defined(__ELF__) && !defined(__OpenBSD__) && !defined(__QNX__) && \
-    !defined(__native_client__) && !defined(__asmjs__) &&             \
-    !defined(__wasm__) && !defined(__HAIKU__) && !defined(__sun) &&   \
-    !defined(__VXWORKS__) && !defined(__hexagon__) && !defined(__XTENSA__)
+#if defined(__ELF__) && !defined(__OpenBSD__) && !defined(__QNX__) &&    \
+    !defined(__asmjs__) && !defined(__wasm__) && !defined(__HAIKU__) &&  \
+    !defined(__sun) && !defined(__VXWORKS__) && !defined(__hexagon__) && \
+    !defined(__XTENSA__)
 #define ABSL_HAVE_ELF_MEM_IMAGE 1
 #endif
 

data/third_party/abseil-cpp/absl/debugging/internal/examine_stack.cc

@@ -143,12 +143,26 @@ void DumpPCAndFrameSizeAndSymbol(OutputWriter* writer, void* writer_arg,
   writer(buf, writer_arg);
 }
 
+void DebugStackTraceHookLegacyAdapter(void* const stack[], int depth,
+                                      OutputWriter* writer, void* writer_arg) {
+  debug_stack_trace_hook(stack, depth, /*crash_pc=*/nullptr, writer,
+                         writer_arg);
+}
+
 }  // namespace
 
 void RegisterDebugStackTraceHook(SymbolizeUrlEmitter hook) {
   debug_stack_trace_hook = hook;
 }
 
+SymbolizeUrlEmitterLegacy GetDebugStackTraceHookLegacy() {
+  if (debug_stack_trace_hook == nullptr) {
+    // No prior call to RegisterDebugStackTraceHook.
+    return nullptr;
+  }
+  return &DebugStackTraceHookLegacyAdapter;
+}
+
 SymbolizeUrlEmitter GetDebugStackTraceHook() { return debug_stack_trace_hook; }
 
 // Returns the program counter from signal context, nullptr if
@@ -309,7 +323,7 @@ void DumpStackTrace(int min_dropped_frames, int max_num_frames,
 
   auto hook = GetDebugStackTraceHook();
   if (hook != nullptr) {
-    (*hook)(stack, depth, writer, writer_arg);
+    hook(stack, depth, /*crash_pc=*/nullptr, writer, writer_arg);
   }
 
   if (allocated_bytes != 0) Deallocate(stack, allocated_bytes);

data/third_party/abseil-cpp/absl/debugging/internal/examine_stack.h

@@ -31,13 +31,19 @@ typedef void OutputWriter(const char*, void*);
 // `hook` that is called each time DumpStackTrace() is called.
 // `hook` may be called from a signal handler.
 typedef void (*SymbolizeUrlEmitter)(void* const stack[], int depth,
-                                    OutputWriter* writer, void* writer_arg);
+                                    const void* crash_pc, OutputWriter* writer,
+                                    void* writer_arg);
+typedef void (*SymbolizeUrlEmitterLegacy)(void* const stack[], int depth,
+                                          OutputWriter* writer,
+                                          void* writer_arg);
 
 // Registration of SymbolizeUrlEmitter for use inside of a signal handler.
 // This is inherently unsafe and must be signal safe code.
 void RegisterDebugStackTraceHook(SymbolizeUrlEmitter hook);
 SymbolizeUrlEmitter GetDebugStackTraceHook();
 
+SymbolizeUrlEmitterLegacy GetDebugStackTraceHookLegacy();
+
 // Returns the program counter from signal context, or nullptr if
 // unknown. `vuc` is a ucontext_t*. We use void* to avoid the use of
 // ucontext_t on non-POSIX systems.

data/third_party/abseil-cpp/absl/debugging/internal/stacktrace_aarch64-inl.inc

@@ -123,7 +123,7 @@ static void **NextStackFrame(void **old_frame_pointer, const void *uc,
       // earlier in the stack than the old_frame_pointer, then use it. If it is
       // later, then we have already unwound through it and it needs no special
       // handling.
-      if (pre_signal_frame_pointer >= old_frame_pointer) {
+      if (pre_signal_frame_pointer > old_frame_pointer) {
         new_frame_pointer = pre_signal_frame_pointer;
       }
     }
@@ -212,6 +212,17 @@ static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
   stack_info.sig_stack_low = stack_info.stack_low;
   stack_info.sig_stack_high = kUnknownStackEnd;
 
+#if defined(__linux__)
+  // Similarly for the signal stack, retrieve the information into sig_stack and
+  // then pass it down per call. Calling sigaltstack with nullptr as the first
+  // argument doesn't change the signal stack.
+  stack_t sig_stack;
+  if (sigaltstack(nullptr, &sig_stack) == 0) {
+    stack_info.sig_stack_low = reinterpret_cast<uintptr_t>(sig_stack.ss_sp);
+    stack_info.sig_stack_high = stack_info.sig_stack_low + sig_stack.ss_size;
+  }
+#endif
+
   // The frame pointer points to low address of a frame.  The first 64-bit
   // word of a frame points to the next frame up the call chain, which normally
   // is just after the high address of the current frame.  The second word of

data/third_party/abseil-cpp/absl/debugging/internal/stacktrace_config.h

@@ -43,11 +43,12 @@
   "absl/debugging/internal/stacktrace_emscripten-inl.inc"
 
 #elif defined(__ANDROID__) && __ANDROID_API__ >= 33
-
+#ifdef ABSL_HAVE_THREAD_LOCAL
 // Use the generic implementation for Android 33+ (Android T+). This is the
 // first version of Android for which <execinfo.h> implements backtrace().
 #define ABSL_STACKTRACE_INL_HEADER \
   "absl/debugging/internal/stacktrace_generic-inl.inc"
+#endif  // defined(ABSL_HAVE_THREAD_LOCAL)
 
 #elif defined(__linux__) && !defined(__ANDROID__)
 
@@ -59,11 +60,11 @@
   "absl/debugging/internal/stacktrace_libunwind-inl.inc"
 #define STACKTRACE_USES_LIBUNWIND 1
 #elif defined(NO_FRAME_POINTER) && defined(__has_include)
-#if __has_include(<execinfo.h>)
+#if __has_include(<execinfo.h>) && defined(ABSL_HAVE_THREAD_LOCAL)
 // Note: When using glibc this may require -funwind-tables to function properly.
 #define ABSL_STACKTRACE_INL_HEADER \
   "absl/debugging/internal/stacktrace_generic-inl.inc"
-#endif  // __has_include(<execinfo.h>)
+#endif  // __has_include(<execinfo.h>) && defined(ABSL_HAVE_THREAD_LOCAL)
 #elif defined(__i386__) || defined(__x86_64__)
 #define ABSL_STACKTRACE_INL_HEADER \
   "absl/debugging/internal/stacktrace_x86-inl.inc"
@@ -77,11 +78,11 @@
 #define ABSL_STACKTRACE_INL_HEADER \
   "absl/debugging/internal/stacktrace_riscv-inl.inc"
 #elif defined(__has_include)
-#if __has_include(<execinfo.h>)
+#if __has_include(<execinfo.h>) && defined(ABSL_HAVE_THREAD_LOCAL)
 // Note: When using glibc this may require -funwind-tables to function properly.
 #define ABSL_STACKTRACE_INL_HEADER \
   "absl/debugging/internal/stacktrace_generic-inl.inc"
-#endif  // __has_include(<execinfo.h>)
+#endif  // __has_include(<execinfo.h>) && defined(ABSL_HAVE_THREAD_LOCAL)
 #endif  // defined(__has_include)
 
 #endif  // defined(__linux__) && !defined(__ANDROID__)

data/third_party/abseil-cpp/absl/debugging/internal/stacktrace_emscripten-inl.inc

@@ -52,13 +52,6 @@ static std::atomic<bool> disable_stacktraces(true);  // Disabled until healthy.
 // Waiting until static initializers run seems to be late enough.
 // This file is included into stacktrace.cc so this will only run once.
 ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() {
-  // Check if we can even create stacktraces. If not, bail early and leave
-  // disable_stacktraces set as-is.
-  // clang-format off
-  if (!EM_ASM_INT({ return (typeof wasmOffsetConverter !== 'undefined'); })) {
-    return 0;
-  }
-  // clang-format on
   disable_stacktraces.store(false, std::memory_order_relaxed);
   return 0;
 }();
@@ -81,10 +74,19 @@ static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
   size =
       static_cast<int>(emscripten_stack_unwind_buffer(pc, stack, kStackLength));
 
-  int result_count = size - skip_count;
-  if (result_count < 0) result_count = 0;
-  if (result_count > max_depth) result_count = max_depth;
-  for (int i = 0; i < result_count; i++) result[i] = stack[i + skip_count];
+  int num_frames = size - skip_count;
+  if (num_frames < 0) num_frames = 0;
+  if (num_frames > max_depth) num_frames = max_depth;
+
+  int result_count = 0;
+  for (int i = 0; i < num_frames; i++) {
+    int stack_index = i + skip_count;
+    // Follow x86 and stop if the return address is null (end of stack).
+    if (stack[stack_index] == nullptr) {
+      break;
+    }
+    result[result_count++] = stack[stack_index];
+  }
 
   if (IS_STACK_FRAMES) {
     // No implementation for finding out the stack frames yet.

data/third_party/abseil-cpp/absl/debugging/internal/stacktrace_generic-inl.inc

@@ -71,13 +71,20 @@ static int UnwindImpl(void** result, uintptr_t* frames, int* sizes,
 
   size = backtrace(stack, kStackLength);
   skip_count++;  // we want to skip the current frame as well
-  int result_count = size - skip_count;
-  if (result_count < 0)
-    result_count = 0;
-  if (result_count > max_depth)
-    result_count = max_depth;
-  for (int i = 0; i < result_count; i++)
-    result[i] = stack[i + skip_count];
+
+  int num_frames = size - skip_count;
+  if (num_frames < 0) num_frames = 0;
+  if (num_frames > max_depth) num_frames = max_depth;
+
+  int result_count = 0;
+  for (int i = 0; i < num_frames; i++) {
+    int stack_index = i + skip_count;
+    // Follow x86 and stop if the return address is null (end of stack).
+    if (stack[stack_index] == nullptr) {
+      break;
+    }
+    result[result_count++] = stack[stack_index];
+  }
 
   if (IS_STACK_FRAMES) {
     // No implementation for finding out the stack frames yet.

data/third_party/abseil-cpp/absl/debugging/internal/stacktrace_powerpc-inl.inc

@@ -223,8 +223,9 @@ static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
         }
         if (sizes != nullptr) {
           if (next_sp > sp) {
-            sizes[n] = absl::debugging_internal::StripPointerMetadata(next_sp) -
-                       absl::debugging_internal::StripPointerMetadata(sp);
+            sizes[n] = static_cast<int>(
+                absl::debugging_internal::StripPointerMetadata(next_sp) -
+                absl::debugging_internal::StripPointerMetadata(sp));
           } else {
             // A frame-size of 0 is used to indicate unknown frame size.
             sizes[n] = 0;

data/third_party/abseil-cpp/absl/debugging/internal/stacktrace_riscv-inl.inc

@@ -142,6 +142,10 @@ static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
   void *return_address = nullptr;
   while (frame_pointer && n < max_depth) {
     return_address = frame_pointer[-1];
+    // Follow x86 and stop if the return address is null (end of stack).
+    if (return_address == nullptr) {
+      break;
+    }
 
     // The absl::GetStackFrames routine is called when we are in some
     // informational context (the failure signal handler for example).  Use the
@@ -162,7 +166,8 @@ static int UnwindImpl(void **result, uintptr_t *frames, int *sizes,
               absl::debugging_internal::StripPointerMetadata(frame_pointer);
         }
         if (sizes != nullptr) {
-          sizes[n] = ComputeStackFrameSize(frame_pointer, next_frame_pointer);
+          sizes[n] = static_cast<int>(
+              ComputeStackFrameSize(frame_pointer, next_frame_pointer));
         }
       }
       n++;

data/third_party/abseil-cpp/absl/debugging/internal/stacktrace_x86-inl.inc

@@ -245,6 +245,7 @@ static void **NextStackFrame(void **old_fp, const void *uc,
   }
 #endif
 
+  const size_t page_size = static_cast<size_t>(getpagesize());
   const uintptr_t old_fp_u = reinterpret_cast<uintptr_t>(old_fp);
   const uintptr_t new_fp_u = reinterpret_cast<uintptr_t>(new_fp);
 
@@ -261,19 +262,19 @@ static void **NextStackFrame(void **old_fp, const void *uc,
   // 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;
-
+    // With the stack growing downwards, older stack frame should be
+    // at a greater address that the current one. However if we get multiple
+    // signals handled on altstack the new frame pointer might return to the
+    // main stack, but be different than the value from the most recent
+    // ucontext.
     // If we get a very large frame size, it may be an indication that we
     // guessed frame pointers incorrectly and now risk a paging fault
     // dereferencing a wrong frame pointer. Or maybe not because large frames
     // are possible as well. The main stack is assumed to be readable,
     // so we assume the large frame is legit if we know the real stack bounds
     // and are within the stack.
-    if (new_fp_u - old_fp_u > kMaxFrameBytes) {
-      if (stack_high < kUnknownStackEnd &&
-          static_cast<size_t>(getpagesize()) < stack_low) {
+    if (new_fp_u <= old_fp_u || new_fp_u - old_fp_u > kMaxFrameBytes) {
+      if (stack_high < kUnknownStackEnd && page_size < stack_low) {
         // Stack bounds are known.
         if (!(stack_low < new_fp_u && new_fp_u <= stack_high)) {
           // new_fp_u is not within the known stack.
@@ -310,7 +311,12 @@ static void **NextStackFrame(void **old_fp, const void *uc,
   if (new_fp_u >= 0xffffe000) return nullptr;
 #endif
 #if !defined(_WIN32)
-  if (!STRICT_UNWINDING) {
+  const uintptr_t old_fp_page = old_fp_u & ~(page_size - 1);
+  const uintptr_t new_fp_page = new_fp_u & ~(page_size - 1);
+  if (old_fp_page == new_fp_page && (new_fp_u & (sizeof(void*) - 1)) == 0) {
+    // We dereferenced the old_fp above, so it is safe to dereference
+    // new_fp if it's on the same page as the old_fp and is aligned.
+  } else 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.

data/third_party/abseil-cpp/absl/debugging/internal/symbolize.h

@@ -22,20 +22,20 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 
 #include "absl/base/config.h"
 #include "absl/strings/string_view.h"
 
 #ifdef ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
 #error ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE cannot be directly set
-#elif defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__) \
-      && !defined(__asmjs__) && !defined(__wasm__)
+#elif defined(__ELF__) && defined(__GLIBC__) && !defined(__asmjs__) \
+      && !defined(__wasm__)
 #define ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE 1
 
 #include <elf.h>
 #include <link.h>  // For ElfW() macro.
 #include <functional>
-#include <string>
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -78,44 +78,54 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
-struct SymbolDecoratorArgs {
-  // The program counter we are getting symbolic name for.
-  const void *pc;
-  // 0 for main executable, load address for shared libraries.
-  ptrdiff_t relocation;
-  // Read-only file descriptor for ELF image covering "pc",
-  // or -1 if no such ELF image exists in /proc/self/maps.
-  int fd;
-  // Output buffer, size.
-  // Note: the buffer may not be empty -- default symbolizer may have already
-  // produced some output, and earlier decorators may have adorned it in
-  // some way. You are free to replace or augment the contents (within the
-  // symbol_buf_size limit).
-  char *const symbol_buf;
-  size_t symbol_buf_size;
-  // Temporary scratch space, size.
-  // Use that space in preference to allocating your own stack buffer to
-  // conserve stack.
-  char *const tmp_buf;
-  size_t tmp_buf_size;
-  // User-provided argument
-  void* arg;
-};
-using SymbolDecorator = void (*)(const SymbolDecoratorArgs *);
+class SymbolDecorator;
 
-// Installs a function-pointer as a decorator. Returns a value less than zero
-// if the system cannot install the decorator. Otherwise, returns a unique
-// identifier corresponding to the decorator. This identifier can be used to
-// uninstall the decorator - See RemoveSymbolDecorator() below.
-int InstallSymbolDecorator(SymbolDecorator decorator, void* arg);
+class SymbolDecoratorDeleter {
+ public:
+  void operator()(SymbolDecorator* ptr);
+};
 
-// Removes a previously installed function-pointer decorator. Parameter "ticket"
-// is the return-value from calling InstallSymbolDecorator().
-bool RemoveSymbolDecorator(int ticket);
+using SymbolDecoratorPtr =
+    std::unique_ptr<SymbolDecorator, SymbolDecoratorDeleter>;
+
+// Represents an object that can add additional information to a symbol
+// name.
+class SymbolDecorator {
+ public:
+  // The signature of a factory function used to register and create a symbol
+  // decorator. This function may be called from a signal handler, so it must
+  // use an async-signal-safe allocation mechanism to allocate the returned
+  // object.
+  using Factory = SymbolDecoratorPtr(int fd);
+
+  virtual ~SymbolDecorator() = default;
+
+  // Decorates symbol name with additional information.
+  //
+  // pc represents the program counter we are getting symbolic name for.
+  // relocation is difference between the link-time and the load-time address.
+  // symbol_buf and symbol_buf_size represent the output buffer and its size.
+  // Note that the buffer may not be empty -- default symbolizer may have
+  // already produced some output. You are free to replace or augment the
+  // contents (within the symbol_buf_size limit). tmp_buf and tmp_buf_size
+  // represent temporary scratch space and its size. Use that space in
+  // preference to allocating your own stack buffer to conserve stack.
+  //
+  // This function will not be called concurrently for the same object, but it
+  // may be called from a signal handler, so it must avoid any operation that is
+  // not async-signal-safe. However, it does not have to be reentrant -- if it
+  // is interrupted by a signal and the handler tries to symbolize, the request
+  // will go to a new SymbolDecorator instance.
+  virtual void Decorate(
+      const void* pc,
+      ptrdiff_t relocation,
+      char* symbol_buf, size_t symbol_buf_size,
+      char* tmp_buf, size_t tmp_buf_size) const = 0;
+};
 
-// Remove all installed decorators.  Returns true if successful, false if
-// symbolization is currently in progress.
-bool RemoveAllSymbolDecorators();
+// Registers a new symbol decorator factory and returns the previous one.
+SymbolDecorator::Factory* SetSymbolDecoratorFactory(
+    SymbolDecorator::Factory* factory);
 
 // Registers an address range to a file mapping.
 //

data/third_party/abseil-cpp/absl/debugging/internal/vdso_support.cc

@@ -17,6 +17,7 @@
 // VDSOSupport -- a class representing kernel VDSO (if present).
 
 #include "absl/debugging/internal/vdso_support.h"
+#include "absl/base/attributes.h"
 
 #ifdef ABSL_HAVE_VDSO_SUPPORT     // defined in vdso_support.h
 
@@ -190,6 +191,9 @@ long VDSOSupport::InitAndGetCPU(unsigned *cpu,  // NOLINT(runtime/int)
 // This function must be very fast, and may be called from very
 // low level (e.g. tcmalloc). Hence I avoid things like
 // GoogleOnceInit() and ::operator new.
+// The destination in VDSO is unknown to CFI and VDSO does not set MSAN
+// shadow for the return value.
+ABSL_ATTRIBUTE_NO_SANITIZE_CFI
 ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
 int GetCPU() {
   unsigned cpu;