grpc 1.84.0 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/debugging/symbolize_elf.inc

@@ -67,6 +67,7 @@
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
+#include <memory>
 
 #include "absl/base/casts.h"
 #include "absl/base/dynamic_annotations.h"
@@ -145,16 +146,7 @@ inline constexpr bool kPlatformUsesOPDSections = false;
 // pointers and the first one is the function's entry.
 const size_t kFunctionDescriptorSize = sizeof(void *) * 2;
 
-const int kMaxDecorators = 10;  // Seems like a reasonable upper limit.
-
-struct InstalledSymbolDecorator {
-  SymbolDecorator fn;
-  void *arg;
-  int ticket;
-};
-
-int g_num_decorators;
-InstalledSymbolDecorator g_decorators[kMaxDecorators];
+std::atomic<SymbolDecorator::Factory*> g_decorator_factory = nullptr;
 
 struct FileMappingHint {
   const void *start;
@@ -163,26 +155,16 @@ struct FileMappingHint {
   const char *filename;
 };
 
-// Protects g_decorators.
-// We are using SpinLock and not a Mutex here, because we may be called
-// from inside Mutex::Lock itself, and it prohibits recursive calls.
-// This happens in e.g. base/stacktrace_syscall_unittest.
-// Moreover, we are using only TryLock(), if the decorator list
-// is being modified (is busy), we skip all decorators, and possibly
-// loose some info. Sorry, that's the best we could do.
-ABSL_CONST_INIT absl::base_internal::SpinLock g_decorators_mu(
-    absl::kConstInit, absl::base_internal::SCHEDULE_KERNEL_ONLY);
-
 const int kMaxFileMappingHints = 8;
 int g_num_file_mapping_hints;
 FileMappingHint g_file_mapping_hints[kMaxFileMappingHints];
 // Protects g_file_mapping_hints.
 ABSL_CONST_INIT absl::base_internal::SpinLock g_file_mapping_mu(
-    absl::kConstInit, absl::base_internal::SCHEDULE_KERNEL_ONLY);
+    absl::base_internal::SCHEDULE_KERNEL_ONLY);
 
 // Async-signal-safe function to zero a buffer.
 // memset() is not guaranteed to be async-signal-safe.
-static void SafeMemZero(void* p, size_t size) {
+static void SafeMemZero(void *p, size_t size) {
   unsigned char *c = static_cast<unsigned char *>(p);
   while (size--) {
     *c++ = 0;
@@ -190,32 +172,23 @@ static void SafeMemZero(void* p, size_t size) {
 }
 
 struct ObjFile {
-  ObjFile()
-      : filename(nullptr),
-        start_addr(nullptr),
-        end_addr(nullptr),
-        offset(0),
-        fd(-1),
-        elf_type(-1) {
-    SafeMemZero(&elf_header, sizeof(elf_header));
-    SafeMemZero(&phdr[0], sizeof(phdr));
-  }
-
-  char *filename;
-  const void *start_addr;
-  const void *end_addr;
-  uint64_t offset;
+  char *filename = nullptr;
+  const void *start_addr = nullptr;
+  const void *end_addr = nullptr;
+  uint64_t offset = 0;
 
   // The following fields are initialized on the first access to the
   // object file.
-  int fd;
-  int elf_type;
-  ElfW(Ehdr) elf_header;
+  int fd = -1;
+  int elf_type = -1;
+  ElfW(Ehdr) elf_header = {};
 
   // PT_LOAD program header describing executable code.
   // Normally we expect just one, but SWIFT binaries have two.
   // CUDA binaries have 3 (see cr/473913254 description).
-  std::array<ElfW(Phdr), 4> phdr;
+  std::array<ElfW(Phdr), 4> phdr = {};
+
+  SymbolDecoratorPtr decorator = {};
 };
 
 // Build 4-way associative cache for symbols. Within each cache line, symbols
@@ -232,29 +205,6 @@ struct SymbolCacheLine {
   uint32_t age[ASSOCIATIVITY];
 };
 
-// ---------------------------------------------------------------
-// An async-signal-safe arena for LowLevelAlloc
-static std::atomic<base_internal::LowLevelAlloc::Arena *> g_sig_safe_arena;
-
-static base_internal::LowLevelAlloc::Arena *SigSafeArena() {
-  return g_sig_safe_arena.load(std::memory_order_acquire);
-}
-
-static void InitSigSafeArena() {
-  if (SigSafeArena() == nullptr) {
-    base_internal::LowLevelAlloc::Arena *new_arena =
-        base_internal::LowLevelAlloc::NewArena(
-            base_internal::LowLevelAlloc::kAsyncSignalSafe);
-    base_internal::LowLevelAlloc::Arena *old_value = nullptr;
-    if (!g_sig_safe_arena.compare_exchange_strong(old_value, new_arena,
-                                                  std::memory_order_release,
-                                                  std::memory_order_relaxed)) {
-      // We lost a race to allocate an arena; deallocate.
-      base_internal::LowLevelAlloc::DeleteArena(new_arena);
-    }
-  }
-}
-
 // ---------------------------------------------------------------
 // An AddrMap is a vector of ObjFile, using SigSafeArena() for allocation.
 
@@ -287,9 +237,10 @@ ObjFile *AddrMap::Add() {
     size_t new_allocated = allocated_ * 2 + 50;
     ObjFile *new_obj_ =
         static_cast<ObjFile *>(base_internal::LowLevelAlloc::AllocWithArena(
-            new_allocated * sizeof(*new_obj_), SigSafeArena()));
+            new_allocated * sizeof(*new_obj_), base_internal::SigSafeArena()));
     if (obj_) {
-      memcpy(new_obj_, obj_, allocated_ * sizeof(*new_obj_));
+      std::uninitialized_move_n(obj_, size_, new_obj_);
+      std::destroy_n(obj_, size_);
       base_internal::LowLevelAlloc::Free(obj_);
     }
     obj_ = new_obj_;
@@ -332,11 +283,14 @@ class Symbolizer {
   ~Symbolizer();
   const char *GetSymbol(const void *const pc);
 
+  void UpdateDecoratorsIfNeeded(SymbolDecorator::Factory* decorator_factory);
+
  private:
   char *CopyString(const char *s) {
     size_t len = strlen(s);
-    char *dst = static_cast<char *>(
-        base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena()));
+    char *dst =
+        static_cast<char *>(base_internal::LowLevelAlloc::AllocWithArena(
+            len + 1, base_internal::SigSafeArena()));
     ABSL_RAW_CHECK(dst != nullptr, "out of memory");
     memcpy(dst, s, len + 1);
     return dst;
@@ -367,6 +321,7 @@ class Symbolizer {
   };
 
   AddrMap addr_map_;
+  SymbolDecorator::Factory* decorator_factory_ = nullptr;
 
   bool ok_;
   bool addr_map_read_;
@@ -441,14 +396,17 @@ static size_t SymbolizerSize() {
 // Return (and set null) g_cached_symbolized_state if it is not null.
 // Otherwise return a new symbolizer.
 static Symbolizer *AllocateSymbolizer() {
-  InitSigSafeArena();
+  base_internal::InitSigSafeArena();
   Symbolizer *symbolizer =
       g_cached_symbolizer.exchange(nullptr, std::memory_order_acquire);
-  if (symbolizer != nullptr) {
-    return symbolizer;
-  }
-  return new (base_internal::LowLevelAlloc::AllocWithArena(
-      SymbolizerSize(), SigSafeArena())) Symbolizer();
+  if (symbolizer == nullptr) {
+    void* ptr = base_internal::LowLevelAlloc::AllocWithArena(
+        SymbolizerSize(), base_internal::SigSafeArena());
+    symbolizer = new (ptr) Symbolizer();
+  }
+  symbolizer->UpdateDecoratorsIfNeeded(
+      g_decorator_factory.load(std::memory_order_acquire));
+  return symbolizer;
 }
 
 // Set g_cached_symbolize_state to s if it is null, otherwise
@@ -465,7 +423,7 @@ static void FreeSymbolizer(Symbolizer *s) {
 
 Symbolizer::Symbolizer() : ok_(true), addr_map_read_(false) {
   for (SymbolCacheLine &symbol_cache_line : symbol_cache_) {
-    for (size_t j = 0; j < ABSL_ARRAYSIZE(symbol_cache_line.name); ++j) {
+    for (size_t j = 0; j < std::size(symbol_cache_line.name); ++j) {
       symbol_cache_line.pc[j] = nullptr;
       symbol_cache_line.name[j] = nullptr;
       symbol_cache_line.age[j] = 0;
@@ -482,6 +440,26 @@ Symbolizer::~Symbolizer() {
   ClearAddrMap();
 }
 
+void Symbolizer::UpdateDecoratorsIfNeeded(
+    SymbolDecorator::Factory* decorator_factory) {
+  if (decorator_factory_ == decorator_factory) return;
+
+  for (SymbolCacheLine& symbol_cache_line : symbol_cache_) {
+    for (size_t j = 0; j < std::size(symbol_cache_line.name); ++j) {
+      symbol_cache_line.pc[j] = nullptr;
+      base_internal::LowLevelAlloc::Free(symbol_cache_line.name[j]);
+      symbol_cache_line.name[j] = nullptr;
+      symbol_cache_line.age[j] = 0;
+    }
+  }
+
+  decorator_factory_ = decorator_factory;
+  for (size_t i = 0, end = addr_map_.Size(); i < end; ++i) {
+    ObjFile* obj = addr_map_.At(i);
+    obj->decorator.reset();
+  }
+}
+
 // We don't use assert() since it's not guaranteed to be
 // async-signal-safe.  Instead we define a minimal assertion
 // macro. So far, we don't need pretty printing for __FILE__, etc.
@@ -1409,7 +1387,8 @@ static void MaybeOpenFdFromSelfExe(ObjFile *obj) {
   obj->fd = fd;
 }
 
-static bool MaybeInitializeObjFile(ObjFile *obj) {
+static bool MaybeInitializeObjFile(
+    ObjFile* obj, SymbolDecorator::Factory* decorator_factory) {
   if (obj->fd < 0) {
     obj->fd = OpenReadOnlyWithHighFD(obj->filename);
 
@@ -1469,14 +1448,15 @@ static bool MaybeInitializeObjFile(ObjFile *obj) {
       constexpr int interesting = PF_X | PF_R;
 #endif
 
-      if (phdr.p_type != PT_LOAD
-          || (phdr.p_flags & interesting) != interesting) {
+      if (phdr.p_type != PT_LOAD ||
+          (phdr.p_flags & interesting) != interesting) {
         // Not a LOAD segment, not executable code, and not a function
         // descriptor.
         continue;
       }
       if (num_interesting_load_segments < obj->phdr.size()) {
-        memcpy(&obj->phdr[num_interesting_load_segments++], &phdr, sizeof(phdr));
+        memcpy(&obj->phdr[num_interesting_load_segments++], &phdr,
+               sizeof(phdr));
       } else {
         ABSL_RAW_LOG(
             WARNING, "%s: too many interesting LOAD segments: %zu >= %zu",
@@ -1490,6 +1470,9 @@ static bool MaybeInitializeObjFile(ObjFile *obj) {
       return false;
     }
   }
+  if (decorator_factory != nullptr && obj->decorator == nullptr) {
+    obj->decorator = decorator_factory(obj->fd);
+  }
   return true;
 }
 
@@ -1503,9 +1486,8 @@ static bool MaybeInitializeObjFile(ObjFile *obj) {
 const char *Symbolizer::GetUncachedSymbol(const void *pc) {
   ObjFile *const obj = FindObjFile(pc, 1);
   ptrdiff_t relocation = 0;
-  int fd = -1;
   if (obj != nullptr) {
-    if (MaybeInitializeObjFile(obj)) {
+    if (MaybeInitializeObjFile(obj, decorator_factory_)) {
       const size_t start_addr = reinterpret_cast<size_t>(obj->start_addr);
       if (obj->elf_type == ET_DYN && start_addr >= obj->offset) {
         // This object was relocated.
@@ -1525,7 +1507,8 @@ const char *Symbolizer::GetUncachedSymbol(const void *pc) {
             ABSL_RAW_CHECK(p.p_type == PT_NULL, "unexpected p_type");
             break;
           }
-          if (pc < reinterpret_cast<void *>(start_addr + p.p_vaddr + p.p_memsz)) {
+          if (pc <
+              reinterpret_cast<void *>(start_addr + p.p_vaddr + p.p_memsz)) {
             phdr = &p;
             break;
           }
@@ -1544,7 +1527,6 @@ const char *Symbolizer::GetUncachedSymbol(const void *pc) {
         }
       }
 
-      fd = obj->fd;
       if (GetSymbolFromObjectFile(*obj, pc, relocation, symbol_buf_,
                                   sizeof(symbol_buf_), tmp_buf_,
                                   sizeof(tmp_buf_)) == SYMBOL_FOUND) {
@@ -1569,17 +1551,9 @@ const char *Symbolizer::GetUncachedSymbol(const void *pc) {
 #endif
   }
 
-  if (g_decorators_mu.TryLock()) {
-    if (g_num_decorators > 0) {
-      SymbolDecoratorArgs decorator_args = {
-          pc,       relocation,       fd,     symbol_buf_, sizeof(symbol_buf_),
-          tmp_buf_, sizeof(tmp_buf_), nullptr};
-      for (int i = 0; i < g_num_decorators; ++i) {
-        decorator_args.arg = g_decorators[i].arg;
-        g_decorators[i].fn(&decorator_args);
-      }
-    }
-    g_decorators_mu.Unlock();
+  if (obj != nullptr && obj->decorator != nullptr) {
+    obj->decorator->Decorate(pc, relocation, symbol_buf_, sizeof(symbol_buf_),
+                             tmp_buf_, sizeof(tmp_buf_));
   }
   if (symbol_buf_[0] == '\0') {
     return nullptr;
@@ -1624,61 +1598,19 @@ const char *Symbolizer::GetSymbol(const void *pc) {
 #endif
 }
 
-bool RemoveAllSymbolDecorators(void) {
-  if (!g_decorators_mu.TryLock()) {
-    // Someone else is using decorators. Get out.
-    return false;
-  }
-  g_num_decorators = 0;
-  g_decorators_mu.Unlock();
-  return true;
-}
-
-bool RemoveSymbolDecorator(int ticket) {
-  if (!g_decorators_mu.TryLock()) {
-    // Someone else is using decorators. Get out.
-    return false;
-  }
-  for (int i = 0; i < g_num_decorators; ++i) {
-    if (g_decorators[i].ticket == ticket) {
-      while (i < g_num_decorators - 1) {
-        g_decorators[i] = g_decorators[i + 1];
-        ++i;
-      }
-      g_num_decorators = i;
-      break;
-    }
-  }
-  g_decorators_mu.Unlock();
-  return true;  // Decorator is known to be removed.
-}
-
-int InstallSymbolDecorator(SymbolDecorator decorator, void *arg) {
-  static int ticket = 0;
-
-  if (!g_decorators_mu.TryLock()) {
-    // Someone else is using decorators. Get out.
-    return -2;
-  }
-  int ret = ticket;
-  if (g_num_decorators >= kMaxDecorators) {
-    ret = -1;
-  } else {
-    g_decorators[g_num_decorators] = {decorator, arg, ticket++};
-    ++g_num_decorators;
-  }
-  g_decorators_mu.Unlock();
-  return ret;
+SymbolDecorator::Factory* SetSymbolDecoratorFactory(
+    SymbolDecorator::Factory* factory) {
+  return g_decorator_factory.exchange(factory, std::memory_order_acq_rel);
 }
 
-bool RegisterFileMappingHint(const void *start, const void *end, uint64_t offset,
-                             const char *filename) {
+bool RegisterFileMappingHint(const void *start, const void *end,
+                             uint64_t offset, const char *filename) {
   SAFE_ASSERT(start <= end);
   SAFE_ASSERT(filename != nullptr);
 
-  InitSigSafeArena();
+  base_internal::InitSigSafeArena();
 
-  if (!g_file_mapping_mu.TryLock()) {
+  if (!g_file_mapping_mu.try_lock()) {
     return false;
   }
 
@@ -1688,8 +1620,9 @@ bool RegisterFileMappingHint(const void *start, const void *end, uint64_t offset
   } else {
     // TODO(ckennelly): Move this into a string copy routine.
     size_t len = strlen(filename);
-    char *dst = static_cast<char *>(
-        base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena()));
+    char *dst =
+        static_cast<char *>(base_internal::LowLevelAlloc::AllocWithArena(
+            len + 1, base_internal::SigSafeArena()));
     ABSL_RAW_CHECK(dst != nullptr, "out of memory");
     memcpy(dst, filename, len + 1);
 
@@ -1700,13 +1633,13 @@ bool RegisterFileMappingHint(const void *start, const void *end, uint64_t offset
     hint.filename = dst;
   }
 
-  g_file_mapping_mu.Unlock();
+  g_file_mapping_mu.unlock();
   return ret;
 }
 
 bool GetFileMappingHint(const void **start, const void **end, uint64_t *offset,
                         const char **filename) {
-  if (!g_file_mapping_mu.TryLock()) {
+  if (!g_file_mapping_mu.try_lock()) {
     return false;
   }
   bool found = false;
@@ -1729,7 +1662,7 @@ bool GetFileMappingHint(const void **start, const void **end, uint64_t *offset,
       break;
     }
   }
-  g_file_mapping_mu.Unlock();
+  g_file_mapping_mu.unlock();
   return found;
 }
 
@@ -1765,7 +1698,8 @@ ABSL_NAMESPACE_END
 }  // namespace absl
 
 extern "C" bool AbslInternalGetFileMappingHint(const void **start,
-                                               const void **end, uint64_t *offset,
+                                               const void **end,
+                                               uint64_t *offset,
                                                const char **filename) {
   return absl::debugging_internal::GetFileMappingHint(start, end, offset,
                                                       filename);

data/third_party/abseil-cpp/absl/debugging/symbolize_emscripten.inc

@@ -26,33 +26,20 @@
 
 extern "C" {
 const char* emscripten_pc_get_function(const void* pc);
+void* emscripten_stack_snapshot();
 }
 
-// clang-format off
-EM_JS(bool, HaveOffsetConverter, (),
-      { return typeof wasmOffsetConverter !== 'undefined'; });
-// clang-format on
-
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
-void InitializeSymbolizer(const char*) {
-  if (!HaveOffsetConverter()) {
-    ABSL_RAW_LOG(INFO,
-                 "Symbolization unavailable. Rebuild with -sWASM=1 "
-                 "and -sUSE_OFFSET_CONVERTER=1.");
-  }
-}
+void InitializeSymbolizer(const char*) {}
 
 bool Symbolize(const void* pc, char* out, int out_size) {
-  // Check if we have the offset converter necessary for pc_get_function.
-  // Without it, the program will abort().
-  if (!HaveOffsetConverter()) {
-    return false;
-  }
   if (pc == nullptr || out_size <= 0) {
     return false;
   }
+  // Need to capture a snapshot first.
+  emscripten_stack_snapshot();
   const char* func_name = emscripten_pc_get_function(pc);
   if (func_name == nullptr) {
     return false;

data/third_party/abseil-cpp/absl/debugging/symbolize_unimplemented.inc

@@ -14,16 +14,16 @@
 
 #include <cstdint>
 
-#include "absl/base/internal/raw_logging.h"
+#include "absl/debugging/internal/symbolize.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
 namespace debugging_internal {
 
-int InstallSymbolDecorator(SymbolDecorator, void*) { return -1; }
-bool RemoveSymbolDecorator(int) { return false; }
-bool RemoveAllSymbolDecorators(void) { return false; }
+SymbolDecorator::Factory* SetSymbolDecoratorFactory(SymbolDecorator::Factory*) {
+  return nullptr;
+}
 bool RegisterFileMappingHint(const void *, const void *, uint64_t, const char *) {
   return false;
 }

data/third_party/abseil-cpp/absl/debugging/symbolize_win32.inc

@@ -15,7 +15,6 @@
 // See "Retrieving Symbol Information by Address":
 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms680578(v=vs.85).aspx
 
-#include <ntstatus.h>
 #include <windows.h>
 #include <winternl.h>
 
@@ -58,10 +57,9 @@ void InitializeSymbolizer(const char*) {
     // NTSTATUS (0xC0000004), which can happen when a module load occurs during
     // the SymInitialize call. In this case, we should try calling SymInitialize
     // again.
+    constexpr DWORD kStatusInfoLengthMismatch = DWORD{0xC0000004};
     syminitialize_error = GetLastError();
-    // Both NTSTATUS and DWORD are 32-bit numbers, which makes the cast safe.
-    if (syminitialize_error !=
-        static_cast<DWORD>(STATUS_INFO_LENGTH_MISMATCH)) {
+    if (syminitialize_error != kStatusInfoLengthMismatch) {
       break;
     }
   }

data/third_party/abseil-cpp/absl/flags/commandlineflag.h

@@ -27,10 +27,12 @@
 #define ABSL_FLAGS_COMMANDLINEFLAG_H_
 
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "absl/base/config.h"
 #include "absl/base/fast_type_id.h"
+#include "absl/base/nullability.h"
 #include "absl/flags/internal/commandlineflag.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
@@ -86,11 +88,11 @@ class CommandLineFlag {
   // absl::CommandLineFlag::TryGet()
   //
   // Attempts to retrieve the flag value. Returns value on success,
-  // absl::nullopt otherwise.
+  // std::nullopt otherwise.
   template <typename T>
-  absl::optional<T> TryGet() const {
+  std::optional<T> TryGet() const {
     if (IsRetired() || !IsOfType<T>()) {
-      return absl::nullopt;
+      return std::nullopt;
     }
 
     // Implementation notes:
@@ -118,7 +120,7 @@ class CommandLineFlag {
     Read(&u.value);
     // allow retired flags to be "read", so we can report invalid access.
     if (IsRetired()) {
-      return absl::nullopt;
+      return std::nullopt;
     }
     return std::move(u.value);
   }
@@ -158,7 +160,7 @@ class CommandLineFlag {
   // Sets the value of the flag based on specified string `value`. If the flag
   // was successfully set to new value, it returns true. Otherwise, sets `error`
   // to indicate the error, leaves the flag unchanged, and returns false.
-  bool ParseFrom(absl::string_view value, std::string* error);
+  bool ParseFrom(absl::string_view value, std::string* absl_nonnull error);
 
  protected:
   ~CommandLineFlag() = default;
@@ -188,7 +190,7 @@ class CommandLineFlag {
 
   // Copy-construct a new value of the flag's type in a memory referenced by
   // the dst based on the current flag's value.
-  virtual void Read(void* dst) const = 0;
+  virtual void Read(void* absl_nonnull dst) const = 0;
 
   // To be deleted. Used to return true if flag's current value originated from
   // command line.

data/third_party/abseil-cpp/absl/flags/declare.h

@@ -59,10 +59,19 @@ ABSL_NAMESPACE_END
 
 // Internal implementation of ABSL_DECLARE_FLAG to allow macro expansion of its
 // arguments. Clients must use ABSL_DECLARE_FLAG instead.
+//
+// The non-MSVC implementation declares the flag twice. This is to allow
+// applying attributes to the second declaration. However, this causes a
+// compile error (C4273) in MSVC if a `__declspec` is prepended to the macro.
+#if defined(_MSC_VER)
+#define ABSL_DECLARE_FLAG_INTERNAL(type, name) \
+  extern absl::Flag<type> FLAGS_##name
+#else
 #define ABSL_DECLARE_FLAG_INTERNAL(type, name)               \
   extern absl::Flag<type> FLAGS_##name;                      \
   namespace absl /* block flags in namespaces */ {}          \
   /* second redeclaration is to allow applying attributes */ \
   extern absl::Flag<type> FLAGS_##name
+#endif  // _MSC_VER
 
 #endif  // ABSL_FLAGS_DECLARE_H_

data/third_party/abseil-cpp/absl/flags/flag.h

@@ -241,7 +241,8 @@ ABSL_NAMESPACE_END
     /* default value argument. That keeps temporaries alive */               \
     /* long enough for NonConst to work correctly.          */               \
     static constexpr absl::string_view Value(                                \
-        absl::string_view absl_flag_help = ABSL_FLAG_IMPL_FLAGHELP(txt)) {   \
+        absl::string_view absl_flag_help ABSL_ATTRIBUTE_LIFETIME_BOUND  =     \
+            ABSL_FLAG_IMPL_FLAGHELP(txt)) {                                  \
       return absl_flag_help;                                                 \
     }                                                                        \
     static std::string NonConst() { return std::string(Value()); }           \

data/third_party/abseil-cpp/absl/flags/internal/commandlineflag.h

@@ -58,7 +58,7 @@ class FlagStateInterface {
   virtual ~FlagStateInterface();
 
   // Restores the flag originated this object to the saved state.
-  virtual void Restore() const = 0;
+  virtual void Restore() && = 0;
 };
 
 }  // namespace flags_internal