12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/Twine.h"
14 #include "llvm/ADT/iterator.h"
16 #include "llvm/Support/Casting.h"
17 #include "llvm/Support/Chrono.h"
18 #include "llvm/Support/ManagedStatic.h"
19 #include "llvm/Support/Path.h"
20 #include "llvm/Support/Signals.h"
21 #include "llvm/Support/Threading.h"
22 #include "llvm/Support/raw_ostream.h"
46 const Log::ChannelMap::value_type &entry,
47 llvm::function_ref<
void(llvm::StringRef, llvm::StringRef)> lambda) {
48 lambda(
"all",
"all available logging categories");
49 lambda(
"default",
"default set of logging categories");
50 for (
const auto &category : entry.second.m_channel.categories)
51 lambda(category.name, category.description);
55 const ChannelMap::value_type &entry) {
56 stream << llvm::formatv(
"Logging categories for '{0}':\n", entry.first());
58 [&stream](llvm::StringRef name, llvm::StringRef description) {
59 stream << llvm::formatv(
" {0} - {1}\n", name, description);
64 const ChannelMap::value_type &entry,
65 llvm::ArrayRef<const char *> categories) {
66 bool list_categories =
false;
68 for (
const char *category : categories) {
69 if (llvm::StringRef(
"all").equals_insensitive(category)) {
70 flags |= std::numeric_limits<Log::MaskType>::max();
73 if (llvm::StringRef(
"default").equals_insensitive(category)) {
74 flags |= entry.second.m_channel.default_flags;
77 auto cat = llvm::find_if(entry.second.m_channel.categories,
79 return c.name.equals_insensitive(category);
81 if (cat != entry.second.m_channel.categories.end()) {
85 stream << llvm::formatv(
"error: unrecognized log category '{0}'\n",
87 list_categories =
true;
94 void Log::Enable(
const std::shared_ptr<LogHandler> &handler_sp,
96 llvm::sys::ScopedWriter lock(
m_mutex);
100 m_options.store(options, std::memory_order_relaxed);
107 llvm::sys::ScopedWriter lock(
m_mutex);
109 MaskType mask =
m_mask.fetch_and(~flags, std::memory_order_relaxed);
110 if (!(mask & ~flags)) {
117 llvm::sys::ScopedReader lock(
m_mutex);
119 llvm::dyn_cast_or_null<RotatingLogHandler>(
m_handler.get())) {
120 handler->Dump(output_stream);
127 return m_options.load(std::memory_order_relaxed);
131 return m_mask.load(std::memory_order_relaxed);
140 va_start(args, format);
149 llvm::SmallString<64> FinalMessage;
150 llvm::raw_svector_ostream
Stream(FinalMessage);
153 llvm::SmallString<64> Content;
156 Stream << Content <<
"\n";
164 va_start(args, format);
170 llvm::SmallString<64> Content;
173 Printf(
"error: %s", Content.c_str());
182 va_start(args, format);
189 llvm::SmallString<64> Content;
191 va_start(args, format);
195 Printf(
"warning: %s", Content.c_str());
200 assert(iter.second ==
true);
207 iter->second.Disable(std::numeric_limits<MaskType>::max());
212 uint32_t log_options, llvm::StringRef channel,
213 llvm::ArrayRef<const char *> categories,
214 llvm::raw_ostream &error_stream) {
217 error_stream << llvm::formatv(
"Invalid log channel '{0}'.\n", channel);
221 ? iter->second.m_channel.default_flags
222 :
GetFlags(error_stream, *iter, categories);
223 iter->second.Enable(log_handler_sp, log_options, flags);
228 llvm::ArrayRef<const char *> categories,
229 llvm::raw_ostream &error_stream) {
232 error_stream << llvm::formatv(
"Invalid log channel '{0}'.\n", channel);
236 ? std::numeric_limits<MaskType>::max()
237 :
GetFlags(error_stream, *iter, categories);
238 iter->second.Disable(flags);
243 llvm::raw_ostream &output_stream,
244 llvm::raw_ostream &error_stream) {
247 error_stream << llvm::formatv(
"Invalid log channel '{0}'.\n", channel);
250 if (!iter->second.Dump(output_stream)) {
251 error_stream << llvm::formatv(
252 "log channel '{0}' does not support dumping.\n", channel);
259 llvm::raw_ostream &stream) {
262 stream << llvm::formatv(
"Invalid log channel '{0}'.\n", channel);
271 entry.second.Disable(std::numeric_limits<MaskType>::max());
275 llvm::StringRef channel,
276 llvm::function_ref<
void(llvm::StringRef, llvm::StringRef)> lambda) {
285 std::vector<llvm::StringRef> result;
287 result.push_back(channel.first());
293 stream <<
"No logging channels are currently registered.\n";
306 llvm::StringRef
function) {
311 OS << ++g_sequence_id <<
" ";
315 auto now = std::chrono::duration<double>(
316 std::chrono::system_clock::now().time_since_epoch());
317 OS << llvm::formatv(
"{0:f9} ", now.count());
322 OS << llvm::formatv(
"[{0,0+4}/{1,0+4}] ", getpid(),
323 llvm::get_threadid());
327 llvm::SmallString<32> thread_name;
328 llvm::get_thread_name(thread_name);
330 llvm::SmallString<12> format_str;
331 llvm::raw_svector_ostream format_os(format_str);
332 format_os <<
"{0,-" << llvm::alignTo<16>(thread_name.size()) <<
"} ";
333 OS << llvm::formatv(format_str.c_str(), thread_name);
337 llvm::sys::PrintStackTrace(
OS);
340 (!file.empty() || !
function.empty())) {
341 file = llvm::sys::path::filename(file).take_front(40);
342 function =
function.take_front(40);
343 OS << llvm::formatv(
"{0,-60:60} ", (file +
":" +
function).str());
357 const llvm::formatv_object_base &payload) {
359 llvm::raw_string_ostream
message(message_string);
367 : m_stream(fd, should_close, buffer_size == 0) {
369 m_stream.SetBufferSize(buffer_size);
375 std::lock_guard<std::mutex> guard(
m_mutex);
381 std::lock_guard<std::mutex> guard(
m_mutex);
390 : m_callback(callback), m_baton(baton) {}
397 : m_messages(std::make_unique<std::
string[]>(size)), m_size(size) {}
400 std::lock_guard<std::mutex> guard(
m_mutex);
418 std::lock_guard<std::mutex> guard(
m_mutex);
421 for (
size_t i = start_idx; i < stop_idx; ++i) {