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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
//===-- SBSaveCoreOptions.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/API/SBSaveCoreOptions.h"
#include "lldb/API/SBMemoryRegionInfo.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Symbol/SaveCoreOptions.h"
#include "lldb/Target/ThreadCollection.h"
#include "lldb/Utility/Instrumentation.h"
#include "Utils.h"
using namespace lldb;
SBSaveCoreOptions::SBSaveCoreOptions() {
LLDB_INSTRUMENT_VA(this)
m_opaque_up = std::make_unique<lldb_private::SaveCoreOptions>();
}
SBSaveCoreOptions::SBSaveCoreOptions(const SBSaveCoreOptions &rhs) {
LLDB_INSTRUMENT_VA(this, rhs);
m_opaque_up = clone(rhs.m_opaque_up);
}
SBSaveCoreOptions::~SBSaveCoreOptions() = default;
const SBSaveCoreOptions &
SBSaveCoreOptions::operator=(const SBSaveCoreOptions &rhs) {
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_up = clone(rhs.m_opaque_up);
return *this;
}
SBError SBSaveCoreOptions::SetPluginName(const char *name) {
LLDB_INSTRUMENT_VA(this, name);
return SBError(m_opaque_up->SetPluginName(name));
}
void SBSaveCoreOptions::SetStyle(lldb::SaveCoreStyle style) {
LLDB_INSTRUMENT_VA(this, style);
m_opaque_up->SetStyle(style);
}
void SBSaveCoreOptions::SetOutputFile(lldb::SBFileSpec file_spec) {
LLDB_INSTRUMENT_VA(this, file_spec);
m_opaque_up->SetOutputFile(file_spec.ref());
}
const char *SBSaveCoreOptions::GetPluginName() const {
LLDB_INSTRUMENT_VA(this);
const auto name = m_opaque_up->GetPluginName();
if (!name)
return nullptr;
return lldb_private::ConstString(name.value()).GetCString();
}
SBFileSpec SBSaveCoreOptions::GetOutputFile() const {
LLDB_INSTRUMENT_VA(this);
const auto file_spec = m_opaque_up->GetOutputFile();
if (file_spec)
return SBFileSpec(file_spec.value());
return SBFileSpec();
}
lldb::SaveCoreStyle SBSaveCoreOptions::GetStyle() const {
LLDB_INSTRUMENT_VA(this);
return m_opaque_up->GetStyle();
}
SBError SBSaveCoreOptions::SetProcess(lldb::SBProcess process) {
LLDB_INSTRUMENT_VA(this, process);
return m_opaque_up->SetProcess(process.GetSP());
}
SBProcess SBSaveCoreOptions::GetProcess() {
LLDB_INSTRUMENT_VA(this);
return SBProcess(m_opaque_up->GetProcess());
}
SBError SBSaveCoreOptions::AddThread(lldb::SBThread thread) {
LLDB_INSTRUMENT_VA(this, thread);
return m_opaque_up->AddThread(thread.GetSP());
}
bool SBSaveCoreOptions::RemoveThread(lldb::SBThread thread) {
LLDB_INSTRUMENT_VA(this, thread);
return m_opaque_up->RemoveThread(thread.GetSP());
}
lldb::SBError
SBSaveCoreOptions::AddMemoryRegionToSave(const SBMemoryRegionInfo ®ion) {
LLDB_INSTRUMENT_VA(this, region);
// Currently add memory region can't fail, so we always return a success
// SBerror, but because these API's live forever, this is the most future
// proof thing to do.
m_opaque_up->AddMemoryRegionToSave(region.ref());
return SBError();
}
lldb::SBThreadCollection SBSaveCoreOptions::GetThreadsToSave() const {
LLDB_INSTRUMENT_VA(this);
lldb::ThreadCollectionSP threadcollection_sp =
std::make_shared<lldb_private::ThreadCollection>(
m_opaque_up->GetThreadsToSave());
return SBThreadCollection(threadcollection_sp);
}
void SBSaveCoreOptions::Clear() {
LLDB_INSTRUMENT_VA(this);
m_opaque_up->Clear();
}
uint64_t SBSaveCoreOptions::GetCurrentSizeInBytes(SBError &error) {
LLDB_INSTRUMENT_VA(this, error);
llvm::Expected<uint64_t> expected_bytes =
m_opaque_up->GetCurrentSizeInBytes();
if (!expected_bytes) {
error =
SBError(lldb_private::Status::FromError(expected_bytes.takeError()));
return 0;
}
// Clear the error, so if the clearer uses it we set it to success.
error.Clear();
return *expected_bytes;
}
lldb::SBMemoryRegionInfoList SBSaveCoreOptions::GetMemoryRegionsToSave() {
LLDB_INSTRUMENT_VA(this);
llvm::Expected<lldb_private::CoreFileMemoryRanges> memory_ranges =
m_opaque_up->GetMemoryRegionsToSave();
if (!memory_ranges) {
llvm::consumeError(memory_ranges.takeError());
return SBMemoryRegionInfoList();
}
SBMemoryRegionInfoList memory_region_infos;
for (const auto &range : *memory_ranges) {
SBMemoryRegionInfo region_info(
nullptr, range.GetRangeBase(), range.GetRangeEnd(),
range.data.lldb_permissions, /*mapped=*/true);
memory_region_infos.Append(region_info);
}
return memory_region_infos;
}
lldb_private::SaveCoreOptions &SBSaveCoreOptions::ref() const {
return *m_opaque_up;
}
|
