2 files changed, 11 insertions, 26 deletions
diff --git a/absl/numeric/int128.h b/absl/numeric/int128.h
index 94d2f7ce2985..5e1b3f03c0f2 100644
--- a/absl/numeric/int128.h
+++ b/absl/numeric/int128.h
@@ -570,25 +570,14 @@ inline uint128& uint128::operator*=(uint128 other) {
           static_cast<unsigned __int128>(other);
   return *this;
 #else   // ABSL_HAVE_INTRINSIC128
-  uint64_t a96 = hi_ >> 32;
-  uint64_t a64 = hi_ & 0xffffffff;
   uint64_t a32 = lo_ >> 32;
   uint64_t a00 = lo_ & 0xffffffff;
-  uint64_t b96 = other.hi_ >> 32;
-  uint64_t b64 = other.hi_ & 0xffffffff;
   uint64_t b32 = other.lo_ >> 32;
   uint64_t b00 = other.lo_ & 0xffffffff;
-  // multiply [a96 .. a00] x [b96 .. b00]
-  // terms higher than c96 disappear off the high side
-  // terms c96 and c64 are safe to ignore carry bit
-  uint64_t c96 = a96 * b00 + a64 * b32 + a32 * b64 + a00 * b96;
-  uint64_t c64 = a64 * b00 + a32 * b32 + a00 * b64;
-  this->hi_ = (c96 << 32) + c64;
-  this->lo_ = 0;
-  // add terms after this one at a time to capture carry
+  hi_ = hi_ * other.lo_ + lo_ * other.hi_ + a32 * b32;
+  lo_ = a00 * b00;
   *this += uint128(a32 * b00) << 32;
   *this += uint128(a00 * b32) << 32;
-  *this += a00 * b00;
   return *this;
 #endif  // ABSL_HAVE_INTRINSIC128
 }
diff --git a/absl/synchronization/lifetime_test.cc b/absl/synchronization/lifetime_test.cc
index a3e2701f9208..90c9009b18fa 100644
--- a/absl/synchronization/lifetime_test.cc
+++ b/absl/synchronization/lifetime_test.cc
@@ -18,6 +18,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/internal/raw_logging.h"
+#include "absl/base/thread_annotations.h"
 #include "absl/synchronization/mutex.h"
 #include "absl/synchronization/notification.h"
 
@@ -106,24 +107,19 @@ void TestLocals() {
 // 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 {
+using Function = void (*)();
+
+class OnConstruction {
  public:
-  ConstructorTestRunner(absl::Mutex* mutex, absl::CondVar* condvar,
-                        absl::Notification* notification) {
-    RunTests(mutex, condvar, notification);
-  }
+  explicit OnConstruction(Function fn) { fn(); }
 };
 
-class DestructorTestRunner {
+class OnDestruction {
  public:
-  DestructorTestRunner(absl::Mutex* mutex, absl::CondVar* condvar,
-                       absl::Notification* notification)
-      : mutex_(mutex), condvar_(condvar), notification_(notification) {}
-  ~DestructorTestRunner() { RunTests(mutex_, condvar_, notification_); }
+  explicit OnDestruction(Function fn) : fn_(fn) {}
+  ~OnDestruction() { fn_(); }
  private:
-  absl::Mutex* mutex_;
-  absl::CondVar* condvar_;
-  absl::Notification* notification_;
+  Function fn_;
 };
 
 }  // namespace