Changes imported from Abseil "staging" branch:

  - f59c2332341d6b1a3e045d61eb0065f7a226f807 Avoid preprocessing  '__CUDACC_VER__ >= 70000' on CUDA 9,... by Abseil Team <absl-team@google.com>
  - 12dd22cf967603e9a12d58abfe877989d61844e3 Internal change. by Greg Falcon <gfalcon@google.com>

GitOrigin-RevId: f59c2332341d6b1a3e045d61eb0065f7a226f807
Change-Id: If4f5274e6d638a2ac86f1377e6ac0481dc584f19

13 files changed, 70 insertions, 21 deletions

diff --git a/absl/base/config.h b/absl/base/config.h
index 5802b653..3f3b8b3a 100644
--- a/absl/base/config.h
+++ b/absl/base/config.h
@@ -181,21 +181,21 @@
 // __SIZEOF_INT128__ but not all versions actually support __int128.
 #ifdef ABSL_HAVE_INTRINSIC_INT128
 #error ABSL_HAVE_INTRINSIC_INT128 cannot be directly set
-#elif (defined(__clang__) && defined(__SIZEOF_INT128__) &&               \
-       !defined(__aarch64__)) ||                                         \
-    (defined(__CUDACC__) && defined(__SIZEOF_INT128__) &&                \
-     __CUDACC_VER_MAJOR__ >= 9) ||                                       \
-    (!defined(__clang__) && !defined(__CUDACC__) && defined(__GNUC__) && \
-     defined(__SIZEOF_INT128__))
+#elif defined(__SIZEOF_INT128__)
+#if (defined(__clang__) && !defined(__aarch64__)) ||      \
+    (defined(__CUDACC__) && __CUDACC_VER_MAJOR__ >= 9) || \
+    (!defined(__clang__) && !defined(__CUDACC__) && defined(__GNUC__))
 #define ABSL_HAVE_INTRINSIC_INT128 1
+#elif defined(__CUDACC__)
 // __CUDACC_VER__ is a full version number before CUDA 9, and is defined to a
-// std::string explaining that it has been removed starting with CUDA 9. We can't
-// compare both variants in a single boolean expression because there is no
-// short-circuiting in the preprocessor.
-#elif defined(__CUDACC__) && defined(__SIZEOF_INT128__) && \
-    __CUDACC_VER__ >= 7000
+// std::string explaining that it has been removed starting with CUDA 9. We use
+// nested #ifs because there is no short-circuiting in the preprocessor.
+// NOTE: `__CUDACC__` could be undefined while `__CUDACC_VER__` is defined.
+#if __CUDACC_VER__ >= 70000
 #define ABSL_HAVE_INTRINSIC_INT128 1
-#endif
+#endif  // __CUDACC_VER__ >= 70000
+#endif  // defined(__CUDACC__)
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 
 // ABSL_HAVE_EXCEPTIONS
 //
diff --git a/absl/base/internal/malloc_hook.cc b/absl/base/internal/malloc_hook.cc
index 7165d4cb..52531c68 100644
--- a/absl/base/internal/malloc_hook.cc
+++ b/absl/base/internal/malloc_hook.cc
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "absl/base/attributes.h"
 #include "absl/base/config.h"
 
 #if ABSL_HAVE_MMAP
diff --git a/absl/base/internal/spinlock.cc b/absl/base/internal/spinlock.cc
index 3ac1f4dc..28a2059f 100644
--- a/absl/base/internal/spinlock.cc
+++ b/absl/base/internal/spinlock.cc
@@ -83,11 +83,6 @@ void RegisterSpinLockProfiler(void (*fn)(const void *contendedlock,
   submit_profile_data.Store(fn);
 }
 
-static inline bool IsCooperative(
-    base_internal::SchedulingMode scheduling_mode) {
-  return scheduling_mode == base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL;
-}
-
 // Uncommon constructors.
 SpinLock::SpinLock(base_internal::SchedulingMode mode)
     : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {
diff --git a/absl/base/internal/spinlock.h b/absl/base/internal/spinlock.h
index f486f68a..a9037e3e 100644
--- a/absl/base/internal/spinlock.h
+++ b/absl/base/internal/spinlock.h
@@ -151,6 +151,12 @@ class LOCKABLE SpinLock {
   enum { kWaitTimeMask =                      // Includes kSpinLockSleeper.
     ~(kSpinLockHeld | kSpinLockCooperative | kSpinLockDisabledScheduling) };
 
+  // Returns true if the provided scheduling mode is cooperative.
+  static constexpr bool IsCooperative(
+      base_internal::SchedulingMode scheduling_mode) {
+    return scheduling_mode == base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL;
+  }
+
   uint32_t TryLockInternal(uint32_t lock_value, uint32_t wait_cycles);
   void InitLinkerInitializedAndCooperative();
   void SlowLock() ABSL_ATTRIBUTE_COLD;
diff --git a/absl/base/internal/sysinfo.cc b/absl/base/internal/sysinfo.cc
index 884c3126..dca7d8fd 100644
--- a/absl/base/internal/sysinfo.cc
+++ b/absl/base/internal/sysinfo.cc
@@ -14,6 +14,8 @@
 
 #include "absl/base/internal/sysinfo.h"
 
+#include "absl/base/attributes.h"
+
 #ifdef _WIN32
 #include <shlwapi.h>
 #include <windows.h>
diff --git a/absl/base/internal/thread_identity_test.cc b/absl/base/internal/thread_identity_test.cc
index 7695a091..ecb8af68 100644
--- a/absl/base/internal/thread_identity_test.cc
+++ b/absl/base/internal/thread_identity_test.cc
@@ -18,6 +18,7 @@
 #include <vector>
 
 #include "gtest/gtest.h"
+#include "absl/base/attributes.h"
 #include "absl/base/internal/spinlock.h"
 #include "absl/base/macros.h"
 #include "absl/synchronization/internal/per_thread_sem.h"
diff --git a/absl/base/spinlock_test_common.cc b/absl/base/spinlock_test_common.cc
index 6918603c..1b508848 100644
--- a/absl/base/spinlock_test_common.cc
+++ b/absl/base/spinlock_test_common.cc
@@ -23,6 +23,7 @@
 #include <vector>
 
 #include "gtest/gtest.h"
+#include "absl/base/attributes.h"
 #include "absl/base/internal/low_level_scheduling.h"
 #include "absl/base/internal/scheduling_mode.h"
 #include "absl/base/internal/spinlock.h"
@@ -53,7 +54,6 @@ namespace {
 
 static constexpr int kArrayLength = 10;
 static uint32_t values[kArrayLength];
-
 static SpinLock static_spinlock(base_internal::kLinkerInitialized);
 static SpinLock static_cooperative_spinlock(
     base_internal::kLinkerInitialized,
@@ -61,6 +61,7 @@ static SpinLock static_cooperative_spinlock(
 static SpinLock static_noncooperative_spinlock(
     base_internal::kLinkerInitialized, base_internal::SCHEDULE_KERNEL_ONLY);
 
+
 // Simple integer hash function based on the public domain lookup2 hash.
 // http://burtleburtle.net/bob/c/lookup2.c
 static uint32_t Hash32(uint32_t a, uint32_t c) {
@@ -187,11 +188,9 @@ TEST(SpinLock, WaitCyclesEncoding) {
     SpinLockTest::DecodeWaitCycles(before_max_value);
   EXPECT_GT(expected_max_value_decoded, before_max_value_decoded);
 }
-
 TEST(SpinLockWithThreads, StaticSpinLock) {
   ThreadedTest(&static_spinlock);
 }
-
 TEST(SpinLockWithThreads, StackSpinLock) {
   SpinLock spinlock;
   ThreadedTest(&spinlock);
diff --git a/absl/synchronization/internal/create_thread_identity.cc b/absl/synchronization/internal/create_thread_identity.cc
index 0134a439..e7a65cd8 100644
--- a/absl/synchronization/internal/create_thread_identity.cc
+++ b/absl/synchronization/internal/create_thread_identity.cc
@@ -21,6 +21,7 @@
 
 #include <string.h>
 
+#include "absl/base/attributes.h"
 #include "absl/base/internal/spinlock.h"
 #include "absl/base/internal/thread_identity.h"
 #include "absl/synchronization/internal/per_thread_sem.h"
diff --git a/absl/synchronization/internal/graphcycles.cc b/absl/synchronization/internal/graphcycles.cc
index d7ae0cf3..9bc9c8a0 100644
--- a/absl/synchronization/internal/graphcycles.cc
+++ b/absl/synchronization/internal/graphcycles.cc
@@ -28,6 +28,7 @@
 // (2) When a new edge (x->y) is inserted, do nothing if rank[x] < rank[y].
 // (3) Otherwise: adjust ranks in the neighborhood of x and y.
 
+#include "absl/base/attributes.h"
 // This file is a no-op if the required LowLevelAlloc support is missing.
 #include "absl/base/internal/low_level_alloc.h"
 #ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
diff --git a/absl/synchronization/lifetime_test.cc b/absl/synchronization/lifetime_test.cc
index 6aea60e1..a3e2701f 100644
--- a/absl/synchronization/lifetime_test.cc
+++ b/absl/synchronization/lifetime_test.cc
@@ -69,8 +69,22 @@ void ThreadTwo(absl::Mutex* mutex, absl::CondVar* condvar,
 }
 
 // Launch thread 1 and thread 2, and block on their completion.
+// If any of 'mutex', 'condvar', or 'notification' is nullptr, use a locally
+// constructed instance instead.
 void RunTests(absl::Mutex* mutex, absl::CondVar* condvar,
               absl::Notification* notification) {
+  absl::Mutex default_mutex;
+  absl::CondVar default_condvar;
+  absl::Notification default_notification;
+  if (!mutex) {
+    mutex = &default_mutex;
+  }
+  if (!condvar) {
+    condvar = &default_condvar;
+  }
+  if (!notification) {
+    notification = &default_notification;
+  }
   bool state = false;
   std::thread thread_one(ThreadOne, mutex, condvar, notification, &state);
   std::thread thread_two(ThreadTwo, mutex, condvar, notification, &state);
@@ -85,6 +99,33 @@ void TestLocals() {
   RunTests(&mutex, &condvar, &notification);
 }
 
+// Global variables during start and termination
+//
+// In a translation unit, static storage duration variables are initialized in
+// the order of their definitions, and destroyed in the reverse order of their
+// definitions.  We can use this to arrange for tests to be run on these objects
+// before they are created, and after they are destroyed.
+
+class ConstructorTestRunner {
+ public:
+  ConstructorTestRunner(absl::Mutex* mutex, absl::CondVar* condvar,
+                        absl::Notification* notification) {
+    RunTests(mutex, condvar, notification);
+  }
+};
+
+class DestructorTestRunner {
+ public:
+  DestructorTestRunner(absl::Mutex* mutex, absl::CondVar* condvar,
+                       absl::Notification* notification)
+      : mutex_(mutex), condvar_(condvar), notification_(notification) {}
+  ~DestructorTestRunner() { RunTests(mutex_, condvar_, notification_); }
+ private:
+  absl::Mutex* mutex_;
+  absl::CondVar* condvar_;
+  absl::Notification* notification_;
+};
+
 }  // namespace
 
 int main() {
diff --git a/absl/synchronization/mutex.cc b/absl/synchronization/mutex.cc
index 32d9e3c2..b2aa7439 100644
--- a/absl/synchronization/mutex.cc
+++ b/absl/synchronization/mutex.cc
@@ -249,7 +249,6 @@ static const struct {
   { 0,                           "Signal on " },
   { 0,                           "SignalAll on " },
 };
-
 static absl::base_internal::SpinLock synch_event_mu(
     absl::base_internal::kLinkerInitialized);
 // protects synch_event
diff --git a/absl/synchronization/mutex.h b/absl/synchronization/mutex.h
index bad37c59..26ac7f61 100644
--- a/absl/synchronization/mutex.h
+++ b/absl/synchronization/mutex.h
@@ -875,6 +875,7 @@ class SCOPED_LOCKABLE ReleasableMutexLock {
 
 #ifdef ABSL_INTERNAL_USE_NONPROD_MUTEX
 #else
+
 inline CondVar::CondVar() : cv_(0) {}
 #endif
 
diff --git a/absl/time/clock.cc b/absl/time/clock.cc
index 9f2e0781..59709dea 100644
--- a/absl/time/clock.cc
+++ b/absl/time/clock.cc
@@ -1,5 +1,7 @@
 #include "absl/time/clock.h"
 
+#include "absl/base/attributes.h"
+
 #ifdef _WIN32
 #include <windows.h>
 #endif