Remove debugging_buildflags.h Change-Id: I7deebccf6721718da74625c3c0b3d826b5f3f97d Reviewed-on: https://gn-review.googlesource.com/1140 Reviewed-by: Brett Wilson <brettw@chromium.org> Reviewed-by: Scott Graham <scottmg@chromium.org> Commit-Queue: Scott Graham <scottmg@chromium.org>
diff --git a/base/debug/profiler.cc b/base/debug/profiler.cc index 1ee9483..91619a1 100644 --- a/base/debug/profiler.cc +++ b/base/debug/profiler.cc
@@ -6,7 +6,6 @@ #include <string> -#include "base/debug/debugging_buildflags.h" #include "base/process/process_handle.h" #include "base/strings/string_number_conversions.h" #include "base/strings/string_util.h" @@ -17,52 +16,9 @@ #include "base/win/pe_image.h" #endif // defined(OS_WIN) -// TODO(peria): Enable profiling on Windows. -#if BUILDFLAG(ENABLE_PROFILING) && !defined(NO_TCMALLOC) && !defined(OS_WIN) -#include "third_party/tcmalloc/chromium/src/gperftools/profiler.h" -#endif - namespace base { namespace debug { -// TODO(peria): Enable profiling on Windows. -#if BUILDFLAG(ENABLE_PROFILING) && !defined(NO_TCMALLOC) && !defined(OS_WIN) - -static int profile_count = 0; - -void StartProfiling(const std::string& name) { - ++profile_count; - std::string full_name(name); - std::string pid = IntToString(GetCurrentProcId()); - std::string count = IntToString(profile_count); - ReplaceSubstringsAfterOffset(&full_name, 0, "{pid}", pid); - ReplaceSubstringsAfterOffset(&full_name, 0, "{count}", count); - ProfilerStart(full_name.c_str()); -} - -void StopProfiling() { - ProfilerFlush(); - ProfilerStop(); -} - -void FlushProfiling() { - ProfilerFlush(); -} - -bool BeingProfiled() { - return ProfilingIsEnabledForAllThreads(); -} - -void RestartProfilingAfterFork() { - ProfilerRegisterThread(); -} - -bool IsProfilingSupported() { - return true; -} - -#else - void StartProfiling(const std::string& name) { } @@ -83,8 +39,6 @@ return false; } -#endif - #if !defined(OS_WIN) ReturnAddressLocationResolver GetProfilerReturnAddrResolutionFunc() {
diff --git a/base/debug/stack_trace.cc b/base/debug/stack_trace.cc index 7715121..3a63dae 100644 --- a/base/debug/stack_trace.cc +++ b/base/debug/stack_trace.cc
@@ -12,190 +12,9 @@ #include "base/logging.h" #include "base/macros.h" -#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) - -#if defined(OS_LINUX) || defined(OS_ANDROID) -#include <pthread.h> -#include "base/process/process_handle.h" -#include "base/threading/platform_thread.h" -#endif - -#if defined(OS_MACOSX) -#include <pthread.h> -#endif - -#if defined(OS_LINUX) && defined(__GLIBC__) -extern "C" void* __libc_stack_end; -#endif - -#endif // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) - namespace base { namespace debug { -namespace { - -#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) - -#if defined(__arm__) && defined(__GNUC__) && !defined(__clang__) -// GCC and LLVM generate slightly different frames on ARM, see -// https://llvm.org/bugs/show_bug.cgi?id=18505 - LLVM generates -// x86-compatible frame, while GCC needs adjustment. -constexpr size_t kStackFrameAdjustment = sizeof(uintptr_t); -#else -constexpr size_t kStackFrameAdjustment = 0; -#endif - -uintptr_t GetNextStackFrame(uintptr_t fp) { - return reinterpret_cast<const uintptr_t*>(fp)[0] - kStackFrameAdjustment; -} - -uintptr_t GetStackFramePC(uintptr_t fp) { - return reinterpret_cast<const uintptr_t*>(fp)[1]; -} - -bool IsStackFrameValid(uintptr_t fp, uintptr_t prev_fp, uintptr_t stack_end) { - // With the stack growing downwards, older stack frame must be - // at a greater address that the current one. - if (fp <= prev_fp) return false; - - // Assume huge stack frames are bogus. - if (fp - prev_fp > 100000) return false; - - // Check alignment. - if (fp & (sizeof(uintptr_t) - 1)) return false; - - if (stack_end) { - // Both fp[0] and fp[1] must be within the stack. - if (fp > stack_end - 2 * sizeof(uintptr_t)) return false; - - // Additional check to filter out false positives. - if (GetStackFramePC(fp) < 32768) return false; - } - - return true; -}; - -// ScanStackForNextFrame() scans the stack for a valid frame to allow unwinding -// past system libraries. Only supported on Linux where system libraries are -// usually in the middle of the trace: -// -// TraceStackFramePointers -// <more frames from Chrome> -// base::WorkSourceDispatch <-- unwinding stops (next frame is invalid), -// g_main_context_dispatch ScanStackForNextFrame() is called -// <more frames from glib> -// g_main_context_iteration -// base::MessagePumpGlib::Run <-- ScanStackForNextFrame() finds valid frame, -// base::RunLoop::Run unwinding resumes -// <more frames from Chrome> -// __libc_start_main -// -// For stack scanning to be efficient it's very important for the thread to -// be started by Chrome. In that case we naturally terminate unwinding once -// we reach the origin of the stack (i.e. GetStackEnd()). If the thread is -// not started by Chrome (e.g. Android's main thread), then we end up always -// scanning area at the origin of the stack, wasting time and not finding any -// frames (since Android libraries don't have frame pointers). -// -// ScanStackForNextFrame() returns 0 if it couldn't find a valid frame -// (or if stack scanning is not supported on the current platform). -uintptr_t ScanStackForNextFrame(uintptr_t fp, uintptr_t stack_end) { -#if defined(OS_LINUX) - // Enough to resume almost all prematurely terminated traces. - constexpr size_t kMaxStackScanArea = 8192; - - if (!stack_end) { - // Too dangerous to scan without knowing where the stack ends. - return 0; - } - - fp += sizeof(uintptr_t); // current frame is known to be invalid - uintptr_t last_fp_to_scan = std::min(fp + kMaxStackScanArea, stack_end) - - sizeof(uintptr_t); - for (;fp <= last_fp_to_scan; fp += sizeof(uintptr_t)) { - uintptr_t next_fp = GetNextStackFrame(fp); - if (IsStackFrameValid(next_fp, fp, stack_end)) { - // Check two frames deep. Since stack frame is just a pointer to - // a higher address on the stack, it's relatively easy to find - // something that looks like one. However two linked frames are - // far less likely to be bogus. - uintptr_t next2_fp = GetNextStackFrame(next_fp); - if (IsStackFrameValid(next2_fp, next_fp, stack_end)) { - return fp; - } - } - } -#endif // defined(OS_LINUX) - - return 0; -} - -// Links stack frame |fp| to |parent_fp|, so that during stack unwinding -// TraceStackFramePointers() visits |parent_fp| after visiting |fp|. -// Both frame pointers must come from __builtin_frame_address(). -// Returns previous stack frame |fp| was linked to. -void* LinkStackFrames(void* fpp, void* parent_fp) { - uintptr_t fp = reinterpret_cast<uintptr_t>(fpp) - kStackFrameAdjustment; - void* prev_parent_fp = reinterpret_cast<void**>(fp)[0]; - reinterpret_cast<void**>(fp)[0] = parent_fp; - return prev_parent_fp; -} - -#endif // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) - -} // namespace - -#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) -uintptr_t GetStackEnd() { -#if defined(OS_ANDROID) - // Bionic reads proc/maps on every call to pthread_getattr_np() when called - // from the main thread. So we need to cache end of stack in that case to get - // acceptable performance. - // For all other threads pthread_getattr_np() is fast enough as it just reads - // values from its pthread_t argument. - static uintptr_t main_stack_end = 0; - - bool is_main_thread = GetCurrentProcId() == PlatformThread::CurrentId(); - if (is_main_thread && main_stack_end) { - return main_stack_end; - } - - uintptr_t stack_begin = 0; - size_t stack_size = 0; - pthread_attr_t attributes; - int error = pthread_getattr_np(pthread_self(), &attributes); - if (!error) { - error = pthread_attr_getstack( - &attributes, reinterpret_cast<void**>(&stack_begin), &stack_size); - pthread_attr_destroy(&attributes); - } - DCHECK(!error); - - uintptr_t stack_end = stack_begin + stack_size; - if (is_main_thread) { - main_stack_end = stack_end; - } - return stack_end; // 0 in case of error - -#elif defined(OS_LINUX) && defined(__GLIBC__) - - if (GetCurrentProcId() == PlatformThread::CurrentId()) { - // For the main thread we have a shortcut. - return reinterpret_cast<uintptr_t>(__libc_stack_end); - } - -// No easy way to get end of the stack for non-main threads, -// see crbug.com/617730. -#elif defined(OS_MACOSX) - return reinterpret_cast<uintptr_t>(pthread_get_stackaddr_np(pthread_self())); -#endif - - // Don't know how to get end of the stack. - return 0; -} -#endif // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) - StackTrace::StackTrace() : StackTrace(arraysize(trace_)) {} StackTrace::StackTrace(const void* const* trace, size_t count) { @@ -220,58 +39,5 @@ return stream.str(); } -#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) - -size_t TraceStackFramePointers(const void** out_trace, - size_t max_depth, - size_t skip_initial) { - // Usage of __builtin_frame_address() enables frame pointers in this - // function even if they are not enabled globally. So 'fp' will always - // be valid. - uintptr_t fp = reinterpret_cast<uintptr_t>(__builtin_frame_address(0)) - - kStackFrameAdjustment; - - uintptr_t stack_end = GetStackEnd(); - - size_t depth = 0; - while (depth < max_depth) { - if (skip_initial != 0) { - skip_initial--; - } else { - out_trace[depth++] = reinterpret_cast<const void*>(GetStackFramePC(fp)); - } - - uintptr_t next_fp = GetNextStackFrame(fp); - if (IsStackFrameValid(next_fp, fp, stack_end)) { - fp = next_fp; - continue; - } - - next_fp = ScanStackForNextFrame(fp, stack_end); - if (next_fp) { - fp = next_fp; - continue; - } - - // Failed to find next frame. - break; - } - - return depth; -} - -ScopedStackFrameLinker::ScopedStackFrameLinker(void* fp, void* parent_fp) - : fp_(fp), - parent_fp_(parent_fp), - original_parent_fp_(LinkStackFrames(fp, parent_fp)) {} - -ScopedStackFrameLinker::~ScopedStackFrameLinker() { - void* previous_parent_fp = LinkStackFrames(fp_, original_parent_fp_); - CHECK_EQ(parent_fp_, previous_parent_fp) - << "Stack frame's parent pointer has changed!"; -} - -#endif // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) - } // namespace debug } // namespace base
diff --git a/base/debug/stack_trace.h b/base/debug/stack_trace.h index 81e6672..322e77b 100644 --- a/base/debug/stack_trace.h +++ b/base/debug/stack_trace.h
@@ -11,7 +11,6 @@ #include <string> #include "base/base_export.h" -#include "base/debug/debugging_buildflags.h" #include "base/macros.h" #include "build/build_config.h" @@ -44,11 +43,6 @@ void*)); #endif -// Returns end of the stack, or 0 if we couldn't get it. -#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) -BASE_EXPORT uintptr_t GetStackEnd(); -#endif - // A stacktrace can be helpful in debugging. For example, you can include a // stacktrace member in a object (probably around #ifndef NDEBUG) so that you // can later see where the given object was created from. @@ -108,71 +102,6 @@ size_t count_; }; -#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) -// Traces the stack by using frame pointers. This function is faster but less -// reliable than StackTrace. It should work for debug and profiling builds, -// but not for release builds (although there are some exceptions). -// -// Writes at most |max_depth| frames (instruction pointers) into |out_trace| -// after skipping |skip_initial| frames. Note that the function itself is not -// added to the trace so |skip_initial| should be 0 in most cases. -// Returns number of frames written. -BASE_EXPORT size_t TraceStackFramePointers(const void** out_trace, - size_t max_depth, - size_t skip_initial); - -// Links stack frame |fp| to |parent_fp|, so that during stack unwinding -// TraceStackFramePointers() visits |parent_fp| after visiting |fp|. -// Both frame pointers must come from __builtin_frame_address(). -// Destructor restores original linkage of |fp| to avoid corrupting caller's -// frame register on return. -// -// This class can be used to repair broken stack frame chain in cases -// when execution flow goes into code built without frame pointers: -// -// void DoWork() { -// Call_SomeLibrary(); -// } -// static __thread void* g_saved_fp; -// void Call_SomeLibrary() { -// g_saved_fp = __builtin_frame_address(0); -// some_library_call(...); // indirectly calls SomeLibrary_Callback() -// } -// void SomeLibrary_Callback() { -// ScopedStackFrameLinker linker(__builtin_frame_address(0), g_saved_fp); -// ... -// TraceStackFramePointers(...); -// } -// -// This produces the following trace: -// -// #0 SomeLibrary_Callback() -// #1 <address of the code inside SomeLibrary that called #0> -// #2 DoWork() -// ...rest of the trace... -// -// SomeLibrary doesn't use frame pointers, so when SomeLibrary_Callback() -// is called, stack frame register contains bogus value that becomes callback' -// parent frame address. Without ScopedStackFrameLinker unwinding would've -// stopped at that bogus frame address yielding just two first frames (#0, #1). -// ScopedStackFrameLinker overwrites callback's parent frame address with -// Call_SomeLibrary's frame, so unwinder produces full trace without even -// noticing that stack frame chain was broken. -class BASE_EXPORT ScopedStackFrameLinker { - public: - ScopedStackFrameLinker(void* fp, void* parent_fp); - ~ScopedStackFrameLinker(); - - private: - void* fp_; - void* parent_fp_; - void* original_parent_fp_; - - DISALLOW_COPY_AND_ASSIGN(ScopedStackFrameLinker); -}; - -#endif // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) - namespace internal { #if defined(OS_POSIX) && !defined(OS_ANDROID)
diff --git a/base/debug/stack_trace_unittest.cc b/base/debug/stack_trace_unittest.cc index 959cd53..1fbeea2 100644 --- a/base/debug/stack_trace_unittest.cc +++ b/base/debug/stack_trace_unittest.cc
@@ -8,7 +8,6 @@ #include <sstream> #include <string> -#include "base/debug/debugging_buildflags.h" #include "base/debug/stack_trace.h" #include "base/logging.h" #include "base/process/kill.h" @@ -255,66 +254,5 @@ } #endif // defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_FUCHSIA) -#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) - -template <size_t Depth> -void NOINLINE ExpectStackFramePointers(const void** frames, - size_t max_depth) { - code_start: - // Calling __builtin_frame_address() forces compiler to emit - // frame pointers, even if they are not enabled. - EXPECT_NE(nullptr, __builtin_frame_address(0)); - ExpectStackFramePointers<Depth - 1>(frames, max_depth); - - constexpr size_t frame_index = Depth - 1; - const void* frame = frames[frame_index]; - EXPECT_GE(frame, &&code_start) << "For frame at index " << frame_index; - EXPECT_LE(frame, &&code_end) << "For frame at index " << frame_index; - code_end: return; -} - -template <> -void NOINLINE ExpectStackFramePointers<1>(const void** frames, - size_t max_depth) { - code_start: - // Calling __builtin_frame_address() forces compiler to emit - // frame pointers, even if they are not enabled. - EXPECT_NE(nullptr, __builtin_frame_address(0)); - size_t count = TraceStackFramePointers(frames, max_depth, 0); - ASSERT_EQ(max_depth, count); - - const void* frame = frames[0]; - EXPECT_GE(frame, &&code_start) << "For the top frame"; - EXPECT_LE(frame, &&code_end) << "For the top frame"; - code_end: return; -} - -#if defined(MEMORY_SANITIZER) -// The test triggers use-of-uninitialized-value errors on MSan bots. -// This is expected because we're walking and reading the stack, and -// sometimes we read fp / pc from the place that previously held -// uninitialized value. -#define MAYBE_TraceStackFramePointers DISABLED_TraceStackFramePointers -#else -#define MAYBE_TraceStackFramePointers TraceStackFramePointers -#endif -TEST_F(StackTraceTest, MAYBE_TraceStackFramePointers) { - constexpr size_t kDepth = 5; - const void* frames[kDepth]; - ExpectStackFramePointers<kDepth>(frames, kDepth); -} - -#if defined(OS_ANDROID) || defined(OS_MACOSX) -#define MAYBE_StackEnd StackEnd -#else -#define MAYBE_StackEnd DISABLED_StackEnd -#endif - -TEST_F(StackTraceTest, MAYBE_StackEnd) { - EXPECT_NE(0u, GetStackEnd()); -} - -#endif // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) - } // namespace debug } // namespace base
diff --git a/base/location.h b/base/location.h index 14fe2fa..3f6b804 100644 --- a/base/location.h +++ b/base/location.h
@@ -11,7 +11,6 @@ #include <string> #include "base/base_export.h" -#include "base/debug/debugging_buildflags.h" #include "base/hash.h" namespace base { @@ -83,22 +82,11 @@ BASE_EXPORT const void* GetProgramCounter(); // The macros defined here will expand to the current function. -#if BUILDFLAG(ENABLE_LOCATION_SOURCE) - -// Full source information should be included. -#define FROM_HERE FROM_HERE_WITH_EXPLICIT_FUNCTION(__func__) -#define FROM_HERE_WITH_EXPLICIT_FUNCTION(function_name) \ - ::base::Location::CreateFromHere(function_name, __FILE__, __LINE__) - -#else - // TODO(http://crbug.com/760702) remove the __FILE__ argument from these calls. #define FROM_HERE ::base::Location::CreateFromHere(__FILE__) #define FROM_HERE_WITH_EXPLICIT_FUNCTION(function_name) \ ::base::Location::CreateFromHere(function_name, __FILE__, -1) -#endif - } // namespace base namespace std {
diff --git a/base/trace_event/cfi_backtrace_android.cc b/base/trace_event/cfi_backtrace_android.cc deleted file mode 100644 index 8fd8b95..0000000 --- a/base/trace_event/cfi_backtrace_android.cc +++ /dev/null
@@ -1,314 +0,0 @@ -// Copyright 2018 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/trace_event/cfi_backtrace_android.h" - -#include <sys/mman.h> -#include <sys/types.h> - -#include "base/android/apk_assets.h" - -#if !defined(ARCH_CPU_ARMEL) -#error This file should not be built for this architecture. -#endif - -/* -Basics of unwinding: -For each instruction in a function we need to know what is the offset of SP -(Stack Pointer) to reach the previous function's stack frame. To know which -function is being invoked, we need the return address of the next function. The -CFI information for an instruction is made up of 2 offsets, CFA (Call Frame -Address) offset and RA (Return Address) offset. The CFA offset is the change in -SP made by the function till the current instruction. This depends on amount of -memory allocated on stack by the function plus some registers that the function -stores that needs to be restored at the end of function. So, at each instruction -the CFA offset tells the offset from original SP before the function call. The -RA offset tells us the offset from the previous SP into the current function -where the return address is stored. - -The unwind table file has 2 tables UNW_INDEX and UNW_DATA, inspired from ARM -EHABI format. The first table contains function addresses and an index into the -UNW_DATA table. The second table contains one or more rows for the function -unwind information. - -UNW_INDEX contains two columns of N rows each, where N is the number of -functions. - 1. First column 4 byte rows of all the function start address as offset from - start of the binary, in sorted order. - 2. For each function addr, the second column contains 2 byte indices in order. - The indices are offsets (in count of 2 bytes) of the CFI data from start of - UNW_DATA. -The last entry in the table always contains CANT_UNWIND index to specify the -end address of the last function. - -UNW_DATA contains data of all the functions. Each function data contains N rows. -The data found at the address pointed from UNW_INDEX will be: - 2 bytes: N - number of rows that belong to current function. - N * 4 bytes: N rows of data. 16 bits : Address offset from function start. - 14 bits : CFA offset / 4. - 2 bits : RA offset / 4. -If the RA offset of a row is 0, then use the offset of the previous rows in the -same function. -TODO(ssid): Make sure RA offset is always present. - -See extract_unwind_tables.py for details about how this data is extracted from -breakpad symbol files. -*/ - -extern "C" { -extern char __executable_start; -extern char _etext; -} - -namespace base { -namespace trace_event { - -namespace { - -// The value of index when the function does not have unwind information. -constexpr uint32_t kCantUnwind = 0xFFFF; - -// The mask on the CFI row data that is used to get the high 14 bits and -// multiply it by 4 to get CFA offset. Since the last 2 bits are masked out, a -// shift is not necessary. -constexpr uint16_t kCFAMask = 0xfffc; - -// The mask on the CFI row data that is used to get the low 2 bits and multiply -// it by 4 to get the RA offset. -constexpr uint16_t kRAMask = 0x3; -constexpr uint16_t kRAShift = 2; - -// The code in this file assumes we are running in 32-bit builds since all the -// addresses in the unwind table are specified in 32 bits. -static_assert(sizeof(uintptr_t) == 4, - "The unwind table format is only valid for 32 bit builds."); - -// The CFI data in UNW_DATA table starts with number of rows (N) and then -// followed by N rows of 4 bytes long. The CFIUnwindDataRow represents a single -// row of CFI data of a function in the table. Since we cast the memory at the -// address after the address of number of rows, into an array of -// CFIUnwindDataRow, the size of the struct should be 4 bytes and the order of -// the members is fixed according to the given format. The first 2 bytes tell -// the address of function and last 2 bytes give the CFI data for the offset. -struct CFIUnwindDataRow { - // The address of the instruction in terms of offset from the start of the - // function. - uint16_t addr_offset; - // Represents the CFA and RA offsets to get information about next stack - // frame. This is the CFI data at the point before executing the instruction - // at |addr_offset| from the start of the function. - uint16_t cfi_data; - - // Return the RA offset for the current unwind row. - size_t ra_offset() const { return (cfi_data & kRAMask) << kRAShift; } - - // Returns the CFA offset for the current unwind row. - size_t cfa_offset() const { return cfi_data & kCFAMask; } -}; - -static_assert( - sizeof(CFIUnwindDataRow) == 4, - "The CFIUnwindDataRow struct must be exactly 4 bytes for searching."); - -} // namespace - -// static -CFIBacktraceAndroid* CFIBacktraceAndroid::GetInitializedInstance() { - static CFIBacktraceAndroid* instance = new CFIBacktraceAndroid(); - return instance; -} - -CFIBacktraceAndroid::CFIBacktraceAndroid() - : thread_local_cfi_cache_( - [](void* ptr) { delete static_cast<CFICache*>(ptr); }) { - Initialize(); -} - -CFIBacktraceAndroid::~CFIBacktraceAndroid() {} - -void CFIBacktraceAndroid::Initialize() { - // The address |_etext| gives the end of the .text section in the binary. This - // value is more accurate than parsing the memory map since the mapped - // regions are usualy larger than the .text section. - executable_end_addr_ = reinterpret_cast<uintptr_t>(&_etext); - // The address of |__executable_start| gives the start address of the - // executable. This value is used to find the offset address of the - // instruction in binary from PC. - executable_start_addr_ = reinterpret_cast<uintptr_t>(&__executable_start); - - // This file name is defined by extract_unwind_tables.gni. - static constexpr char kCfiFileName[] = "assets/unwind_cfi_32"; - MemoryMappedFile::Region cfi_region; - int fd = base::android::OpenApkAsset(kCfiFileName, &cfi_region); - if (fd < 0) - return; - cfi_mmap_ = std::make_unique<MemoryMappedFile>(); - // The CFI region starts at |cfi_region.offset|. - if (!cfi_mmap_->Initialize(base::File(fd), cfi_region)) - return; - - ParseCFITables(); - can_unwind_stack_frames_ = true; -} - -void CFIBacktraceAndroid::ParseCFITables() { - // The first 4 bytes in the file is the size of UNW_INDEX table. - static constexpr size_t kUnwIndexRowSize = - sizeof(*unw_index_function_col_) + sizeof(*unw_index_indices_col_); - size_t unw_index_size = 0; - memcpy(&unw_index_size, cfi_mmap_->data(), sizeof(unw_index_size)); - DCHECK_EQ(0u, unw_index_size % kUnwIndexRowSize); - // UNW_INDEX table starts after 4 bytes. - unw_index_function_col_ = - reinterpret_cast<const uintptr_t*>(cfi_mmap_->data()) + 1; - unw_index_row_count_ = unw_index_size / kUnwIndexRowSize; - unw_index_indices_col_ = reinterpret_cast<const uint16_t*>( - unw_index_function_col_ + unw_index_row_count_); - - // The UNW_DATA table data is right after the end of UNW_INDEX table. - // Interpret the UNW_DATA table as an array of 2 byte numbers since the - // indexes we have from the UNW_INDEX table are in terms of 2 bytes. - unw_data_start_addr_ = unw_index_indices_col_ + unw_index_row_count_; -} - -size_t CFIBacktraceAndroid::Unwind(const void** out_trace, size_t max_depth) { - // This function walks the stack using the call frame information to find the - // return addresses of all the functions that belong to current binary in call - // stack. For each function the CFI table defines the offset of the previous - // call frame and offset where the return address is stored. - if (!can_unwind_stack_frames()) - return 0; - - // Get the current register state. This register state can be taken at any - // point in the function and the unwind information would be for this point. - // Define local variables before trying to get the current PC and SP to make - // sure the register state obtained is consistent with each other. - uintptr_t pc = 0, sp = 0; - asm volatile("mov %0, pc" : "=r"(pc)); - asm volatile("mov %0, sp" : "=r"(sp)); - - // We can only unwind as long as the pc is within the chrome.so. - size_t depth = 0; - while (pc > executable_start_addr_ && pc <= executable_end_addr_ && - depth < max_depth) { - out_trace[depth++] = reinterpret_cast<void*>(pc); - // The offset of function from the start of the chrome.so binary: - uintptr_t func_addr = pc - executable_start_addr_; - CFIRow cfi{}; - if (!FindCFIRowForPC(func_addr, &cfi)) - break; - - // The rules for unwinding using the CFI information are: - // SP_prev = SP_cur + cfa_offset and - // PC_prev = * (SP_prev - ra_offset). - sp = sp + cfi.cfa_offset; - memcpy(&pc, reinterpret_cast<uintptr_t*>(sp - cfi.ra_offset), - sizeof(uintptr_t)); - } - return depth; -} - -bool CFIBacktraceAndroid::FindCFIRowForPC(uintptr_t func_addr, - CFIBacktraceAndroid::CFIRow* cfi) { - auto* cache = GetThreadLocalCFICache(); - *cfi = {0}; - if (cache->Find(func_addr, cfi)) - return true; - - // Consider each column of UNW_INDEX table as arrays of uintptr_t (function - // addresses) and uint16_t (indices). Define start and end iterator on the - // first column array (addresses) and use std::lower_bound() to binary search - // on this array to find the required function address. - static const uintptr_t* const unw_index_fn_end = - unw_index_function_col_ + unw_index_row_count_; - const uintptr_t* found = - std::lower_bound(unw_index_function_col_, unw_index_fn_end, func_addr); - - // If found is start, then the given function is not in the table. If the - // given pc is start of a function then we cannot unwind. - if (found == unw_index_function_col_ || *found == func_addr) - return false; - - // std::lower_bound() returns the iter that corresponds to the first address - // that is greater than the given address. So, the required iter is always one - // less than the value returned by std::lower_bound(). - --found; - uintptr_t func_start_addr = *found; - size_t row_num = found - unw_index_function_col_; - uint16_t index = unw_index_indices_col_[row_num]; - DCHECK_LE(func_start_addr, func_addr); - // If the index is CANT_UNWIND then we do not have unwind infomation for the - // function. - if (index == kCantUnwind) - return false; - - // The unwind data for the current function is at an offsset of the index - // found in UNW_INDEX table. - const uint16_t* unwind_data = unw_data_start_addr_ + index; - // The value of first 2 bytes is the CFI data row count for the function. - uint16_t row_count = 0; - memcpy(&row_count, unwind_data, sizeof(row_count)); - // And the actual CFI rows start after 2 bytes from the |unwind_data|. Cast - // the data into an array of CFIUnwindDataRow since the struct is designed to - // represent each row. We should be careful to read only |row_count| number of - // elements in the array. - const CFIUnwindDataRow* function_data = - reinterpret_cast<const CFIUnwindDataRow*>(unwind_data + 1); - - // Iterate through the CFI rows of the function to find the row that gives - // offset for the given instruction address. - CFIUnwindDataRow cfi_row = {0, 0}; - uint16_t ra_offset = 0; - for (uint16_t i = 0; i < row_count; ++i) { - CFIUnwindDataRow row; - memcpy(&row, function_data + i, sizeof(CFIUnwindDataRow)); - // The return address of the function is the instruction that is not yet - // been executed. The cfi row specifies the unwind info before executing the - // given instruction. If the given address is equal to the instruction - // offset, then use the current row. Or use the row with highest address - // less than the given address. - if (row.addr_offset + func_start_addr > func_addr) - break; - - cfi_row = row; - // The ra offset of the last specified row should be used, if unspecified. - // So, keep updating the RA offset till we reach the correct CFI row. - // TODO(ssid): This should be fixed in the format and we should always - // output ra offset. - if (cfi_row.ra_offset()) - ra_offset = cfi_row.ra_offset(); - } - DCHECK_NE(0u, cfi_row.addr_offset); - *cfi = {cfi_row.cfa_offset(), ra_offset}; - DCHECK(cfi->cfa_offset); - DCHECK(cfi->ra_offset); - - // safe to update since the cache is thread local. - cache->Add(func_addr, *cfi); - return true; -} - -CFIBacktraceAndroid::CFICache* CFIBacktraceAndroid::GetThreadLocalCFICache() { - auto* cache = static_cast<CFICache*>(thread_local_cfi_cache_.Get()); - if (!cache) { - cache = new CFICache(); - thread_local_cfi_cache_.Set(cache); - } - return cache; -} - -void CFIBacktraceAndroid::CFICache::Add(uintptr_t address, CFIRow cfi) { - cache_[address % kLimit] = {address, cfi}; -} - -bool CFIBacktraceAndroid::CFICache::Find(uintptr_t address, CFIRow* cfi) { - if (cache_[address % kLimit].address == address) { - *cfi = cache_[address % kLimit].cfi; - return true; - } - return false; -} - -} // namespace trace_event -} // namespace base
diff --git a/base/trace_event/cfi_backtrace_android.h b/base/trace_event/cfi_backtrace_android.h deleted file mode 100644 index 0c51332..0000000 --- a/base/trace_event/cfi_backtrace_android.h +++ /dev/null
@@ -1,157 +0,0 @@ -// Copyright 2018 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. - -#ifndef BASE_TRACE_EVENT_CFI_BACKTRACE_ANDROID_H_ -#define BASE_TRACE_EVENT_CFI_BACKTRACE_ANDROID_H_ - -#include <stddef.h> -#include <stdint.h> - -#include <memory> - -#include "base/base_export.h" -#include "base/debug/debugging_buildflags.h" -#include "base/files/memory_mapped_file.h" -#include "base/gtest_prod_util.h" -#include "base/threading/thread_local_storage.h" - -namespace base { -namespace trace_event { - -// This class is used to unwind stack frames in the current thread. The unwind -// information (dwarf debug info) is stripped from the chrome binary and we do -// not build with exception tables (ARM EHABI) in release builds. So, we use a -// custom unwind table which is generated and added to specific android builds, -// when add_unwind_tables_in_apk build option is specified. This unwind table -// contains information for unwinding stack frames when the functions calls are -// from lib[mono]chrome.so. The file is added as an asset to the apk and the -// table is used to unwind stack frames for profiling. This class implements -// methods to read and parse the unwind table and unwind stack frames using this -// data. -class BASE_EXPORT CFIBacktraceAndroid { - public: - // Creates and initializes by memory mapping the unwind tables from apk assets - // on first call. - static CFIBacktraceAndroid* GetInitializedInstance(); - - // Returns true if stack unwinding is possible using CFI unwind tables in apk. - // There is no need to check this before each unwind call. Will always return - // the same value based on CFI tables being present in the binary. - bool can_unwind_stack_frames() const { return can_unwind_stack_frames_; } - - // Returns the program counters by unwinding stack in the current thread in - // order of latest call frame first. Unwinding works only if - // can_unwind_stack_frames() returns true. This function allocates memory from - // heap for caches. For each stack frame, this method searches through the - // unwind table mapped in memory to find the unwind information for function - // and walks the stack to find all the return address. This only works until - // the last function call from the chrome.so. We do not have unwind - // information to unwind beyond any frame outside of chrome.so. Calls to - // Unwind() are thread safe and lock free, once Initialize() returns success. - size_t Unwind(const void** out_trace, size_t max_depth); - - private: - FRIEND_TEST_ALL_PREFIXES(CFIBacktraceAndroidTest, TestCFICache); - FRIEND_TEST_ALL_PREFIXES(CFIBacktraceAndroidTest, TestFindCFIRow); - FRIEND_TEST_ALL_PREFIXES(CFIBacktraceAndroidTest, TestUnwinding); - - // The CFI information that correspond to an instruction. - struct CFIRow { - bool operator==(const CFIBacktraceAndroid::CFIRow& o) const { - return cfa_offset == o.cfa_offset && ra_offset == o.ra_offset; - } - - // The offset of the call frame address of previous function from the - // current stack pointer. Rule for unwinding SP: SP_prev = SP_cur + - // cfa_offset. - uint16_t cfa_offset = 0; - // The offset of location of return address from the previous call frame - // address. Rule for unwinding PC: PC_prev = * (SP_prev - ra_offset). - uint16_t ra_offset = 0; - }; - - // A simple cache that stores entries in table using prime modulo hashing. - // This cache with 500 entries already gives us 95% hit rate, and fits in a - // single system page (usually 4KiB). Using a thread local cache for each - // thread gives us 30% improvements on performance of heap profiling. - class CFICache { - public: - // Add new item to the cache. It replaces an existing item with same hash. - // Constant time operation. - void Add(uintptr_t address, CFIRow cfi); - - // Finds the given address and fills |cfi| with the info for the address. - // returns true if found, otherwise false. Assumes |address| is never 0. - bool Find(uintptr_t address, CFIRow* cfi); - - private: - FRIEND_TEST_ALL_PREFIXES(CFIBacktraceAndroidTest, TestCFICache); - - // Size is the highest prime which fits the cache in a single system page, - // usually 4KiB. A prime is chosen to make sure addresses are hashed evenly. - static const int kLimit = 509; - - struct AddrAndCFI { - uintptr_t address; - CFIRow cfi; - }; - AddrAndCFI cache_[kLimit] = {}; - }; - - static_assert(sizeof(CFIBacktraceAndroid::CFICache) < 4096, - "The cache does not fit in a single page."); - - CFIBacktraceAndroid(); - ~CFIBacktraceAndroid(); - - // Initializes unwind tables using the CFI asset file in the apk if present. - // Also stores the limits of mapped region of the lib[mono]chrome.so binary, - // since the unwind is only feasible for addresses within the .so file. Once - // initialized, the memory map of the unwind table is never cleared since we - // cannot guarantee that all the threads are done using the memory map when - // heap profiling is turned off. But since we keep the memory map is clean, - // the system can choose to evict the unused pages when needed. This would - // still reduce the total amount of address space available in process. - void Initialize(); - - // Finds the UNW_INDEX and UNW_DATA tables in from the CFI file memory map. - void ParseCFITables(); - - // Finds the CFI row for the given |func_addr| in terms of offset from - // the start of the current binary. - bool FindCFIRowForPC(uintptr_t func_addr, CFIRow* out); - - CFICache* GetThreadLocalCFICache(); - - // Details about the memory mapped region which contains the libchrome.so - // library file. - uintptr_t executable_start_addr_ = 0; - uintptr_t executable_end_addr_ = 0; - - // The start address of the memory mapped unwind table asset file. Unique ptr - // because it is replaced in tests. - std::unique_ptr<MemoryMappedFile> cfi_mmap_; - - // The UNW_INDEX table: Start address of the function address column. The - // memory segment corresponding to this column is treated as an array of - // uintptr_t. - const uintptr_t* unw_index_function_col_ = nullptr; - // The UNW_INDEX table: Start address of the index column. The memory segment - // corresponding to this column is treated as an array of uint16_t. - const uint16_t* unw_index_indices_col_ = nullptr; - // The number of rows in UNW_INDEX table. - size_t unw_index_row_count_ = 0; - - // The start address of UNW_DATA table. - const uint16_t* unw_data_start_addr_ = nullptr; - - bool can_unwind_stack_frames_ = false; - - ThreadLocalStorage::Slot thread_local_cfi_cache_; -}; - -} // namespace trace_event -} // namespace base - -#endif // BASE_TRACE_EVENT_CFI_BACKTRACE_ANDROID_H_
diff --git a/base/trace_event/cfi_backtrace_android_unittest.cc b/base/trace_event/cfi_backtrace_android_unittest.cc deleted file mode 100644 index 3ad3d33..0000000 --- a/base/trace_event/cfi_backtrace_android_unittest.cc +++ /dev/null
@@ -1,197 +0,0 @@ -// Copyright 2018 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/trace_event/cfi_backtrace_android.h" - -#include "base/files/file_util.h" -#include "testing/gtest/include/gtest/gtest.h" - -namespace base { -namespace trace_event { - -namespace { - -void* GetPC() { - return __builtin_return_address(0); -} - -} // namespace - -TEST(CFIBacktraceAndroidTest, TestUnwinding) { - auto* unwinder = CFIBacktraceAndroid::GetInitializedInstance(); - EXPECT_TRUE(unwinder->can_unwind_stack_frames()); - EXPECT_GT(unwinder->executable_start_addr_, 0u); - EXPECT_GT(unwinder->executable_end_addr_, unwinder->executable_start_addr_); - EXPECT_GT(unwinder->cfi_mmap_->length(), 0u); - - const size_t kMaxFrames = 100; - const void* frames[kMaxFrames]; - size_t unwind_count = unwinder->Unwind(frames, kMaxFrames); - // Expect at least 2 frames in the result. - ASSERT_GT(unwind_count, 2u); - EXPECT_LE(unwind_count, kMaxFrames); - - const size_t kMaxCurrentFuncCodeSize = 50; - const uintptr_t current_pc = reinterpret_cast<uintptr_t>(GetPC()); - const uintptr_t actual_frame = reinterpret_cast<uintptr_t>(frames[2]); - EXPECT_NEAR(current_pc, actual_frame, kMaxCurrentFuncCodeSize); - - for (size_t i = 0; i < unwind_count; ++i) { - EXPECT_GT(reinterpret_cast<uintptr_t>(frames[i]), - unwinder->executable_start_addr_); - EXPECT_LT(reinterpret_cast<uintptr_t>(frames[i]), - unwinder->executable_end_addr_); - } -} - -// Flaky: https://bugs.chromium.org/p/chromium/issues/detail?id=829555 -TEST(CFIBacktraceAndroidTest, DISABLED_TestFindCFIRow) { - auto* unwinder = CFIBacktraceAndroid::GetInitializedInstance(); - /* Input is generated from the CFI file: - STACK CFI INIT 1000 500 - STACK CFI 1002 .cfa: sp 272 + .ra: .cfa -4 + ^ r4: .cfa -16 + - STACK CFI 1008 .cfa: sp 544 + .r1: .cfa -0 + ^ r4: .cfa -16 + ^ - STACK CFI 1040 .cfa: sp 816 + .r1: .cfa -0 + ^ r4: .cfa -16 + ^ - STACK CFI 1050 .cfa: sp 816 + .ra: .cfa -8 + ^ r4: .cfa -16 + ^ - STACK CFI 1080 .cfa: sp 544 + .r1: .cfa -0 + ^ r4: .cfa -16 + ^ - - STACK CFI INIT 2000 22 - STACK CFI 2004 .cfa: sp 16 + .ra: .cfa -12 + ^ r4: .cfa -16 + ^ - STACK CFI 2008 .cfa: sp 16 + .ra: .cfa -12 + ^ r4: .cfa -16 + ^ - - STACK CFI INIT 2024 100 - STACK CFI 2030 .cfa: sp 48 + .ra: .cfa -12 + ^ r4: .cfa -16 + ^ - STACK CFI 2100 .cfa: sp 64 + .r1: .cfa -0 + ^ r4: .cfa -16 + ^ - - STACK CFI INIT 2200 10 - STACK CFI 2204 .cfa: sp 44 + .ra: .cfa -8 + ^ r4: .cfa -16 + ^ - */ - uint16_t input[] = {// UNW_INDEX size - 0x2A, - - // UNW_INDEX address column (4 byte rows). - 0x0, 0x1000, 0x0, 0x1502, 0x0, 0x2000, 0x0, 0x2024, 0x0, - 0x2126, 0x0, 0x2200, 0x0, 0x2212, 0x0, - - // UNW_INDEX index column (2 byte rows). - 0x0, 0xffff, 0xb, 0x10, 0xffff, 0x15, 0xffff, - - // UNW_DATA table. - 0x5, 0x2, 0x111, 0x8, 0x220, 0x40, 0x330, 0x50, 0x332, - 0x80, 0x220, 0x2, 0x4, 0x13, 0x8, 0x13, 0x2, 0xc, 0x33, - 0xdc, 0x40, 0x1, 0x4, 0x2e}; - FilePath temp_path; - CreateTemporaryFile(&temp_path); - EXPECT_EQ( - static_cast<int>(sizeof(input)), - WriteFile(temp_path, reinterpret_cast<char*>(input), sizeof(input))); - - unwinder->cfi_mmap_.reset(new MemoryMappedFile()); - unwinder->cfi_mmap_->Initialize(temp_path); - unwinder->ParseCFITables(); - - CFIBacktraceAndroid::CFIRow cfi_row = {0}; - EXPECT_FALSE(unwinder->FindCFIRowForPC(0x01, &cfi_row)); - EXPECT_FALSE(unwinder->FindCFIRowForPC(0x100, &cfi_row)); - EXPECT_FALSE(unwinder->FindCFIRowForPC(0x1502, &cfi_row)); - EXPECT_FALSE(unwinder->FindCFIRowForPC(0x3000, &cfi_row)); - EXPECT_FALSE(unwinder->FindCFIRowForPC(0x2024, &cfi_row)); - EXPECT_FALSE(unwinder->FindCFIRowForPC(0x2212, &cfi_row)); - - const CFIBacktraceAndroid::CFIRow kRow1 = {0x110, 0x4}; - const CFIBacktraceAndroid::CFIRow kRow2 = {0x220, 0x4}; - const CFIBacktraceAndroid::CFIRow kRow3 = {0x220, 0x8}; - const CFIBacktraceAndroid::CFIRow kRow4 = {0x30, 0xc}; - const CFIBacktraceAndroid::CFIRow kRow5 = {0x2c, 0x8}; - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1002, &cfi_row)); - EXPECT_EQ(kRow1, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1003, &cfi_row)); - EXPECT_EQ(kRow1, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1008, &cfi_row)); - EXPECT_EQ(kRow2, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1009, &cfi_row)); - EXPECT_EQ(kRow2, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1039, &cfi_row)); - EXPECT_EQ(kRow2, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1080, &cfi_row)); - EXPECT_EQ(kRow3, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1100, &cfi_row)); - EXPECT_EQ(kRow3, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x2050, &cfi_row)); - EXPECT_EQ(kRow4, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x2208, &cfi_row)); - EXPECT_EQ(kRow5, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x2210, &cfi_row)); - EXPECT_EQ(kRow5, cfi_row); - - // Test if cache is used on the future calls to Find, all addresses should - // have different hash. Resetting the memory map to make sure it is never - // accessed in Find(). - unwinder->cfi_mmap_.reset(new MemoryMappedFile()); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1002, &cfi_row)); - EXPECT_EQ(kRow1, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1003, &cfi_row)); - EXPECT_EQ(kRow1, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1008, &cfi_row)); - EXPECT_EQ(kRow2, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1009, &cfi_row)); - EXPECT_EQ(kRow2, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1039, &cfi_row)); - EXPECT_EQ(kRow2, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1080, &cfi_row)); - EXPECT_EQ(kRow3, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x1100, &cfi_row)); - EXPECT_EQ(kRow3, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x2050, &cfi_row)); - EXPECT_EQ(kRow4, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x2208, &cfi_row)); - EXPECT_EQ(kRow5, cfi_row); - EXPECT_TRUE(unwinder->FindCFIRowForPC(0x2210, &cfi_row)); - EXPECT_EQ(kRow5, cfi_row); -} - -TEST(CFIBacktraceAndroidTest, TestCFICache) { - // Use ASSERT macros in this function since they are in loop and using EXPECT - // prints too many failures. - CFIBacktraceAndroid::CFICache cache; - CFIBacktraceAndroid::CFIRow cfi; - - // Empty cache should not find anything. - EXPECT_FALSE(cache.Find(1, &cfi)); - - // Insert 1 - 2*kLimit - for (size_t i = 1; i <= 2 * cache.kLimit; ++i) { - CFIBacktraceAndroid::CFIRow val = {4 * i, 2 * i}; - cache.Add(i, val); - ASSERT_TRUE(cache.Find(i, &cfi)); - ASSERT_EQ(cfi, val); - - // Inserting more than kLimit items evicts |i - cache.kLimit| from cache. - if (i >= cache.kLimit) - ASSERT_FALSE(cache.Find(i - cache.kLimit, &cfi)); - } - // Cache contains kLimit+1 - 2*kLimit. - - // Check that 1 - kLimit cannot be found. - for (size_t i = 1; i <= cache.kLimit; ++i) { - ASSERT_FALSE(cache.Find(i, &cfi)); - } - - // Check if kLimit+1 - 2*kLimit still exists in cache. - for (size_t i = cache.kLimit + 1; i <= 2 * cache.kLimit; ++i) { - CFIBacktraceAndroid::CFIRow val = {4 * i, 2 * i}; - ASSERT_TRUE(cache.Find(i, &cfi)); - ASSERT_EQ(cfi, val); - } - - // Insert 2*kLimit+1, will evict kLimit. - cfi = {1, 1}; - cache.Add(2 * cache.kLimit + 1, cfi); - EXPECT_TRUE(cache.Find(2 * cache.kLimit + 1, &cfi)); - EXPECT_FALSE(cache.Find(cache.kLimit + 1, &cfi)); - // Cache contains kLimit+1 - 2*kLimit. -} - -} // namespace trace_event -} // namespace base
diff --git a/base/trace_event/heap_profiler_allocation_context_tracker.cc b/base/trace_event/heap_profiler_allocation_context_tracker.cc index 556719e..977f3b1 100644 --- a/base/trace_event/heap_profiler_allocation_context_tracker.cc +++ b/base/trace_event/heap_profiler_allocation_context_tracker.cc
@@ -8,7 +8,6 @@ #include <iterator> #include "base/atomicops.h" -#include "base/debug/debugging_buildflags.h" #include "base/debug/leak_annotations.h" #include "base/debug/stack_trace.h" #include "base/no_destructor.h" @@ -17,10 +16,6 @@ #include "base/trace_event/heap_profiler_allocation_context.h" #include "build/build_config.h" -#if defined(OS_ANDROID) && BUILDFLAG(CAN_UNWIND_WITH_CFI_TABLE) -#include "base/trace_event/cfi_backtrace_android.h" -#endif - #if defined(OS_LINUX) || defined(OS_ANDROID) #include <sys/prctl.h> #endif @@ -219,27 +214,11 @@ // kMaxFrameCount + 1 frames, so that we know if there are more frames // than our backtrace capacity. #if !defined(OS_NACL) // We don't build base/debug/stack_trace.cc for NaCl. -#if defined(OS_ANDROID) && BUILDFLAG(CAN_UNWIND_WITH_CFI_TABLE) - const void* frames[Backtrace::kMaxFrameCount + 1]; - static_assert(arraysize(frames) >= Backtrace::kMaxFrameCount, - "not requesting enough frames to fill Backtrace"); - size_t frame_count = - CFIBacktraceAndroid::GetInitializedInstance()->Unwind( - frames, arraysize(frames)); -#elif BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS) - const void* frames[Backtrace::kMaxFrameCount + 1]; - static_assert(arraysize(frames) >= Backtrace::kMaxFrameCount, - "not requesting enough frames to fill Backtrace"); - size_t frame_count = debug::TraceStackFramePointers( - frames, arraysize(frames), - 1 /* exclude this function from the trace */); -#else // Fall-back to capturing the stack with base::debug::StackTrace, // which is likely slower, but more reliable. base::debug::StackTrace stack_trace(Backtrace::kMaxFrameCount + 1); size_t frame_count = 0u; const void* const* frames = stack_trace.Addresses(&frame_count); -#endif // If there are too many frames, keep the ones furthest from main(). size_t backtrace_capacity = backtrace_end - backtrace;
diff --git a/base/trace_event/memory_dump_manager.cc b/base/trace_event/memory_dump_manager.cc index 54c93a2..9e595d6 100644 --- a/base/trace_event/memory_dump_manager.cc +++ b/base/trace_event/memory_dump_manager.cc
@@ -41,10 +41,6 @@ #if defined(OS_ANDROID) #include "base/trace_event/java_heap_dump_provider_android.h" -#if BUILDFLAG(CAN_UNWIND_WITH_CFI_TABLE) -#include "base/trace_event/cfi_backtrace_android.h" -#endif - #endif // defined(OS_ANDROID) namespace base {
diff --git a/base/trace_event/trace_event.h b/base/trace_event/trace_event.h index 38528aa..2569f5e 100644 --- a/base/trace_event/trace_event.h +++ b/base/trace_event/trace_event.h
@@ -15,7 +15,6 @@ #include <string> #include "base/atomicops.h" -#include "base/debug/debugging_buildflags.h" #include "base/macros.h" #include "base/time/time.h" #include "base/time/time_override.h" @@ -439,24 +438,6 @@ INTERNAL_TRACE_EVENT_UID(ScopedContext) \ INTERNAL_TRACE_EVENT_UID(scoped_context)(context); -#if BUILDFLAG(ENABLE_LOCATION_SOURCE) - -// Implementation detail: internal macro to trace a task execution with the -// location where it was posted from. -// -// This implementation is for when location sources are available. -// TODO(ssid): The program counter of the current task should be added here. -#define INTERNAL_TRACE_TASK_EXECUTION(run_function, task) \ - TRACE_EVENT2("toplevel", run_function, "src_file", \ - (task).posted_from.file_name(), "src_func", \ - (task).posted_from.function_name()); \ - TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION INTERNAL_TRACE_EVENT_UID( \ - task_event)((task).posted_from.file_name()); \ - TRACE_HEAP_PROFILER_API_SCOPED_WITH_PROGRAM_COUNTER \ - INTERNAL_TRACE_EVENT_UID(task_pc_event)((task).posted_from.program_counter()); - -#else - // TODO(http://crbug.com760702) remove file name and just pass the program // counter to the heap profiler macro. // TODO(ssid): The program counter of the current task should be added here. @@ -467,8 +448,6 @@ TRACE_HEAP_PROFILER_API_SCOPED_WITH_PROGRAM_COUNTER \ INTERNAL_TRACE_EVENT_UID(task_pc_event)((task).posted_from.program_counter()); -#endif - namespace trace_event_internal { // Specify these values when the corresponding argument of AddTraceEvent is not
diff --git a/tools/gn/bootstrap/bootstrap.py b/tools/gn/bootstrap/bootstrap.py index cbbce40..e964f84 100755 --- a/tools/gn/bootstrap/bootstrap.py +++ b/tools/gn/bootstrap/bootstrap.py
@@ -227,16 +227,6 @@ mkdir_p(root_gen_dir) write_buildflag_header_manually(root_gen_dir, - 'base/debug/debugging_buildflags.h', - { - 'ENABLE_LOCATION_SOURCE': 'false', - 'ENABLE_PROFILING': 'false', - 'CAN_UNWIND_WITH_FRAME_POINTERS': 'false', - 'UNSAFE_DEVELOPER_BUILD': 'false', - 'CAN_UNWIND_WITH_CFI_TABLE': 'false', - }) - - write_buildflag_header_manually(root_gen_dir, 'base/memory/protected_memory_buildflags.h', { 'USE_LLD': 'false' })