1 //===-- sanitizer_symbolize.cpp ---------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Implementation of weak hooks from sanitizer_symbolizer_posix_libcdep.cpp. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include <stdio.h> 14 15 #include <string> 16 17 #include "llvm/DebugInfo/Symbolize/DIPrinter.h" 18 #include "llvm/DebugInfo/Symbolize/Symbolize.h" 19 20 static llvm::symbolize::LLVMSymbolizer *Symbolizer = nullptr; 21 static bool Demangle = true; 22 static bool InlineFrames = true; 23 24 static llvm::symbolize::LLVMSymbolizer *getDefaultSymbolizer() { 25 if (Symbolizer) 26 return Symbolizer; 27 llvm::symbolize::LLVMSymbolizer::Options Opts; 28 Opts.Demangle = Demangle; 29 Symbolizer = new llvm::symbolize::LLVMSymbolizer(Opts); 30 return Symbolizer; 31 } 32 33 static llvm::symbolize::PrinterConfig getDefaultPrinterConfig() { 34 llvm::symbolize::PrinterConfig Config; 35 Config.Pretty = false; 36 Config.Verbose = false; 37 Config.PrintFunctions = true; 38 Config.PrintAddress = false; 39 Config.SourceContextLines = 0; 40 return Config; 41 } 42 43 namespace __sanitizer { 44 int internal_snprintf(char *buffer, unsigned long length, const char *format, 45 ...); 46 } // namespace __sanitizer 47 48 extern "C" { 49 50 typedef uint64_t u64; 51 52 bool __sanitizer_symbolize_code(const char *ModuleName, uint64_t ModuleOffset, 53 char *Buffer, int MaxLength) { 54 std::string Result; 55 { 56 llvm::raw_string_ostream OS(Result); 57 llvm::symbolize::PrinterConfig Config = getDefaultPrinterConfig(); 58 llvm::symbolize::Request Request{ModuleName, ModuleOffset}; 59 auto Printer = 60 std::make_unique<llvm::symbolize::LLVMPrinter>(OS, OS, Config); 61 62 // TODO: it is neccessary to set proper SectionIndex here. 63 // object::SectionedAddress::UndefSection works for only absolute addresses. 64 if (InlineFrames) { 65 auto ResOrErr = getDefaultSymbolizer()->symbolizeInlinedCode( 66 ModuleName, 67 {ModuleOffset, llvm::object::SectionedAddress::UndefSection}); 68 Printer->print(Request, 69 ResOrErr ? ResOrErr.get() : llvm::DIInliningInfo()); 70 } else { 71 auto ResOrErr = getDefaultSymbolizer()->symbolizeCode( 72 ModuleName, 73 {ModuleOffset, llvm::object::SectionedAddress::UndefSection}); 74 Printer->print(Request, ResOrErr ? ResOrErr.get() : llvm::DILineInfo()); 75 } 76 } 77 return __sanitizer::internal_snprintf(Buffer, MaxLength, "%s", 78 Result.c_str()) < MaxLength; 79 } 80 81 bool __sanitizer_symbolize_data(const char *ModuleName, uint64_t ModuleOffset, 82 char *Buffer, int MaxLength) { 83 std::string Result; 84 { 85 llvm::symbolize::PrinterConfig Config = getDefaultPrinterConfig(); 86 llvm::raw_string_ostream OS(Result); 87 llvm::symbolize::Request Request{ModuleName, ModuleOffset}; 88 auto Printer = 89 std::make_unique<llvm::symbolize::LLVMPrinter>(OS, OS, Config); 90 91 // TODO: it is neccessary to set proper SectionIndex here. 92 // object::SectionedAddress::UndefSection works for only absolute addresses. 93 auto ResOrErr = getDefaultSymbolizer()->symbolizeData( 94 ModuleName, 95 {ModuleOffset, llvm::object::SectionedAddress::UndefSection}); 96 Printer->print(Request, ResOrErr ? ResOrErr.get() : llvm::DIGlobal()); 97 } 98 return __sanitizer::internal_snprintf(Buffer, MaxLength, "%s", 99 Result.c_str()) < MaxLength; 100 } 101 102 void __sanitizer_symbolize_flush() { 103 if (Symbolizer) 104 Symbolizer->flush(); 105 } 106 107 int __sanitizer_symbolize_demangle(const char *Name, char *Buffer, 108 int MaxLength) { 109 std::string Result = 110 llvm::symbolize::LLVMSymbolizer::DemangleName(Name, nullptr); 111 return __sanitizer::internal_snprintf(Buffer, MaxLength, "%s", 112 Result.c_str()) < MaxLength 113 ? static_cast<int>(Result.size() + 1) 114 : 0; 115 } 116 117 bool __sanitizer_symbolize_set_demangle(bool Value) { 118 // Must be called before LLVMSymbolizer created. 119 if (Symbolizer) 120 return false; 121 Demangle = Value; 122 return true; 123 } 124 125 bool __sanitizer_symbolize_set_inline_frames(bool Value) { 126 InlineFrames = Value; 127 return true; 128 } 129 130 // Override __cxa_atexit and ignore callbacks. 131 // This prevents crashes in a configuration when the symbolizer 132 // is built into sanitizer runtime and consequently into the test process. 133 // LLVM libraries have some global objects destroyed during exit, 134 // so if the test process triggers any bugs after that, the symbolizer crashes. 135 // An example stack trace of such crash: 136 // 137 // #1 __cxa_throw 138 // #2 std::__u::__throw_system_error 139 // #3 std::__u::recursive_mutex::lock 140 // #4 __sanitizer_llvm::ManagedStaticBase::RegisterManagedStatic 141 // #5 __sanitizer_llvm::errorToErrorCode 142 // #6 __sanitizer_llvm::getFileAux 143 // #7 __sanitizer_llvm::MemoryBuffer::getFileOrSTDIN 144 // #10 __sanitizer_llvm::symbolize::LLVMSymbolizer::getOrCreateModuleInfo 145 // #13 __sanitizer::Symbolizer::SymbolizeData 146 // #14 __tsan::SymbolizeData 147 // #16 __tsan::ReportRace 148 // #18 __tsan_write4 149 // #19 race() () at test/tsan/atexit4.cpp 150 // #20 cxa_at_exit_wrapper 151 // #21 __cxa_finalize 152 // #22 __do_fini 153 // 154 // For the standalone llvm-symbolizer this does not hurt, 155 // we just don't destroy few global objects on exit. 156 int __cxa_atexit(void (*f)(void *a), void *arg, void *dso) { return 0; } 157 158 } // extern "C" 159