[scudo] Replacing std::atomic with Sanitizer's atomics

[cryptoad]

Summary

In an effort to getting rid of dependencies to external libraries, we are
replacing atomic PackedHeader use of std::atomic with Sanitizer's
atomic_uint64_t, which allows us to avoid -latomic.

[phosek]

test/scudo/lit.cfg

21–22

Is this still needed?

[cryptoad]

test/scudo/lit.cfg

21–22

I use std::vector and other things in the tests.
I could rewrite them and get rid of it, but malloc.cpp, realloc.cpp and interface.cpp need -lstdc++ in their current state.

[cryptoad]

Making -lstdc++ explicit in tests that require it, thus allowing removal from
the general lit.cfg.

[alekseyshl]

LGTM

lib/scudo/scudo_allocator.h

 #include "scudo_flags.h"
 
 #include "sanitizer_common/sanitizer_allocator.h"
 
 #if !SANITIZER_LINUX
 # error "The Scudo hardened allocator is currently only supported on Linux."
 #endif
 
-#include <atomic>
-
 namespace __scudo {
 
 enum AllocType : u8 {
   FromMalloc    = 0, // Memory block came from malloc, realloc, calloc, etc.
   FromNew       = 1, // Memory block came from operator new.
   FromNewArray  = 2, // Memory block came from operator new [].
   FromMemalign  = 3, // Memory block came from memalign, posix_memalign, etc.
 };
struct UnpackedHeader {
   u64 AllocType   : 2;  // malloc, new, new[], or memalign
   u64 Offset      : 16; // Offset from the beginning of the backend
                         // allocation to the beginning of the chunk itself,
                         // in multiples of MinAlignment. See comment about
                         // its maximum value and test in init().
   u64 Salt        : 8;
 };
 
-typedef std::atomic<PackedHeader> AtomicPackedHeader;
+typedef atomic_uint64_t AtomicPackedHeader;
 COMPILER_CHECK(sizeof(UnpackedHeader) == sizeof(PackedHeader));
 
 // Minimum alignment of 8 bytes for 32-bit, 16 for 64-bit
 const uptr MinAlignmentLog = FIRST_32_SECOND_64(3, 4);
 const uptr MaxAlignmentLog = 24; // 16 MB
 const uptr MinAlignment = 1 << MinAlignmentLog;
 const uptr MaxAlignment = 1 << MaxAlignmentLog;
 

lib/scudo/scudo_allocator.cpp

u16 computeChecksum(UnpackedHeader *Header) const {
     return static_cast<u16>(Crc);
   }
 
   // Checks the validity of a chunk by verifying its checksum.
   bool isValid() {
     UnpackedHeader NewUnpackedHeader;
     const AtomicPackedHeader *AtomicHeader =
         reinterpret_cast<const AtomicPackedHeader *>(this);
-    PackedHeader NewPackedHeader =
-        AtomicHeader->load(std::memory_order_relaxed);
+    PackedHeader NewPackedHeader = atomic_load_relaxed(AtomicHeader);
     NewUnpackedHeader = bit_cast<UnpackedHeader>(NewPackedHeader);
     return (NewUnpackedHeader.Checksum == computeChecksum(&NewUnpackedHeader));
   }
 
   // Loads and unpacks the header, verifying the checksum in the process.
   void loadHeader(UnpackedHeader *NewUnpackedHeader) const {
     const AtomicPackedHeader *AtomicHeader =
         reinterpret_cast<const AtomicPackedHeader *>(this);
-    PackedHeader NewPackedHeader =
-        AtomicHeader->load(std::memory_order_relaxed);
+    PackedHeader NewPackedHeader = atomic_load_relaxed(AtomicHeader);
     *NewUnpackedHeader = bit_cast<UnpackedHeader>(NewPackedHeader);
     if (NewUnpackedHeader->Checksum != computeChecksum(NewUnpackedHeader)) {
       dieWithMessage("ERROR: corrupted chunk header at address %p\n", this);
     }
   }
 
   // Packs and stores the header, computing the checksum in the process.
   void storeHeader(UnpackedHeader *NewUnpackedHeader) {
     NewUnpackedHeader->Checksum = computeChecksum(NewUnpackedHeader);
     PackedHeader NewPackedHeader = bit_cast<PackedHeader>(*NewUnpackedHeader);
     AtomicPackedHeader *AtomicHeader =
         reinterpret_cast<AtomicPackedHeader *>(this);
-    AtomicHeader->store(NewPackedHeader, std::memory_order_relaxed);
+    atomic_store_relaxed(AtomicHeader, NewPackedHeader);
   }
 
   // Packs and stores the header, computing the checksum in the process. We
   // compare the current header with the expected provided one to ensure that
   // we are not being raced by a corruption occurring in another thread.
   void compareExchangeHeader(UnpackedHeader *NewUnpackedHeader,
                              UnpackedHeader *OldUnpackedHeader) {
     NewUnpackedHeader->Checksum = computeChecksum(NewUnpackedHeader);
     PackedHeader NewPackedHeader = bit_cast<PackedHeader>(*NewUnpackedHeader);
     PackedHeader OldPackedHeader = bit_cast<PackedHeader>(*OldUnpackedHeader);
     AtomicPackedHeader *AtomicHeader =
         reinterpret_cast<AtomicPackedHeader *>(this);
-    if (!AtomicHeader->compare_exchange_strong(OldPackedHeader,
-                                               NewPackedHeader,
-                                               std::memory_order_relaxed,
-                                               std::memory_order_relaxed)) {
+    if (!atomic_compare_exchange_strong(AtomicHeader,
+                                        &OldPackedHeader,
+                                        memory_order_relaxed)) {
       dieWithMessage("ERROR: race on chunk header at address %p\n", this);
     }
   }
 };
 
 static bool ScudoInitIsRunning = false;
 
 static pthread_once_t GlobalInited = PTHREAD_ONCE_INIT;

test/scudo/interface.cpp

-// RUN: %clang_scudo %s -o %t
+// RUN: %clang_scudo %s -lstdc++ -o %t
 // RUN: %run %t 2>&1
 
 // Tests that the sanitizer interface functions behave appropriately.
 
 #include <stdlib.h>
 
 #include <vector>
 

test/scudo/lit.cfg

base_lib = os.path.join(config.compiler_rt_libdir,
                         "libclang_rt.scudo-%s.a" % config.target_arch)
 whole_archive = "-Wl,-whole-archive %s -Wl,-no-whole-archive " % base_lib
 
 # Test suffixes.
 config.suffixes = ['.c', '.cc', '.cpp']
 
 # C flags.
 c_flags = ([config.target_cflags] +
            ["-std=c++11",
-           "-lstdc++",
            "-lrt",
-           "-latomic",
            "-ldl",
            "-pthread",
            "-fPIE",
            "-pie",
            "-O0"])
 
 def build_invocation(compile_flags):                                            
   return " " + " ".join([config.clang] + compile_flags) + " "                   
 
 # Add clang substitutions.
 config.substitutions.append( ("%clang_scudo ",
                               build_invocation(c_flags) + whole_archive) )
 
 # Hardened Allocator tests are currently supported on Linux only.
 if config.host_os not in ['Linux']:
    config.unsupported = True

test/scudo/malloc.cpp

-// RUN: %clang_scudo %s -o %t
+// RUN: %clang_scudo %s -lstdc++ -o %t
 // RUN: %run %t 2>&1
 
 // Tests that a regular workflow of allocation, memory fill and free works as
 // intended. Tests various sizes serviced by the primary and secondary
 // allocators.
 
 #include <stdlib.h>
 #include <string.h>

test/scudo/realloc.cpp

-// RUN: %clang_scudo %s -o %t
+// RUN: %clang_scudo %s -lstdc++ -o %t
 // RUN:     %run %t pointers 2>&1
 // RUN:     %run %t contents 2>&1
 // RUN: not %run %t memalign 2>&1 | FileCheck %s
 
 // Tests that our reallocation function returns the same pointer when the
 // requested size can fit into the previously allocated chunk. Also tests that
 // a new chunk is returned if the size is greater, and that the contents of the
 // chunk are left unchanged.