Changes imported from Abseil "staging" branch:

  - b527a3e4b36b644ac424e3c525b1cd393f6f6c40 Fix some typos in the usage examples by Jorg Brown <[email protected]>
  - 82be4a9adf3bb0ddafc0d46274969c99afffe870 Fix typo in optional.h comment. by Abseil Team <[email protected]>
  - d6ee63bf8fc51fba074c23b33cebc28c808d7f07 Remove internal-only identifiers from code. by Daniel Katz <[email protected]>
  - f9c3ad2f0d73f53b21603638af8b4bed636e79f4 Use easier understandable names for absl::StartsWith and ... by Abseil Team <[email protected]>
  - 7c16c14fefee89c927b8789d6043c4691bcffc9b Add -Wno-missing-prototypes back to the LLVM copts. by Derek Mauro <[email protected]>
  - 2f4b7d2e50c7023240242f1e15db60ccd7e8768d IWYU | absl/strings by Juemin Yang <[email protected]>
  - a99cbcc1daa34a2d6a2bb26de275e05173cc77e9 IWYU | absl/type by Juemin Yang <[email protected]>
  - 12e1146d0fc76c071d7e0ebaabb62f0a984fae66 Use LLVM_FLAGS and LLVM_TEST_FLAGS when --compiler=llvm. by Derek Mauro <[email protected]>
  - cd6bea616abda558d0bace5bd77455662a233688 IWYU | absl/debugging by Juemin Yang <[email protected]>
  - d9a7382e59d46a8581b6b7a31cd5a48bb89326e9 IWYU | absl/synchronization by Juemin Yang <[email protected]>
  - 07ec7d6d5a4a666f4183c5d0ed9c342baa7b24bc IWYU | absl/numeric by Juemin Yang <[email protected]>
  - 12bfe40051f4270f8707e191af5652f83f2f750c Remove the RoundTrip{Float,Double}ToBuffer routines from ... by Jorg Brown <[email protected]>
  - eeb4fd67c9d97f66cb9475c3c5e51ab132f1c810 Adds conversion functions for converting between absl/tim... by Greg Miller <[email protected]>
  - 59a2108d05d4ea85dc5cc11e49b2cd2335d4295a Change Substitute to use %.6g formatting rather than 15/1... by Jorg Brown <[email protected]>
  - 394becb48e0fcd161642cdaac5120d32567e0ef8 IWYU | absl/meta by Juemin Yang <[email protected]>
  - 1e5da6e8da336699b2469dcf6dda025b9b0ec4c9 Rewrite atomic_hook.h to not use std::atomic<T*> under Wi... by Greg Falcon <[email protected]>

GitOrigin-RevId: b527a3e4b36b644ac424e3c525b1cd393f6f6c40
Change-Id: I14e331d91c956ef045ac7927091a9f179716de0c

Author: Abseil Team

absl/BUILD.bazel

@@ -25,20 +25,6 @@ config_setting(
     },
 )
 
-config_setting(
-    name = "hybrid_compiler",
-    values = {
-        "compiler": "hybrid",
-    },
-)
-
-config_setting(
-    name = "llvm_warnings",
-    values = {
-        "define": "ABSL_LLVM_WARNINGS=1",
-    },
-)
-
 # following configs are based on mapping defined in: https://git.io/v5Ijz
 config_setting(
     name = "ios",

absl/base/BUILD.bazel

@@ -30,9 +30,6 @@ package(default_visibility = ["//visibility:public"])
 
 licenses(["notice"])  # Apache 2.0
 
-# Some header files in //base are directly exported for unusual use cases,
-# and the ABSL versions must also be exported for those users.
-
 exports_files(["thread_annotations.h"])
 
 cc_library(
@@ -188,7 +185,7 @@ cc_library(
     hdrs = ["internal/throw_delegate.h"],
     copts = ABSL_DEFAULT_COPTS + ABSL_EXCEPTIONS_FLAG,
     features = [
-        "-use_header_modules",  # b/33207452
+        "-use_header_modules",
     ],
     deps = [
         ":base",

absl/base/attributes.h

@@ -526,7 +526,7 @@
 //
 // Note that this attribute is redundant if the variable is declared constexpr.
 #if ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
-// NOLINTNEXTLINE(whitespace/braces) (b/36288871)
+// NOLINTNEXTLINE(whitespace/braces)
 #define ABSL_CONST_INIT [[clang::require_constant_initialization]]
 #else
 #define ABSL_CONST_INIT

absl/base/internal/atomic_hook.h

@@ -18,28 +18,12 @@
 
 #include <atomic>
 #include <cassert>
+#include <cstdint>
 #include <utility>
 
 namespace absl {
 namespace base_internal {
 
-// In current versions of MSVC (as of July 2017), a std::atomic<T> where T is a
-// pointer to function cannot be constant-initialized with an address constant
-// expression.  That is, the following code does not compile:
-//   void NoOp() {}
-//   constexpr std::atomic<void(*)()> ptr(NoOp);
-//
-// This is the only compiler we support that seems to have this issue.  We
-// conditionalize on MSVC here to use a fallback implementation.  But we
-// should revisit this occasionally.  If MSVC fixes this compiler bug, we
-// can then change this to be conditionalized on the value on _MSC_FULL_VER
-// instead.
-#ifdef _MSC_FULL_VER
-#define ABSL_HAVE_FUNCTION_ADDRESS_CONSTANT_EXPRESSION 0
-#else
-#define ABSL_HAVE_FUNCTION_ADDRESS_CONSTANT_EXPRESSION 1
-#endif
-
 template <typename T>
 class AtomicHook;
 
@@ -55,7 +39,7 @@ class AtomicHook<ReturnType (*)(Args...)> {
  public:
   using FnPtr = ReturnType (*)(Args...);
 
-  constexpr AtomicHook() : hook_(DummyFunction) {}
+  constexpr AtomicHook() : hook_(kInitialValue) {}
 
   // Stores the provided function pointer as the value for this hook.
   //
@@ -64,28 +48,16 @@ class AtomicHook<ReturnType (*)(Args...)> {
   // as a memory_order_release operation, and read accesses are implemented as
   // memory_order_acquire.
   void Store(FnPtr fn) {
-    assert(fn);
-    FnPtr expected = DummyFunction;
-    hook_.compare_exchange_strong(expected, fn, std::memory_order_acq_rel,
-                                  std::memory_order_acquire);
-    // If the compare and exchange failed, make sure that's because hook_ was
-    // already set to `fn` by an earlier call.  Any other state reflects an API
-    // violation (calling Store() multiple times with different values).
-    //
-    // Avoid ABSL_RAW_CHECK, since raw logging depends on AtomicHook.
-    assert(expected == DummyFunction || expected == fn);
+    bool success = DoStore(fn);
+    static_cast<void>(success);
+    assert(success);
   }
 
   // Invokes the registered callback.  If no callback has yet been registered, a
   // default-constructed object of the appropriate type is returned instead.
   template <typename... CallArgs>
   ReturnType operator()(CallArgs&&... args) const {
-    FnPtr hook = hook_.load(std::memory_order_acquire);
-    if (ABSL_HAVE_FUNCTION_ADDRESS_CONSTANT_EXPRESSION || hook) {
-      return hook(std::forward<CallArgs>(args)...);
-    } else {
-      return ReturnType();
-    }
+    return DoLoad()(std::forward<CallArgs>(args)...);
   }
 
   // Returns the registered callback, or nullptr if none has been registered.
@@ -98,23 +70,79 @@ class AtomicHook<ReturnType (*)(Args...)> {
   // Load()() unless you must conditionalize behavior on whether a hook was
   // registered.
   FnPtr Load() const {
-    FnPtr ptr = hook_.load(std::memory_order_acquire);
+    FnPtr ptr = DoLoad();
     return (ptr == DummyFunction) ? nullptr : ptr;
   }
 
  private:
-#if ABSL_HAVE_FUNCTION_ADDRESS_CONSTANT_EXPRESSION
   static ReturnType DummyFunction(Args...) {
     return ReturnType();
   }
+
+  // Current versions of MSVC (as of September 2017) have a broken
+  // implementation of std::atomic<T*>:  Its constructor attempts to do the
+  // equivalent of a reinterpret_cast in a constexpr context, which is not
+  // allowed.
+  //
+  // This causes an issue when building with LLVM under Windows.  To avoid this,
+  // we use a less-efficient, intptr_t-based implementation on Windows.
+
+#ifdef _MSC_FULL_VER
+#define ABSL_HAVE_WORKING_ATOMIC_POINTER 0
 #else
-  static constexpr FnPtr DummyFunction = nullptr;
+#define ABSL_HAVE_WORKING_ATOMIC_POINTER 1
 #endif
 
+#if ABSL_HAVE_WORKING_ATOMIC_POINTER
+  static constexpr FnPtr kInitialValue = &DummyFunction;
+
+  // Return the stored value, or DummyFunction if no value has been stored.
+  FnPtr DoLoad() const { return hook_.load(std::memory_order_acquire); }
+
+  // Store the given value.  Returns false if a different value was already
+  // stored to this object.
+  bool DoStore(FnPtr fn) {
+    assert(fn);
+    FnPtr expected = DummyFunction;
+    hook_.compare_exchange_strong(expected, fn, std::memory_order_acq_rel,
+                                  std::memory_order_acquire);
+    const bool store_succeeded = (expected == DummyFunction);
+    const bool same_value_already_stored = (expected == fn);
+    return store_succeeded || same_value_already_stored;
+  }
+
   std::atomic<FnPtr> hook_;
+#else  // !ABSL_HAVE_WORKING_ATOMIC_POINTER
+  // Use a sentinel value unlikely to be the address of an actual function.
+  static constexpr intptr_t kInitialValue = 0;
+
+  static_assert(sizeof(intptr_t) >= sizeof(FnPtr),
+                "intptr_t can't contain a function pointer");
+
+  FnPtr DoLoad() const {
+    const intptr_t value = hook_.load(std::memory_order_acquire);
+    if (value == 0) {
+      return DummyFunction;
+    }
+    return reinterpret_cast<FnPtr>(value);
+  }
+
+  bool DoStore(FnPtr fn) {
+    assert(fn);
+    const auto value = reinterpret_cast<intptr_t>(fn);
+    intptr_t expected = 0;
+    hook_.compare_exchange_strong(expected, value, std::memory_order_acq_rel,
+                                  std::memory_order_acquire);
+    const bool store_succeeded = (expected == 0);
+    const bool same_value_already_stored = (expected == value);
+    return store_succeeded || same_value_already_stored;
+  }
+
+  std::atomic<intptr_t> hook_;
+#endif
 };
 
-#undef ABSL_HAVE_FUNCTION_ADDRESS_CONSTANT_EXPRESSION
+#undef ABSL_HAVE_WORKING_ATOMIC_POINTER
 
 }  // namespace base_internal
 }  // namespace absl

absl/base/internal/low_level_scheduling.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// Core interfaces and definitions used by by low-level //base interfaces such
-// as SpinLock.
+// Core interfaces and definitions used by by low-level interfaces such as
+// SpinLock.
 
 #ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
 #define ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_

absl/base/internal/malloc_hook.cc

@@ -453,16 +453,13 @@ void MallocHook::InvokeSbrkHookSlow(const void* result, ptrdiff_t increment) {
 }  // namespace base_internal
 }  // namespace absl
 
-ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(google_malloc);
-ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(google_malloc);
-// actual functions are in debugallocation.cc or tcmalloc.cc
 ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(malloc_hook);
 ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(malloc_hook);
 // actual functions are in this file, malloc_hook.cc, and low_level_alloc.cc
+ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(google_malloc);
+ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(google_malloc);
 ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(blink_malloc);
 ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(blink_malloc);
-// actual functions are in third_party/blink_headless/.../{PartitionAlloc,
-// FastMalloc}.cpp.
 
 #define ADDR_IN_ATTRIBUTE_SECTION(addr, name)                         \
   (reinterpret_cast<uintptr_t>(ABSL_ATTRIBUTE_SECTION_START(name)) <= \
@@ -486,23 +483,21 @@ static inline bool InHookCaller(const void* caller) {
 static absl::once_flag in_hook_caller_once;
 
 static void InitializeInHookCaller() {
-  ABSL_INIT_ATTRIBUTE_SECTION_VARS(google_malloc);
-  if (ABSL_ATTRIBUTE_SECTION_START(google_malloc) ==
-      ABSL_ATTRIBUTE_SECTION_STOP(google_malloc)) {
-    ABSL_RAW_LOG(ERROR,
-                 "google_malloc section is missing, "
-                 "thus InHookCaller is broken!");
-  }
   ABSL_INIT_ATTRIBUTE_SECTION_VARS(malloc_hook);
   if (ABSL_ATTRIBUTE_SECTION_START(malloc_hook) ==
       ABSL_ATTRIBUTE_SECTION_STOP(malloc_hook)) {
     ABSL_RAW_LOG(ERROR,
                  "malloc_hook section is missing, "
                  "thus InHookCaller is broken!");
   }
+  ABSL_INIT_ATTRIBUTE_SECTION_VARS(google_malloc);
+  if (ABSL_ATTRIBUTE_SECTION_START(google_malloc) ==
+      ABSL_ATTRIBUTE_SECTION_STOP(google_malloc)) {
+    ABSL_RAW_LOG(ERROR,
+                 "google_malloc section is missing, "
+                 "thus InHookCaller is broken!");
+  }
   ABSL_INIT_ATTRIBUTE_SECTION_VARS(blink_malloc);
-  // The blink_malloc section is only expected to be present in binaries
-  // linking against the blink rendering engine in third_party/blink_headless.
 }
 
 // We can improve behavior/compactness of this function
@@ -574,7 +569,8 @@ extern "C" int MallocHook_GetCallerStackTrace(
 // still allow users to disable this in special cases that can't be easily
 // detected during compilation, via -DABSL_MALLOC_HOOK_MMAP_DISABLE or #define
 // ABSL_MALLOC_HOOK_MMAP_DISABLE.
-// TODO(b/62370839): Remove MALLOC_HOOK_MMAP_DISABLE in CROSSTOOL for tsan and
+//
+// TODO(absl-team): Remove MALLOC_HOOK_MMAP_DISABLE in CROSSTOOL for tsan and
 // msan config; Replace MALLOC_HOOK_MMAP_DISABLE with
 // ABSL_MALLOC_HOOK_MMAP_DISABLE for other special cases.
 #if !defined(THREAD_SANITIZER) && !defined(MEMORY_SANITIZER) && \

absl/base/internal/raw_logging.cc

@@ -34,10 +34,10 @@
 //
 // This preprocessor token is also defined in raw_io.cc.  If you need to copy
 // this, consider moving both to config.h instead.
-#if defined(__linux__) || defined(__APPLE__) || defined(__Fuchsia__) || \
-    defined(__GENCLAVE__)
+#if defined(__linux__) || defined(__APPLE__) || defined(__Fuchsia__)
 #include <unistd.h>
 
+
 #define ABSL_HAVE_POSIX_WRITE 1
 #define ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
 #else
@@ -110,10 +110,6 @@ namespace {
 
 // CAVEAT: vsnprintf called from *DoRawLog below has some (exotic) code paths
 // that invoke malloc() and getenv() that might acquire some locks.
-// If this becomes a problem we should reimplement a subset of vsnprintf
-// that does not need locks and malloc.
-// E.g. google3/third_party/clearsilver/core/util/snprintf.c
-// looks like such a reimplementation.
 
 // Helper for RawLog below.
 // *DoRawLog writes to *buf of *size and move them past the written portion.

absl/base/internal/scheduling_mode.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// Core interfaces and definitions used by by low-level //base interfaces such
-// as SpinLock.
+// Core interfaces and definitions used by by low-level interfaces such as
+// SpinLock.
 
 #ifndef ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
 #define ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_

absl/base/internal/spinlock_wait.h

@@ -18,10 +18,6 @@
 // Operations to make atomic transitions on a word, and to allow
 // waiting for those transitions to become possible.
 
-// This file is used internally in spinlock.cc and once.cc, and a few other
-// places listing in //base:spinlock_wait_users.  If you need to use it outside
-// of //base, please request permission to be added to that list.
-
 #include <stdint.h>
 #include <atomic>
 

absl/base/internal/sysinfo.cc

@@ -57,10 +57,7 @@ static int num_cpus = 0;
 static double nominal_cpu_frequency = 1.0;  // 0.0 might be dangerous.
 
 static int GetNumCPUs() {
-#if defined(__myriad2__) || defined(__GENCLAVE__)
-  // TODO(b/28296132): Calling std::thread::hardware_concurrency() induces a
-  // link error on myriad2 builds.
-  // TODO(b/62709537): Support std::thread::hardware_concurrency() in gEnclalve.
+#if defined(__myriad2__)
   return 1;
 #else
   // Other possibilities: