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
|
//===-- SBFile.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/API/SBFile.h"
#include "lldb/API/SBError.h"
#include "lldb/Host/File.h"
#include "lldb/Utility/Instrumentation.h"
using namespace lldb;
using namespace lldb_private;
SBFile::~SBFile() = default;
SBFile::SBFile(FileSP file_sp) : m_opaque_sp(file_sp) {
// We have no way to capture the incoming FileSP as the class isn't
// instrumented, so pretend that it's always null.
LLDB_INSTRUMENT_VA(this, file_sp);
}
SBFile::SBFile(const SBFile &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
LLDB_INSTRUMENT_VA(this, rhs);
}
SBFile &SBFile ::operator=(const SBFile &rhs) {
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
SBFile::SBFile() { LLDB_INSTRUMENT_VA(this); }
SBFile::SBFile(FILE *file, bool transfer_ownership) {
LLDB_INSTRUMENT_VA(this, file, transfer_ownership);
m_opaque_sp = std::make_shared<NativeFile>(file, transfer_ownership);
}
SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) {
LLDB_INSTRUMENT_VA(this, fd, mode, transfer_owndership);
auto options = File::GetOptionsFromMode(mode);
if (!options) {
llvm::consumeError(options.takeError());
return;
}
m_opaque_sp =
std::make_shared<NativeFile>(fd, options.get(), transfer_owndership);
}
SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) {
LLDB_INSTRUMENT_VA(this, buf, num_bytes, bytes_read);
SBError error;
if (!m_opaque_sp) {
error.SetErrorString("invalid SBFile");
*bytes_read = 0;
} else {
Status status = m_opaque_sp->Read(buf, num_bytes);
error.SetError(status);
*bytes_read = num_bytes;
}
return error;
}
SBError SBFile::Write(const uint8_t *buf, size_t num_bytes,
size_t *bytes_written) {
LLDB_INSTRUMENT_VA(this, buf, num_bytes, bytes_written);
SBError error;
if (!m_opaque_sp) {
error.SetErrorString("invalid SBFile");
*bytes_written = 0;
} else {
Status status = m_opaque_sp->Write(buf, num_bytes);
error.SetError(status);
*bytes_written = num_bytes;
}
return error;
}
SBError SBFile::Flush() {
LLDB_INSTRUMENT_VA(this);
SBError error;
if (!m_opaque_sp) {
error.SetErrorString("invalid SBFile");
} else {
Status status = m_opaque_sp->Flush();
error.SetError(status);
}
return error;
}
bool SBFile::IsValid() const {
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp && m_opaque_sp->IsValid();
}
SBError SBFile::Close() {
LLDB_INSTRUMENT_VA(this);
SBError error;
if (m_opaque_sp) {
Status status = m_opaque_sp->Close();
error.SetError(status);
}
return error;
}
SBFile::operator bool() const {
LLDB_INSTRUMENT_VA(this);
return IsValid();
}
bool SBFile::operator!() const {
LLDB_INSTRUMENT_VA(this);
return !IsValid();
}
FileSP SBFile::GetFile() const {
LLDB_INSTRUMENT_VA(this);
return m_opaque_sp;
}
|
