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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
//===-- SaveCoreOptions.cpp -------------------------------------*- C++ -*-===//
//
// 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/Symbol/SaveCoreOptions.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h"
using namespace lldb;
using namespace lldb_private;
Status SaveCoreOptions::SetPluginName(const char *name) {
Status error;
if (!name || !name[0]) {
m_plugin_name = std::nullopt;
return error;
}
if (!PluginManager::IsRegisteredObjectFilePluginName(name)) {
return Status::FromErrorStringWithFormat(
"plugin name '%s' is not a valid ObjectFile plugin name", name);
return error;
}
m_plugin_name = name;
return error;
}
void SaveCoreOptions::SetStyle(lldb::SaveCoreStyle style) { m_style = style; }
void SaveCoreOptions::SetOutputFile(FileSpec file) { m_file = file; }
std::optional<std::string> SaveCoreOptions::GetPluginName() const {
return m_plugin_name;
}
lldb::SaveCoreStyle SaveCoreOptions::GetStyle() const {
return m_style.value_or(lldb::eSaveCoreUnspecified);
}
const std::optional<lldb_private::FileSpec>
SaveCoreOptions::GetOutputFile() const {
return m_file;
}
Status SaveCoreOptions::SetProcess(lldb::ProcessSP process_sp) {
Status error;
if (!process_sp) {
ClearProcessSpecificData();
m_process_sp.reset();
return error;
}
if (!process_sp->IsValid()) {
error = Status::FromErrorString("Cannot assign an invalid process.");
return error;
}
// Don't clear any process specific data if the process is the same.
if (m_process_sp == process_sp)
return error;
ClearProcessSpecificData();
m_process_sp = process_sp;
return error;
}
Status SaveCoreOptions::AddThread(lldb::ThreadSP thread_sp) {
Status error;
if (!thread_sp) {
error = Status::FromErrorString("invalid thread");
return error;
}
if (m_process_sp) {
if (m_process_sp != thread_sp->GetProcess()) {
error = Status::FromErrorString(
"Cannot add a thread from a different process.");
return error;
}
} else {
m_process_sp = thread_sp->GetProcess();
}
m_threads_to_save.insert(thread_sp->GetID());
return error;
}
bool SaveCoreOptions::RemoveThread(lldb::ThreadSP thread_sp) {
return thread_sp && m_threads_to_save.erase(thread_sp->GetID()) > 0;
}
bool SaveCoreOptions::ShouldThreadBeSaved(lldb::tid_t tid) const {
// If the user specified no threads to save, then we save all threads.
if (m_threads_to_save.empty())
return true;
return m_threads_to_save.count(tid) > 0;
}
Status SaveCoreOptions::EnsureValidConfiguration(
lldb::ProcessSP process_sp) const {
Status error;
std::string error_str;
if (!m_threads_to_save.empty() && GetStyle() == lldb::eSaveCoreFull)
error_str += "Cannot save a full core with a subset of threads\n";
if (m_process_sp && m_process_sp != process_sp)
error_str += "Cannot save core for process using supplied core options. "
"Options were constructed targeting a different process. \n";
if (!error_str.empty())
error = Status(error_str);
return error;
}
void SaveCoreOptions::ClearProcessSpecificData() {
// Deliberately not following the formatter style here to indicate that
// this method will be expanded in the future.
m_threads_to_save.clear();
}
void SaveCoreOptions::Clear() {
m_file = std::nullopt;
m_plugin_name = std::nullopt;
m_style = std::nullopt;
m_threads_to_save.clear();
m_process_sp.reset();
}
|
