Repo created

TMessagesProj/jni/voip/webrtc/base/android/reached_addresses_bitset.cc

@@ -0,0 +1,99 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/android/reached_addresses_bitset.h"
+
+#include "base/android/library_loader/anchor_functions.h"
+#include "base/android/library_loader/anchor_functions_buildflags.h"
+#include "base/logging.h"
+#include "base/no_destructor.h"
+
+namespace base {
+namespace android {
+
+namespace {
+constexpr size_t kBitsPerElement = sizeof(uint32_t) * 8;
+
+#if BUILDFLAG(SUPPORTS_CODE_ORDERING)
+// Enough for 1 << 29 bytes of code, 512MB.
+constexpr size_t kTextBitfieldSize = 1 << 20;
+std::atomic<uint32_t> g_text_bitfield[kTextBitfieldSize];
+#endif
+}  // namespace
+
+// static
+ReachedAddressesBitset* ReachedAddressesBitset::GetTextBitset() {
+#if BUILDFLAG(SUPPORTS_CODE_ORDERING)
+  static base::NoDestructor<ReachedAddressesBitset> text_bitset(
+      kStartOfText, kEndOfText, g_text_bitfield, kTextBitfieldSize);
+  return text_bitset.get();
+#else
+  return nullptr;
+#endif
+}
+
+void ReachedAddressesBitset::RecordAddress(uintptr_t address) {
+  // |address| is outside of the range.
+  if (address < start_address_ || address >= end_address_)
+    return;
+
+  uint32_t offset = address - start_address_;
+  uint32_t offset_index = offset / kBytesGranularity;
+
+  // Atomically set the corresponding bit in the array.
+  std::atomic<uint32_t>* element = reached_ + (offset_index / kBitsPerElement);
+
+  // First, a racy check. This saves a CAS if the bit is already set, and
+  // allows the cache line to remain shared across CPUs in this case.
+  uint32_t value = element->load(std::memory_order_relaxed);
+  uint32_t mask = 1 << (offset_index % kBitsPerElement);
+  if (value & mask)
+    return;
+  element->fetch_or(mask, std::memory_order_relaxed);
+}
+
+std::vector<uint32_t> ReachedAddressesBitset::GetReachedOffsets() const {
+  std::vector<uint32_t> offsets;
+  const size_t elements = NumberOfReachableElements();
+
+  for (size_t i = 0; i < elements; ++i) {
+    uint32_t element = reached_[i].load(std::memory_order_relaxed);
+    // No reached addresses at this element.
+    if (element == 0)
+      continue;
+
+    for (size_t j = 0; j < 32; ++j) {
+      if (!((element >> j) & 1))
+        continue;
+
+      uint32_t offset_index = i * 32 + j;
+      uint32_t offset = offset_index * kBytesGranularity;
+      offsets.push_back(offset);
+    }
+  }
+
+  return offsets;
+}
+
+ReachedAddressesBitset::ReachedAddressesBitset(
+    uintptr_t start_address,
+    uintptr_t end_address,
+    std::atomic<uint32_t>* storage_ptr,
+    size_t storage_size)
+    : start_address_(start_address),
+      end_address_(end_address),
+      reached_(storage_ptr) {
+  DCHECK_LE(start_address_, end_address_);
+  DCHECK_LE(NumberOfReachableElements(), storage_size * kBitsPerElement);
+}
+
+size_t ReachedAddressesBitset::NumberOfReachableElements() const {
+  size_t reachable_bits =
+      (end_address_ + kBytesGranularity - 1) / kBytesGranularity -
+      start_address_ / kBytesGranularity;
+  return (reachable_bits + kBitsPerElement - 1) / kBitsPerElement;
+}
+
+}  // namespace android
+}  // namespace base