Revert of Oilpan: Refactor the way we calculate heap statistics

Source/wtf/Atomics.h

 /*
  * Copyright (C) 2007, 2008, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 38 matching lines @@
 
 namespace WTF {
 
 #if COMPILER(MSVC)
 
 // atomicAdd returns the result of the addition.
 ALWAYS_INLINE int atomicAdd(int volatile* addend, int increment)
 {
     return InterlockedExchangeAdd(reinterpret_cast<long volatile*>(addend), static_cast<long>(increment)) + increment;
 }
-ALWAYS_INLINE unsigned atomicAdd(unsigned volatile* addend, unsigned increment)
-{
-    return InterlockedExchangeAdd(reinterpret_cast<long volatile*>(addend), static_cast<long>(increment)) + increment;
-}
-#if defined(_WIN64)
-ALWAYS_INLINE unsigned long atomicAdd(unsigned long volatile* addend, unsigned long increment)
-{
-    return InterlockedExchangeAdd64(reinterpret_cast<long long volatile*>(addend), static_cast<long long>(increment)) + increment;
-}
-#endif
 
 // atomicSubtract returns the result of the subtraction.
 ALWAYS_INLINE int atomicSubtract(int volatile* addend, int decrement)
 {
     return InterlockedExchangeAdd(reinterpret_cast<long volatile*>(addend), static_cast<long>(-decrement)) - decrement;
 }
-ALWAYS_INLINE unsigned atomicSubtract(unsigned volatile* addend, unsigned decrement)
-{
-    return InterlockedExchangeAdd(reinterpret_cast<long volatile*>(addend), -static_cast<long>(decrement)) - decrement;
-}
-#if defined(_WIN64)
-ALWAYS_INLINE unsigned long atomicSubtract(unsigned long volatile* addend, unsigned long decrement)
-{
-    return InterlockedExchangeAdd64(reinterpret_cast<long long volatile*>(addend), -static_cast<long long>(decrement)) - decrement;
-}
-#endif
 
 ALWAYS_INLINE int atomicIncrement(int volatile* addend) { return InterlockedIncrement(reinterpret_cast<long volatile*>(addend)); }
 ALWAYS_INLINE int atomicDecrement(int volatile* addend) { return InterlockedDecrement(reinterpret_cast<long volatile*>(addend)); }
 
 ALWAYS_INLINE int64_t atomicIncrement(int64_t volatile* addend) { return InterlockedIncrement64(reinterpret_cast<long long volatile*>(addend)); }
 ALWAYS_INLINE int64_t atomicDecrement(int64_t volatile* addend) { return InterlockedDecrement64(reinterpret_cast<long long volatile*>(addend)); }
 
 ALWAYS_INLINE int atomicTestAndSetToOne(int volatile* ptr)
 {
     int ret = InterlockedExchange(reinterpret_cast<long volatile*>(ptr), 1);
     ASSERT(!ret || ret == 1);
     return ret;
 }
 
 ALWAYS_INLINE void atomicSetOneToZero(int volatile* ptr)
 {
     ASSERT(*ptr == 1);
     InterlockedExchange(reinterpret_cast<long volatile*>(ptr), 0);
 }
 
 #else
 
 // atomicAdd returns the result of the addition.
 ALWAYS_INLINE int atomicAdd(int volatile* addend, int increment) { return __sync_add_and_fetch(addend, increment); }
-ALWAYS_INLINE unsigned atomicAdd(unsigned volatile* addend, unsigned increment) { return __sync_add_and_fetch(addend, increment); }
-ALWAYS_INLINE unsigned long atomicAdd(unsigned long volatile* addend, unsigned long increment) { return __sync_add_and_fetch(addend, increment); }
 // atomicSubtract returns the result of the subtraction.
 ALWAYS_INLINE int atomicSubtract(int volatile* addend, int decrement) { return __sync_sub_and_fetch(addend, decrement); }
-ALWAYS_INLINE unsigned atomicSubtract(unsigned volatile* addend, unsigned decrement) { return __sync_sub_and_fetch(addend, decrement); }
-ALWAYS_INLINE unsigned long atomicSubtract(unsigned long volatile* addend, unsigned long decrement) { return __sync_sub_and_fetch(addend, decrement); }
 
 ALWAYS_INLINE int atomicIncrement(int volatile* addend) { return atomicAdd(addend, 1); }
 ALWAYS_INLINE int atomicDecrement(int volatile* addend) { return atomicSubtract(addend, 1); }
 
 ALWAYS_INLINE int64_t atomicIncrement(int64_t volatile* addend) { return __sync_add_and_fetch(addend, 1); }
 ALWAYS_INLINE int64_t atomicDecrement(int64_t volatile* addend) { return __sync_sub_and_fetch(addend, 1); }
 
 ALWAYS_INLINE int atomicTestAndSetToOne(int volatile* ptr)
 {
     int ret = __sync_lock_test_and_set(ptr, 1);
@@ skipping 139 matching lines @@
 using WTF::acquireLoad;
 using WTF::releaseStore;
 
 // These methods allow loading from and storing to poisoned memory. Only
 // use these methods if you know what you are doing since they will
 // silence use-after-poison errors from ASan.
 using WTF::asanUnsafeAcquireLoad;
 using WTF::asanUnsafeReleaseStore;
 
 #endif // Atomics_h