[XRay][compiler-rt] Remove reliance on C++ ABI from BufferQueue

[dberris]

Summary

This is part of the work to address http://llvm.org/PR32274.

We remove the calls to array-placement-new and array-delete. This allows
us to rely on the internal memory management provided by
sanitizer_common/sanitizer_internal_allocator.h.

[kpw]

compiler-rt/lib/xray/xray_buffer_queue.cc

33

Can you template the array init and still be ABI compliant? Other than initialization, these are identical other than the type and that could be traited.

If you can't or feel that would be less readable, feel free to resolve this comment.

[dberris]

• fixup: use a template for array init

compiler-rt/lib/xray/xray_buffer_queue.cc

33

Thanks! Much more readable with a template indeed.

compiler-rt/lib/xray/xray_buffer_queue.h

public:
   };
 
   struct Buffer {
     void *Data = nullptr;
     size_t Size = 0;
     BufferExtents *Extents;
   };
 
-private:
   struct BufferRep {
     // The managed buffer.
     Buffer Buff;
 
     // This is true if the buffer has been returned to the available queue, and
     // is considered "used" by another thread.
     bool Used = false;
   };
 
+private:
   // This models a ForwardIterator. |T| Must be either a `Buffer` or `const
   // Buffer`. Note that we only advance to the "used" buffers, when
   // incrementing, so that at dereference we're always at a valid point.
   template <class T> class Iterator {
   public:
     BufferRep *Buffers = nullptr;
     size_t Offset = 0;
     size_t Max = 0;

compiler-rt/lib/xray/xray_buffer_queue.cc

 //
 // Defines the interface for a buffer queue implementation.
 //
 //===----------------------------------------------------------------------===//
 #include "xray_buffer_queue.h"
 #include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_libc.h"
+#include <memory>
 
 using namespace __xray;
 using namespace __sanitizer;
 
+static BufferQueue::BufferRep *initArray(size_t N) {
+  auto A = reinterpret_cast<BufferQueue::BufferRep *>(InternalAlloc(
+      N * sizeof(BufferQueue::BufferRep), nullptr, kCacheLineSize));
+  if (A != nullptr)
+    while (N > 0)
+      new (A + (--N)) BufferQueue::BufferRep();
+  return A;
+}
+
+static void **initOwnedBuffers(size_t N) {
+  auto A = reinterpret_cast<void **>(
+      InternalAlloc(sizeof(void *) * N, nullptr, kCacheLineSize));
+  if (A != nullptr)
+    while (N > 0)
+      new (A + --N) void *{nullptr};
+  return A;
+}
+
 BufferQueue::BufferQueue(size_t B, size_t N, bool &Success)
-    : BufferSize(B), Buffers(new BufferRep[N]()), BufferCount(N), Finalizing{0},
-      OwnedBuffers(new void *[N]()), Next(Buffers), First(Buffers),
+    : BufferSize(B), Buffers(initArray(N)), BufferCount(N), Finalizing{0},
+      OwnedBuffers(initOwnedBuffers(N)), Next(Buffers), First(Buffers),
       LiveBuffers(0) {
+  if (Buffers == nullptr) {
+    Success = false;
+    return;
+  }
+  if (OwnedBuffers == nullptr) {
+    // Clean up the buffers we've already allocated.
+    for (auto B = Buffers, E = Buffers + BufferCount; B != E; ++B)
+      B->~BufferRep();
+    InternalFree(Buffers);
+    Success = false;
+    return;
+  };
+
   for (size_t i = 0; i < N; ++i) {
     auto &T = Buffers[i];
     void *Tmp = InternalAlloc(BufferSize, nullptr, 64);
     if (Tmp == nullptr) {
       Success = false;
       return;
     }
     void *Extents = InternalAlloc(sizeof(BufferExtents), nullptr, 64);

 
 BufferQueue::~BufferQueue() {
   for (auto I = Buffers, E = Buffers + BufferCount; I != E; ++I) {
     auto &T = *I;
     auto &Buf = T.Buff;
     InternalFree(Buf.Data);
     InternalFree(Buf.Extents);
   }
-  delete[] Buffers;
-  delete[] OwnedBuffers;
+  for (auto B = Buffers, E = Buffers + BufferCount; B != E; ++B)
+    B->~BufferRep();
+  InternalFree(Buffers);
+  InternalFree(OwnedBuffers);
 }