re2 1.23.0 → 1.23.2

package/vendor/abseil-cpp/absl/time/civil_time_test.cc

@@ -78,8 +78,7 @@ TEST(CivilTime, FieldsConstruction) {
             absl::FormatCivilTime(absl::CivilMinute(2015, 1, 2)));
   EXPECT_EQ("2015-01-01T00:00",
             absl::FormatCivilTime(absl::CivilMinute(2015, 1)));
-  EXPECT_EQ("2015-01-01T00:00",
-            absl::FormatCivilTime(absl::CivilMinute(2015)));
+  EXPECT_EQ("2015-01-01T00:00", absl::FormatCivilTime(absl::CivilMinute(2015)));
 
   EXPECT_EQ("2015-01-02T03",
             absl::FormatCivilTime(absl::CivilHour(2015, 1, 2, 3, 4, 5)));
@@ -89,82 +88,63 @@ TEST(CivilTime, FieldsConstruction) {
             absl::FormatCivilTime(absl::CivilHour(2015, 1, 2, 3)));
   EXPECT_EQ("2015-01-02T00",
             absl::FormatCivilTime(absl::CivilHour(2015, 1, 2)));
-  EXPECT_EQ("2015-01-01T00",
-            absl::FormatCivilTime(absl::CivilHour(2015, 1)));
-  EXPECT_EQ("2015-01-01T00",
-            absl::FormatCivilTime(absl::CivilHour(2015)));
+  EXPECT_EQ("2015-01-01T00", absl::FormatCivilTime(absl::CivilHour(2015, 1)));
+  EXPECT_EQ("2015-01-01T00", absl::FormatCivilTime(absl::CivilHour(2015)));
 
   EXPECT_EQ("2015-01-02",
             absl::FormatCivilTime(absl::CivilDay(2015, 1, 2, 3, 4, 5)));
   EXPECT_EQ("2015-01-02",
             absl::FormatCivilTime(absl::CivilDay(2015, 1, 2, 3, 4)));
-  EXPECT_EQ("2015-01-02",
-            absl::FormatCivilTime(absl::CivilDay(2015, 1, 2, 3)));
-  EXPECT_EQ("2015-01-02",
-            absl::FormatCivilTime(absl::CivilDay(2015, 1, 2)));
-  EXPECT_EQ("2015-01-01",
-            absl::FormatCivilTime(absl::CivilDay(2015, 1)));
-  EXPECT_EQ("2015-01-01",
-            absl::FormatCivilTime(absl::CivilDay(2015)));
+  EXPECT_EQ("2015-01-02", absl::FormatCivilTime(absl::CivilDay(2015, 1, 2, 3)));
+  EXPECT_EQ("2015-01-02", absl::FormatCivilTime(absl::CivilDay(2015, 1, 2)));
+  EXPECT_EQ("2015-01-01", absl::FormatCivilTime(absl::CivilDay(2015, 1)));
+  EXPECT_EQ("2015-01-01", absl::FormatCivilTime(absl::CivilDay(2015)));
 
   EXPECT_EQ("2015-01",
             absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2, 3, 4, 5)));
   EXPECT_EQ("2015-01",
             absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2, 3, 4)));
-  EXPECT_EQ("2015-01",
-            absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2, 3)));
-  EXPECT_EQ("2015-01",
-            absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2)));
-  EXPECT_EQ("2015-01",
-            absl::FormatCivilTime(absl::CivilMonth(2015, 1)));
-  EXPECT_EQ("2015-01",
-            absl::FormatCivilTime(absl::CivilMonth(2015)));
+  EXPECT_EQ("2015-01", absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2, 3)));
+  EXPECT_EQ("2015-01", absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2)));
+  EXPECT_EQ("2015-01", absl::FormatCivilTime(absl::CivilMonth(2015, 1)));
+  EXPECT_EQ("2015-01", absl::FormatCivilTime(absl::CivilMonth(2015)));
 
   EXPECT_EQ("2015",
             absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3, 4, 5)));
-  EXPECT_EQ("2015",
-            absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3, 4)));
-  EXPECT_EQ("2015",
-            absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3)));
-  EXPECT_EQ("2015",
-            absl::FormatCivilTime(absl::CivilYear(2015, 1, 2)));
-  EXPECT_EQ("2015",
-            absl::FormatCivilTime(absl::CivilYear(2015, 1)));
-  EXPECT_EQ("2015",
-            absl::FormatCivilTime(absl::CivilYear(2015)));
+  EXPECT_EQ("2015", absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3, 4)));
+  EXPECT_EQ("2015", absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3)));
+  EXPECT_EQ("2015", absl::FormatCivilTime(absl::CivilYear(2015, 1, 2)));
+  EXPECT_EQ("2015", absl::FormatCivilTime(absl::CivilYear(2015, 1)));
+  EXPECT_EQ("2015", absl::FormatCivilTime(absl::CivilYear(2015)));
 }
 
 TEST(CivilTime, FieldsConstructionLimits) {
   const int kIntMax = std::numeric_limits<int>::max();
-  EXPECT_EQ("2038-01-19T03:14:07",
-            absl::FormatCivilTime(absl::CivilSecond(
-                1970, 1, 1, 0, 0, kIntMax)));
-  EXPECT_EQ("6121-02-11T05:21:07",
-            absl::FormatCivilTime(absl::CivilSecond(
-                1970, 1, 1, 0, kIntMax, kIntMax)));
+  EXPECT_EQ("2038-01-19T03:14:07", absl::FormatCivilTime(absl::CivilSecond(
+                                       1970, 1, 1, 0, 0, kIntMax)));
+  EXPECT_EQ("6121-02-11T05:21:07", absl::FormatCivilTime(absl::CivilSecond(
+                                       1970, 1, 1, 0, kIntMax, kIntMax)));
   EXPECT_EQ("251104-11-20T12:21:07",
-            absl::FormatCivilTime(absl::CivilSecond(
-                1970, 1, 1, kIntMax, kIntMax, kIntMax)));
+            absl::FormatCivilTime(
+                absl::CivilSecond(1970, 1, 1, kIntMax, kIntMax, kIntMax)));
   EXPECT_EQ("6130715-05-30T12:21:07",
-            absl::FormatCivilTime(absl::CivilSecond(
-                1970, 1, kIntMax, kIntMax, kIntMax, kIntMax)));
+            absl::FormatCivilTime(absl::CivilSecond(1970, 1, kIntMax, kIntMax,
+                                                    kIntMax, kIntMax)));
   EXPECT_EQ("185087685-11-26T12:21:07",
             absl::FormatCivilTime(absl::CivilSecond(
                 1970, kIntMax, kIntMax, kIntMax, kIntMax, kIntMax)));
 
   const int kIntMin = std::numeric_limits<int>::min();
-  EXPECT_EQ("1901-12-13T20:45:52",
-            absl::FormatCivilTime(absl::CivilSecond(
-                1970, 1, 1, 0, 0, kIntMin)));
-  EXPECT_EQ("-2182-11-20T18:37:52",
-            absl::FormatCivilTime(absl::CivilSecond(
-                1970, 1, 1, 0, kIntMin, kIntMin)));
+  EXPECT_EQ("1901-12-13T20:45:52", absl::FormatCivilTime(absl::CivilSecond(
+                                       1970, 1, 1, 0, 0, kIntMin)));
+  EXPECT_EQ("-2182-11-20T18:37:52", absl::FormatCivilTime(absl::CivilSecond(
+                                        1970, 1, 1, 0, kIntMin, kIntMin)));
   EXPECT_EQ("-247165-02-11T10:37:52",
-            absl::FormatCivilTime(absl::CivilSecond(
-                1970, 1, 1, kIntMin, kIntMin, kIntMin)));
+            absl::FormatCivilTime(
+                absl::CivilSecond(1970, 1, 1, kIntMin, kIntMin, kIntMin)));
   EXPECT_EQ("-6126776-08-01T10:37:52",
-            absl::FormatCivilTime(absl::CivilSecond(
-                1970, 1, kIntMin, kIntMin, kIntMin, kIntMin)));
+            absl::FormatCivilTime(absl::CivilSecond(1970, 1, kIntMin, kIntMin,
+                                                    kIntMin, kIntMin)));
   EXPECT_EQ("-185083747-10-31T10:37:52",
             absl::FormatCivilTime(absl::CivilSecond(
                 1970, kIntMin, kIntMin, kIntMin, kIntMin, kIntMin)));
@@ -173,14 +153,10 @@ TEST(CivilTime, FieldsConstructionLimits) {
 TEST(CivilTime, RangeLimits) {
   const absl::civil_year_t kYearMax =
       std::numeric_limits<absl::civil_year_t>::max();
-  EXPECT_EQ(absl::CivilYear(kYearMax),
-            absl::CivilYear::max());
-  EXPECT_EQ(absl::CivilMonth(kYearMax, 12),
-            absl::CivilMonth::max());
-  EXPECT_EQ(absl::CivilDay(kYearMax, 12, 31),
-            absl::CivilDay::max());
-  EXPECT_EQ(absl::CivilHour(kYearMax, 12, 31, 23),
-            absl::CivilHour::max());
+  EXPECT_EQ(absl::CivilYear(kYearMax), absl::CivilYear::max());
+  EXPECT_EQ(absl::CivilMonth(kYearMax, 12), absl::CivilMonth::max());
+  EXPECT_EQ(absl::CivilDay(kYearMax, 12, 31), absl::CivilDay::max());
+  EXPECT_EQ(absl::CivilHour(kYearMax, 12, 31, 23), absl::CivilHour::max());
   EXPECT_EQ(absl::CivilMinute(kYearMax, 12, 31, 23, 59),
             absl::CivilMinute::max());
   EXPECT_EQ(absl::CivilSecond(kYearMax, 12, 31, 23, 59, 59),
@@ -188,16 +164,11 @@ TEST(CivilTime, RangeLimits) {
 
   const absl::civil_year_t kYearMin =
       std::numeric_limits<absl::civil_year_t>::min();
-  EXPECT_EQ(absl::CivilYear(kYearMin),
-            absl::CivilYear::min());
-  EXPECT_EQ(absl::CivilMonth(kYearMin, 1),
-            absl::CivilMonth::min());
-  EXPECT_EQ(absl::CivilDay(kYearMin, 1, 1),
-            absl::CivilDay::min());
-  EXPECT_EQ(absl::CivilHour(kYearMin, 1, 1, 0),
-            absl::CivilHour::min());
-  EXPECT_EQ(absl::CivilMinute(kYearMin, 1, 1, 0, 0),
-            absl::CivilMinute::min());
+  EXPECT_EQ(absl::CivilYear(kYearMin), absl::CivilYear::min());
+  EXPECT_EQ(absl::CivilMonth(kYearMin, 1), absl::CivilMonth::min());
+  EXPECT_EQ(absl::CivilDay(kYearMin, 1, 1), absl::CivilDay::min());
+  EXPECT_EQ(absl::CivilHour(kYearMin, 1, 1, 0), absl::CivilHour::min());
+  EXPECT_EQ(absl::CivilMinute(kYearMin, 1, 1, 0, 0), absl::CivilMinute::min());
   EXPECT_EQ(absl::CivilSecond(kYearMin, 1, 1, 0, 0, 0),
             absl::CivilSecond::min());
 }
@@ -250,8 +221,7 @@ TEST(CivilTime, ImplicitCrossAlignment) {
       (std::is_convertible<absl::CivilSecond, absl::CivilMinute>::value));
   EXPECT_FALSE(
       (std::is_convertible<absl::CivilSecond, absl::CivilHour>::value));
-  EXPECT_FALSE(
-      (std::is_convertible<absl::CivilSecond, absl::CivilDay>::value));
+  EXPECT_FALSE((std::is_convertible<absl::CivilSecond, absl::CivilDay>::value));
   EXPECT_FALSE(
       (std::is_convertible<absl::CivilSecond, absl::CivilMonth>::value));
   EXPECT_FALSE(
@@ -259,27 +229,20 @@ TEST(CivilTime, ImplicitCrossAlignment) {
 
   EXPECT_FALSE(
       (std::is_convertible<absl::CivilMinute, absl::CivilHour>::value));
-  EXPECT_FALSE(
-      (std::is_convertible<absl::CivilMinute, absl::CivilDay>::value));
+  EXPECT_FALSE((std::is_convertible<absl::CivilMinute, absl::CivilDay>::value));
   EXPECT_FALSE(
       (std::is_convertible<absl::CivilMinute, absl::CivilMonth>::value));
   EXPECT_FALSE(
       (std::is_convertible<absl::CivilMinute, absl::CivilYear>::value));
 
-  EXPECT_FALSE(
-      (std::is_convertible<absl::CivilHour, absl::CivilDay>::value));
-  EXPECT_FALSE(
-      (std::is_convertible<absl::CivilHour, absl::CivilMonth>::value));
-  EXPECT_FALSE(
-      (std::is_convertible<absl::CivilHour, absl::CivilYear>::value));
+  EXPECT_FALSE((std::is_convertible<absl::CivilHour, absl::CivilDay>::value));
+  EXPECT_FALSE((std::is_convertible<absl::CivilHour, absl::CivilMonth>::value));
+  EXPECT_FALSE((std::is_convertible<absl::CivilHour, absl::CivilYear>::value));
 
-  EXPECT_FALSE(
-      (std::is_convertible<absl::CivilDay, absl::CivilMonth>::value));
-  EXPECT_FALSE(
-      (std::is_convertible<absl::CivilDay, absl::CivilYear>::value));
+  EXPECT_FALSE((std::is_convertible<absl::CivilDay, absl::CivilMonth>::value));
+  EXPECT_FALSE((std::is_convertible<absl::CivilDay, absl::CivilYear>::value));
 
-  EXPECT_FALSE(
-      (std::is_convertible<absl::CivilMonth, absl::CivilYear>::value));
+  EXPECT_FALSE((std::is_convertible<absl::CivilMonth, absl::CivilYear>::value));
 }
 
 TEST(CivilTime, ExplicitCrossAlignment) {
@@ -417,8 +380,7 @@ TEST(CivilTime, Relational) {
   // Tests the relational operators of two different civil-time types.
   TEST_RELATIONAL(absl::CivilDay(2014, 1, 1),
                   absl::CivilMinute(2014, 1, 1, 1, 1));
-  TEST_RELATIONAL(absl::CivilDay(2014, 1, 1),
-                  absl::CivilMonth(2014, 2));
+  TEST_RELATIONAL(absl::CivilDay(2014, 1, 1), absl::CivilMonth(2014, 2));
 
 #undef TEST_RELATIONAL
 }
@@ -812,8 +774,7 @@ TEST(CivilTime, ParseEdgeCases) {
   EXPECT_EQ("-9223372036854775808-01-01T00:00", absl::FormatCivilTime(mm));
 
   absl::CivilHour hh;
-  EXPECT_TRUE(
-      absl::ParseLenientCivilTime("9223372036854775807-12-31T23", &hh));
+  EXPECT_TRUE(absl::ParseLenientCivilTime("9223372036854775807-12-31T23", &hh));
   EXPECT_EQ("9223372036854775807-12-31T23", absl::FormatCivilTime(hh));
   EXPECT_TRUE(
       absl::ParseLenientCivilTime("-9223372036854775808-01-01T00", &hh));
@@ -1181,19 +1142,13 @@ TEST(CivilTime, LeapYears) {
       int day;
     } leap_day;  // The date of the day after Feb 28.
   } kLeapYearTable[]{
-      {1900, 365, {3, 1}},
-      {1999, 365, {3, 1}},
+      {1900, 365, {3, 1}},  {1999, 365, {3, 1}},
       {2000, 366, {2, 29}},  // leap year
-      {2001, 365, {3, 1}},
-      {2002, 365, {3, 1}},
-      {2003, 365, {3, 1}},
-      {2004, 366, {2, 29}},  // leap year
-      {2005, 365, {3, 1}},
-      {2006, 365, {3, 1}},
-      {2007, 365, {3, 1}},
-      {2008, 366, {2, 29}},  // leap year
-      {2009, 365, {3, 1}},
-      {2100, 365, {3, 1}},
+      {2001, 365, {3, 1}},  {2002, 365, {3, 1}},
+      {2003, 365, {3, 1}},  {2004, 366, {2, 29}},  // leap year
+      {2005, 365, {3, 1}},  {2006, 365, {3, 1}},
+      {2007, 365, {3, 1}},  {2008, 366, {2, 29}},  // leap year
+      {2009, 365, {3, 1}},  {2100, 365, {3, 1}},
   };
 
   for (int i = 0; i < ABSL_ARRAYSIZE(kLeapYearTable); ++i) {
@@ -1223,7 +1178,7 @@ TEST(CivilTime, FirstThursdayInMonth) {
 
   // Bonus: Date of Thanksgiving in the United States
   // Rule: Fourth Thursday of November
-  const absl::CivilDay thanksgiving = thursday +  7 * 3;
+  const absl::CivilDay thanksgiving = thursday + 7 * 3;
   EXPECT_EQ("2014-11-27", absl::FormatCivilTime(thanksgiving));
 }
 

package/vendor/abseil-cpp/absl/time/clock.cc

@@ -125,7 +125,7 @@ class UnscaledCycleClockWrapperForGetCurrentTime {
 // spin-delay tuning.
 
 // Acquire seqlock (*seq) and return the value to be written to unlock.
-static inline uint64_t SeqAcquire(std::atomic<uint64_t> *seq) {
+static inline uint64_t SeqAcquire(std::atomic<uint64_t>* seq) {
   uint64_t x = seq->fetch_add(1, std::memory_order_relaxed);
 
   // We put a release fence between update to *seq and writes to shared data.
@@ -140,7 +140,7 @@ static inline uint64_t SeqAcquire(std::atomic<uint64_t> *seq) {
 
 // Release seqlock (*seq) by writing x to it---a value previously returned by
 // SeqAcquire.
-static inline void SeqRelease(std::atomic<uint64_t> *seq, uint64_t x) {
+static inline void SeqRelease(std::atomic<uint64_t>* seq, uint64_t x) {
   // The unlock store to *seq must have release ordering so that all
   // updates to shared data must finish before this store.
   seq->store(x, std::memory_order_release);  // release lock for readers
@@ -218,7 +218,7 @@ ABSL_CONST_INIT static TimeState time_state;
 // assumed to be complete resyncs, which shouldn't happen.  If they do, a full
 // reinitialization of the outer algorithm should occur.)
 static int64_t GetCurrentTimeNanosFromKernel(uint64_t last_cycleclock,
-                                             uint64_t *cycleclock)
+                                             uint64_t* cycleclock)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) {
   uint64_t local_approx_syscall_time_in_cycles =  // local copy
       time_state.approx_syscall_time_in_cycles.load(std::memory_order_relaxed);
@@ -274,8 +274,8 @@ static int64_t GetCurrentTimeNanosSlowPath() ABSL_ATTRIBUTE_COLD;
 // Read the contents of *atomic into *sample.
 // Each field is read atomically, but to maintain atomicity between fields,
 // the access must be done under a lock.
-static void ReadTimeSampleAtomic(const struct TimeSampleAtomic *atomic,
-                                 struct TimeSample *sample) {
+static void ReadTimeSampleAtomic(const struct TimeSampleAtomic* atomic,
+                                 struct TimeSample* sample) {
   sample->base_ns = atomic->base_ns.load(std::memory_order_relaxed);
   sample->base_cycles = atomic->base_cycles.load(std::memory_order_relaxed);
   sample->nsscaled_per_cycle =
@@ -338,18 +338,20 @@ int64_t GetCurrentTimeNanos() {
   // to the same shared data.
   seq_read0 = time_state.seq.load(std::memory_order_acquire);
 
-  base_ns = time_state.last_sample.base_ns.load(std::memory_order_relaxed);
+  // The algorithm does not require that the following four loads be ordered
+  // with respect to one another; it requires only that they precede the load of
+  // time_state.seq below them. Nevertheless, we mark each of them as an
+  // acquire-load, rather than using a barrier immediately before the
+  // time_state.seq load, because the former is likely faster on most CPUs of
+  // interest. Architectures that may see a regression because of this approach
+  // include PowerPC and MIPS.
+  base_ns = time_state.last_sample.base_ns.load(std::memory_order_acquire);
   base_cycles =
-      time_state.last_sample.base_cycles.load(std::memory_order_relaxed);
+      time_state.last_sample.base_cycles.load(std::memory_order_acquire);
   nsscaled_per_cycle =
-      time_state.last_sample.nsscaled_per_cycle.load(std::memory_order_relaxed);
+      time_state.last_sample.nsscaled_per_cycle.load(std::memory_order_acquire);
   min_cycles_per_sample = time_state.last_sample.min_cycles_per_sample.load(
-      std::memory_order_relaxed);
-
-  // This acquire fence pairs with the release fence in SeqAcquire.  Since it
-  // is sequenced between reads of shared data and seq_read1, the reads of
-  // shared data are effectively acquiring.
-  std::atomic_thread_fence(std::memory_order_acquire);
+      std::memory_order_acquire);
 
   // The shared-data reads are effectively acquire ordered, and the
   // shared-data writes are effectively release ordered. Therefore if our
@@ -397,7 +399,7 @@ static uint64_t SafeDivideAndScale(uint64_t a, uint64_t b) {
 
 static uint64_t UpdateLastSample(
     uint64_t now_cycles, uint64_t now_ns, uint64_t delta_cycles,
-    const struct TimeSample *sample) ABSL_ATTRIBUTE_COLD;
+    const struct TimeSample* sample) ABSL_ATTRIBUTE_COLD;
 
 // The slow path of GetCurrentTimeNanos().  This is taken while gathering
 // initial samples, when enough time has elapsed since the last sample, and if
@@ -454,7 +456,7 @@ static int64_t GetCurrentTimeNanosSlowPath()
 // for readers.  Returns the new estimated time.
 static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
                                  uint64_t delta_cycles,
-                                 const struct TimeSample *sample)
+                                 const struct TimeSample* sample)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) {
   uint64_t estimated_base_ns = now_ns;
   uint64_t lock_value =

package/vendor/abseil-cpp/absl/time/clock_test.cc

@@ -114,8 +114,8 @@ TEST(SleepFor, Bounded) {
   EXPECT_TRUE(AssertSleepForBounded(d, early, late, timeout,
                                     AlarmPolicy::kWithoutAlarm));
 #if defined(ABSL_HAVE_ALARM)
-  EXPECT_TRUE(AssertSleepForBounded(d, early, late, timeout,
-                                    AlarmPolicy::kWithAlarm));
+  EXPECT_TRUE(
+      AssertSleepForBounded(d, early, late, timeout, AlarmPolicy::kWithAlarm));
 #endif
 }
 

package/vendor/abseil-cpp/absl/time/duration_benchmark.cc

@@ -358,6 +358,150 @@ void BM_Duration_ToInt64Hours(benchmark::State& state) {
 }
 BENCHMARK(BM_Duration_ToInt64Hours);
 
+//
+// ToDoubleXYZ
+//
+void BM_Duration_ToDoubleNanoseconds(benchmark::State& state) {
+  absl::Duration d = absl::Seconds(100000);
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d);
+    double result = absl::ToDoubleNanoseconds(d);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleNanoseconds);
+
+void BM_Duration_ToDoubleMicroseconds(benchmark::State& state) {
+  absl::Duration d = absl::Seconds(100000);
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d);
+    double result = absl::ToDoubleMicroseconds(d);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleMicroseconds);
+
+void BM_Duration_ToDoubleMilliseconds(benchmark::State& state) {
+  absl::Duration d = absl::Seconds(100000);
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d);
+    double result = absl::ToDoubleMilliseconds(d);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleMilliseconds);
+
+void BM_Duration_ToDoubleSeconds(benchmark::State& state) {
+  absl::Duration d = absl::Seconds(100000);
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d);
+    double result = absl::ToDoubleSeconds(d);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleSeconds);
+
+void BM_Duration_ToDoubleMinutes(benchmark::State& state) {
+  absl::Duration d = absl::Seconds(100000);
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d);
+    double result = absl::ToDoubleMinutes(d);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleMinutes);
+
+void BM_Duration_ToDoubleHours(benchmark::State& state) {
+  absl::Duration d = absl::Seconds(100000);
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d);
+    double result = absl::ToDoubleHours(d);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleHours);
+
+//
+// ToDoubleXYZ Latency
+//
+void BM_Duration_ToDoubleNanoseconds_Latency(benchmark::State& state) {
+  absl::Duration d1 = absl::Seconds(100000);
+  absl::Duration d2 = absl::Seconds(100000);
+  double result = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d1);
+    benchmark::DoNotOptimize(d2);
+    benchmark::DoNotOptimize(result);
+    result = absl::ToDoubleNanoseconds(result < 0 ? d1 : d2);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleNanoseconds_Latency);
+
+void BM_Duration_ToDoubleMicroseconds_Latency(benchmark::State& state) {
+  absl::Duration d1 = absl::Seconds(100000);
+  absl::Duration d2 = absl::Seconds(100000);
+  double result = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d1);
+    benchmark::DoNotOptimize(d2);
+    benchmark::DoNotOptimize(result);
+    result = absl::ToDoubleMicroseconds(result < 0 ? d1 : d2);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleMicroseconds_Latency);
+
+void BM_Duration_ToDoubleMilliseconds_Latency(benchmark::State& state) {
+  absl::Duration d1 = absl::Seconds(100000);
+  absl::Duration d2 = absl::Seconds(100000);
+  double result = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d1);
+    benchmark::DoNotOptimize(d2);
+    benchmark::DoNotOptimize(result);
+    result = absl::ToDoubleMilliseconds(result < 0 ? d1 : d2);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleMilliseconds_Latency);
+
+void BM_Duration_ToDoubleSeconds_Latency(benchmark::State& state) {
+  absl::Duration d1 = absl::Seconds(100000);
+  absl::Duration d2 = absl::Seconds(100000);
+  double result = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d1);
+    benchmark::DoNotOptimize(d2);
+    benchmark::DoNotOptimize(result);
+    result = absl::ToDoubleSeconds(result < 0 ? d1 : d2);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleSeconds_Latency);
+
+void BM_Duration_ToDoubleMinutes_Latency(benchmark::State& state) {
+  absl::Duration d1 = absl::Seconds(100000);
+  absl::Duration d2 = absl::Seconds(100000);
+  double result = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d1);
+    benchmark::DoNotOptimize(d2);
+    benchmark::DoNotOptimize(result);
+    result = absl::ToDoubleMinutes(result < 0 ? d1 : d2);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleMinutes_Latency);
+
+void BM_Duration_ToDoubleHours_Latency(benchmark::State& state) {
+  absl::Duration d1 = absl::Seconds(100000);
+  absl::Duration d2 = absl::Seconds(100000);
+  double result = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(d1);
+    benchmark::DoNotOptimize(d2);
+    benchmark::DoNotOptimize(result);
+    result = absl::ToDoubleHours(result < 0 ? d1 : d2);
+  }
+}
+BENCHMARK(BM_Duration_ToDoubleHours_Latency);
+
 //
 // To/FromTimespec
 //

package/vendor/abseil-cpp/absl/time/duration_test.cc

@@ -57,8 +57,7 @@ absl::Duration ApproxYears(int64_t n) { return absl::Hours(n) * 365 * 24; }
 // timespec ts1, ts2;
 // EXPECT_THAT(ts1, TimespecMatcher(ts2));
 MATCHER_P(TimespecMatcher, ts, "") {
-  if (ts.tv_sec == arg.tv_sec && ts.tv_nsec == arg.tv_nsec)
-    return true;
+  if (ts.tv_sec == arg.tv_sec && ts.tv_nsec == arg.tv_nsec) return true;
   *result_listener << "expected: {" << ts.tv_sec << ", " << ts.tv_nsec << "} ";
   *result_listener << "actual: {" << arg.tv_sec << ", " << arg.tv_nsec << "}";
   return false;
@@ -68,8 +67,7 @@ MATCHER_P(TimespecMatcher, ts, "") {
 // timeval tv1, tv2;
 // EXPECT_THAT(tv1, TimevalMatcher(tv2));
 MATCHER_P(TimevalMatcher, tv, "") {
-  if (tv.tv_sec == arg.tv_sec && tv.tv_usec == arg.tv_usec)
-    return true;
+  if (tv.tv_sec == arg.tv_sec && tv.tv_usec == arg.tv_usec) return true;
   *result_listener << "expected: {" << tv.tv_sec << ", " << tv.tv_usec << "} ";
   *result_listener << "actual: {" << arg.tv_sec << ", " << arg.tv_usec << "}";
   return false;
@@ -223,12 +221,12 @@ TEST(Duration, ToConversionDeprecated) {
 
 template <int64_t N>
 void TestFromChronoBasicEquality() {
-  using std::chrono::nanoseconds;
+  using std::chrono::hours;
   using std::chrono::microseconds;
   using std::chrono::milliseconds;
-  using std::chrono::seconds;
   using std::chrono::minutes;
-  using std::chrono::hours;
+  using std::chrono::nanoseconds;
+  using std::chrono::seconds;
 
   static_assert(absl::Nanoseconds(N) == absl::FromChrono(nanoseconds(N)), "");
   static_assert(absl::Microseconds(N) == absl::FromChrono(microseconds(N)), "");
@@ -288,12 +286,12 @@ TEST(Duration, FromChrono) {
 
 template <int64_t N>
 void TestToChrono() {
-  using std::chrono::nanoseconds;
+  using std::chrono::hours;
   using std::chrono::microseconds;
   using std::chrono::milliseconds;
-  using std::chrono::seconds;
   using std::chrono::minutes;
-  using std::chrono::hours;
+  using std::chrono::nanoseconds;
+  using std::chrono::seconds;
 
   EXPECT_EQ(nanoseconds(N), absl::ToChronoNanoseconds(absl::Nanoseconds(N)));
   EXPECT_EQ(microseconds(N), absl::ToChronoMicroseconds(absl::Microseconds(N)));
@@ -320,12 +318,12 @@ void TestToChrono() {
 }
 
 TEST(Duration, ToChrono) {
-  using std::chrono::nanoseconds;
+  using std::chrono::hours;
   using std::chrono::microseconds;
   using std::chrono::milliseconds;
-  using std::chrono::seconds;
   using std::chrono::minutes;
-  using std::chrono::hours;
+  using std::chrono::nanoseconds;
+  using std::chrono::seconds;
 
   TestToChrono<kint64min>();
   TestToChrono<-1>();
@@ -546,18 +544,18 @@ TEST(Duration, InfinityMultiplication) {
   const absl::Duration sec_min = absl::Seconds(kint64min);
   const absl::Duration inf = absl::InfiniteDuration();
 
-#define TEST_INF_MUL_WITH_TYPE(T)                                     \
-  EXPECT_EQ(inf, inf * static_cast<T>(2));                            \
-  EXPECT_EQ(-inf, inf * static_cast<T>(-2));                          \
-  EXPECT_EQ(-inf, -inf * static_cast<T>(2));                          \
-  EXPECT_EQ(inf, -inf * static_cast<T>(-2));                          \
-  EXPECT_EQ(inf, inf * static_cast<T>(0));                            \
-  EXPECT_EQ(-inf, -inf * static_cast<T>(0));                          \
-  EXPECT_EQ(inf, sec_max * static_cast<T>(2));                        \
-  EXPECT_EQ(inf, sec_min * static_cast<T>(-2));                       \
-  EXPECT_EQ(inf, (sec_max / static_cast<T>(2)) * static_cast<T>(3));  \
-  EXPECT_EQ(-inf, sec_max * static_cast<T>(-2));                      \
-  EXPECT_EQ(-inf, sec_min * static_cast<T>(2));                       \
+#define TEST_INF_MUL_WITH_TYPE(T)                                    \
+  EXPECT_EQ(inf, inf* static_cast<T>(2));                            \
+  EXPECT_EQ(-inf, inf* static_cast<T>(-2));                          \
+  EXPECT_EQ(-inf, -inf* static_cast<T>(2));                          \
+  EXPECT_EQ(inf, -inf* static_cast<T>(-2));                          \
+  EXPECT_EQ(inf, inf* static_cast<T>(0));                            \
+  EXPECT_EQ(-inf, -inf* static_cast<T>(0));                          \
+  EXPECT_EQ(inf, sec_max* static_cast<T>(2));                        \
+  EXPECT_EQ(inf, sec_min* static_cast<T>(-2));                       \
+  EXPECT_EQ(inf, (sec_max / static_cast<T>(2)) * static_cast<T>(3)); \
+  EXPECT_EQ(-inf, sec_max* static_cast<T>(-2));                      \
+  EXPECT_EQ(-inf, sec_min* static_cast<T>(2));                       \
   EXPECT_EQ(-inf, (sec_min / static_cast<T>(2)) * static_cast<T>(3));
 
   TEST_INF_MUL_WITH_TYPE(int64_t);  // NOLINT(readability/function)
@@ -932,9 +930,9 @@ TEST(Duration, RelationalOperators) {
 #ifdef ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON
 
 TEST(Duration, SpaceshipOperators) {
-#define TEST_REL_OPS(UNIT)               \
+#define TEST_REL_OPS(UNIT)                                               \
   static_assert(UNIT(2) <=> UNIT(2) == std::strong_ordering::equal, ""); \
-  static_assert(UNIT(1) <=> UNIT(2) == std::strong_ordering::less, ""); \
+  static_assert(UNIT(1) <=> UNIT(2) == std::strong_ordering::less, "");  \
   static_assert(UNIT(3) <=> UNIT(2) == std::strong_ordering::greater, "");
 
   TEST_REL_OPS(absl::Nanoseconds);
@@ -1159,8 +1157,7 @@ TEST(Duration, Multiplication) {
   EXPECT_EQ(0, absl::Nanoseconds(-1) / absl::Seconds(1));  // Actual -1e-9
 
   // Tests identity a = (a/b)*b + a%b
-#define TEST_MOD_IDENTITY(a, b) \
-  EXPECT_EQ((a), ((a) / (b))*(b) + ((a)%(b)))
+#define TEST_MOD_IDENTITY(a, b) EXPECT_EQ((a), ((a) / (b)) * (b) + ((a) % (b)))
 
   TEST_MOD_IDENTITY(absl::Seconds(0), absl::Seconds(2));
   TEST_MOD_IDENTITY(absl::Seconds(1), absl::Seconds(1));

package/vendor/abseil-cpp/absl/time/internal/cctz/BUILD.bazel

@@ -59,7 +59,13 @@ cc_library(
         "src/time_zone_posix.h",
         "src/tzfile.h",
         "src/zone_info_source.cc",
-    ],
+    ] + select({
+        "@platforms//os:windows": [
+            "src/time_zone_name_win.cc",
+            "src/time_zone_name_win.h",
+        ],
+        "//conditions:default": [],
+    }),
     hdrs = [
         "include/cctz/time_zone.h",
         "include/cctz/zone_info_source.h",

package/vendor/abseil-cpp/absl/time/internal/cctz/src/time_zone_format.cc

@@ -13,12 +13,14 @@
 //   limitations under the License.
 
 #if !defined(HAS_STRPTIME)
-#if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__VXWORKS__)
+#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__VXWORKS__)
+#define HAS_STRPTIME 0
+#else
 #define HAS_STRPTIME 1  // Assume everyone else has strptime().
 #endif
 #endif
 
-#if defined(HAS_STRPTIME) && HAS_STRPTIME
+#if HAS_STRPTIME
 #if !defined(_XOPEN_SOURCE) && !defined(__FreeBSD__) && !defined(__OpenBSD__)
 #define _XOPEN_SOURCE 500  // Exposes definitions for SUSv2 (UNIX 98).
 #endif