SIGNED_MIN now calculated without causing undefined behavior

Author: Erik McClure

include/bss_alloc_ring.h

@@ -212,9 +212,12 @@ namespace bss_util {
     }
 
     BSS_ALIGN(16) bss_PTag<Bucket> _gc; // Contains a list of discarded buckets
+#pragma warning(push)
+#pragma warning(disable:4251)
     BSS_ALIGN(16) std::atomic<Bucket*> _root;
     BSS_ALIGN(64) std::atomic<size_t> _readers; // How many threads are currently depending on _root to not change
     BSS_ALIGN(64) std::atomic_bool _flag; // Blocking flag for when _root needs to change
+#pragma warning(pop)
     size_t _lastsize; // Last size used for a bucket.
     Bucket* _list; // root of permanent list of all active allocated buckets.
   };

include/bss_util.h

@@ -71,15 +71,11 @@ namespace bss_util {
 #endif
     typedef typename std::make_unsigned<SIGNED>::type UNSIGNED;
 
-    static const UNSIGNED UNSIGNED_MIN=0;
-    static const UNSIGNED UNSIGNED_MAX=(((UNSIGNED)2)<<(BITS-1))-((UNSIGNED)1); //these are all done carefully to ensure no overflow is ever utilized unless appropriate and it respects an arbitrary bit limit. We use 2<<(BITS-1) here to avoid shifting more bits than there are bits in the type.
-    static const SIGNED SIGNED_MIN_RAW=(((SIGNED)1)<<(BITS-1)); // When we have normal bit lengths (8,16, etc) this will correctly result in a negative value in two's complement.
-#ifdef BSS_COMPILER_GCC
-    static const SIGNED SIGNED_MIN=-((__int128)SIGNED_MIN_RAW); // GCC is a pedantic fuckwad that treats signed overflow as undefined even if I want it to overflow, so we work around it.
-#else
-    static const SIGNED SIGNED_MIN=(-SIGNED_MIN_RAW); // However if we have unusual bit lengths (3,19, etc) the raw bit representation will be technically correct in the context of that sized integer, but since we have to round to a real integer size to represent the number, the literal interpretation will be wrong. This yields the proper minimum value.
-#endif
-    static const SIGNED SIGNED_MAX=((~SIGNED_MIN_RAW)&UNSIGNED_MAX);
+    static const UNSIGNED UNSIGNED_MIN = 0;
+    static const UNSIGNED UNSIGNED_MAX = (((UNSIGNED)2) << (BITS - 1)) - ((UNSIGNED)1); //these are all done carefully to ensure no overflow is ever utilized unless appropriate and it respects an arbitrary bit limit. We use 2<<(BITS-1) here to avoid shifting more bits than there are bits in the type.
+    static const SIGNED SIGNED_MIN_RAW = (SIGNED)(((UNSIGNED)1) << (BITS - 1)); // When we have normal bit lengths (8,16, etc) this will correctly result in a negative value in two's complement.
+    static const SIGNED SIGNED_MIN = (((SIGNED)~0) << (BITS - 1)); // However if we have unusual bit lengths (3,19, etc) the raw bit representation will be technically correct in the context of that sized integer, but since we have to round to a real integer size to represent the number, the literal interpretation will be wrong. This yields the proper minimum value.
+    static const SIGNED SIGNED_MAX = ((~SIGNED_MIN_RAW)&UNSIGNED_MAX);
   };
   template<typename T>
   struct TBitLimit : public BitLimit<sizeof(T)<<3> {};

test/main.cpp

@@ -4129,7 +4129,7 @@ void _locklessqueue_consume(void* p)
 {
   while(!startflag.load());
   T* q = (T*)p;
-  uint c;
+  unsigned short c;
   while((c = lq_pos.fetch_add(1, std::memory_order_relaxed))<TESTNUM) {
     while(!q->Pop(lq_end[c]));
   }
@@ -4140,7 +4140,7 @@ void _locklessqueue_produce(void* p)
 {
   while(!startflag.load());
   T* q = (T*)p;
-  uint64 c;
+  size_t c;
   while((c = lq_c.fetch_add(1, std::memory_order_relaxed))<=TESTNUM) {
     q->Push(c);
   }