[clang-tools-extra] [sanitizer_symbolizer] Symbolizer Markup for linux (PR #66126)
Andres Villegas via cfe-commits
cfe-commits at lists.llvm.org
Tue Sep 12 12:25:53 PDT 2023
=?utf-8?q?Andrés?= Villegas <andresvi at google.com>,
=?utf-8?q?Andrés?= Villegas <andresvi at google.com>,
=?utf-8?q?Andrés?= Villegas <andresvi at google.com>,
=?utf-8?q?Andrés?= Villegas <andresvi at google.com>
https://github.com/avillega updated https://github.com/llvm/llvm-project/pull/66126:
>From 953a832b2e38d28d1b0e11ea3f5a2b05d69640b9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Villegas?= <andresvi at google.com>
Date: Thu, 10 Aug 2023 18:19:46 +0000
Subject: [PATCH 1/5] [sanitizer] Symbolizer Markup for linux.
This change adds support for sanitizer symbolizer markup
for linux. For more informationa about symbolzier markup
please visit https://llvm.org/docs/SymbolizerMarkupFormat.html
---
compiler-rt/lib/hwasan/hwasan_report.cpp | 44 ++++-
.../lib/sanitizer_common/CMakeLists.txt | 1 +
.../lib/sanitizer_common/sanitizer_flags.inc | 3 +
.../sanitizer_stacktrace_libcdep.cpp | 64 +++++-
.../sanitizer_stacktrace_printer.cpp | 31 ++-
.../sanitizer_stacktrace_printer.h | 10 +-
.../sanitizer_common/sanitizer_symbolizer.h | 5 +-
.../sanitizer_symbolizer_internal.h | 1 -
.../sanitizer_symbolizer_libcdep.cpp | 12 ++
.../sanitizer_symbolizer_markup.cpp | 186 +++++++++++++++---
.../sanitizer_symbolizer_markup.h | 69 +++++++
.../sanitizer_symbolizer_posix_libcdep.cpp | 7 +
.../sanitizer_symbolizer_report.cpp | 1 +
.../sanitizer_stacktrace_printer_test.cpp | 36 ++--
compiler-rt/lib/tsan/rtl/tsan_report.cpp | 10 +
15 files changed, 413 insertions(+), 67 deletions(-)
create mode 100644 compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h
diff --git a/compiler-rt/lib/hwasan/hwasan_report.cpp b/compiler-rt/lib/hwasan/hwasan_report.cpp
index efe6f57704919a4..9e8fe03510213af 100644
--- a/compiler-rt/lib/hwasan/hwasan_report.cpp
+++ b/compiler-rt/lib/hwasan/hwasan_report.cpp
@@ -248,6 +248,44 @@ static void PrintStackAllocations(StackAllocationsRingBuffer *sa,
if (SymbolizedStack *frame = Symbolizer::GetOrInit()->SymbolizePC(pc)) {
RenderFrame(&frame_desc, " %F %L", 0, frame->info.address, &frame->info,
common_flags()->symbolize_vs_style,
+ common_flags()->enable_symbolizer_markup,
+ common_flags()->strip_path_prefix);
+ frame->ClearAll();
+ }
+ Printf("%s\n", frame_desc.data());
+ frame_desc.clear();
+ }
+}
+
+
+static void PrintStackAllocationsMarkup(StackAllocationsRingBuffer *sa) {
+ // For symbolizer markup it is just necessary to have dump stack
+ // frames for offline symbolization.
+
+ uptr frames = Min((uptr)flags()->stack_history_size, sa->size());
+ if (const ListOfModules *modules =
+ Symbolizer::GetOrInit()->GetRefreshedListOfModules()) {
+ InternalScopedString modules_res;
+ RenderModules(&modules_res, modules,
+ /*symbolizer_markup=*/ true);
+ Printf("%s", modules_res.data());
+ }
+
+ InternalScopedString frame_desc;
+ Printf("Previously allocated frames:\n");
+ for (uptr i = 0; i < frames; i++) {
+ const uptr *record_addr = &(*sa)[i];
+ uptr record = *record_addr;
+ if (!record)
+ break;
+ uptr pc_mask = (1ULL << 48) - 1;
+ uptr pc = record & pc_mask;
+ frame_desc.append(" record_addr:0x%zx record:0x%zx",
+ reinterpret_cast<uptr>(record_addr), record);
+ if (SymbolizedStack *frame = Symbolizer::GetOrInit()->SymbolizePC(pc)) {
+ RenderFrame(&frame_desc, "", 0, frame->info.address, &frame->info,
+ common_flags()->symbolize_vs_style,
+ /*symbolizer_markup=*/ true,
common_flags()->strip_path_prefix);
frame->ClearAll();
}
@@ -425,7 +463,11 @@ void PrintAddressDescription(
auto *sa = (t == GetCurrentThread() && current_stack_allocations)
? current_stack_allocations
: t->stack_allocations();
- PrintStackAllocations(sa, addr_tag, untagged_addr);
+ if (common_flags()->enable_symbolizer_markup) {
+ PrintStackAllocations(sa, addr_tag, untagged_addr);
+ } else {
+ PrintStackAllocationsMarkup(sa);
+ }
num_descriptions_printed++;
}
});
diff --git a/compiler-rt/lib/sanitizer_common/CMakeLists.txt b/compiler-rt/lib/sanitizer_common/CMakeLists.txt
index d8517f3de06a493..de398edea32753b 100644
--- a/compiler-rt/lib/sanitizer_common/CMakeLists.txt
+++ b/compiler-rt/lib/sanitizer_common/CMakeLists.txt
@@ -191,6 +191,7 @@ set(SANITIZER_IMPL_HEADERS
sanitizer_symbolizer_internal.h
sanitizer_symbolizer_libbacktrace.h
sanitizer_symbolizer_mac.h
+ sanitizer_symbolizer_markup.h
sanitizer_syscall_generic.inc
sanitizer_syscall_linux_aarch64.inc
sanitizer_syscall_linux_arm.inc
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_flags.inc b/compiler-rt/lib/sanitizer_common/sanitizer_flags.inc
index 6148ae56067cae0..a83c2fafe48a6e6 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_flags.inc
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_flags.inc
@@ -269,3 +269,6 @@ COMMON_FLAG(bool, detect_write_exec, false,
COMMON_FLAG(bool, test_only_emulate_no_memorymap, false,
"TEST ONLY fail to read memory mappings to emulate sanitized "
"\"init\"")
+COMMON_FLAG(bool, enable_symbolizer_markup, false,
+ "Use sanitizer symbolizer "
+ "markup, available only on Linux and Fuchsia.")
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp
index 47983ee7ec713f2..6a6da22c2e3e12e 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp
@@ -11,10 +11,12 @@
//===----------------------------------------------------------------------===//
#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
#include "sanitizer_placement_new.h"
#include "sanitizer_stacktrace.h"
#include "sanitizer_stacktrace_printer.h"
#include "sanitizer_symbolizer.h"
+#include "sanitizer_symbolizer_markup.h"
namespace __sanitizer {
@@ -26,10 +28,10 @@ class StackTraceTextPrinter {
InternalScopedString *output,
InternalScopedString *dedup_token)
: stack_trace_fmt_(stack_trace_fmt),
- frame_delimiter_(frame_delimiter),
- output_(output),
dedup_token_(dedup_token),
- symbolize_(RenderNeedsSymbolization(stack_trace_fmt)) {}
+ symbolize_(RenderNeedsSymbolization(stack_trace_fmt, false)),
+ frame_delimiter_(frame_delimiter),
+ output_(output) {}
bool ProcessAddressFrames(uptr pc) {
SymbolizedStack *frames = symbolize_
@@ -43,6 +45,7 @@ class StackTraceTextPrinter {
RenderFrame(output_, stack_trace_fmt_, frame_num_++, cur->info.address,
symbolize_ ? &cur->info : nullptr,
common_flags()->symbolize_vs_style,
+ common_flags()->enable_symbolizer_markup,
common_flags()->strip_path_prefix);
if (prev_len != output_->length())
@@ -69,12 +72,45 @@ class StackTraceTextPrinter {
}
const char *stack_trace_fmt_;
- const char frame_delimiter_;
int dedup_frames_ = common_flags()->dedup_token_length;
- uptr frame_num_ = 0;
- InternalScopedString *output_;
InternalScopedString *dedup_token_;
const bool symbolize_ = false;
+
+ protected:
+ uptr frame_num_ = 0;
+ const char frame_delimiter_;
+ InternalScopedString *output_;
+};
+
+class StackTraceMarkupPrinter : public StackTraceTextPrinter {
+ public:
+ StackTraceMarkupPrinter(InternalScopedString *output)
+ : StackTraceTextPrinter("", '\n', output, nullptr){};
+
+ bool ProcessAddressFrames(uptr pc) {
+ SymbolizedStack *frames = Symbolizer::GetOrInit()->SymbolizePC(pc);
+
+ if (!frames)
+ return false;
+
+ if (const ListOfModules *modules =
+ Symbolizer::GetOrInit()->GetRefreshedListOfModules()) {
+ RenderModulesMarkup(output_, modules);
+ }
+
+ for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
+ uptr prev_len = output_->length();
+ RenderFrame(output_, "", frame_num_++, cur->info.address, nullptr,
+ common_flags()->symbolize_vs_style,
+ /*symbolizer_markup=*/true,
+ common_flags()->strip_path_prefix);
+
+ if (prev_len != output_->length())
+ output_->append("%c", frame_delimiter_);
+ }
+ frames->ClearAll();
+ return true;
+ }
};
static void CopyStringToBuffer(const InternalScopedString &str, char *out_buf,
@@ -94,8 +130,11 @@ void StackTrace::PrintTo(InternalScopedString *output) const {
CHECK(output);
InternalScopedString dedup_token;
- StackTraceTextPrinter printer(common_flags()->stack_trace_format, '\n',
- output, &dedup_token);
+ StackTraceTextPrinter printer =
+ common_flags()->enable_symbolizer_markup
+ ? StackTraceMarkupPrinter(output)
+ : StackTraceTextPrinter(common_flags()->stack_trace_format, '\n',
+ output, &dedup_token);
if (trace == nullptr || size == 0) {
output->append(" <empty stack>\n\n");
@@ -194,7 +233,11 @@ void __sanitizer_symbolize_pc(uptr pc, const char *fmt, char *out_buf,
pc = StackTrace::GetPreviousInstructionPc(pc);
InternalScopedString output;
- StackTraceTextPrinter printer(fmt, '\0', &output, nullptr);
+ StackTraceTextPrinter printer =
+ common_flags()->enable_symbolizer_markup
+ ? StackTraceMarkupPrinter(&output)
+ : StackTraceTextPrinter(fmt, '\0', &output, nullptr);
+
if (!printer.ProcessAddressFrames(pc)) {
output.clear();
output.append("<can't symbolize>");
@@ -210,7 +253,8 @@ void __sanitizer_symbolize_global(uptr data_addr, const char *fmt,
DataInfo DI;
if (!Symbolizer::GetOrInit()->SymbolizeData(data_addr, &DI)) return;
InternalScopedString data_desc;
- RenderData(&data_desc, fmt, &DI, common_flags()->strip_path_prefix);
+ RenderData(&data_desc, fmt, &DI, common_flags()->enable_symbolizer_markup,
+ common_flags()->strip_path_prefix);
internal_strncpy(out_buf, data_desc.data(), out_buf_size);
out_buf[out_buf_size - 1] = 0;
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp
index 45c480d225c7f5a..b29e688b214c6ed 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp
@@ -14,7 +14,7 @@
#include "sanitizer_file.h"
#include "sanitizer_flags.h"
-#include "sanitizer_fuchsia.h"
+#include "sanitizer_symbolizer_markup.h"
namespace __sanitizer {
@@ -143,7 +143,12 @@ static const char kDefaultFormat[] = " #%n %p %F %L";
void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
uptr address, const AddressInfo *info, bool vs_style,
- const char *strip_path_prefix) {
+ bool symbolizer_markup, const char *strip_path_prefix) {
+ if (symbolizer_markup) {
+ RenderFrameMarkup(buffer, format, frame_no, address, info, vs_style,
+ strip_path_prefix);
+ return;
+ }
// info will be null in the case where symbolization is not needed for the
// given format. This ensures that the code below will get a hard failure
// rather than print incorrect information in case RenderNeedsSymbolization
@@ -250,7 +255,11 @@ void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
}
}
-bool RenderNeedsSymbolization(const char *format) {
+bool RenderNeedsSymbolization(const char *format, bool symbolizer_markup) {
+ if (symbolizer_markup) {
+ // Online symbolization is never needed for symbolizer markup.
+ return false;
+ }
if (0 == internal_strcmp(format, "DEFAULT"))
format = kDefaultFormat;
for (const char *p = format; *p != '\0'; p++) {
@@ -274,7 +283,12 @@ bool RenderNeedsSymbolization(const char *format) {
}
void RenderData(InternalScopedString *buffer, const char *format,
- const DataInfo *DI, const char *strip_path_prefix) {
+ const DataInfo *DI, bool symbolizer_markup,
+ const char *strip_path_prefix) {
+ if (symbolizer_markup) {
+ RenderDataMarkup(buffer, format, DI, strip_path_prefix);
+ return;
+ }
for (const char *p = format; *p != '\0'; p++) {
if (*p != '%') {
buffer->append("%c", *p);
@@ -333,4 +347,13 @@ void RenderModuleLocation(InternalScopedString *buffer, const char *module,
buffer->append("+0x%zx)", offset);
}
+void RenderModules(InternalScopedString *buffer, const ListOfModules *modules,
+ bool symbolizer_markup) {
+ // Rendering all the modules is only needed for symbolizer markup
+ if (!symbolizer_markup)
+ return;
+
+ RenderModulesMarkup(buffer, modules);
+}
+
} // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h
index bf2755a2e8f458d..f514feada1f59be 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h
@@ -50,9 +50,9 @@ const char *StripFunctionName(const char *function);
// %M - prints module basename and offset, if it is known, or PC.
void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
uptr address, const AddressInfo *info, bool vs_style,
- const char *strip_path_prefix = "");
+ bool symbolizer_markup, const char *strip_path_prefix = "");
-bool RenderNeedsSymbolization(const char *format);
+bool RenderNeedsSymbolization(const char *format, bool symbolizer_markup);
void RenderSourceLocation(InternalScopedString *buffer, const char *file,
int line, int column, bool vs_style,
@@ -67,7 +67,11 @@ void RenderModuleLocation(InternalScopedString *buffer, const char *module,
// Also accepts:
// %g - name of the global variable.
void RenderData(InternalScopedString *buffer, const char *format,
- const DataInfo *DI, const char *strip_path_prefix = "");
+ const DataInfo *DI, bool symbolizer_markup,
+ const char *strip_path_prefix = "");
+
+void RenderModules(InternalScopedString *buffer, const ListOfModules *modules,
+ bool symbolizer_markup);
} // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.h b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.h
index df24aaca3abf645..4006b69291df7bc 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.h
@@ -20,7 +20,6 @@
#include "sanitizer_common.h"
#include "sanitizer_mutex.h"
-#include "sanitizer_vector.h"
namespace __sanitizer {
@@ -154,6 +153,10 @@ class Symbolizer final {
void InvalidateModuleList();
+ // returns the list of modules if it was refreshed
+ // otherwise returns nullptr.
+ const ListOfModules *GetRefreshedListOfModules();
+
private:
// GetModuleNameAndOffsetForPC has to return a string to the caller.
// Since the corresponding module might get unloaded later, we should create
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_internal.h b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_internal.h
index 3ec4d80105a245a..fce98bfabdbeb0c 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_internal.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_internal.h
@@ -15,7 +15,6 @@
#include "sanitizer_file.h"
#include "sanitizer_symbolizer.h"
-#include "sanitizer_vector.h"
namespace __sanitizer {
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
index a6f82ced2036731..aa5523ce36949a6 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
@@ -11,9 +11,12 @@
//===----------------------------------------------------------------------===//
#include "sanitizer_allocator_internal.h"
+#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
#include "sanitizer_internal_defs.h"
#include "sanitizer_platform.h"
#include "sanitizer_symbolizer_internal.h"
+#include "sanitizer_symbolizer_markup.h"
namespace __sanitizer {
@@ -188,6 +191,15 @@ void Symbolizer::RefreshModules() {
modules_fresh_ = true;
}
+const ListOfModules *Symbolizer::GetRefreshedListOfModules() {
+ if (!modules_fresh_) {
+ RefreshModules();
+ }
+
+ CHECK(modules_fresh_);
+ return &modules_;
+}
+
static const LoadedModule *SearchForModule(const ListOfModules &modules,
uptr address) {
for (uptr i = 0; i < modules.size(); i++) {
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
index c8c10de10d03a24..a96bcb0e88b31c4 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
@@ -11,20 +11,140 @@
// Implementation of offline markup symbolizer.
//===----------------------------------------------------------------------===//
-#include "sanitizer_platform.h"
-#if SANITIZER_SYMBOLIZER_MARKUP
+#include "sanitizer_symbolizer_markup.h"
-#if SANITIZER_FUCHSIA
+#include "sanitizer_common.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_platform.h"
+#include "sanitizer_stacktrace.h"
+#include "sanitizer_symbolizer.h"
#include "sanitizer_symbolizer_fuchsia.h"
-# endif
-# include <limits.h>
-# include <unwind.h>
+namespace __sanitizer {
-# include "sanitizer_stacktrace.h"
-# include "sanitizer_symbolizer.h"
+void RenderDataMarkup(InternalScopedString *buffer, const char *format,
+ const DataInfo *DI, const char *strip_path_prefix) {
+ buffer->append(kFormatData, DI->start);
+}
-namespace __sanitizer {
+bool RenderNeedsSymbolizationMarkup(const char *format) { return false; }
+
+void RenderFrameMarkup(InternalScopedString *buffer, const char *format,
+ int frame_no, uptr address, const AddressInfo *info,
+ bool vs_style, const char *strip_path_prefix) {
+ CHECK(!RenderNeedsSymbolizationMarkup(format));
+ buffer->append(kFormatFrame, frame_no, address);
+}
+
+// Simplier view of a LoadedModule. It only holds information necessary to
+// identify unique modules.
+struct RenderedModule {
+ char *full_name;
+ u8 uuid[kModuleUUIDSize]; // BuildId
+ uptr base_address;
+};
+
+bool ModulesEq(const LoadedModule *module,
+ const RenderedModule *renderedModule) {
+ return module->base_address() == renderedModule->base_address &&
+ internal_memcmp(module->uuid(), renderedModule->uuid,
+ module->uuid_size()) == 0 &&
+ internal_strcmp(module->full_name(), renderedModule->full_name) == 0;
+}
+
+bool ModuleHasBeenRendered(
+ const LoadedModule *module,
+ const InternalMmapVectorNoCtor<RenderedModule> *renderedModules) {
+ for (auto *it = renderedModules->begin(); it != renderedModules->end();
+ ++it) {
+ const auto &renderedModule = *it;
+ if (ModulesEq(module, &renderedModule)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void RenderModulesMarkup(InternalScopedString *buffer,
+ const ListOfModules *modules) {
+ // Keeps track of the modules that have been rendered.
+ static bool initialized = false;
+ static InternalMmapVectorNoCtor<RenderedModule> renderedModules;
+ if (!initialized) {
+ renderedModules.Initialize(modules->size());
+ initialized = true;
+ }
+
+ if (!renderedModules.size()) {
+ buffer->append("{{{reset}}}\n");
+ }
+
+ for (auto *moduleIt = modules->begin(); moduleIt != modules->end();
+ ++moduleIt) {
+ const LoadedModule &module = *moduleIt;
+
+ if (ModuleHasBeenRendered(&module, &renderedModules)) {
+ continue;
+ }
+
+ buffer->append("{{{module:%d:%s:elf:", renderedModules.size(),
+ module.full_name());
+ for (uptr i = 0; i < module.uuid_size(); i++) {
+ buffer->append("%02x", module.uuid()[i]);
+ }
+ buffer->append("}}}\n");
+
+ const auto ranges = module.ranges();
+ for (const auto &range : ranges) {
+ buffer->append("{{{mmap:%p:%p:load:%d:r", range.beg,
+ range.end - range.beg, renderedModules.size());
+ if (range.writable)
+ buffer->append("w");
+ if (range.executable)
+ buffer->append("x");
+
+ // module.base_address = dlpi_addr
+ // range.beg = dlpi_addr + p_vaddr
+ // relative address = p_vaddr = range.beg - module.base_address
+ buffer->append(":%p}}}\n", range.beg - module.base_address());
+ }
+
+ renderedModules.push_back({});
+ RenderedModule &curModule = renderedModules.back();
+ curModule.full_name = internal_strdup(module.full_name());
+ internal_memcpy(curModule.uuid, module.uuid(), module.uuid_size());
+ curModule.base_address = module.base_address();
+ }
+}
+
+MarkupSymbolizer *MarkupSymbolizer::get(LowLevelAllocator *alloc) {
+ return new (*alloc) MarkupSymbolizer();
+}
+
+bool MarkupSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
+ char buffer[kFormatFunctionMax];
+ internal_snprintf(buffer, sizeof(buffer), kFormatFunction, addr);
+ stack->info.function = internal_strdup(buffer);
+ return true;
+}
+
+bool MarkupSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
+ info->Clear();
+ info->start = addr;
+ return true;
+}
+
+// This is used by UBSan for type names, and by ASan for global variable names.
+// It's expected to return a static buffer that will be reused on each call.
+const char *MarkupSymbolizer::Demangle(const char *name) {
+ static char buffer[kFormatDemangleMax];
+ internal_snprintf(buffer, sizeof(buffer), kFormatDemangle, name);
+ return buffer;
+}
+
+#if SANITIZER_SYMBOLIZER_MARKUP
+# include <limits.h>
+# include <unwind.h>
// This generic support for offline symbolizing is based on the
// Fuchsia port. We don't do any actual symbolization per se.
@@ -38,9 +158,9 @@ namespace __sanitizer {
// This is used by UBSan for type names, and by ASan for global variable names.
// It's expected to return a static buffer that will be reused on each call.
const char *Symbolizer::Demangle(const char *name) {
- static char buffer[kFormatDemangleMax];
- internal_snprintf(buffer, sizeof(buffer), kFormatDemangle, name);
- return buffer;
+ SymbolizerTool *markupSymbolizer = tools_.front();
+ CHECK(markupSymbolizer);
+ return markupSymbolizer->Demangle(name);
}
// This is used mostly for suppression matching. Making it work
@@ -66,38 +186,45 @@ bool Symbolizer::SymbolizeFrame(uptr addr, FrameInfo *info) { return false; }
// to render stack frames, but that should be changed to use
// RenderStackFrame.
SymbolizedStack *Symbolizer::SymbolizePC(uptr addr) {
+ SymbolizerTool *markupSymbolizer = tools_.front();
+ CHECK(markupSymbolizer);
+
SymbolizedStack *s = SymbolizedStack::New(addr);
- char buffer[kFormatFunctionMax];
- internal_snprintf(buffer, sizeof(buffer), kFormatFunction, addr);
- s->info.function = internal_strdup(buffer);
+ markupSymbolizer->SymbolizePC(addr, s);
return s;
}
// Always claim we succeeded, so that RenderDataInfo will be called.
bool Symbolizer::SymbolizeData(uptr addr, DataInfo *info) {
- info->Clear();
- info->start = addr;
- return true;
+ SymbolizerTool *markupSymbolizer = tools_.front();
+ CHECK(markupSymbolizer);
+ return markupSymbolizer->SymbolizeData(addr, info);
}
// We ignore the format argument to __sanitizer_symbolize_global.
void RenderData(InternalScopedString *buffer, const char *format,
- const DataInfo *DI, const char *strip_path_prefix) {
- buffer->append(kFormatData, DI->start);
+ const DataInfo *DI, bool symbolizer_markup,
+ const char *strip_path_prefix) {
+ RenderDataMarkup(buffer, format, DI, strip_path_prefix);
}
-bool RenderNeedsSymbolization(const char *format) { return false; }
+bool RenderNeedsSymbolization(const char *format, bool symbolizer_markup) {
+ return RenderNeedsSymbolizationMarkup(format);
+}
// We don't support the stack_trace_format flag at all.
void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
uptr address, const AddressInfo *info, bool vs_style,
const char *strip_path_prefix) {
- CHECK(!RenderNeedsSymbolization(format));
- buffer->append(kFormatFrame, frame_no, address);
+ RenderFrameMarkup(buffer, format, frame_no, address, info, vs_style,
+ strip_path_prefix);
}
Symbolizer *Symbolizer::PlatformInit() {
- return new (symbolizer_allocator_) Symbolizer({});
+ IntrusiveList<SymbolizerTool> tools;
+ SymbolizerTool *tool = MarkupSymbolizer::get(&symbolizer_allocator_);
+ tools.push_back(tool);
+ return new (symbolizer_allocator_) Symbolizer(tools);
}
void Symbolizer::LateInitialize() { Symbolizer::GetOrInit(); }
@@ -107,7 +234,7 @@ void ReportDeadlySignal(const SignalContext &sig, u32 tid,
UnwindSignalStackCallbackType unwind,
const void *unwind_context) {}
-#if SANITIZER_CAN_SLOW_UNWIND
+# if SANITIZER_CAN_SLOW_UNWIND
struct UnwindTraceArg {
BufferedStackTrace *stack;
u32 max_depth;
@@ -117,7 +244,8 @@ _Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context *ctx, void *param) {
UnwindTraceArg *arg = static_cast<UnwindTraceArg *>(param);
CHECK_LT(arg->stack->size, arg->max_depth);
uptr pc = _Unwind_GetIP(ctx);
- if (pc < PAGE_SIZE) return _URC_NORMAL_STOP;
+ if (pc < PAGE_SIZE)
+ return _URC_NORMAL_STOP;
arg->stack->trace_buffer[arg->stack->size++] = pc;
return (arg->stack->size == arg->max_depth ? _URC_NORMAL_STOP
: _URC_NO_REASON);
@@ -143,8 +271,8 @@ void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {
CHECK_GE(max_depth, 2);
UNREACHABLE("signal context doesn't exist");
}
-#endif // SANITIZER_CAN_SLOW_UNWIND
-
-} // namespace __sanitizer
+# endif // SANITIZER_CAN_SLOW_UNWIND
#endif // SANITIZER_SYMBOLIZER_MARKUP
+
+} // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h
new file mode 100644
index 000000000000000..a09278c30bbd216
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h
@@ -0,0 +1,69 @@
+//===-- sanitizer_symbolizer_markup.h -----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between various sanitizers' runtime libraries.
+//
+// Definitions of the offline markup symbolizer.
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_SYMBOLIZER_MARKUP_H
+#define SANITIZER_SYMBOLIZER_MARKUP_H
+
+#include "sanitizer_common.h"
+#include "sanitizer_symbolizer.h"
+#include "sanitizer_symbolizer_internal.h"
+
+namespace __sanitizer {
+
+// This generic support for offline symbolizing is based on the
+// Fuchsia port. We don't do any actual symbolization per se.
+// Instead, we emit text containing raw addresses and raw linkage
+// symbol names, embedded in Fuchsia's symbolization markup format.
+// Fuchsia's logging infrastructure emits enough information about
+// process memory layout that a post-processing filter can do the
+// symbolization and pretty-print the markup. See the spec at:
+// https://fuchsia.googlesource.com/zircon/+/master/docs/symbolizer_markup.md
+
+class MarkupSymbolizer final : public SymbolizerTool {
+ public:
+ static MarkupSymbolizer *get(LowLevelAllocator *alloc);
+
+ // This is used in some places for suppression checking, which we
+ // don't really support for Fuchsia. It's also used in UBSan to
+ // identify a PC location to a function name, so we always fill in
+ // the function member with a string containing markup around the PC
+ // value.
+ // TODO(mcgrathr): Under SANITIZER_GO, it's currently used by TSan
+ // to render stack frames, but that should be changed to use
+ // RenderStackFrame.
+ bool SymbolizePC(uptr addr, SymbolizedStack *stack) override;
+
+ // Always claim we succeeded, so that RenderDataInfo will be called.
+ bool SymbolizeData(uptr addr, DataInfo *info) override;
+
+ // May return NULL if demangling failed.
+ // This is used by UBSan for type names, and by ASan for global variable
+ // names. It's expected to return a static buffer that will be reused on each
+ // call.
+ const char *Demangle(const char *name) override;
+};
+
+// We ignore the format argument to __sanitizer_symbolize_global.
+void RenderDataMarkup(InternalScopedString *, const char *, const DataInfo *,
+ const char *);
+
+bool RenderNeedsSymbolizationMarkup(const char *format);
+
+// We don't support the stack_trace_format flag at all.
+void RenderFrameMarkup(InternalScopedString *, const char *, int, uptr,
+ const AddressInfo *, bool, const char *);
+
+void RenderModulesMarkup(InternalScopedString *, const ListOfModules *);
+} // namespace __sanitizer
+
+#endif // SANITIZER_SYMBOLIZER_MARKUP_H
\ No newline at end of file
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
index 1a5e38faea88747..c1f89d652904e50 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
@@ -32,6 +32,7 @@
# include "sanitizer_symbolizer_internal.h"
# include "sanitizer_symbolizer_libbacktrace.h"
# include "sanitizer_symbolizer_mac.h"
+# include "sanitizer_symbolizer_markup.h"
// C++ demangling function, as required by Itanium C++ ABI. This is weak,
// because we do not require a C++ ABI library to be linked to a program
@@ -470,6 +471,12 @@ static void ChooseSymbolizerTools(IntrusiveList<SymbolizerTool> *list,
VReport(2, "Symbolizer is disabled.\n");
return;
}
+ if (common_flags()->enable_symbolizer_markup) {
+ VReport(2, "Using symbolizer markup.\n");
+ SymbolizerTool *tool = MarkupSymbolizer::get(allocator);
+ list->push_back(tool);
+ return;
+ }
if (IsAllocatorOutOfMemory()) {
VReport(2, "Cannot use internal symbolizer: out of memory\n");
} else if (SymbolizerTool *tool = InternalSymbolizer::get(allocator)) {
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_report.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_report.cpp
index 73915715c5ba2c0..7fd21b90ecf62bd 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_report.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_report.cpp
@@ -35,6 +35,7 @@ void ReportErrorSummary(const char *error_type, const AddressInfo &info,
buff.append("%s ", error_type);
RenderFrame(&buff, "%L %F", 0, info.address, &info,
common_flags()->symbolize_vs_style,
+ common_flags()->enable_symbolizer_markup,
common_flags()->strip_path_prefix);
ReportErrorSummary(buff.data(), alt_tool_name);
}
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cpp b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cpp
index 489ef4dbb5b7d4c..96c7571574f4c9b 100644
--- a/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cpp
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cpp
@@ -84,7 +84,7 @@ TEST(SanitizerStacktracePrinter, RenderFrame) {
"%% Frame:%n PC:%p Module:%m ModuleOffset:%o "
"Function:%f FunctionOffset:%q Source:%s Line:%l "
"Column:%c",
- frame_no, info.address, &info, false, "/path/to/");
+ frame_no, info.address, &info, false, false, "/path/to/");
EXPECT_STREQ("% Frame:42 PC:0x400000 Module:my/module ModuleOffset:0x200 "
"Function:foo FunctionOffset:0x100 Source:my/source Line:10 "
"Column:5",
@@ -97,7 +97,7 @@ TEST(SanitizerStacktracePrinter, RenderFrame) {
"%% Frame:%n PC:%p Module:%m ModuleOffset:%o "
"Function:%f FunctionOffset:%q Source:%s Line:%l "
"Column:%c",
- frame_no, info.address, &info, false, "/path/to/");
+ frame_no, info.address, &info, false, false, "/path/to/");
EXPECT_STREQ("% Frame:42 PC:0x400000 Module:my/module ModuleOffset:0x200 "
"Function:bar FunctionOffset:0x100 Source:my/source Line:10 "
"Column:5",
@@ -107,26 +107,26 @@ TEST(SanitizerStacktracePrinter, RenderFrame) {
// Test special format specifiers.
info.address = 0x400000;
- RenderFrame(&str, "%M", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%M", frame_no, info.address, &info, false, false);
EXPECT_NE(nullptr, internal_strstr(str.data(), "400000"));
str.clear();
- RenderFrame(&str, "%L", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%L", frame_no, info.address, &info, false, false);
EXPECT_STREQ("(<unknown module>)", str.data());
str.clear();
info.module = internal_strdup("/path/to/module");
info.module_offset = 0x200;
- RenderFrame(&str, "%M", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%M", frame_no, info.address, &info, false, false);
EXPECT_NE(nullptr, internal_strstr(str.data(), "(module+0x"));
EXPECT_NE(nullptr, internal_strstr(str.data(), "200"));
str.clear();
- RenderFrame(&str, "%L", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%L", frame_no, info.address, &info, false, false);
EXPECT_STREQ("(/path/to/module+0x200)", str.data());
str.clear();
- RenderFrame(&str, "%b", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%b", frame_no, info.address, &info, false, false);
EXPECT_STREQ("", str.data());
str.clear();
@@ -134,7 +134,7 @@ TEST(SanitizerStacktracePrinter, RenderFrame) {
info.uuid[0] = 0x55;
info.uuid[1] = 0x66;
- RenderFrame(&str, "%M", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%M", frame_no, info.address, &info, false, false);
EXPECT_NE(nullptr, internal_strstr(str.data(), "(module+0x"));
EXPECT_NE(nullptr, internal_strstr(str.data(), "200"));
#if SANITIZER_APPLE
@@ -144,7 +144,7 @@ TEST(SanitizerStacktracePrinter, RenderFrame) {
#endif
str.clear();
- RenderFrame(&str, "%L", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%L", frame_no, info.address, &info, false, false);
#if SANITIZER_APPLE
EXPECT_STREQ("(/path/to/module+0x200)", str.data());
#else
@@ -152,46 +152,46 @@ TEST(SanitizerStacktracePrinter, RenderFrame) {
#endif
str.clear();
- RenderFrame(&str, "%b", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%b", frame_no, info.address, &info, false, false);
EXPECT_STREQ("(BuildId: 5566)", str.data());
str.clear();
info.function = internal_strdup("my_function");
- RenderFrame(&str, "%F", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%F", frame_no, info.address, &info, false, false);
EXPECT_STREQ("in my_function", str.data());
str.clear();
info.function_offset = 0x100;
- RenderFrame(&str, "%F %S", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%F %S", frame_no, info.address, &info, false, false);
EXPECT_STREQ("in my_function+0x100 <null>", str.data());
str.clear();
info.file = internal_strdup("my_file");
- RenderFrame(&str, "%F %S", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%F %S", frame_no, info.address, &info, false, false);
EXPECT_STREQ("in my_function my_file", str.data());
str.clear();
info.line = 10;
- RenderFrame(&str, "%F %S", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%F %S", frame_no, info.address, &info, false, false);
EXPECT_STREQ("in my_function my_file:10", str.data());
str.clear();
info.column = 5;
- RenderFrame(&str, "%S %L", frame_no, info.address, &info, false);
+ RenderFrame(&str, "%S %L", frame_no, info.address, &info, false, false);
EXPECT_STREQ("my_file:10:5 my_file:10:5", str.data());
str.clear();
- RenderFrame(&str, "%S %L", frame_no, info.address, &info, true);
+ RenderFrame(&str, "%S %L", frame_no, info.address, &info, true, false);
EXPECT_STREQ("my_file(10,5) my_file(10,5)", str.data());
str.clear();
info.column = 0;
- RenderFrame(&str, "%F %S", frame_no, info.address, &info, true);
+ RenderFrame(&str, "%F %S", frame_no, info.address, &info, true, false);
EXPECT_STREQ("in my_function my_file(10)", str.data());
str.clear();
info.line = 0;
- RenderFrame(&str, "%F %S", frame_no, info.address, &info, true);
+ RenderFrame(&str, "%F %S", frame_no, info.address, &info, true, false);
EXPECT_STREQ("in my_function my_file", str.data());
str.clear();
diff --git a/compiler-rt/lib/tsan/rtl/tsan_report.cpp b/compiler-rt/lib/tsan/rtl/tsan_report.cpp
index 3ae666e1212f72c..c31b30d98ae34b7 100644
--- a/compiler-rt/lib/tsan/rtl/tsan_report.cpp
+++ b/compiler-rt/lib/tsan/rtl/tsan_report.cpp
@@ -103,12 +103,22 @@ void PrintStack(const ReportStack *ent) {
Printf(" [failed to restore the stack]\n\n");
return;
}
+
+ if (const ListOfModules *modules =
+ Symbolizer::GetOrInit()->GetRefreshedListOfModules()) {
+ InternalScopedString modules_res;
+ RenderModules(&modules_res, modules,
+ common_flags()->enable_symbolizer_markup);
+ Printf("%s", modules_res.data());
+ }
+
SymbolizedStack *frame = ent->frames;
for (int i = 0; frame && frame->info.address; frame = frame->next, i++) {
InternalScopedString res;
RenderFrame(&res, common_flags()->stack_trace_format, i,
frame->info.address, &frame->info,
common_flags()->symbolize_vs_style,
+ common_flags()->enable_symbolizer_markup,
common_flags()->strip_path_prefix);
Printf("%s\n", res.data());
}
>From 2863cef6656f0c222464a1f67a65f63f57a8ab72 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Villegas?= <andresvi at google.com>
Date: Fri, 8 Sep 2023 19:46:52 +0000
Subject: [PATCH 2/5] Fix review comments
---
compiler-rt/lib/hwasan/hwasan_report.cpp | 11 +++++------
.../sanitizer_stacktrace_printer.cpp | 9 ---------
.../sanitizer_stacktrace_printer.h | 3 ---
.../sanitizer_symbolizer_markup.cpp | 5 +++++
compiler-rt/lib/tsan/rtl/tsan_report.cpp | 15 +++++++++------
5 files changed, 19 insertions(+), 24 deletions(-)
diff --git a/compiler-rt/lib/hwasan/hwasan_report.cpp b/compiler-rt/lib/hwasan/hwasan_report.cpp
index 9e8fe03510213af..a91adbbad911325 100644
--- a/compiler-rt/lib/hwasan/hwasan_report.cpp
+++ b/compiler-rt/lib/hwasan/hwasan_report.cpp
@@ -30,6 +30,7 @@
#include "sanitizer_common/sanitizer_stackdepot.h"
#include "sanitizer_common/sanitizer_stacktrace_printer.h"
#include "sanitizer_common/sanitizer_symbolizer.h"
+#include "sanitizer_common/sanitizer_symbolizer_markup.h"
using namespace __sanitizer;
@@ -263,11 +264,11 @@ static void PrintStackAllocationsMarkup(StackAllocationsRingBuffer *sa) {
// frames for offline symbolization.
uptr frames = Min((uptr)flags()->stack_history_size, sa->size());
+
if (const ListOfModules *modules =
Symbolizer::GetOrInit()->GetRefreshedListOfModules()) {
InternalScopedString modules_res;
- RenderModules(&modules_res, modules,
- /*symbolizer_markup=*/ true);
+ RenderModulesMarkup(&modules_res, modules);
Printf("%s", modules_res.data());
}
@@ -280,8 +281,6 @@ static void PrintStackAllocationsMarkup(StackAllocationsRingBuffer *sa) {
break;
uptr pc_mask = (1ULL << 48) - 1;
uptr pc = record & pc_mask;
- frame_desc.append(" record_addr:0x%zx record:0x%zx",
- reinterpret_cast<uptr>(record_addr), record);
if (SymbolizedStack *frame = Symbolizer::GetOrInit()->SymbolizePC(pc)) {
RenderFrame(&frame_desc, "", 0, frame->info.address, &frame->info,
common_flags()->symbolize_vs_style,
@@ -464,9 +463,9 @@ void PrintAddressDescription(
? current_stack_allocations
: t->stack_allocations();
if (common_flags()->enable_symbolizer_markup) {
- PrintStackAllocations(sa, addr_tag, untagged_addr);
- } else {
PrintStackAllocationsMarkup(sa);
+ } else {
+ PrintStackAllocations(sa, addr_tag, untagged_addr);
}
num_descriptions_printed++;
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp
index b29e688b214c6ed..911d4f95810e6f3 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp
@@ -347,13 +347,4 @@ void RenderModuleLocation(InternalScopedString *buffer, const char *module,
buffer->append("+0x%zx)", offset);
}
-void RenderModules(InternalScopedString *buffer, const ListOfModules *modules,
- bool symbolizer_markup) {
- // Rendering all the modules is only needed for symbolizer markup
- if (!symbolizer_markup)
- return;
-
- RenderModulesMarkup(buffer, modules);
-}
-
} // namespace __sanitizer
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h
index f514feada1f59be..f2674cecaf6390b 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.h
@@ -70,9 +70,6 @@ void RenderData(InternalScopedString *buffer, const char *format,
const DataInfo *DI, bool symbolizer_markup,
const char *strip_path_prefix = "");
-void RenderModules(InternalScopedString *buffer, const ListOfModules *modules,
- bool symbolizer_markup);
-
} // namespace __sanitizer
#endif // SANITIZER_STACKTRACE_PRINTER_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
index a96bcb0e88b31c4..c8473b614e7e117 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
@@ -14,6 +14,7 @@
#include "sanitizer_symbolizer_markup.h"
#include "sanitizer_common.h"
+#include "sanitizer_internal_defs.h"
#include "sanitizer_libc.h"
#include "sanitizer_platform.h"
#include "sanitizer_stacktrace.h"
@@ -112,7 +113,11 @@ void RenderModulesMarkup(InternalScopedString *buffer,
renderedModules.push_back({});
RenderedModule &curModule = renderedModules.back();
curModule.full_name = internal_strdup(module.full_name());
+
+ // kModuleUUIDSize is the size of curModule.uuid
+ CHECK_GE(kModuleUUIDSize, module.uuid_size());
internal_memcpy(curModule.uuid, module.uuid(), module.uuid_size());
+
curModule.base_address = module.base_address();
}
}
diff --git a/compiler-rt/lib/tsan/rtl/tsan_report.cpp b/compiler-rt/lib/tsan/rtl/tsan_report.cpp
index c31b30d98ae34b7..0579fadb27caae9 100644
--- a/compiler-rt/lib/tsan/rtl/tsan_report.cpp
+++ b/compiler-rt/lib/tsan/rtl/tsan_report.cpp
@@ -12,10 +12,12 @@
#include "tsan_report.h"
#include "tsan_platform.h"
#include "tsan_rtl.h"
+
#include "sanitizer_common/sanitizer_file.h"
#include "sanitizer_common/sanitizer_placement_new.h"
#include "sanitizer_common/sanitizer_report_decorator.h"
#include "sanitizer_common/sanitizer_stacktrace_printer.h"
+#include "sanitizer_common/sanitizer_symbolizer_markup.h"
namespace __tsan {
@@ -104,12 +106,13 @@ void PrintStack(const ReportStack *ent) {
return;
}
- if (const ListOfModules *modules =
- Symbolizer::GetOrInit()->GetRefreshedListOfModules()) {
- InternalScopedString modules_res;
- RenderModules(&modules_res, modules,
- common_flags()->enable_symbolizer_markup);
- Printf("%s", modules_res.data());
+ if (common_flags()->enable_symbolizer_markup) {
+ if (const ListOfModules *modules =
+ Symbolizer::GetOrInit()->GetRefreshedListOfModules()) {
+ InternalScopedString modules_res;
+ RenderModulesMarkup(&modules_res, modules);
+ Printf("%s", modules_res.data());
+ }
}
SymbolizedStack *frame = ent->frames;
>From 00051aaeccdf291b4b7fc3990f8516c5f2c31c4c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Villegas?= <andresvi at google.com>
Date: Tue, 12 Sep 2023 16:59:57 +0000
Subject: [PATCH 3/5] Add test for symbolizer markup
---
.../sanitizer_stacktrace_libcdep.cpp | 53 ++++++++++---------
.../sanitizer_symbolizer_markup.cpp | 9 +---
.../sanitizer_symbolizer_markup.h | 4 +-
.../sanitizer_symbolizer_posix_libcdep.cpp | 3 +-
.../sanitizer_stacktrace_printer_test.cpp | 9 ++++
.../use-after-free-symbolizer-markup.cpp | 18 +++++++
6 files changed, 60 insertions(+), 36 deletions(-)
create mode 100644 compiler-rt/test/asan/TestCases/Linux/use-after-free-symbolizer-markup.cpp
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp
index 6a6da22c2e3e12e..25104a1da0ef799 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp
@@ -12,7 +12,6 @@
#include "sanitizer_common.h"
#include "sanitizer_flags.h"
-#include "sanitizer_placement_new.h"
#include "sanitizer_stacktrace.h"
#include "sanitizer_stacktrace_printer.h"
#include "sanitizer_symbolizer.h"
@@ -28,10 +27,10 @@ class StackTraceTextPrinter {
InternalScopedString *output,
InternalScopedString *dedup_token)
: stack_trace_fmt_(stack_trace_fmt),
- dedup_token_(dedup_token),
- symbolize_(RenderNeedsSymbolization(stack_trace_fmt, false)),
frame_delimiter_(frame_delimiter),
- output_(output) {}
+ output_(output),
+ dedup_token_(dedup_token),
+ symbolize_(RenderNeedsSymbolization(stack_trace_fmt, false)){}
bool ProcessAddressFrames(uptr pc) {
SymbolizedStack *frames = symbolize_
@@ -72,20 +71,18 @@ class StackTraceTextPrinter {
}
const char *stack_trace_fmt_;
+ const char frame_delimiter_;
int dedup_frames_ = common_flags()->dedup_token_length;
- InternalScopedString *dedup_token_;
- const bool symbolize_ = false;
-
- protected:
uptr frame_num_ = 0;
- const char frame_delimiter_;
InternalScopedString *output_;
+ InternalScopedString *dedup_token_;
+ const bool symbolize_ = false;
};
-class StackTraceMarkupPrinter : public StackTraceTextPrinter {
+class StackTraceMarkupPrinter {
public:
StackTraceMarkupPrinter(InternalScopedString *output)
- : StackTraceTextPrinter("", '\n', output, nullptr){};
+ : output_(output) {}
bool ProcessAddressFrames(uptr pc) {
SymbolizedStack *frames = Symbolizer::GetOrInit()->SymbolizePC(pc);
@@ -106,11 +103,15 @@ class StackTraceMarkupPrinter : public StackTraceTextPrinter {
common_flags()->strip_path_prefix);
if (prev_len != output_->length())
- output_->append("%c", frame_delimiter_);
+ output_->append("%c", '\n');
}
frames->ClearAll();
return true;
}
+
+ private:
+ InternalScopedString *output_;
+ uptr frame_num_ = 0;
};
static void CopyStringToBuffer(const InternalScopedString &str, char *out_buf,
@@ -130,12 +131,11 @@ void StackTrace::PrintTo(InternalScopedString *output) const {
CHECK(output);
InternalScopedString dedup_token;
- StackTraceTextPrinter printer =
- common_flags()->enable_symbolizer_markup
- ? StackTraceMarkupPrinter(output)
- : StackTraceTextPrinter(common_flags()->stack_trace_format, '\n',
- output, &dedup_token);
+ StackTraceMarkupPrinter markup_printer(output);
+ StackTraceTextPrinter text_printer(common_flags()->stack_trace_format, '\n',
+ output, &dedup_token);
+
if (trace == nullptr || size == 0) {
output->append(" <empty stack>\n\n");
return;
@@ -145,7 +145,10 @@ void StackTrace::PrintTo(InternalScopedString *output) const {
// PCs in stack traces are actually the return addresses, that is,
// addresses of the next instructions after the call.
uptr pc = GetPreviousInstructionPc(trace[i]);
- CHECK(printer.ProcessAddressFrames(pc));
+ bool result = common_flags()->enable_symbolizer_markup ?
+ markup_printer.ProcessAddressFrames(pc) :
+ text_printer.ProcessAddressFrames(pc);
+ CHECK(result);
}
// Always add a trailing empty line after stack trace.
@@ -233,12 +236,14 @@ void __sanitizer_symbolize_pc(uptr pc, const char *fmt, char *out_buf,
pc = StackTrace::GetPreviousInstructionPc(pc);
InternalScopedString output;
- StackTraceTextPrinter printer =
- common_flags()->enable_symbolizer_markup
- ? StackTraceMarkupPrinter(&output)
- : StackTraceTextPrinter(fmt, '\0', &output, nullptr);
-
- if (!printer.ProcessAddressFrames(pc)) {
+ StackTraceMarkupPrinter markup_printer(&output);
+ StackTraceTextPrinter text_printer(fmt, '\0', &output, nullptr);
+
+ bool result = common_flags()->enable_symbolizer_markup ?
+ markup_printer.ProcessAddressFrames(pc) :
+ text_printer.ProcessAddressFrames(pc);
+
+ if (!result) {
output.clear();
output.append("<can't symbolize>");
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
index c8473b614e7e117..f20084084ab937c 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
@@ -95,8 +95,7 @@ void RenderModulesMarkup(InternalScopedString *buffer,
}
buffer->append("}}}\n");
- const auto ranges = module.ranges();
- for (const auto &range : ranges) {
+ for (const auto &range : module.ranges()) {
buffer->append("{{{mmap:%p:%p:load:%d:r", range.beg,
range.end - range.beg, renderedModules.size());
if (range.writable)
@@ -122,10 +121,6 @@ void RenderModulesMarkup(InternalScopedString *buffer,
}
}
-MarkupSymbolizer *MarkupSymbolizer::get(LowLevelAllocator *alloc) {
- return new (*alloc) MarkupSymbolizer();
-}
-
bool MarkupSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
char buffer[kFormatFunctionMax];
internal_snprintf(buffer, sizeof(buffer), kFormatFunction, addr);
@@ -227,7 +222,7 @@ void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
Symbolizer *Symbolizer::PlatformInit() {
IntrusiveList<SymbolizerTool> tools;
- SymbolizerTool *tool = MarkupSymbolizer::get(&symbolizer_allocator_);
+ SymbolizerTool *tool = new(symbolizer_allocator_) MarkupSymbolizer();
tools.push_back(tool);
return new (symbolizer_allocator_) Symbolizer(tools);
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h
index a09278c30bbd216..15a4493e15eae7b 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h
@@ -31,8 +31,6 @@ namespace __sanitizer {
class MarkupSymbolizer final : public SymbolizerTool {
public:
- static MarkupSymbolizer *get(LowLevelAllocator *alloc);
-
// This is used in some places for suppression checking, which we
// don't really support for Fuchsia. It's also used in UBSan to
// identify a PC location to a function name, so we always fill in
@@ -66,4 +64,4 @@ void RenderFrameMarkup(InternalScopedString *, const char *, int, uptr,
void RenderModulesMarkup(InternalScopedString *, const ListOfModules *);
} // namespace __sanitizer
-#endif // SANITIZER_SYMBOLIZER_MARKUP_H
\ No newline at end of file
+#endif // SANITIZER_SYMBOLIZER_MARKUP_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
index b0832b638db5228..b3712f841ba7e36 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
@@ -473,8 +473,7 @@ static void ChooseSymbolizerTools(IntrusiveList<SymbolizerTool> *list,
}
if (common_flags()->enable_symbolizer_markup) {
VReport(2, "Using symbolizer markup.\n");
- SymbolizerTool *tool = MarkupSymbolizer::get(allocator);
- list->push_back(tool);
+ list->push_back(new(*allocator) MarkupSymbolizer());
return;
}
if (IsAllocatorOutOfMemory()) {
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cpp b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cpp
index 96c7571574f4c9b..5189161103ae4f7 100644
--- a/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cpp
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_stacktrace_printer_test.cpp
@@ -196,6 +196,15 @@ TEST(SanitizerStacktracePrinter, RenderFrame) {
str.clear();
info.Clear();
+
+ // Test for symbolizer markup
+ info.address = 0xaa00;
+ RenderFrame(&str, "", frame_no, info.address, &info, false, true);
+ EXPECT_NE(nullptr, internal_strstr(str.data(), "{{{bt:42:"));
+ EXPECT_NE(nullptr, internal_strstr(str.data(), "aa00"));
+ EXPECT_NE(nullptr, internal_strstr(str.data(), "}}}"));
+ str.clear();
+ info.Clear();
}
} // namespace __sanitizer
diff --git a/compiler-rt/test/asan/TestCases/Linux/use-after-free-symbolizer-markup.cpp b/compiler-rt/test/asan/TestCases/Linux/use-after-free-symbolizer-markup.cpp
new file mode 100644
index 000000000000000..83d65d71dc7abad
--- /dev/null
+++ b/compiler-rt/test/asan/TestCases/Linux/use-after-free-symbolizer-markup.cpp
@@ -0,0 +1,18 @@
+// Test that verify that a asan produces valid symbolizer markup when enabled.
+// It does not test that asan works correctly.
+// RUN: %clangxx_asan -O1 %s -o %t
+// RUN: env ASAN_OPTIONS=enable_symbolizer_markup=1 not %run %t 2>&1 | FileCheck %s
+// REQUIRES: linux
+
+#include <stdlib.h>
+int main() {
+ char *x = (char*)malloc(10 * sizeof(char));
+ free(x);
+ return x[5];
+}
+// COM: For element syntax see: https://llvm.org/docs/SymbolizerMarkupFormat.html
+// COM: OPEN is {{{ and CLOSE is }}}
+// CHECK: [[OPEN:{{{]]reset[[CLOSE:}}}]]
+// CHECK: [[OPEN]]module:[[MOD_ID:[0-9]+]]:{{.+}}:elf:{{[0-9a-fA-F]+}}[[CLOSE]]
+// CHECK: [[OPEN]]mmap:{{0x[0-9a-fA-F]+:0x[0-9a-fA-F]+}}:load:[[MOD_ID]]:{{r[wx]{0,2}:0x[0-9a-fA-F]+}}[[CLOSE]]
+// CHECK: [[OPEN]]bt:{{[0-9]+}}:0x{{[0-9a-fA-F]+}}[[CLOSE]]
>From 4d28dd32143ead2c75ed002e98696b3f120fa496 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Villegas?= <andresvi at google.com>
Date: Tue, 12 Sep 2023 18:35:49 +0000
Subject: [PATCH 4/5] Remove unnecesary parameters and style changes
---
.../sanitizer_stacktrace_printer.cpp | 5 ++--
.../sanitizer_symbolizer_markup.cpp | 25 ++++++++-----------
.../sanitizer_symbolizer_markup.h | 11 ++++----
3 files changed, 17 insertions(+), 24 deletions(-)
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp
index 911d4f95810e6f3..fd4e206c2958817 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp
@@ -145,8 +145,7 @@ void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
uptr address, const AddressInfo *info, bool vs_style,
bool symbolizer_markup, const char *strip_path_prefix) {
if (symbolizer_markup) {
- RenderFrameMarkup(buffer, format, frame_no, address, info, vs_style,
- strip_path_prefix);
+ RenderFrameMarkup(buffer, frame_no, address);
return;
}
// info will be null in the case where symbolization is not needed for the
@@ -286,7 +285,7 @@ void RenderData(InternalScopedString *buffer, const char *format,
const DataInfo *DI, bool symbolizer_markup,
const char *strip_path_prefix) {
if (symbolizer_markup) {
- RenderDataMarkup(buffer, format, DI, strip_path_prefix);
+ RenderDataMarkup(buffer, DI);
return;
}
for (const char *p = format; *p != '\0'; p++) {
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
index f20084084ab937c..c91d20184d967da 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
@@ -23,17 +23,14 @@
namespace __sanitizer {
-void RenderDataMarkup(InternalScopedString *buffer, const char *format,
- const DataInfo *DI, const char *strip_path_prefix) {
+void RenderDataMarkup(InternalScopedString *buffer, const DataInfo *DI) {
buffer->append(kFormatData, DI->start);
}
-bool RenderNeedsSymbolizationMarkup(const char *format) { return false; }
+bool RenderNeedsSymbolizationMarkup() { return false; }
-void RenderFrameMarkup(InternalScopedString *buffer, const char *format,
- int frame_no, uptr address, const AddressInfo *info,
- bool vs_style, const char *strip_path_prefix) {
- CHECK(!RenderNeedsSymbolizationMarkup(format));
+void RenderFrameMarkup(InternalScopedString *buffer, int frame_no, uptr address) {
+ CHECK(!RenderNeedsSymbolizationMarkup());
buffer->append(kFormatFrame, frame_no, address);
}
@@ -205,19 +202,18 @@ bool Symbolizer::SymbolizeData(uptr addr, DataInfo *info) {
void RenderData(InternalScopedString *buffer, const char *format,
const DataInfo *DI, bool symbolizer_markup,
const char *strip_path_prefix) {
- RenderDataMarkup(buffer, format, DI, strip_path_prefix);
+ RenderDataMarkup(buffer, DI);
}
bool RenderNeedsSymbolization(const char *format, bool symbolizer_markup) {
- return RenderNeedsSymbolizationMarkup(format);
+ return RenderNeedsSymbolizationMarkup();
}
// We don't support the stack_trace_format flag at all.
void RenderFrame(InternalScopedString *buffer, const char *format, int frame_no,
uptr address, const AddressInfo *info, bool vs_style,
const char *strip_path_prefix) {
- RenderFrameMarkup(buffer, format, frame_no, address, info, vs_style,
- strip_path_prefix);
+ RenderFrameMarkup(buffer, frame_no, address);
}
Symbolizer *Symbolizer::PlatformInit() {
@@ -234,7 +230,7 @@ void ReportDeadlySignal(const SignalContext &sig, u32 tid,
UnwindSignalStackCallbackType unwind,
const void *unwind_context) {}
-# if SANITIZER_CAN_SLOW_UNWIND
+#if SANITIZER_CAN_SLOW_UNWIND
struct UnwindTraceArg {
BufferedStackTrace *stack;
u32 max_depth;
@@ -244,8 +240,7 @@ _Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context *ctx, void *param) {
UnwindTraceArg *arg = static_cast<UnwindTraceArg *>(param);
CHECK_LT(arg->stack->size, arg->max_depth);
uptr pc = _Unwind_GetIP(ctx);
- if (pc < PAGE_SIZE)
- return _URC_NORMAL_STOP;
+ if (pc < PAGE_SIZE) return _URC_NORMAL_STOP;
arg->stack->trace_buffer[arg->stack->size++] = pc;
return (arg->stack->size == arg->max_depth ? _URC_NORMAL_STOP
: _URC_NO_REASON);
@@ -271,7 +266,7 @@ void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {
CHECK_GE(max_depth, 2);
UNREACHABLE("signal context doesn't exist");
}
-# endif // SANITIZER_CAN_SLOW_UNWIND
+#endif // SANITIZER_CAN_SLOW_UNWIND
#endif // SANITIZER_SYMBOLIZER_MARKUP
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h
index 15a4493e15eae7b..1ad85572c8c96fa 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h
@@ -52,16 +52,15 @@ class MarkupSymbolizer final : public SymbolizerTool {
};
// We ignore the format argument to __sanitizer_symbolize_global.
-void RenderDataMarkup(InternalScopedString *, const char *, const DataInfo *,
- const char *);
+void RenderDataMarkup(InternalScopedString *buffer, const DataInfo *DI);
-bool RenderNeedsSymbolizationMarkup(const char *format);
+bool RenderNeedsSymbolizationMarkup();
// We don't support the stack_trace_format flag at all.
-void RenderFrameMarkup(InternalScopedString *, const char *, int, uptr,
- const AddressInfo *, bool, const char *);
+void RenderFrameMarkup(InternalScopedString *buffer, int frame_no, uptr address);
-void RenderModulesMarkup(InternalScopedString *, const ListOfModules *);
+void RenderModulesMarkup(InternalScopedString *buffer, const ListOfModules *modules);
} // namespace __sanitizer
#endif // SANITIZER_SYMBOLIZER_MARKUP_H
+
>From bd9e559ef080b2ceadf96cf40a8c206ab8153387 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Villegas?= <andresvi at google.com>
Date: Tue, 12 Sep 2023 19:25:35 +0000
Subject: [PATCH 5/5] Add style changes
---
.../sanitizer_common/sanitizer_symbolizer_markup.cpp | 10 ++++++----
.../lib/sanitizer_common/sanitizer_symbolizer_markup.h | 7 ++++---
2 files changed, 10 insertions(+), 7 deletions(-)
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
index c91d20184d967da..110fa8f0c74afa9 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.cpp
@@ -29,7 +29,8 @@ void RenderDataMarkup(InternalScopedString *buffer, const DataInfo *DI) {
bool RenderNeedsSymbolizationMarkup() { return false; }
-void RenderFrameMarkup(InternalScopedString *buffer, int frame_no, uptr address) {
+void RenderFrameMarkup(InternalScopedString *buffer, int frame_no,
+ uptr address) {
CHECK(!RenderNeedsSymbolizationMarkup());
buffer->append(kFormatFrame, frame_no, address);
}
@@ -230,7 +231,7 @@ void ReportDeadlySignal(const SignalContext &sig, u32 tid,
UnwindSignalStackCallbackType unwind,
const void *unwind_context) {}
-#if SANITIZER_CAN_SLOW_UNWIND
+# if SANITIZER_CAN_SLOW_UNWIND
struct UnwindTraceArg {
BufferedStackTrace *stack;
u32 max_depth;
@@ -240,7 +241,8 @@ _Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context *ctx, void *param) {
UnwindTraceArg *arg = static_cast<UnwindTraceArg *>(param);
CHECK_LT(arg->stack->size, arg->max_depth);
uptr pc = _Unwind_GetIP(ctx);
- if (pc < PAGE_SIZE) return _URC_NORMAL_STOP;
+ if (pc < PAGE_SIZE)
+ return _URC_NORMAL_STOP;
arg->stack->trace_buffer[arg->stack->size++] = pc;
return (arg->stack->size == arg->max_depth ? _URC_NORMAL_STOP
: _URC_NO_REASON);
@@ -266,7 +268,7 @@ void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {
CHECK_GE(max_depth, 2);
UNREACHABLE("signal context doesn't exist");
}
-#endif // SANITIZER_CAN_SLOW_UNWIND
+# endif // SANITIZER_CAN_SLOW_UNWIND
#endif // SANITIZER_SYMBOLIZER_MARKUP
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h
index 1ad85572c8c96fa..5b0636c45f53931 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_markup.h
@@ -57,10 +57,11 @@ void RenderDataMarkup(InternalScopedString *buffer, const DataInfo *DI);
bool RenderNeedsSymbolizationMarkup();
// We don't support the stack_trace_format flag at all.
-void RenderFrameMarkup(InternalScopedString *buffer, int frame_no, uptr address);
+void RenderFrameMarkup(InternalScopedString *buffer, int frame_no,
+ uptr address);
-void RenderModulesMarkup(InternalScopedString *buffer, const ListOfModules *modules);
+void RenderModulesMarkup(InternalScopedString *buffer,
+ const ListOfModules *modules);
} // namespace __sanitizer
#endif // SANITIZER_SYMBOLIZER_MARKUP_H
-
More information about the cfe-commits
mailing list