100 lines
3.0 KiB
C++
100 lines
3.0 KiB
C++
|
// 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
|