blob: b2a08165dd6ca211f39f2cbdbf53346783ab24e4 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
//===-- Diagnostics.cpp ---------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/Diagnostics.h"
#include "lldb/Utility/LLDBAssert.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/raw_ostream.h"
#include <optional>
using namespace lldb_private;
using namespace lldb;
using namespace llvm;
static constexpr size_t g_num_log_messages = 100;
void Diagnostics::Initialize() {
lldbassert(!InstanceImpl() && "Already initialized.");
InstanceImpl().emplace();
}
void Diagnostics::Terminate() {
lldbassert(InstanceImpl() && "Already terminated.");
InstanceImpl().reset();
}
bool Diagnostics::Enabled() { return InstanceImpl().operator bool(); }
std::optional<Diagnostics> &Diagnostics::InstanceImpl() {
static std::optional<Diagnostics> g_diagnostics;
return g_diagnostics;
}
Diagnostics &Diagnostics::Instance() { return *InstanceImpl(); }
Diagnostics::Diagnostics() : m_log_handler(g_num_log_messages) {}
Diagnostics::~Diagnostics() {}
Diagnostics::CallbackID Diagnostics::AddCallback(Callback callback) {
std::lock_guard<std::mutex> guard(m_callbacks_mutex);
CallbackID id = m_callback_id++;
m_callbacks.emplace_back(id, callback);
return id;
}
void Diagnostics::RemoveCallback(CallbackID id) {
std::lock_guard<std::mutex> guard(m_callbacks_mutex);
llvm::erase_if(m_callbacks,
[id](const CallbackEntry &e) { return e.id == id; });
}
bool Diagnostics::Dump(raw_ostream &stream) {
Expected<FileSpec> diagnostics_dir = CreateUniqueDirectory();
if (!diagnostics_dir) {
stream << "unable to create diagnostic dir: "
<< toString(diagnostics_dir.takeError()) << '\n';
return false;
}
return Dump(stream, *diagnostics_dir);
}
bool Diagnostics::Dump(raw_ostream &stream, const FileSpec &dir) {
stream << "LLDB diagnostics will be written to " << dir.GetPath() << "\n";
stream << "Please include the directory content when filing a bug report\n";
if (Error error = Create(dir)) {
stream << toString(std::move(error)) << '\n';
return false;
}
return true;
}
llvm::Expected<FileSpec> Diagnostics::CreateUniqueDirectory() {
SmallString<128> diagnostics_dir;
std::error_code ec =
sys::fs::createUniqueDirectory("diagnostics", diagnostics_dir);
if (ec)
return errorCodeToError(ec);
return FileSpec(diagnostics_dir.str());
}
Error Diagnostics::Create(const FileSpec &dir) {
if (Error err = DumpDiangosticsLog(dir))
return err;
for (CallbackEntry e : m_callbacks) {
if (Error err = e.callback(dir))
return err;
}
return Error::success();
}
llvm::Error Diagnostics::DumpDiangosticsLog(const FileSpec &dir) const {
FileSpec log_file = dir.CopyByAppendingPathComponent("diagnostics.log");
std::error_code ec;
llvm::raw_fd_ostream stream(log_file.GetPath(), ec, llvm::sys::fs::OF_None);
if (ec)
return errorCodeToError(ec);
m_log_handler.Dump(stream);
return Error::success();
}
void Diagnostics::Report(llvm::StringRef message) {
m_log_handler.Emit(message);
}
|
