[XRay] Rename Buffer.Buffer to Buffer.Data

[comicfans44]

Summary

some compiler (msvc) treats Buffer.Buffer as constructor and refuse to compile. NFC

[dberris]

LGTM

[dberris]

Ping @comicfans44 -- has this landed upstream, or did you need help landing this?

[comicfans44]

Hi @dberris , seems this is still not upstreamed , could you help me landing it?

compiler-rt/trunk/lib/xray/tests/unit/buffer_queue_test.cc

 }
 
 TEST(BufferQueueTest, GetAndRelease) {
   bool Success = false;
   BufferQueue Buffers(kSize, 1, Success);
   ASSERT_TRUE(Success);
   BufferQueue::Buffer Buf;
   ASSERT_EQ(Buffers.getBuffer(Buf), BufferQueue::ErrorCode::Ok);
-  ASSERT_NE(nullptr, Buf.Buffer);
+  ASSERT_NE(nullptr, Buf.Data);
   ASSERT_EQ(Buffers.releaseBuffer(Buf), BufferQueue::ErrorCode::Ok);
-  ASSERT_EQ(nullptr, Buf.Buffer);
+  ASSERT_EQ(nullptr, Buf.Data);
 }
 
 TEST(BufferQueueTest, GetUntilFailed) {
   bool Success = false;
   BufferQueue Buffers(kSize, 1, Success);
   ASSERT_TRUE(Success);
   BufferQueue::Buffer Buf0;
   EXPECT_EQ(Buffers.getBuffer(Buf0), BufferQueue::ErrorCode::Ok);
   BufferQueue::Buffer Buf1;
   EXPECT_EQ(BufferQueue::ErrorCode::NotEnoughMemory, Buffers.getBuffer(Buf1));
   EXPECT_EQ(Buffers.releaseBuffer(Buf0), BufferQueue::ErrorCode::Ok);
 }
 
 TEST(BufferQueueTest, ReleaseUnknown) {
   bool Success = false;
   BufferQueue Buffers(kSize, 1, Success);
   ASSERT_TRUE(Success);
   BufferQueue::Buffer Buf;
-  Buf.Buffer = reinterpret_cast<void *>(0xdeadbeef);
+  Buf.Data = reinterpret_cast<void *>(0xdeadbeef);
   Buf.Size = kSize;
   EXPECT_EQ(BufferQueue::ErrorCode::UnrecognizedBuffer,
             Buffers.releaseBuffer(Buf));
 }
 
 TEST(BufferQueueTest, ErrorsWhenFinalising) {
   bool Success = false;
   BufferQueue Buffers(kSize, 2, Success);
   ASSERT_TRUE(Success);
   BufferQueue::Buffer Buf;
   ASSERT_EQ(Buffers.getBuffer(Buf), BufferQueue::ErrorCode::Ok);
-  ASSERT_NE(nullptr, Buf.Buffer);
+  ASSERT_NE(nullptr, Buf.Data);
   ASSERT_EQ(Buffers.finalize(), BufferQueue::ErrorCode::Ok);
   BufferQueue::Buffer OtherBuf;
   ASSERT_EQ(BufferQueue::ErrorCode::QueueFinalizing,
             Buffers.getBuffer(OtherBuf));
   ASSERT_EQ(BufferQueue::ErrorCode::QueueFinalizing,
             Buffers.finalize());
   ASSERT_EQ(Buffers.releaseBuffer(Buf), BufferQueue::ErrorCode::Ok);
 }

compiler-rt/trunk/lib/xray/xray_buffer_queue.h

 /// trace collection.
 class BufferQueue {
  public:
   struct alignas(64) BufferExtents {
     __sanitizer::atomic_uint64_t Size;
   };
 
   struct Buffer {
-    void *Buffer = nullptr;
+    void *Data = nullptr;
     size_t Size = 0;
     BufferExtents* Extents;
   };
 
  private:
   struct BufferRep {
     // The managed buffer.
     Buffer Buff;

compiler-rt/trunk/lib/xray/xray_buffer_queue.cc

if (Tmp == nullptr) {
       return;
     }
     void *Extents = InternalAlloc(sizeof(BufferExtents), nullptr, 64);
     if (Extents == nullptr) {
       Success = false;
       return;
     }
     auto &Buf = T.Buff;
-    Buf.Buffer = Tmp;
+    Buf.Data = Tmp;
     Buf.Size = B;
     Buf.Extents = reinterpret_cast<BufferExtents *>(Extents);
     OwnedBuffers[i] = Tmp;
   }
   Success = true;
 }
 
 BufferQueue::ErrorCode BufferQueue::getBuffer(Buffer &Buf) {
BufferQueue::ErrorCode BufferQueue::getBuffer(Buffer &Buf) {
 
   return ErrorCode::Ok;
 }
 
 BufferQueue::ErrorCode BufferQueue::releaseBuffer(Buffer &Buf) {
   // Blitz through the buffers array to find the buffer.
   bool Found = false;
   for (auto I = OwnedBuffers, E = OwnedBuffers + BufferCount; I != E; ++I) {
-    if (*I == Buf.Buffer) {
+    if (*I == Buf.Data) {
       Found = true;
       break;
     }
   }
   if (!Found)
     return ErrorCode::UnrecognizedBuffer;
 
   __sanitizer::SpinMutexLock Guard(&Mutex);
 
   // This points to a semantic bug, we really ought to not be releasing more
   // buffers than we actually get.
   if (LiveBuffers == 0)
     return ErrorCode::NotEnoughMemory;
 
   // Now that the buffer has been released, we mark it as "used".
   First->Buff = Buf;
   First->Used = true;
-  Buf.Buffer = nullptr;
+  Buf.Data = nullptr;
   Buf.Size = 0;
   --LiveBuffers;
   if (++First == (Buffers + BufferCount))
     First = Buffers;
 
   return ErrorCode::Ok;
 }
 
 BufferQueue::ErrorCode BufferQueue::finalize() {
   if (__sanitizer::atomic_exchange(&Finalizing, 1,
                                    __sanitizer::memory_order_acq_rel))
     return ErrorCode::QueueFinalizing;
   return ErrorCode::Ok;
 }
 
 BufferQueue::~BufferQueue() {
   for (auto I = Buffers, E = Buffers + BufferCount; I != E; ++I) {
     auto &T = *I;
     auto &Buf = T.Buff;
-    InternalFree(Buf.Buffer);
+    InternalFree(Buf.Data);
     InternalFree(Buf.Extents);
   }
   delete[] Buffers;
   delete[] OwnedBuffers;
 }

compiler-rt/trunk/lib/xray/xray_fdr_logging.cc

BQ->apply([&](const BufferQueue::Buffer &B) {
     ExtentsRecord.Type = uint8_t(RecordType::Metadata);
     ExtentsRecord.RecordKind =
         uint8_t(MetadataRecord::RecordKinds::BufferExtents);
     std::memcpy(ExtentsRecord.Data, &BufferExtents, sizeof(BufferExtents));
     if (BufferExtents > 0) {
       retryingWriteAll(Fd, reinterpret_cast<char *>(&ExtentsRecord),
                        reinterpret_cast<char *>(&ExtentsRecord) +
                            sizeof(MetadataRecord));
-      retryingWriteAll(Fd, reinterpret_cast<char *>(B.Buffer),
-                       reinterpret_cast<char *>(B.Buffer) + BufferExtents);
+      retryingWriteAll(Fd, reinterpret_cast<char *>(B.Data),
+                       reinterpret_cast<char *>(B.Data) + BufferExtents);
     }
   });
 
   __sanitizer::atomic_store(&LogFlushStatus,
                             XRayLogFlushStatus::XRAY_LOG_FLUSHED,
                             __sanitizer::memory_order_release);
   return XRayLogFlushStatus::XRAY_LOG_FLUSHED;
 }
XRayLogInitStatus fdrLoggingInit(std::size_t BufferSize, std::size_t BufferMax,
   static bool UNUSED Once = [] {
     pthread_key_create(&__xray_fdr_internal::Key, +[](void *) {
       auto &TLD = __xray_fdr_internal::getThreadLocalData();
       if (TLD.BQ == nullptr)
         return;
       auto EC = TLD.BQ->releaseBuffer(TLD.Buffer);
       if (EC != BufferQueue::ErrorCode::Ok)
         Report("At thread exit, failed to release buffer at %p; error=%s\n",
-               TLD.Buffer.Buffer, BufferQueue::getErrorString(EC));
+               TLD.Buffer.Data, BufferQueue::getErrorString(EC));
     });
     return false;
   }();
 
   // Arg1 handler should go in first to avoid concurrent code accidentally
   // falling back to arg0 when it should have ran arg1.
   __xray_set_handler_arg1(fdrLoggingHandleArg1);
   // Install the actual handleArg0 handler after initialising the buffers.

compiler-rt/trunk/lib/xray/xray_fdr_logging_impl.h

static void writeNewBufferPreamble(pid_t Tid,
   __sanitizer::atomic_store(&TLD.Buffer.Extents->Size, sizeof(Metadata),
                             __sanitizer::memory_order_release);
 }
 
 inline void setupNewBuffer(int (*wall_clock_reader)(
     clockid_t, struct timespec *)) XRAY_NEVER_INSTRUMENT {
   auto &TLD = getThreadLocalData();
   auto &B = TLD.Buffer;
-  TLD.RecordPtr = static_cast<char *>(B.Buffer);
+  TLD.RecordPtr = static_cast<char *>(B.Data);
   pid_t Tid = syscall(SYS_gettid);
   timespec TS{0, 0};
   // This is typically clock_gettime, but callers have injection ability.
   wall_clock_reader(CLOCK_MONOTONIC, &TS);
   writeNewBufferPreamble(Tid, TS);
   TLD.NumConsecutiveFnEnters = 0;
   TLD.NumTailCalls = 0;
 }
while (TLD.NumTailCalls > 0) {
     decrementExtents(2 * FunctionRecSize);
   }
 }
 
 inline bool releaseThreadLocalBuffer(BufferQueue &BQArg) {
   auto &TLD = getThreadLocalData();
   auto EC = BQArg.releaseBuffer(TLD.Buffer);
   if (EC != BufferQueue::ErrorCode::Ok) {
-    Report("Failed to release buffer at %p; error=%s\n", TLD.Buffer.Buffer,
+    Report("Failed to release buffer at %p; error=%s\n", TLD.Buffer.Data,
            BufferQueue::getErrorString(EC));
     return false;
   }
   return true;
 }
 
 inline bool prepareBuffer(uint64_t TSC, unsigned char CPU,
                           int (*wall_clock_reader)(clockid_t,
                                                    struct timespec *),
                           size_t MaxSize) XRAY_NEVER_INSTRUMENT {
   auto &TLD = getThreadLocalData();
-  char *BufferStart = static_cast<char *>(TLD.Buffer.Buffer);
+  char *BufferStart = static_cast<char *>(TLD.Buffer.Data);
   if ((TLD.RecordPtr + MaxSize) > (BufferStart + TLD.Buffer.Size)) {
     if (!releaseThreadLocalBuffer(*TLD.BQ))
       return false;
     auto EC = TLD.BQ->getBuffer(TLD.Buffer);
     if (EC != BufferQueue::ErrorCode::Ok) {
       Report("Failed to acquire a buffer; error=%s\n",
              BufferQueue::getErrorString(EC));
       return false;
if (__sanitizer::atomic_load(&LoggingStatus,
                                __sanitizer::memory_order_acquire) !=
           XRayLogInitStatus::XRAY_LOG_INITIALIZED ||
       LBQ->finalizing()) {
     if (!releaseThreadLocalBuffer(*LBQ))
       return false;
     TLD.RecordPtr = nullptr;
   }
 
-  if (TLD.Buffer.Buffer == nullptr) {
+  if (TLD.Buffer.Data == nullptr) {
     auto EC = LBQ->getBuffer(TLD.Buffer);
     if (EC != BufferQueue::ErrorCode::Ok) {
       auto LS = __sanitizer::atomic_load(&LoggingStatus,
                                          __sanitizer::memory_order_acquire);
       if (LS != XRayLogInitStatus::XRAY_LOG_FINALIZING &&
           LS != XRayLogInitStatus::XRAY_LOG_FINALIZED)
         Report("Failed to acquire a buffer; error=%s\n",
                BufferQueue::getErrorString(EC));
if (Delta <= std::numeric_limits<uint32_t>::max())
     return Delta;
 
   writeTSCWrapMetadata(TSC);
   return 0;
 }
 
 inline void endBufferIfFull() XRAY_NEVER_INSTRUMENT {
   auto &TLD = getThreadLocalData();
-  auto BufferStart = static_cast<char *>(TLD.Buffer.Buffer);
+  auto BufferStart = static_cast<char *>(TLD.Buffer.Data);
   if ((TLD.RecordPtr + MetadataRecSize) - BufferStart <=
       ptrdiff_t{MetadataRecSize}) {
     if (!releaseThreadLocalBuffer(*TLD.BQ))
       return;
     TLD.RecordPtr = nullptr;
   }
 }
 
inline void processFunctionHook(int32_t FuncId, XRayEntryType Entry,
   // properly before doing any further writing.
   size_t MaxSize = FunctionRecSize + 2 * MetadataRecSize;
   if (!prepareBuffer(TSC, CPU, wall_clock_reader, MaxSize)) {
     TLD.BQ = nullptr;
     return;
   }
 
   // By this point, we are now ready to write up to 40 bytes (explained above).
-  assert((TLD.RecordPtr + MaxSize) - static_cast<char *>(TLD.Buffer.Buffer) >=
+  assert((TLD.RecordPtr + MaxSize) - static_cast<char *>(TLD.Buffer.Data) >=
              static_cast<ptrdiff_t>(MetadataRecSize) &&
          "Misconfigured BufferQueue provided; Buffer size not large enough.");
 
   auto RecordTSCDelta = writeCurrentCPUTSC(TLD, TSC, CPU);
   TLD.LastTSC = TSC;
   TLD.CurrentCPU = CPU;
   switch (Entry) {
   case XRayEntryType::ENTRY: