This is an archive of the discontinued LLVM Phabricator instance.

Differential D26698

Remove SBStream accessor that lets you manipulate the internal buffer.
ClosedPublic

Authored by zturner on Nov 15 2016, 1:44 PM.

Details

Reviewers
beanz
tfiala
Commits
rGc156427ded1d: Don't allow direct access to StreamString's internal buffer.
rLLDB287152: Don't allow direct access to StreamString's internal buffer.
rL287152: Don't allow direct access to StreamString's internal buffer.
Summary

Instead of having overloads that return std::string& and const std::string&, instead have one function that returns llvm::StringRef. People should not be modifying the internal contents of a stream's buffer, as that goes against the concept of a stream, which is supposed to provide forward-only access. This makes it easier in the future to port StreamString over to llvm::raw_ostream.

I don't need a detailed review of the code, I mostly just need to make sure it compiles on OSX. I made sure it compiles on Linux and Windows, but I can't easily test OSX.

Diff Detail

Repository
rL LLVM

Event Timeline

zturner updated this revision to Diff 78068.Nov 15 2016, 1:44 PM
zturner retitled this revision from to Remove SBStream accessor that lets you manipulate the internal buffer..
zturner updated this object.
zturner added reviewers: beanz, tfiala.
zturner added a subscriber: lldb-commits.
Herald added subscribers: nemanjai, kubamracek, danalbert, emaste. · View Herald TranscriptNov 15 2016, 1:44 PM
tfiala edited edge metadata.Nov 15 2016, 5:45 PM

I can run this through in the morning on macOS.

tfiala added a comment.Nov 16 2016, 10:42 AM

Hi Zachary,

I'm uploading a file of diffs I needed to get the macOS build to compile and link. There were a small handful of macOS-only paths that needed an adjustment. You'll want to look those over to see if I did them the right way.

I'm now in the process of running the tests. Back on that in a bit.

D26698_macos_build_fixes.diff5 MBDownload

tfiala added a comment.Nov 16 2016, 11:18 AM

TestTerminal.py's test_launch_in_terminal() is timing out consistently with the current change + my diff attached above.

I'm looking into it now. (It quite possibly is due to the build fixes I did above).

I'm attaching the 'sample' (callstack sampling) from the failure here.

TestTerminal.py-58148.sample.zip14 KBDownload

tfiala accepted this revision.Nov 16 2016, 11:28 AM
tfiala edited edge metadata.

Here is the adjusted patch that fixes the issue I was seeing on TestTerminal.py. My first set of changes had a lifetime issue where I needed a const char* that was synthesized on the fly and went away by the time I needed it.

LGTM on macOS with this patch applied:

D26698_macos_build_fixes_v2.diff5 MBDownload

This revision is now accepted and ready to land.Nov 16 2016, 11:28 AM
tfiala mentioned this in D26721: Make AutoComplete code use StringRef.Nov 16 2016, 11:30 AM
Closed by commit rL287152: Don't allow direct access to StreamString's internal buffer. (authored by zturner). · Explain WhyNov 16 2016, 1:25 PM
This revision was automatically updated to reflect the committed changes.
labath mentioned this in D65739: [API] Have SBCommandReturnObject::GetOutput/Error return "" instead of nullptr.Aug 5 2019, 5:34 AM
labath mentioned this in rL368806: [API] Have SBCommandReturnObject::GetOutput/Error return "" instead of nullptr.Aug 14 2019, 1:13 AM
labath mentioned this in rG72ef113d40ef: [API] Have SBCommandReturnObject::GetOutput/Error return "" instead of nullptr.

Revision Contents

PathSize
lldb/
trunk/
include/
lldb/
Core/
2 lines
1 line
1 line
6 lines
DataFormatters/
7 lines
Host/
1 line
Interpreter/
17 lines
Target/
1 line
packages/
Python/
lldbsuite/
test/
2 lines
source/
API/
19 lines
2 lines
11 lines
2 lines
Commands/
4 lines
12 lines
6 lines
4 lines
2 lines
12 lines
2 lines
10 lines
12 lines
6 lines
Core/
2 lines
6 lines
2 lines
2 lines
4 lines
13 lines
2 lines
27 lines
18 lines
1 line
12 lines
10 lines
6 lines
2 lines
5 lines
52 lines
DataFormatters/
5 lines
7 lines
9 lines
4 lines
13 lines
2 lines
Expression/
2 lines
2 lines
10 lines
Host/
macosx/
11 lines
posix/
2 lines
windows/
5 lines
Interpreter/
13 lines
2 lines
77 lines
24 lines
4 lines
2 lines
2 lines
4 lines
10 lines
Plugins/
ABI/
MacOSX-arm64/
2 lines
SysV-arm64/
2 lines
SysV-mips/
2 lines
SysV-mips64/
2 lines
SysV-ppc/
2 lines
SysV-ppc64/
2 lines
SysV-s390x/
2 lines
SysV-x86_64/
2 lines
Disassembler/
llvm/
8 lines
DynamicLoader/
POSIX-DYLD/
2 lines
ExpressionParser/
Clang/
11 lines
4 lines
Instruction/
ARM/
4 lines
Language/
CPlusPlus/
4 lines
2 lines
5 lines
5 lines
2 lines
2 lines
2 lines
Go/
2 lines
Java/
2 lines
ObjC/
4 lines
4 lines
4 lines
4 lines
12 lines
LanguageRuntime/
ObjC/
AppleObjCRuntime/
2 lines
RenderScript/
RenderScriptRuntime/
2 lines
MemoryHistory/
asan/
2 lines
ObjectFile/
Mach-O/
3 lines
OperatingSystem/
Python/
5 lines
Platform/
Android/
2 lines
FreeBSD/
2 lines
Kalimba/
2 lines
Linux/
6 lines
MacOSX/
2 lines
2 lines
8 lines
4 lines
2 lines
2 lines
2 lines
2 lines
NetBSD/
2 lines
POSIX/
2 lines
Windows/
4 lines
gdb-server/
4 lines
Process/
MacOSX-Kernel/
2 lines
Utility/
6 lines
2 lines
gdb-remote/
10 lines
26 lines
3 lines
3 lines
17 lines
ScriptInterpreter/
Python/
6 lines
StructuredData/
DarwinLog/
14 lines
SymbolFile/
DWARF/
4 lines
2 lines
2 lines
UnwindAssembly/
InstEmulation/
15 lines
Symbol/
2 lines
Target/
6 lines
58 lines
10 lines
2 lines
5 lines
3 lines
4 lines
3 lines
2 lines
tools/
argdumper/
3 lines
unittests/
ScriptInterpreter/
Python/
14 lines

Diff 78253

lldb/trunk/include/lldb/Core/Error.h

Show First 20 Lines • Show All 239 Lines • ▼ Show 20 Linespublic:
/// error strings that the standard type callbacks typically /// error strings that the standard type callbacks typically
/// provide. This allows custom strings to be supplied as an /// provide. This allows custom strings to be supplied as an
/// error explanation. The error string value will remain until the /// error explanation. The error string value will remain until the
/// error value is cleared or a new error value/type is assigned. /// error value is cleared or a new error value/type is assigned.
/// ///
/// @param err_str /// @param err_str
/// The new custom error string to copy and cache. /// The new custom error string to copy and cache.
//------------------------------------------------------------------ //------------------------------------------------------------------
void SetErrorString(const char *err_str); void SetErrorString(llvm::StringRef err_str);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Set the current error string to a formatted error string. /// Set the current error string to a formatted error string.
/// ///
/// @param format /// @param format
/// A printf style format string /// A printf style format string
//------------------------------------------------------------------ //------------------------------------------------------------------
int SetErrorStringWithFormat(const char *format, ...) int SetErrorStringWithFormat(const char *format, ...)
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Log.h

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Linespublic:
//------------------------------------------------------------------ //------------------------------------------------------------------
Log(); Log();
Log(const lldb::StreamSP &stream_sp); Log(const lldb::StreamSP &stream_sp);
virtual ~Log(); virtual ~Log();
virtual void PutCString(const char *cstr); virtual void PutCString(const char *cstr);
virtual void PutString(llvm::StringRef str);
// CLEANUP: Add llvm::raw_ostream &Stream() function. // CLEANUP: Add llvm::raw_ostream &Stream() function.
virtual void Printf(const char *format, ...) virtual void Printf(const char *format, ...)
__attribute__((format(printf, 2, 3))); __attribute__((format(printf, 2, 3)));
virtual void VAPrintf(const char *format, va_list args); virtual void VAPrintf(const char *format, va_list args);
virtual void LogIf(uint32_t mask, const char *fmt, ...) virtual void LogIf(uint32_t mask, const char *fmt, ...)
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/StreamGDBRemote.h

Show All 36 Linespublic:
/// A block of data. /// A block of data.
/// ///
/// @param[in] src_len /// @param[in] src_len
/// The amount of data to write. /// The amount of data to write.
/// ///
/// @return /// @return
/// Number of bytes written. /// Number of bytes written.
//------------------------------------------------------------------ //------------------------------------------------------------------
// TODO: Convert this function to take ArrayRef<uint8_t>
int PutEscapedBytes(const void *s, size_t src_len); int PutEscapedBytes(const void *s, size_t src_len);
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_StreamGDBRemote_h_ #endif // liblldb_StreamGDBRemote_h_

lldb/trunk/include/lldb/Core/StreamString.h

Show All 26 Linespublic:
void Flush() override; void Flush() override;
size_t Write(const void *s, size_t length) override; size_t Write(const void *s, size_t length) override;
void Clear(); void Clear();
bool Empty() const; bool Empty() const;
const char *GetData() const;
size_t GetSize() const; size_t GetSize() const;
size_t GetSizeOfLastLine() const; size_t GetSizeOfLastLine() const;
std::string &GetString(); llvm::StringRef GetString() const;
const std::string &GetString() const; const char *GetData() const { return m_packet.c_str(); }
void FillLastLineToColumn(uint32_t column, char fill_char); void FillLastLineToColumn(uint32_t column, char fill_char);
protected: protected:
std::string m_packet; std::string m_packet;
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_StreamString_h_ #endif // liblldb_StreamString_h_

lldb/trunk/include/lldb/DataFormatters/FormatClasses.h

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Linesprivate:
ConstString m_type_for_cache; ConstString m_type_for_cache;
CandidateLanguagesVector m_candidate_languages; CandidateLanguagesVector m_candidate_languages;
}; };
class TypeNameSpecifierImpl { class TypeNameSpecifierImpl {
public: public:
TypeNameSpecifierImpl() : m_is_regex(false), m_type() {} TypeNameSpecifierImpl() : m_is_regex(false), m_type() {}
TypeNameSpecifierImpl(const char *name, bool is_regex) TypeNameSpecifierImpl(llvm::StringRef name, bool is_regex)
: m_is_regex(is_regex), m_type() { : m_is_regex(is_regex), m_type() {
if (name) m_type.m_type_name = name;
m_type.m_type_name.assign(name);
} }
// if constructing with a given type, is_regex cannot be true since we are // if constructing with a given type, is_regex cannot be true since we are
// giving an exact type to match // giving an exact type to match
TypeNameSpecifierImpl(lldb::TypeSP type) : m_is_regex(false), m_type() { TypeNameSpecifierImpl(lldb::TypeSP type) : m_is_regex(false), m_type() {
if (type) { if (type) {
m_type.m_type_name.assign(type->GetName().GetCString()); m_type.m_type_name = type->GetName().GetStringRef();
m_type.m_type_pair.SetType(type); m_type.m_type_pair.SetType(type);
} }
} }
TypeNameSpecifierImpl(CompilerType type) : m_is_regex(false), m_type() { TypeNameSpecifierImpl(CompilerType type) : m_is_regex(false), m_type() {
if (type.IsValid()) { if (type.IsValid()) {
m_type.m_type_name.assign(type.GetConstTypeName().GetCString()); m_type.m_type_name.assign(type.GetConstTypeName().GetCString());
m_type.m_type_pair.SetType(type); m_type.m_type_pair.SetType(type);
Show All 40 Lines

lldb/trunk/include/lldb/Host/Host.h

Show First 20 Lines • Show All 234 Lines • ▼ Show 20 Lines#endif // defined (__APPLE__) || defined (__linux__) || defined (__FreeBSD__) ||
/// Perform expansion of the command-line for this launch info /// Perform expansion of the command-line for this launch info
/// This can potentially involve wildcard expansion /// This can potentially involve wildcard expansion
// environment variable replacement, and whatever other // environment variable replacement, and whatever other
// argument magic the platform defines as part of its typical // argument magic the platform defines as part of its typical
// user experience // user experience
//------------------------------------------------------------------ //------------------------------------------------------------------
static Error ShellExpandArguments(ProcessLaunchInfo &launch_info); static Error ShellExpandArguments(ProcessLaunchInfo &launch_info);
// TODO: Convert this function to take a StringRef.
static Error RunShellCommand( static Error RunShellCommand(
const char *command, // Shouldn't be NULL const char *command, // Shouldn't be NULL
const FileSpec &working_dir, // Pass empty FileSpec to use the current const FileSpec &working_dir, // Pass empty FileSpec to use the current
// working directory // working directory
int *status_ptr, // Pass NULL if you don't want the process exit status int *status_ptr, // Pass NULL if you don't want the process exit status
int *signo_ptr, // Pass NULL if you don't want the signal that caused the int *signo_ptr, // Pass NULL if you don't want the signal that caused the
// process to exit // process to exit
std::string std::string
Show All 30 Lines

lldb/trunk/include/lldb/Interpreter/CommandReturnObject.h

Show All 14 Lines
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Core/STLUtils.h" #include "lldb/Core/STLUtils.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h" #include "lldb/Core/StreamString.h"
#include "lldb/Core/StreamTee.h" #include "lldb/Core/StreamTee.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "llvm/ADT/StringRef.h"
#include <memory>
namespace lldb_private { namespace lldb_private {
class CommandReturnObject { class CommandReturnObject {
public: public:
CommandReturnObject(); CommandReturnObject();
~CommandReturnObject(); ~CommandReturnObject();
const char *GetOutputData() { llvm::StringRef GetOutputData() {
lldb::StreamSP stream_sp(m_out_stream.GetStreamAtIndex(eStreamStringIndex)); lldb::StreamSP stream_sp(m_out_stream.GetStreamAtIndex(eStreamStringIndex));
if (stream_sp) if (stream_sp)
return static_cast<StreamString *>(stream_sp.get())->GetData(); return static_pointer_cast<StreamString>(stream_sp)->GetString();
return ""; return llvm::StringRef();
} }
const char *GetErrorData() { llvm::StringRef GetErrorData() {
lldb::StreamSP stream_sp(m_err_stream.GetStreamAtIndex(eStreamStringIndex)); lldb::StreamSP stream_sp(m_err_stream.GetStreamAtIndex(eStreamStringIndex));
if (stream_sp) if (stream_sp)
return static_cast<StreamString *>(stream_sp.get())->GetData(); return static_pointer_cast<StreamString>(stream_sp)->GetString();
else return llvm::StringRef();
return "";
} }
Stream &GetOutputStream() { Stream &GetOutputStream() {
// Make sure we at least have our normal string stream output stream // Make sure we at least have our normal string stream output stream
lldb::StreamSP stream_sp(m_out_stream.GetStreamAtIndex(eStreamStringIndex)); lldb::StreamSP stream_sp(m_out_stream.GetStreamAtIndex(eStreamStringIndex));
if (!stream_sp) { if (!stream_sp) {
stream_sp.reset(new StreamString()); stream_sp.reset(new StreamString());
m_out_stream.SetStreamAtIndex(eStreamStringIndex, stream_sp); m_out_stream.SetStreamAtIndex(eStreamStringIndex, stream_sp);
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/Process.h

Show First 20 Lines • Show All 1,912 Lines • ▼ Show 20 Linespublic:
/// contains the data to write. /// contains the data to write.
/// ///
/// @param[in] size /// @param[in] size
/// The number of bytes to write. /// The number of bytes to write.
/// ///
/// @return /// @return
/// The number of bytes that were actually written. /// The number of bytes that were actually written.
//------------------------------------------------------------------ //------------------------------------------------------------------
// TODO: change this to take an ArrayRef<uint8_t>
size_t WriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, size_t WriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size,
Error &error); Error &error);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Actually allocate memory in the process. /// Actually allocate memory in the process.
/// ///
/// This function will allocate memory in the process's address /// This function will allocate memory in the process's address
/// space. This can't rely on the generic function calling mechanism, /// space. This can't rely on the generic function calling mechanism,
▲ Show 20 Lines • Show All 1,253 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/lldbtest.py

Show First 20 Lines • Show All 2,189 Lines • ▼ Show 20 Lines def expect(
# No execution required, just compare str against the golden input. # No execution required, just compare str against the golden input.
if isinstance(str, lldb.SBCommandReturnObject): if isinstance(str, lldb.SBCommandReturnObject):
output = str.GetOutput() output = str.GetOutput()
else: else:
output = str output = str
with recording(self, trace) as sbuf: with recording(self, trace) as sbuf:
print("looking at:", output, file=sbuf) print("looking at:", output, file=sbuf)
if output is None:
output = ""
# The heading says either "Expecting" or "Not expecting". # The heading says either "Expecting" or "Not expecting".
heading = "Expecting" if matching else "Not expecting" heading = "Expecting" if matching else "Not expecting"
# Start from the startstr, if specified. # Start from the startstr, if specified.
# If there's no startstr, set the initial state appropriately. # If there's no startstr, set the initial state appropriately.
matched = output.startswith(startstr) if startstr else ( matched = output.startswith(startstr) if startstr else (
True if matching else False) True if matching else False)
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBCommandReturnObject.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
bool SBCommandReturnObject::IsValid() const { bool SBCommandReturnObject::IsValid() const {
return m_opaque_ap.get() != nullptr; return m_opaque_ap.get() != nullptr;
} }
const char *SBCommandReturnObject::GetOutput() { const char *SBCommandReturnObject::GetOutput() {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (m_opaque_ap) { if (m_opaque_ap) {
llvm::StringRef output = m_opaque_ap->GetOutputData();
ConstString result(output.empty() ? llvm::StringRef("") : output);
if (log) if (log)
log->Printf("SBCommandReturnObject(%p)::GetOutput () => \"%s\"", log->Printf("SBCommandReturnObject(%p)::GetOutput () => \"%s\"",
static_cast<void *>(m_opaque_ap.get()), static_cast<void *>(m_opaque_ap.get()), result.AsCString());
m_opaque_ap->GetOutputData());
return m_opaque_ap->GetOutputData(); return result.AsCString();
} }
if (log) if (log)
log->Printf("SBCommandReturnObject(%p)::GetOutput () => nullptr", log->Printf("SBCommandReturnObject(%p)::GetOutput () => nullptr",
static_cast<void *>(m_opaque_ap.get())); static_cast<void *>(m_opaque_ap.get()));
return nullptr; return nullptr;
} }
const char *SBCommandReturnObject::GetError() { const char *SBCommandReturnObject::GetError() {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (m_opaque_ap) { if (m_opaque_ap) {
llvm::StringRef output = m_opaque_ap->GetErrorData();
ConstString result(output.empty() ? llvm::StringRef("") : output);
if (log) if (log)
log->Printf("SBCommandReturnObject(%p)::GetError () => \"%s\"", log->Printf("SBCommandReturnObject(%p)::GetError () => \"%s\"",
static_cast<void *>(m_opaque_ap.get()), static_cast<void *>(m_opaque_ap.get()), result.AsCString());
m_opaque_ap->GetErrorData());
return m_opaque_ap->GetErrorData(); return result.AsCString();
} }
if (log) if (log)
log->Printf("SBCommandReturnObject(%p)::GetError () => nullptr", log->Printf("SBCommandReturnObject(%p)::GetError () => nullptr",
static_cast<void *>(m_opaque_ap.get())); static_cast<void *>(m_opaque_ap.get()));
return nullptr; return nullptr;
} }
size_t SBCommandReturnObject::GetOutputSize() { size_t SBCommandReturnObject::GetOutputSize() {
return (m_opaque_ap ? strlen(m_opaque_ap->GetOutputData()) : 0); return (m_opaque_ap ? m_opaque_ap->GetOutputData().size() : 0);
} }
size_t SBCommandReturnObject::GetErrorSize() { size_t SBCommandReturnObject::GetErrorSize() {
return (m_opaque_ap ? strlen(m_opaque_ap->GetErrorData()) : 0); return (m_opaque_ap ? m_opaque_ap->GetErrorData().size() : 0);
} }
size_t SBCommandReturnObject::PutOutput(FILE *fh) { size_t SBCommandReturnObject::PutOutput(FILE *fh) {
if (fh) { if (fh) {
size_t num_bytes = GetOutputSize(); size_t num_bytes = GetOutputSize();
if (num_bytes) if (num_bytes)
return ::fprintf(fh, "%s", GetOutput()); return ::fprintf(fh, "%s", GetOutput());
} }
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBFrame.cpp

Show First 20 Lines • Show All 1,289 Lines • ▼ Show 20 Lines if (stop_locker.TryLock(&process->GetRunLock())) {
if (frame) { if (frame) {
if (target->GetDisplayExpressionsInCrashlogs()) { if (target->GetDisplayExpressionsInCrashlogs()) {
StreamString frame_description; StreamString frame_description;
frame->DumpUsingSettingsFormat(&frame_description); frame->DumpUsingSettingsFormat(&frame_description);
Host::SetCrashDescriptionWithFormat( Host::SetCrashDescriptionWithFormat(
"SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value " "SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value "
"= %u) %s", "= %u) %s",
expr, options.GetFetchDynamicValue(), expr, options.GetFetchDynamicValue(),
frame_description.GetString().c_str()); frame_description.GetData());
} }
exe_results = target->EvaluateExpression(expr, frame, expr_value_sp, exe_results = target->EvaluateExpression(expr, frame, expr_value_sp,
options.ref()); options.ref());
expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue()); expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
if (target->GetDisplayExpressionsInCrashlogs()) if (target->GetDisplayExpressionsInCrashlogs())
Host::SetCrashDescription(nullptr); Host::SetCrashDescription(nullptr);
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBStream.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Linesvoid SBStream::RedirectToFile(const char *path, bool append) {
if (path == nullptr) if (path == nullptr)
return; return;
std::string local_data; std::string local_data;
if (m_opaque_ap.get()) { if (m_opaque_ap.get()) {
// See if we have any locally backed data. If so, copy it so we can then // See if we have any locally backed data. If so, copy it so we can then
// redirect it to the file so we don't lose the data // redirect it to the file so we don't lose the data
if (!m_is_file) if (!m_is_file)
local_data.swap( local_data = static_cast<StreamString *>(m_opaque_ap.get())->GetString();
static_cast<StreamString *>(m_opaque_ap.get())->GetString());
} }
StreamFile *stream_file = new StreamFile; StreamFile *stream_file = new StreamFile;
uint32_t open_options = File::eOpenOptionWrite | File::eOpenOptionCanCreate; uint32_t open_options = File::eOpenOptionWrite | File::eOpenOptionCanCreate;
if (append) if (append)
open_options |= File::eOpenOptionAppend; open_options |= File::eOpenOptionAppend;
else else
open_options |= File::eOpenOptionTruncate; open_options |= File::eOpenOptionTruncate;
stream_file->GetFile().Open(path, open_options, stream_file->GetFile().Open(path, open_options,
Show All 16 Linesvoid SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) {
if (fh == nullptr) if (fh == nullptr)
return; return;
std::string local_data; std::string local_data;
if (m_opaque_ap.get()) { if (m_opaque_ap.get()) {
// See if we have any locally backed data. If so, copy it so we can then // See if we have any locally backed data. If so, copy it so we can then
// redirect it to the file so we don't lose the data // redirect it to the file so we don't lose the data
if (!m_is_file) if (!m_is_file)
local_data.swap( local_data = static_cast<StreamString *>(m_opaque_ap.get())->GetString();
static_cast<StreamString *>(m_opaque_ap.get())->GetString());
} }
m_opaque_ap.reset(new StreamFile(fh, transfer_fh_ownership)); m_opaque_ap.reset(new StreamFile(fh, transfer_fh_ownership));
if (m_opaque_ap.get()) { if (m_opaque_ap.get()) {
m_is_file = true; m_is_file = true;
// If we had any data locally in our StreamString, then pass that along to // If we had any data locally in our StreamString, then pass that along to
// the to new file we are redirecting to. // the to new file we are redirecting to.
if (!local_data.empty()) if (!local_data.empty())
m_opaque_ap->Write(&local_data[0], local_data.size()); m_opaque_ap->Write(&local_data[0], local_data.size());
} else } else
m_is_file = false; m_is_file = false;
} }
void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) { void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) {
std::string local_data; std::string local_data;
if (m_opaque_ap.get()) { if (m_opaque_ap.get()) {
// See if we have any locally backed data. If so, copy it so we can then // See if we have any locally backed data. If so, copy it so we can then
// redirect it to the file so we don't lose the data // redirect it to the file so we don't lose the data
if (!m_is_file) if (!m_is_file)
local_data.swap( local_data = static_cast<StreamString *>(m_opaque_ap.get())->GetString();
static_cast<StreamString *>(m_opaque_ap.get())->GetString());
} }
m_opaque_ap.reset(new StreamFile(::fdopen(fd, "w"), transfer_fh_ownership)); m_opaque_ap.reset(new StreamFile(::fdopen(fd, "w"), transfer_fh_ownership));
if (m_opaque_ap.get()) { if (m_opaque_ap.get()) {
m_is_file = true; m_is_file = true;
// If we had any data locally in our StreamString, then pass that along to // If we had any data locally in our StreamString, then pass that along to
// the to new file we are redirecting to. // the to new file we are redirecting to.
Show All 15 Lines
void SBStream::Clear() { void SBStream::Clear() {
if (m_opaque_ap.get()) { if (m_opaque_ap.get()) {
// See if we have any locally backed data. If so, copy it so we can then // See if we have any locally backed data. If so, copy it so we can then
// redirect it to the file so we don't lose the data // redirect it to the file so we don't lose the data
if (m_is_file) if (m_is_file)
m_opaque_ap.reset(); m_opaque_ap.reset();
else else
static_cast<StreamString *>(m_opaque_ap.get())->GetString().clear(); static_cast<StreamString *>(m_opaque_ap.get())->Clear();
} }
} }

lldb/trunk/source/API/SBTarget.cpp

Show First 20 Lines • Show All 2,127 Lines • ▼ Show 20 Lines
#ifdef LLDB_CONFIGURATION_DEBUG #ifdef LLDB_CONFIGURATION_DEBUG
StreamString frame_description; StreamString frame_description;
if (frame) if (frame)
frame->DumpUsingSettingsFormat(&frame_description); frame->DumpUsingSettingsFormat(&frame_description);
Host::SetCrashDescriptionWithFormat( Host::SetCrashDescriptionWithFormat(
"SBTarget::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = " "SBTarget::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = "
"%u) %s", "%u) %s",
expr, options.GetFetchDynamicValue(), expr, options.GetFetchDynamicValue(),
frame_description.GetString().c_str()); frame_description.GetString().str().c_str());
#endif #endif
exe_results = exe_results =
target->EvaluateExpression(expr, frame, expr_value_sp, options.ref()); target->EvaluateExpression(expr, frame, expr_value_sp, options.ref());
expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue()); expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
#ifdef LLDB_CONFIGURATION_DEBUG #ifdef LLDB_CONFIGURATION_DEBUG
Host::SetCrashDescription(NULL); Host::SetCrashDescription(NULL);
#endif #endif
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp

Show First 20 Lines • Show All 1,552 Lines • ▼ Show 20 Lines bool DoExecute(Args &command, CommandReturnObject &result) override {
default: default:
break; break;
} }
if (num_cleared > 0) { if (num_cleared > 0) {
Stream &output_stream = result.GetOutputStream(); Stream &output_stream = result.GetOutputStream();
output_stream.Printf("%d breakpoints cleared:\n", num_cleared); output_stream.Printf("%d breakpoints cleared:\n", num_cleared);
output_stream << ss.GetData(); output_stream << ss.GetString();
output_stream.EOL(); output_stream.EOL();
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
} else { } else {
result.AppendError("Breakpoint clear: No breakpoint cleared."); result.AppendError("Breakpoint clear: No breakpoint cleared.");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
} }
return result.Succeeded(); return result.Succeeded();
▲ Show 20 Lines • Show All 422 Lines • ▼ Show 20 Lines if (m_name_options.m_name.OptionWasSet()) {
target->GetBreakpointList().GetListMutex(lock); target->GetBreakpointList().GetListMutex(lock);
BreakpointList &breakpoints = target->GetBreakpointList(); BreakpointList &breakpoints = target->GetBreakpointList();
for (BreakpointSP bp_sp : breakpoints.Breakpoints()) { for (BreakpointSP bp_sp : breakpoints.Breakpoints()) {
if (bp_sp->MatchesName(name)) { if (bp_sp->MatchesName(name)) {
StreamString s; StreamString s;
bp_sp->GetDescription(&s, eDescriptionLevelBrief); bp_sp->GetDescription(&s, eDescriptionLevelBrief);
s.EOL(); s.EOL();
result.AppendMessage(s.GetData()); result.AppendMessage(s.GetString());
} }
} }
} else if (m_name_options.m_breakpoint.OptionWasSet()) { } else if (m_name_options.m_breakpoint.OptionWasSet()) {
BreakpointSP bp_sp = target->GetBreakpointList().FindBreakpointByID( BreakpointSP bp_sp = target->GetBreakpointList().FindBreakpointByID(
m_name_options.m_breakpoint.GetCurrentValue()); m_name_options.m_breakpoint.GetCurrentValue());
if (bp_sp) { if (bp_sp) {
std::vector<std::string> names; std::vector<std::string> names;
▲ Show 20 Lines • Show All 433 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectCommands.cpp

Show First 20 Lines • Show All 942 Lines • ▼ Show 20 Lines if (m_interpreter.CommandExists(command_name)) {
} }
} else { } else {
StreamString error_msg_stream; StreamString error_msg_stream;
const bool generate_apropos = true; const bool generate_apropos = true;
const bool generate_type_lookup = false; const bool generate_type_lookup = false;
CommandObjectHelp::GenerateAdditionalHelpAvenuesMessage( CommandObjectHelp::GenerateAdditionalHelpAvenuesMessage(
&error_msg_stream, command_name, nullptr, nullptr, generate_apropos, &error_msg_stream, command_name, nullptr, nullptr, generate_apropos,
generate_type_lookup); generate_type_lookup);
result.AppendErrorWithFormat("%s", error_msg_stream.GetData()); result.AppendError(error_msg_stream.GetString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
} }
return result.Succeeded(); return result.Succeeded();
} }
}; };
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
▲ Show 20 Lines • Show All 321 Lines • ▼ Show 20 Lines CommandObjectPythonFunction(CommandInterpreter &interpreter, std::string name,
ScriptedCommandSynchronicity synch) ScriptedCommandSynchronicity synch)
: CommandObjectRaw(interpreter, name), : CommandObjectRaw(interpreter, name),
m_function_name(funct), m_synchro(synch), m_fetched_help_long(false) { m_function_name(funct), m_synchro(synch), m_fetched_help_long(false) {
if (!help.empty()) if (!help.empty())
SetHelp(help); SetHelp(help);
else { else {
StreamString stream; StreamString stream;
stream.Printf("For more information run 'help %s'", name.c_str()); stream.Printf("For more information run 'help %s'", name.c_str());
SetHelp(stream.GetData()); SetHelp(stream.GetString());
} }
} }
~CommandObjectPythonFunction() override = default; ~CommandObjectPythonFunction() override = default;
bool IsRemovable() const override { return true; } bool IsRemovable() const override { return true; }
const std::string &GetFunctionName() { return m_function_name; } const std::string &GetFunctionName() { return m_function_name; }
Show All 29 Lines if (!scripter ||
!scripter->RunScriptBasedCommand(m_function_name.c_str(), !scripter->RunScriptBasedCommand(m_function_name.c_str(),
raw_command_line, m_synchro, result, raw_command_line, m_synchro, result,
error, m_exe_ctx)) { error, m_exe_ctx)) {
result.AppendError(error.AsCString()); result.AppendError(error.AsCString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
} else { } else {
// Don't change the status if the command already set it... // Don't change the status if the command already set it...
if (result.GetStatus() == eReturnStatusInvalid) { if (result.GetStatus() == eReturnStatusInvalid) {
if (result.GetOutputData() == nullptr || if (result.GetOutputData().empty())
result.GetOutputData()[0] == '\0')
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
else else
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
} }
} }
return result.Succeeded(); return result.Succeeded();
} }
Show All 10 Lines CommandObjectScriptingObject(CommandInterpreter &interpreter,
std::string name, std::string name,
StructuredData::GenericSP cmd_obj_sp, StructuredData::GenericSP cmd_obj_sp,
ScriptedCommandSynchronicity synch) ScriptedCommandSynchronicity synch)
: CommandObjectRaw(interpreter, name), : CommandObjectRaw(interpreter, name),
m_cmd_obj_sp(cmd_obj_sp), m_synchro(synch), m_fetched_help_short(false), m_cmd_obj_sp(cmd_obj_sp), m_synchro(synch), m_fetched_help_short(false),
m_fetched_help_long(false) { m_fetched_help_long(false) {
StreamString stream; StreamString stream;
stream.Printf("For more information run 'help %s'", name.c_str()); stream.Printf("For more information run 'help %s'", name.c_str());
SetHelp(stream.GetData()); SetHelp(stream.GetString());
if (ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter()) if (ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter())
GetFlags().Set(scripter->GetFlagsForCommandObject(cmd_obj_sp)); GetFlags().Set(scripter->GetFlagsForCommandObject(cmd_obj_sp));
} }
~CommandObjectScriptingObject() override = default; ~CommandObjectScriptingObject() override = default;
bool IsRemovable() const override { return true; } bool IsRemovable() const override { return true; }
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines bool DoExecute(const char *raw_command_line,
if (!scripter || if (!scripter ||
!scripter->RunScriptBasedCommand(m_cmd_obj_sp, raw_command_line, !scripter->RunScriptBasedCommand(m_cmd_obj_sp, raw_command_line,
m_synchro, result, error, m_exe_ctx)) { m_synchro, result, error, m_exe_ctx)) {
result.AppendError(error.AsCString()); result.AppendError(error.AsCString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
} else { } else {
// Don't change the status if the command already set it... // Don't change the status if the command already set it...
if (result.GetStatus() == eReturnStatusInvalid) { if (result.GetStatus() == eReturnStatusInvalid) {
if (result.GetOutputData() == nullptr || if (result.GetOutputData().empty())
result.GetOutputData()[0] == '\0')
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
else else
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
} }
} }
return result.Succeeded(); return result.Succeeded();
} }
▲ Show 20 Lines • Show All 539 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectHelp.cpp

Show First 20 Lines • Show All 142 Lines • ▼ Show 20 Lines if (cmd_obj != nullptr) {
if (matches.GetSize() >= 2) { if (matches.GetSize() >= 2) {
StreamString s; StreamString s;
s.Printf("ambiguous command %s", cmd_string.c_str()); s.Printf("ambiguous command %s", cmd_string.c_str());
size_t num_matches = matches.GetSize(); size_t num_matches = matches.GetSize();
for (size_t match_idx = 0; match_idx < num_matches; match_idx++) { for (size_t match_idx = 0; match_idx < num_matches; match_idx++) {
s.Printf("\n\t%s", matches.GetStringAtIndex(match_idx)); s.Printf("\n\t%s", matches.GetStringAtIndex(match_idx));
} }
s.Printf("\n"); s.Printf("\n");
result.AppendError(s.GetData()); result.AppendError(s.GetString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else if (!sub_cmd_obj) { } else if (!sub_cmd_obj) {
StreamString error_msg_stream; StreamString error_msg_stream;
GenerateAdditionalHelpAvenuesMessage( GenerateAdditionalHelpAvenuesMessage(
&error_msg_stream, cmd_string.c_str(), &error_msg_stream, cmd_string.c_str(),
m_interpreter.GetCommandPrefix(), sub_command.c_str()); m_interpreter.GetCommandPrefix(), sub_command.c_str());
result.AppendErrorWithFormat("%s", error_msg_stream.GetData()); result.AppendError(error_msg_stream.GetString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else { } else {
GenerateAdditionalHelpAvenuesMessage( GenerateAdditionalHelpAvenuesMessage(
&result.GetOutputStream(), cmd_string.c_str(), &result.GetOutputStream(), cmd_string.c_str(),
m_interpreter.GetCommandPrefix(), sub_command.c_str()); m_interpreter.GetCommandPrefix(), sub_command.c_str());
result.GetOutputStream().Printf( result.GetOutputStream().Printf(
"\nThe closest match is '%s'. Help on it follows.\n\n", "\nThe closest match is '%s'. Help on it follows.\n\n",
Show All 26 Lines if (cmd_obj != nullptr) {
Stream &output_strm = result.GetOutputStream(); Stream &output_strm = result.GetOutputStream();
CommandObject::GetArgumentHelp(output_strm, arg_type, m_interpreter); CommandObject::GetArgumentHelp(output_strm, arg_type, m_interpreter);
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
} else { } else {
StreamString error_msg_stream; StreamString error_msg_stream;
GenerateAdditionalHelpAvenuesMessage(&error_msg_stream, GenerateAdditionalHelpAvenuesMessage(&error_msg_stream,
command.GetArgumentAtIndex(0), command.GetArgumentAtIndex(0),
m_interpreter.GetCommandPrefix()); m_interpreter.GetCommandPrefix());
result.AppendErrorWithFormat("%s", error_msg_stream.GetData()); result.AppendError(error_msg_stream.GetString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
} }
} }
} }
return result.Succeeded(); return result.Succeeded();
} }
Show All 32 Lines

lldb/trunk/source/Commands/CommandObjectMemory.cpp

Show First 20 Lines • Show All 817 Lines • ▼ Show 20 Lines if (clang_ast_type.GetOpaqueQualType()) {
DumpValueObjectOptions options(m_varobj_options.GetAsDumpOptions( DumpValueObjectOptions options(m_varobj_options.GetAsDumpOptions(
eLanguageRuntimeDescriptionDisplayVerbosityFull, format)); eLanguageRuntimeDescriptionDisplayVerbosityFull, format));
valobj_sp->Dump(*output_stream, options); valobj_sp->Dump(*output_stream, options);
} else { } else {
result.AppendErrorWithFormat( result.AppendErrorWithFormat(
"failed to create a value object for: (%s) %s\n", "failed to create a value object for: (%s) %s\n",
view_as_type_cstr, name_strm.GetString().c_str()); view_as_type_cstr, name_strm.GetData());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} }
} }
return true; return true;
} }
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
▲ Show 20 Lines • Show All 737 Lines • ▼ Show 20 Lines for (size_t i = 0; i < num_value_args; ++i) {
} }
buffer.PutMaxHex64(uval64, item_byte_size); buffer.PutMaxHex64(uval64, item_byte_size);
break; break;
} }
} }
if (!buffer.GetString().empty()) { if (!buffer.GetString().empty()) {
Error error; Error error;
if (process->WriteMemory(addr, buffer.GetString().c_str(), if (process->WriteMemory(addr, buffer.GetString().data(),
buffer.GetString().size(), buffer.GetString().size(),
error) == buffer.GetString().size()) error) == buffer.GetString().size())
return true; return true;
else { else {
result.AppendErrorWithFormat("Memory write to 0x%" PRIx64 result.AppendErrorWithFormat("Memory write to 0x%" PRIx64
" failed: %s.\n", " failed: %s.\n",
addr, error.AsCString()); addr, error.AsCString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectMultiword.cpp

Show First 20 Lines • Show All 254 Lines • ▼ Show 20 Linesvoid CommandObjectMultiword::AproposAllSubCommands(llvm::StringRef prefix,
for (pos = m_subcommand_dict.begin(); pos != m_subcommand_dict.end(); ++pos) { for (pos = m_subcommand_dict.begin(); pos != m_subcommand_dict.end(); ++pos) {
const char *command_name = pos->first.c_str(); const char *command_name = pos->first.c_str();
CommandObject *sub_cmd_obj = pos->second.get(); CommandObject *sub_cmd_obj = pos->second.get();
StreamString complete_command_name; StreamString complete_command_name;
complete_command_name << prefix << " " << command_name; complete_command_name << prefix << " " << command_name;
if (sub_cmd_obj->HelpTextContainsWord(search_word)) { if (sub_cmd_obj->HelpTextContainsWord(search_word)) {
commands_found.AppendString(complete_command_name.GetData()); commands_found.AppendString(complete_command_name.GetString());
commands_help.AppendString(sub_cmd_obj->GetHelp()); commands_help.AppendString(sub_cmd_obj->GetHelp());
} }
if (sub_cmd_obj->IsMultiwordObject()) if (sub_cmd_obj->IsMultiwordObject())
sub_cmd_obj->AproposAllSubCommands(complete_command_name.GetString(), sub_cmd_obj->AproposAllSubCommands(complete_command_name.GetString(),
search_word, commands_found, search_word, commands_found,
commands_help); commands_help);
} }
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectProcess.cpp

Show First 20 Lines • Show All 236 Lines • ▼ Show 20 Lines if (error.Success()) {
if (process_sp) { if (process_sp) {
// There is a race condition where this thread will return up the call // There is a race condition where this thread will return up the call
// stack to the main command // stack to the main command
// handler and show an (lldb) prompt before HandlePrivateEvent (from // handler and show an (lldb) prompt before HandlePrivateEvent (from
// PrivateStateThread) has // PrivateStateThread) has
// a chance to call PushProcessIOHandler(). // a chance to call PushProcessIOHandler().
process_sp->SyncIOHandler(0, 2000); process_sp->SyncIOHandler(0, 2000);
const char *data = stream.GetData(); llvm::StringRef data = stream.GetString();
if (data && strlen(data) > 0) if (!data.empty())
result.AppendMessage(stream.GetData()); result.AppendMessage(data);
const char *archname = const char *archname =
exe_module_sp->GetArchitecture().GetArchitectureName(); exe_module_sp->GetArchitecture().GetArchitectureName();
result.AppendMessageWithFormat( result.AppendMessageWithFormat(
"Process %" PRIu64 " launched: '%s' (%s)\n", process_sp->GetID(), "Process %" PRIu64 " launched: '%s' (%s)\n", process_sp->GetID(),
exe_module_sp->GetFileSpec().GetPath().c_str(), archname); exe_module_sp->GetFileSpec().GetPath().c_str(), archname);
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
result.SetDidChangeProcessState(true); result.SetDidChangeProcessState(true);
} else { } else {
▲ Show 20 Lines • Show All 243 Lines • ▼ Show 20 Lines bool DoExecute(Args &command, CommandReturnObject &result) override {
} }
m_interpreter.UpdateExecutionContext(nullptr); m_interpreter.UpdateExecutionContext(nullptr);
StreamString stream; StreamString stream;
const auto error = target->Attach(m_options.attach_info, &stream); const auto error = target->Attach(m_options.attach_info, &stream);
if (error.Success()) { if (error.Success()) {
ProcessSP process_sp(target->GetProcessSP()); ProcessSP process_sp(target->GetProcessSP());
if (process_sp) { if (process_sp) {
if (stream.GetData()) result.AppendMessage(stream.GetString());
result.AppendMessage(stream.GetData());
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
result.SetDidChangeProcessState(true); result.SetDidChangeProcessState(true);
result.SetAbnormalStopWasExpected(true); result.SetAbnormalStopWasExpected(true);
} else { } else {
result.AppendError( result.AppendError(
"no error returned from Target::Attach, and target has no process"); "no error returned from Target::Attach, and target has no process");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
} }
▲ Show 20 Lines • Show All 184 Lines • ▼ Show 20 Lines if (state == eStateStopped) {
// a chance to call PushProcessIOHandler(). // a chance to call PushProcessIOHandler().
process->SyncIOHandler(iohandler_id, 2000); process->SyncIOHandler(iohandler_id, 2000);
result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n", result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n",
process->GetID()); process->GetID());
if (synchronous_execution) { if (synchronous_execution) {
// If any state changed events had anything to say, add that to the // If any state changed events had anything to say, add that to the
// result // result
if (stream.GetData()) result.AppendMessage(stream.GetString());
result.AppendMessage(stream.GetData());
result.SetDidChangeProcessState(true); result.SetDidChangeProcessState(true);
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
} else { } else {
result.SetStatus(eReturnStatusSuccessContinuingNoResult); result.SetStatus(eReturnStatusSuccessContinuingNoResult);
} }
} else { } else {
result.AppendErrorWithFormat("Failed to resume process: %s.\n", result.AppendErrorWithFormat("Failed to resume process: %s.\n",
▲ Show 20 Lines • Show All 942 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectQuit.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
bool CommandObjectQuit::DoExecute(Args &command, CommandReturnObject &result) { bool CommandObjectQuit::DoExecute(Args &command, CommandReturnObject &result) {
bool is_a_detach = true; bool is_a_detach = true;
if (ShouldAskForConfirmation(is_a_detach)) { if (ShouldAskForConfirmation(is_a_detach)) {
StreamString message; StreamString message;
message.Printf("Quitting LLDB will %s one or more processes. Do you really " message.Printf("Quitting LLDB will %s one or more processes. Do you really "
"want to proceed", "want to proceed",
(is_a_detach ? "detach from" : "kill")); (is_a_detach ? "detach from" : "kill"));
if (!m_interpreter.Confirm(message.GetData(), true)) { if (!m_interpreter.Confirm(message.GetString(), true)) {
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} }
} }
const uint32_t event_type = const uint32_t event_type =
CommandInterpreter::eBroadcastBitQuitCommandReceived; CommandInterpreter::eBroadcastBitQuitCommandReceived;
m_interpreter.BroadcastEvent(event_type); m_interpreter.BroadcastEvent(event_type);
result.SetStatus(eReturnStatusQuit); result.SetStatus(eReturnStatusQuit);
return true; return true;
} }

lldb/trunk/source/Commands/CommandObjectTarget.cpp

Show First 20 Lines • Show All 2,457 Lines • ▼ Show 20 Lines if (target == nullptr) {
} else { } else {
StreamString strm; StreamString strm;
module_spec.GetUUID().Dump(&strm); module_spec.GetUUID().Dump(&strm);
if (module_spec.GetFileSpec()) { if (module_spec.GetFileSpec()) {
if (module_spec.GetSymbolFileSpec()) { if (module_spec.GetSymbolFileSpec()) {
result.AppendErrorWithFormat( result.AppendErrorWithFormat(
"Unable to create the executable or symbol file with " "Unable to create the executable or symbol file with "
"UUID %s with path %s and symbol file %s", "UUID %s with path %s and symbol file %s",
strm.GetString().c_str(), strm.GetData(),
module_spec.GetFileSpec().GetPath().c_str(), module_spec.GetFileSpec().GetPath().c_str(),
module_spec.GetSymbolFileSpec().GetPath().c_str()); module_spec.GetSymbolFileSpec().GetPath().c_str());
} else { } else {
result.AppendErrorWithFormat( result.AppendErrorWithFormat(
"Unable to create the executable or symbol file with " "Unable to create the executable or symbol file with "
"UUID %s with path %s", "UUID %s with path %s",
strm.GetString().c_str(), strm.GetData(),
module_spec.GetFileSpec().GetPath().c_str()); module_spec.GetFileSpec().GetPath().c_str());
} }
} else { } else {
result.AppendErrorWithFormat("Unable to create the executable " result.AppendErrorWithFormat("Unable to create the executable "
"or symbol file with UUID %s", "or symbol file with UUID %s",
strm.GetString().c_str()); strm.GetData());
} }
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} }
} else { } else {
StreamString strm; StreamString strm;
module_spec.GetUUID().Dump(&strm); module_spec.GetUUID().Dump(&strm);
result.AppendErrorWithFormat( result.AppendErrorWithFormat(
"Unable to locate the executable or symbol file with UUID %s", "Unable to locate the executable or symbol file with UUID %s",
strm.GetString().c_str()); strm.GetData());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} }
} else { } else {
result.AppendError( result.AppendError(
"one or more executable image paths must be specified"); "one or more executable image paths must be specified");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
▲ Show 20 Lines • Show All 1,721 Lines • ▼ Show 20 Lines if (argc == 0) {
} else if (file_option_set) { } else if (file_option_set) {
error_strm.PutCString( error_strm.PutCString(
"unable to find debug symbols for the executable file "); "unable to find debug symbols for the executable file ");
error_strm << module_spec.GetFileSpec(); error_strm << module_spec.GetFileSpec();
} else if (frame_option_set) { } else if (frame_option_set) {
error_strm.PutCString( error_strm.PutCString(
"unable to find debug symbols for the current frame"); "unable to find debug symbols for the current frame");
} }
result.AppendError(error_strm.GetData()); result.AppendError(error_strm.GetString());
} }
} else { } else {
result.AppendError("one or more symbol file paths must be specified, " result.AppendError("one or more symbol file paths must be specified, "
"or options must be specified"); "or options must be specified");
} }
} else { } else {
if (uuid_option_set) { if (uuid_option_set) {
result.AppendError("specify either one or more paths to symbol files " result.AppendError("specify either one or more paths to symbol files "
▲ Show 20 Lines • Show All 623 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectThread.cpp

Show First 20 Lines • Show All 669 Lines • ▼ Show 20 Lines if (new_plan_sp) {
// and show an (lldb) prompt before HandlePrivateEvent (from // and show an (lldb) prompt before HandlePrivateEvent (from
// PrivateStateThread) has // PrivateStateThread) has
// a chance to call PushProcessIOHandler(). // a chance to call PushProcessIOHandler().
process->SyncIOHandler(iohandler_id, 2000); process->SyncIOHandler(iohandler_id, 2000);
if (synchronous_execution) { if (synchronous_execution) {
// If any state changed events had anything to say, add that to the // If any state changed events had anything to say, add that to the
// result // result
if (stream.GetData()) if (stream.GetSize() > 0)
result.AppendMessage(stream.GetData()); result.AppendMessage(stream.GetString());
process->GetThreadList().SetSelectedThreadByID(thread->GetID()); process->GetThreadList().SetSelectedThreadByID(thread->GetID());
result.SetDidChangeProcessState(true); result.SetDidChangeProcessState(true);
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
} else { } else {
result.SetStatus(eReturnStatusSuccessContinuingNoResult); result.SetStatus(eReturnStatusSuccessContinuingNoResult);
} }
} else { } else {
▲ Show 20 Lines • Show All 160 Lines • ▼ Show 20 Lines if ((state == eStateCrashed) || (state == eStateStopped) ||
// We should not be holding the thread list lock when we do this. // We should not be holding the thread list lock when we do this.
if (error.Success()) { if (error.Success()) {
result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n", result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n",
process->GetID()); process->GetID());
if (synchronous_execution) { if (synchronous_execution) {
// If any state changed events had anything to say, add that to the // If any state changed events had anything to say, add that to the
// result // result
if (stream.GetData()) if (stream.GetSize() > 0)
result.AppendMessage(stream.GetData()); result.AppendMessage(stream.GetString());
result.SetDidChangeProcessState(true); result.SetDidChangeProcessState(true);
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
} else { } else {
result.SetStatus(eReturnStatusSuccessContinuingNoResult); result.SetStatus(eReturnStatusSuccessContinuingNoResult);
} }
} else { } else {
result.AppendErrorWithFormat("Failed to resume process: %s\n", result.AppendErrorWithFormat("Failed to resume process: %s\n",
▲ Show 20 Lines • Show All 312 Lines • ▼ Show 20 Lines if (process == nullptr) {
error = process->Resume(); error = process->Resume();
if (error.Success()) { if (error.Success()) {
result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n", result.AppendMessageWithFormat("Process %" PRIu64 " resuming\n",
process->GetID()); process->GetID());
if (synchronous_execution) { if (synchronous_execution) {
// If any state changed events had anything to say, add that to the // If any state changed events had anything to say, add that to the
// result // result
if (stream.GetData()) if (stream.GetSize() > 0)
result.AppendMessage(stream.GetData()); result.AppendMessage(stream.GetString());
result.SetDidChangeProcessState(true); result.SetDidChangeProcessState(true);
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
} else { } else {
result.SetStatus(eReturnStatusSuccessContinuingNoResult); result.SetStatus(eReturnStatusSuccessContinuingNoResult);
} }
} else { } else {
result.AppendErrorWithFormat("Failed to resume process: %s.\n", result.AppendErrorWithFormat("Failed to resume process: %s.\n",
▲ Show 20 Lines • Show All 790 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectType.cpp

Show First 20 Lines • Show All 3,004 Lines • ▼ Show 20 Lines CommandObjectFormatterInfo(CommandInterpreter &interpreter,
const char *formatter_name, const char *formatter_name,
DiscoveryFunction discovery_func) DiscoveryFunction discovery_func)
: CommandObjectRaw(interpreter, "", "", "", : CommandObjectRaw(interpreter, "", "", "",
eCommandRequiresFrame), eCommandRequiresFrame),
m_formatter_name(formatter_name ? formatter_name : ""), m_formatter_name(formatter_name ? formatter_name : ""),
m_discovery_function(discovery_func) { m_discovery_function(discovery_func) {
StreamString name; StreamString name;
name.Printf("type %s info", formatter_name); name.Printf("type %s info", formatter_name);
SetCommandName(name.GetData()); SetCommandName(name.GetString());
StreamString help; StreamString help;
help.Printf("This command evaluates the provided expression and shows " help.Printf("This command evaluates the provided expression and shows "
"which %s is applied to the resulting value (if any).", "which %s is applied to the resulting value (if any).",
formatter_name); formatter_name);
SetHelp(help.GetData()); SetHelp(help.GetString());
StreamString syntax; StreamString syntax;
syntax.Printf("type %s info <expr>", formatter_name); syntax.Printf("type %s info <expr>", formatter_name);
SetSyntax(syntax.GetData()); SetSyntax(syntax.GetString());
} }
~CommandObjectFormatterInfo() override = default; ~CommandObjectFormatterInfo() override = default;
protected: protected:
bool DoExecute(const char *command, CommandReturnObject &result) override { bool DoExecute(const char *command, CommandReturnObject &result) override {
TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget(); TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget();
Thread *thread = GetDefaultThread(); Thread *thread = GetDefaultThread();
▲ Show 20 Lines • Show All 197 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Address.cpp

Show First 20 Lines • Show All 710 Lines • ▼ Show 20 Lines if (process) {
Address dereferenced_addr; Address dereferenced_addr;
if (dereferenced_addr.SetLoadAddress(dereferenced_load_addr, if (dereferenced_addr.SetLoadAddress(dereferenced_load_addr,
target)) { target)) {
StreamString strm; StreamString strm;
if (dereferenced_addr.Dump(&strm, exe_scope, if (dereferenced_addr.Dump(&strm, exe_scope,
DumpStyleResolvedDescription, DumpStyleResolvedDescription,
DumpStyleInvalid, addr_size)) { DumpStyleInvalid, addr_size)) {
s->Address(dereferenced_load_addr, addr_size, " -> ", " "); s->Address(dereferenced_load_addr, addr_size, " -> ", " ");
s->Write(strm.GetData(), strm.GetSize()); s->Write(strm.GetString().data(), strm.GetSize());
return true; return true;
} }
} }
} }
} }
} }
if (fallback_style != DumpStyleInvalid) if (fallback_style != DumpStyleInvalid)
return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size); return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

lldb/trunk/source/Core/DataExtractor.cpp

Show First 20 Lines • Show All 1,975 Lines • ▼ Show 20 Lineslldb::offset_t DataExtractor::PutToLog(Log *log, offset_t start_offset,
offset_t end_offset; offset_t end_offset;
uint32_t count; uint32_t count;
StreamString sstr; StreamString sstr;
for (offset = start_offset, end_offset = offset + length, count = 0; for (offset = start_offset, end_offset = offset + length, count = 0;
ValidOffset(offset) && offset < end_offset; ++count) { ValidOffset(offset) && offset < end_offset; ++count) {
if ((count % num_per_line) == 0) { if ((count % num_per_line) == 0) {
// Print out any previous string // Print out any previous string
if (sstr.GetSize() > 0) { if (sstr.GetSize() > 0) {
log->Printf("%s", sstr.GetData()); log->PutString(sstr.GetString());
sstr.Clear(); sstr.Clear();
} }
// Reset string offset and fill the current line string with address: // Reset string offset and fill the current line string with address:
if (base_addr != LLDB_INVALID_ADDRESS) if (base_addr != LLDB_INVALID_ADDRESS)
sstr.Printf("0x%8.8" PRIx64 ":", sstr.Printf("0x%8.8" PRIx64 ":",
(uint64_t)(base_addr + (offset - start_offset))); (uint64_t)(base_addr + (offset - start_offset)));
} }
Show All 21 Lines case TypeULEB128:
sstr.Printf(format ? format : " 0x%" PRIx64, GetULEB128(&offset)); sstr.Printf(format ? format : " 0x%" PRIx64, GetULEB128(&offset));
break; break;
case TypeSLEB128: case TypeSLEB128:
sstr.Printf(format ? format : " %" PRId64, GetSLEB128(&offset)); sstr.Printf(format ? format : " %" PRId64, GetSLEB128(&offset));
break; break;
} }
} }
if (sstr.GetSize() > 0) if (!sstr.Empty())
log->Printf("%s", sstr.GetData()); log->PutString(sstr.GetString());
return offset; // Return the offset at which we ended up return offset; // Return the offset at which we ended up
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// DumpUUID // DumpUUID
// //
// Dump out a UUID starting at 'offset' bytes into the buffer // Dump out a UUID starting at 'offset' bytes into the buffer
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Debugger.cpp

Show First 20 Lines • Show All 314 Lines • ▼ Show 20 Lines if (strcmp(property_path, g_properties[ePropertyPrompt].name) == 0) {
StreamString feedback_stream; StreamString feedback_stream;
if (!target_sp->LoadScriptingResources(errors, &feedback_stream)) { if (!target_sp->LoadScriptingResources(errors, &feedback_stream)) {
StreamFileSP stream_sp(GetErrorFile()); StreamFileSP stream_sp(GetErrorFile());
if (stream_sp) { if (stream_sp) {
for (auto error : errors) { for (auto error : errors) {
stream_sp->Printf("%s\n", error.AsCString()); stream_sp->Printf("%s\n", error.AsCString());
} }
if (feedback_stream.GetSize()) if (feedback_stream.GetSize())
stream_sp->Printf("%s", feedback_stream.GetData()); stream_sp->PutCString(feedback_stream.GetString());
} }
} }
} }
} else if (is_escape_non_printables) { } else if (is_escape_non_printables) {
DataVisualization::ForceUpdate(); DataVisualization::ForceUpdate();
} }
} }
return error; return error;
▲ Show 20 Lines • Show All 1,393 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Disassembler.cpp

Show First 20 Lines • Show All 729 Lines • ▼ Show 20 Linesvoid Instruction::Dump(lldb_private::Stream *s, uint32_t max_opcode_byte_size,
ss.PutCString(m_mnemonics); ss.PutCString(m_mnemonics);
if (!m_comment.empty()) { if (!m_comment.empty()) {
ss.FillLastLineToColumn( ss.FillLastLineToColumn(
opcode_pos + opcode_column_width + operand_column_width, ' '); opcode_pos + opcode_column_width + operand_column_width, ' ');
ss.PutCString(" ; "); ss.PutCString(" ; ");
ss.PutCString(m_comment); ss.PutCString(m_comment);
} }
s->Write(ss.GetData(), ss.GetSize()); s->PutCString(ss.GetString());
} }
bool Instruction::DumpEmulation(const ArchSpec &arch) { bool Instruction::DumpEmulation(const ArchSpec &arch) {
std::unique_ptr<EmulateInstruction> insn_emulator_ap( std::unique_ptr<EmulateInstruction> insn_emulator_ap(
EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr)); EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr));
if (insn_emulator_ap) { if (insn_emulator_ap) {
insn_emulator_ap->SetInstruction(GetOpcode(), GetAddress(), nullptr); insn_emulator_ap->SetInstruction(GetOpcode(), GetAddress(), nullptr);
return insn_emulator_ap->EvaluateInstruction(0); return insn_emulator_ap->EvaluateInstruction(0);
▲ Show 20 Lines • Show All 705 Lines • Show Last 20 Lines

lldb/trunk/source/Core/EmulateInstruction.cpp

Show First 20 Lines • Show All 188 Lines • ▼ Show 20 Lines
} }
bool EmulateInstruction::WriteMemoryUnsigned(const Context &context, bool EmulateInstruction::WriteMemoryUnsigned(const Context &context,
lldb::addr_t addr, uint64_t uval, lldb::addr_t addr, uint64_t uval,
size_t uval_byte_size) { size_t uval_byte_size) {
StreamString strm(Stream::eBinary, GetAddressByteSize(), GetByteOrder()); StreamString strm(Stream::eBinary, GetAddressByteSize(), GetByteOrder());
strm.PutMaxHex64(uval, uval_byte_size); strm.PutMaxHex64(uval, uval_byte_size);
size_t bytes_written = m_write_mem_callback(this, m_baton, context, addr, size_t bytes_written = m_write_mem_callback(
strm.GetData(), uval_byte_size); this, m_baton, context, addr, strm.GetString().data(), uval_byte_size);
return (bytes_written == uval_byte_size); return (bytes_written == uval_byte_size);
} }
bool EmulateInstruction::WriteMemory(const Context &context, lldb::addr_t addr, bool EmulateInstruction::WriteMemory(const Context &context, lldb::addr_t addr,
const void *src, size_t src_len) { const void *src, size_t src_len) {
if (m_write_mem_callback != nullptr) if (m_write_mem_callback != nullptr)
return m_write_mem_callback(this, m_baton, context, addr, src, src_len) == return m_write_mem_callback(this, m_baton, context, addr, src, src_len) ==
src_len; src_len;
▲ Show 20 Lines • Show All 378 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Error.cpp

Show First 20 Lines • Show All 258 Lines • ▼ Show 20 Lines
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Set accessor for the error string value for a specific error. // Set accessor for the error string value for a specific error.
// This allows any string to be supplied as an error explanation. // This allows any string to be supplied as an error explanation.
// The error string value will remain until the error value is // The error string value will remain until the error value is
// cleared or a new error value/type is assigned. // cleared or a new error value/type is assigned.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void Error::SetErrorString(const char *err_str) { void Error::SetErrorString(llvm::StringRef err_str) {
if (err_str != nullptr && err_str[0]) { if (!err_str.empty()) {
// If we have an error string, we should always at least have // If we have an error string, we should always at least have an error
// an error set to a generic value. // set to a generic value.
if (Success()) if (Success())
SetErrorToGenericError(); SetErrorToGenericError();
}
m_string = err_str; m_string = err_str;
} else
m_string.clear();
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Set the current error string to a formatted error string. /// Set the current error string to a formatted error string.
/// ///
/// @param format /// @param format
/// A printf style format string /// A printf style format string
//------------------------------------------------------------------ //------------------------------------------------------------------
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Event.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Linesvoid Event::Dump(Stream *s) const {
if (broadcaster) { if (broadcaster) {
StreamString event_name; StreamString event_name;
if (broadcaster->GetEventNames(event_name, m_type, false)) if (broadcaster->GetEventNames(event_name, m_type, false))
s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x (%s), data = ", s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x (%s), data = ",
static_cast<const void *>(this), static_cast<const void *>(this),
static_cast<void *>(broadcaster), static_cast<void *>(broadcaster),
broadcaster->GetBroadcasterName().GetCString(), m_type, broadcaster->GetBroadcasterName().GetCString(), m_type,
event_name.GetString().c_str()); event_name.GetData());
else else
s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x, data = ", s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x, data = ",
static_cast<const void *>(this), static_cast<const void *>(this),
static_cast<void *>(broadcaster), static_cast<void *>(broadcaster),
broadcaster->GetBroadcasterName().GetCString(), m_type); broadcaster->GetBroadcasterName().GetCString(), m_type);
} else } else
s->Printf("%p Event: broadcaster = NULL, type = 0x%8.8x, data = ", s->Printf("%p Event: broadcaster = NULL, type = 0x%8.8x, data = ",
static_cast<const void *>(this), m_type); static_cast<const void *>(this), m_type);
▲ Show 20 Lines • Show All 229 Lines • Show Last 20 Lines

lldb/trunk/source/Core/FormatEntity.cpp

Show First 20 Lines • Show All 823 Lines • ▼ Show 20 Linesstatic bool DumpValue(Stream &s, const SymbolContext *sc,
// if we were originally dealing with just a T - that would get // if we were originally dealing with just a T - that would get
// us into an endless recursion // us into an endless recursion
if (target->IsBitfield() && was_var_indexed) { if (target->IsBitfield() && was_var_indexed) {
// TODO: check for a (T:n)-specific summary - we should still obey that // TODO: check for a (T:n)-specific summary - we should still obey that
StreamString bitfield_name; StreamString bitfield_name;
bitfield_name.Printf("%s:%d", target->GetTypeName().AsCString(), bitfield_name.Printf("%s:%d", target->GetTypeName().AsCString(),
target->GetBitfieldBitSize()); target->GetBitfieldBitSize());
lldb::TypeNameSpecifierImplSP type_sp( lldb::TypeNameSpecifierImplSP type_sp(
new TypeNameSpecifierImpl(bitfield_name.GetData(), false)); new TypeNameSpecifierImpl(bitfield_name.GetString(), false));
if (val_obj_display == if (val_obj_display ==
ValueObject::eValueObjectRepresentationStyleSummary && ValueObject::eValueObjectRepresentationStyleSummary &&
!DataVisualization::GetSummaryForType(type_sp)) !DataVisualization::GetSummaryForType(type_sp))
val_obj_display = ValueObject::eValueObjectRepresentationStyleValue; val_obj_display = ValueObject::eValueObjectRepresentationStyleValue;
} }
// TODO use flags for these // TODO use flags for these
const uint32_t type_info_flags = const uint32_t type_info_flags =
Show All 20 Lines if (target->HasSpecialPrintableRepresentation(val_obj_display,
bool success = target->DumpPrintableRepresentation( bool success = target->DumpPrintableRepresentation(
str_temp, val_obj_display, custom_format); str_temp, val_obj_display, custom_format);
if (log) if (log)
log->Printf("[Debugger::FormatPrompt] special cases did%s match", log->Printf("[Debugger::FormatPrompt] special cases did%s match",
success ? "" : "n't"); success ? "" : "n't");
// should not happen // should not happen
if (success) if (success)
s << str_temp.GetData(); s << str_temp.GetString();
return true; return true;
} else { } else {
if (was_plain_var) // if ${var} if (was_plain_var) // if ${var}
{ {
s << target->GetTypeName() << " @ " << target->GetLocationAsCString(); s << target->GetTypeName() << " @ " << target->GetLocationAsCString();
} else if (is_pointer) // if pointer, value is the address stored } else if (is_pointer) // if pointer, value is the address stored
{ {
target->DumpPrintableRepresentation( target->DumpPrintableRepresentation(
▲ Show 20 Lines • Show All 624 Lines • ▼ Show 20 Lines if (sc->function)
language_plugin = Language::FindPlugin(sc->function->GetLanguage()); language_plugin = Language::FindPlugin(sc->function->GetLanguage());
else if (sc->symbol) else if (sc->symbol)
language_plugin = Language::FindPlugin(sc->symbol->GetLanguage()); language_plugin = Language::FindPlugin(sc->symbol->GetLanguage());
if (language_plugin) { if (language_plugin) {
language_plugin_handled = language_plugin->GetFunctionDisplayName( language_plugin_handled = language_plugin->GetFunctionDisplayName(
sc, exe_ctx, Language::FunctionNameRepresentation::eName, ss); sc, exe_ctx, Language::FunctionNameRepresentation::eName, ss);
} }
if (language_plugin_handled) { if (language_plugin_handled) {
s.PutCString(ss.GetData()); s << ss.GetString();
return true; return true;
} else { } else {
const char *name = nullptr; const char *name = nullptr;
if (sc->function) if (sc->function)
name = sc->function->GetName().AsCString(nullptr); name = sc->function->GetName().AsCString(nullptr);
else if (sc->symbol) else if (sc->symbol)
name = sc->symbol->GetName().AsCString(nullptr); name = sc->symbol->GetName().AsCString(nullptr);
if (name) { if (name) {
Show All 25 Lines case Entry::Type::FunctionNameNoArgs: {
else if (sc->symbol) else if (sc->symbol)
language_plugin = Language::FindPlugin(sc->symbol->GetLanguage()); language_plugin = Language::FindPlugin(sc->symbol->GetLanguage());
if (language_plugin) { if (language_plugin) {
language_plugin_handled = language_plugin->GetFunctionDisplayName( language_plugin_handled = language_plugin->GetFunctionDisplayName(
sc, exe_ctx, Language::FunctionNameRepresentation::eNameWithNoArgs, sc, exe_ctx, Language::FunctionNameRepresentation::eNameWithNoArgs,
ss); ss);
} }
if (language_plugin_handled) { if (language_plugin_handled) {
s.PutCString(ss.GetData()); s << ss.GetString();
return true; return true;
} else { } else {
ConstString name; ConstString name;
if (sc->function) if (sc->function)
name = sc->function->GetNameNoArguments(); name = sc->function->GetNameNoArguments();
else if (sc->symbol) else if (sc->symbol)
name = sc->symbol->GetNameNoArguments(); name = sc->symbol->GetNameNoArguments();
if (name) { if (name) {
Show All 12 Lines if (sc->function)
language_plugin = Language::FindPlugin(sc->function->GetLanguage()); language_plugin = Language::FindPlugin(sc->function->GetLanguage());
else if (sc->symbol) else if (sc->symbol)
language_plugin = Language::FindPlugin(sc->symbol->GetLanguage()); language_plugin = Language::FindPlugin(sc->symbol->GetLanguage());
if (language_plugin) { if (language_plugin) {
language_plugin_handled = language_plugin->GetFunctionDisplayName( language_plugin_handled = language_plugin->GetFunctionDisplayName(
sc, exe_ctx, Language::FunctionNameRepresentation::eNameWithArgs, ss); sc, exe_ctx, Language::FunctionNameRepresentation::eNameWithArgs, ss);
} }
if (language_plugin_handled) { if (language_plugin_handled) {
s.PutCString(ss.GetData()); s << ss.GetString();
return true; return true;
} else { } else {
// Print the function name with arguments in it // Print the function name with arguments in it
if (sc->function) { if (sc->function) {
ExecutionContextScope *exe_scope = ExecutionContextScope *exe_scope =
exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr; exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr;
const char *cstr = sc->function->GetName().AsCString(nullptr); const char *cstr = sc->function->GetName().AsCString(nullptr);
if (cstr) { if (cstr) {
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines if (language_plugin_handled) {
const size_t num_args = args.GetSize(); const size_t num_args = args.GetSize();
for (size_t arg_idx = 0; arg_idx < num_args; ++arg_idx) { for (size_t arg_idx = 0; arg_idx < num_args; ++arg_idx) {
std::string buffer; std::string buffer;
VariableSP var_sp(args.GetVariableAtIndex(arg_idx)); VariableSP var_sp(args.GetVariableAtIndex(arg_idx));
ValueObjectSP var_value_sp( ValueObjectSP var_value_sp(
ValueObjectVariable::Create(exe_scope, var_sp)); ValueObjectVariable::Create(exe_scope, var_sp));
StreamString ss; StreamString ss;
const char *var_representation = nullptr; llvm::StringRef var_representation;
const char *var_name = var_value_sp->GetName().GetCString(); const char *var_name = var_value_sp->GetName().GetCString();
if (var_value_sp->GetCompilerType().IsValid()) { if (var_value_sp->GetCompilerType().IsValid()) {
if (var_value_sp && exe_scope->CalculateTarget()) if (var_value_sp && exe_scope->CalculateTarget())
var_value_sp = var_value_sp =
var_value_sp->GetQualifiedRepresentationIfAvailable( var_value_sp->GetQualifiedRepresentationIfAvailable(
exe_scope->CalculateTarget() exe_scope->CalculateTarget()
->TargetProperties::GetPreferDynamicValue(), ->TargetProperties::GetPreferDynamicValue(),
exe_scope->CalculateTarget() exe_scope->CalculateTarget()
->TargetProperties::GetEnableSyntheticValue()); ->TargetProperties::GetEnableSyntheticValue());
if (var_value_sp->GetCompilerType().IsAggregateType() && if (var_value_sp->GetCompilerType().IsAggregateType() &&
DataVisualization::ShouldPrintAsOneLiner(*var_value_sp)) { DataVisualization::ShouldPrintAsOneLiner(*var_value_sp)) {
static StringSummaryFormat format( static StringSummaryFormat format(
TypeSummaryImpl::Flags() TypeSummaryImpl::Flags()
.SetHideItemNames(false) .SetHideItemNames(false)
.SetShowMembersOneLiner(true), .SetShowMembersOneLiner(true),
""); "");
format.FormatObject(var_value_sp.get(), buffer, format.FormatObject(var_value_sp.get(), buffer,
TypeSummaryOptions()); TypeSummaryOptions());
var_representation = buffer.c_str(); var_representation = buffer;
} else } else
var_value_sp->DumpPrintableRepresentation( var_value_sp->DumpPrintableRepresentation(
ss, ValueObject::ValueObjectRepresentationStyle:: ss, ValueObject::ValueObjectRepresentationStyle::
eValueObjectRepresentationStyleSummary, eValueObjectRepresentationStyleSummary,
eFormatDefault, eFormatDefault,
ValueObject::PrintableRepresentationSpecialCases::eAllow, ValueObject::PrintableRepresentationSpecialCases::eAllow,
false); false);
} }
if (ss.GetData() && ss.GetSize()) if (!ss.GetString().empty())
var_representation = ss.GetData(); var_representation = ss.GetString();
if (arg_idx > 0) if (arg_idx > 0)
s.PutCString(", "); s.PutCString(", ");
if (var_value_sp->GetError().Success()) { if (var_value_sp->GetError().Success()) {
if (var_representation) if (!var_representation.empty())
s.Printf("%s=%s", var_name, var_representation); s.Printf("%s=%s", var_name, var_representation.str().c_str());
else else
s.Printf("%s=%s at %s", var_name, s.Printf("%s=%s at %s", var_name,
var_value_sp->GetTypeName().GetCString(), var_value_sp->GetTypeName().GetCString(),
var_value_sp->GetLocationAsCString()); var_value_sp->GetLocationAsCString());
} else } else
s.Printf("%s=<unavailable>", var_name); s.Printf("%s=<unavailable>", var_name);
} }
▲ Show 20 Lines • Show All 174 Lines • ▼ Show 20 Lines if (key.equals(entry_def->name) || entry_def->name[0] == '*') {
if (value.empty()) { if (value.empty()) {
if (entry_def->type == FormatEntity::Entry::Type::Invalid) { if (entry_def->type == FormatEntity::Entry::Type::Invalid) {
if (entry_def->children) { if (entry_def->children) {
StreamString error_strm; StreamString error_strm;
error_strm.Printf("'%s' can't be specified on its own, you must " error_strm.Printf("'%s' can't be specified on its own, you must "
"access one of its children: ", "access one of its children: ",
entry_def->name); entry_def->name);
DumpCommaSeparatedChildEntryNames(error_strm, entry_def); DumpCommaSeparatedChildEntryNames(error_strm, entry_def);
error.SetErrorStringWithFormat("%s", error.SetErrorStringWithFormat("%s", error_strm.GetData());
error_strm.GetString().c_str());
} else if (sep_char == ':') { } else if (sep_char == ':') {
// Any value whose separator is a with a ':' means this value has a // Any value whose separator is a with a ':' means this value has a
// string argument // string argument
// that needs to be stored in the entry (like "${script.var:}"). // that needs to be stored in the entry (like "${script.var:}").
// In this case the string value is the empty string which is ok. // In this case the string value is the empty string which is ok.
} else { } else {
error.SetErrorStringWithFormat("%s", "invalid entry definitions"); error.SetErrorStringWithFormat("%s", "invalid entry definitions");
} }
Show All 20 Linesstatic Error ParseEntry(const llvm::StringRef &format_str,
if (parent->type == FormatEntity::Entry::Type::Root) if (parent->type == FormatEntity::Entry::Type::Root)
error_strm.Printf( error_strm.Printf(
"invalid top level item '%s'. Valid top level items are: ", "invalid top level item '%s'. Valid top level items are: ",
key.str().c_str()); key.str().c_str());
else else
error_strm.Printf("invalid member '%s' in '%s'. Valid members are: ", error_strm.Printf("invalid member '%s' in '%s'. Valid members are: ",
key.str().c_str(), parent->name); key.str().c_str(), parent->name);
DumpCommaSeparatedChildEntryNames(error_strm, parent); DumpCommaSeparatedChildEntryNames(error_strm, parent);
error.SetErrorStringWithFormat("%s", error_strm.GetString().c_str()); error.SetErrorStringWithFormat("%s", error_strm.GetData());
return error; return error;
} }
static const FormatEntity::Entry::Definition * static const FormatEntity::Entry::Definition *
FindEntry(const llvm::StringRef &format_str, FindEntry(const llvm::StringRef &format_str,
const FormatEntity::Entry::Definition *parent, const FormatEntity::Entry::Definition *parent,
llvm::StringRef &remainder) { llvm::StringRef &remainder) {
Error error; Error error;
▲ Show 20 Lines • Show All 450 Lines • Show Last 20 Lines

lldb/trunk/source/Core/IOHandler.cpp

Show First 20 Lines • Show All 2,416 Lines • ▼ Show 20 Lines if (thread) {
if (frame_sp) { if (frame_sp) {
StreamString strm; StreamString strm;
const SymbolContext &sc = const SymbolContext &sc =
frame_sp->GetSymbolContext(eSymbolContextEverything); frame_sp->GetSymbolContext(eSymbolContextEverything);
ExecutionContext exe_ctx(frame_sp); ExecutionContext exe_ctx(frame_sp);
if (FormatEntity::Format(m_format, strm, &sc, &exe_ctx, nullptr, if (FormatEntity::Format(m_format, strm, &sc, &exe_ctx, nullptr,
nullptr, false, false)) { nullptr, false, false)) {
int right_pad = 1; int right_pad = 1;
window.PutCStringTruncated(strm.GetString().c_str(), right_pad); window.PutCStringTruncated(strm.GetString().str().c_str(), right_pad);
} }
} }
} }
} }
void TreeDelegateGenerateChildren(TreeItem &item) override { void TreeDelegateGenerateChildren(TreeItem &item) override {
// No children for frames yet... // No children for frames yet...
} }
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linespublic:
void TreeDelegateDrawTreeItem(TreeItem &item, Window &window) override { void TreeDelegateDrawTreeItem(TreeItem &item, Window &window) override {
ThreadSP thread_sp = GetThread(item); ThreadSP thread_sp = GetThread(item);
if (thread_sp) { if (thread_sp) {
StreamString strm; StreamString strm;
ExecutionContext exe_ctx(thread_sp); ExecutionContext exe_ctx(thread_sp);
if (FormatEntity::Format(m_format, strm, nullptr, &exe_ctx, nullptr, if (FormatEntity::Format(m_format, strm, nullptr, &exe_ctx, nullptr,
nullptr, false, false)) { nullptr, false, false)) {
int right_pad = 1; int right_pad = 1;
window.PutCStringTruncated(strm.GetString().c_str(), right_pad); window.PutCStringTruncated(strm.GetString().str().c_str(), right_pad);
} }
} }
} }
void TreeDelegateGenerateChildren(TreeItem &item) override { void TreeDelegateGenerateChildren(TreeItem &item) override {
ProcessSP process_sp = GetProcess(); ProcessSP process_sp = GetProcess();
if (process_sp && process_sp->IsAlive()) { if (process_sp && process_sp->IsAlive()) {
StateType state = process_sp->GetState(); StateType state = process_sp->GetState();
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Linespublic:
void TreeDelegateDrawTreeItem(TreeItem &item, Window &window) override { void TreeDelegateDrawTreeItem(TreeItem &item, Window &window) override {
ProcessSP process_sp = GetProcess(); ProcessSP process_sp = GetProcess();
if (process_sp && process_sp->IsAlive()) { if (process_sp && process_sp->IsAlive()) {
StreamString strm; StreamString strm;
ExecutionContext exe_ctx(process_sp); ExecutionContext exe_ctx(process_sp);
if (FormatEntity::Format(m_format, strm, nullptr, &exe_ctx, nullptr, if (FormatEntity::Format(m_format, strm, nullptr, &exe_ctx, nullptr,
nullptr, false, false)) { nullptr, false, false)) {
int right_pad = 1; int right_pad = 1;
window.PutCStringTruncated(strm.GetString().c_str(), right_pad); window.PutCStringTruncated(strm.GetString().str().c_str(), right_pad);
} }
} }
} }
void TreeDelegateGenerateChildren(TreeItem &item) override { void TreeDelegateGenerateChildren(TreeItem &item) override {
ProcessSP process_sp = GetProcess(); ProcessSP process_sp = GetProcess();
if (process_sp && process_sp->IsAlive()) { if (process_sp && process_sp->IsAlive()) {
StateType state = process_sp->GetState(); StateType state = process_sp->GetState();
▲ Show 20 Lines • Show All 724 Lines • ▼ Show 20 Lines if (text && text[0]) {
m_text.SplitIntoLines(text); m_text.SplitIntoLines(text);
m_text.AppendString(""); m_text.AppendString("");
} }
if (key_help_array) { if (key_help_array) {
for (KeyHelp *key = key_help_array; key->ch; ++key) { for (KeyHelp *key = key_help_array; key->ch; ++key) {
StreamString key_description; StreamString key_description;
key_description.Printf("%10s - %s", CursesKeyToCString(key->ch), key_description.Printf("%10s - %s", CursesKeyToCString(key->ch),
key->description); key->description);
m_text.AppendString(std::move(key_description.GetString())); m_text.AppendString(key_description.GetString());
} }
} }
} }
HelpDialogDelegate::~HelpDialogDelegate() = default; HelpDialogDelegate::~HelpDialogDelegate() = default;
bool HelpDialogDelegate::WindowDelegateDraw(Window &window, bool force) { bool HelpDialogDelegate::WindowDelegateDraw(Window &window, bool force) {
window.Erase(); window.Erase();
▲ Show 20 Lines • Show All 268 Lines • ▼ Show 20 Lines case eMenuID_Process: {
if (thread_name && thread_name[0]) if (thread_name && thread_name[0])
thread_menu_title.Printf(" %s", thread_name); thread_menu_title.Printf(" %s", thread_name);
else { else {
const char *queue_name = thread_sp->GetQueueName(); const char *queue_name = thread_sp->GetQueueName();
if (queue_name && queue_name[0]) if (queue_name && queue_name[0])
thread_menu_title.Printf(" %s", queue_name); thread_menu_title.Printf(" %s", queue_name);
} }
menu.AddSubmenu( menu.AddSubmenu(
MenuSP(new Menu(thread_menu_title.GetString().c_str(), nullptr, MenuSP(new Menu(thread_menu_title.GetString().str().c_str(),
menu_char, thread_sp->GetID()))); nullptr, menu_char, thread_sp->GetID())));
} }
} else if (submenus.size() > 7) { } else if (submenus.size() > 7) {
// Remove the separator and any other thread submenu items // Remove the separator and any other thread submenu items
// that were previously added // that were previously added
submenus.erase(submenus.begin() + 7, submenus.end()); submenus.erase(submenus.begin() + 7, submenus.end());
} }
// Since we are adding and removing items we need to recalculate the name // Since we are adding and removing items we need to recalculate the name
// lengths // lengths
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines if (process) {
window.Printf("Process: %5" PRIu64 " %10s", process->GetID(), window.Printf("Process: %5" PRIu64 " %10s", process->GetID(),
StateAsCString(state)); StateAsCString(state));
if (StateIsStoppedState(state, true)) { if (StateIsStoppedState(state, true)) {
StreamString strm; StreamString strm;
if (thread && FormatEntity::Format(m_format, strm, nullptr, &exe_ctx, if (thread && FormatEntity::Format(m_format, strm, nullptr, &exe_ctx,
nullptr, nullptr, false, false)) { nullptr, nullptr, false, false)) {
window.MoveCursor(40, 0); window.MoveCursor(40, 0);
window.PutCStringTruncated(strm.GetString().c_str(), 1); window.PutCStringTruncated(strm.GetString().str().c_str(), 1);
} }
window.MoveCursor(60, 0); window.MoveCursor(60, 0);
if (frame) if (frame)
window.Printf("Frame: %3u PC = 0x%16.16" PRIx64, window.Printf("Frame: %3u PC = 0x%16.16" PRIx64,
frame->GetFrameIndex(), frame->GetFrameIndex(),
frame->GetFrameCodeAddress().GetOpcodeLoadAddress( frame->GetFrameCodeAddress().GetOpcodeLoadAddress(
exe_ctx.GetTargetPtr())); exe_ctx.GetTargetPtr()));
▲ Show 20 Lines • Show All 212 Lines • ▼ Show 20 Lines bool WindowDelegateDraw(Window &window, bool force) override {
const int window_width = window.GetWidth(); const int window_width = window.GetWidth();
window.Erase(); window.Erase();
window.DrawTitleBox("Sources"); window.DrawTitleBox("Sources");
if (!m_title.GetString().empty()) { if (!m_title.GetString().empty()) {
window.AttributeOn(A_REVERSE); window.AttributeOn(A_REVERSE);
window.MoveCursor(1, 1); window.MoveCursor(1, 1);
window.PutChar(' '); window.PutChar(' ');
window.PutCStringTruncated(m_title.GetString().c_str(), 1); window.PutCStringTruncated(m_title.GetString().str().c_str(), 1);
int x = window.GetCursorX(); int x = window.GetCursorX();
if (x < window_width - 1) { if (x < window_width - 1) {
window.Printf("%*s", window_width - x - 1, ""); window.Printf("%*s", window_width - x - 1, "");
} }
window.AttributeOff(A_REVERSE); window.AttributeOff(A_REVERSE);
} }
Target *target = exe_ctx.GetTargetPtr(); Target *target = exe_ctx.GetTargetPtr();
▲ Show 20 Lines • Show All 205 Lines • ▼ Show 20 Lines if (num_source_lines > 0) {
if (mnemonic != nullptr && operands != nullptr && comment != nullptr) if (mnemonic != nullptr && operands != nullptr && comment != nullptr)
strm.Printf("%-8s %-25s ; %s", mnemonic, operands, comment); strm.Printf("%-8s %-25s ; %s", mnemonic, operands, comment);
else if (mnemonic != nullptr && operands != nullptr) else if (mnemonic != nullptr && operands != nullptr)
strm.Printf("%-8s %s", mnemonic, operands); strm.Printf("%-8s %s", mnemonic, operands);
else if (mnemonic != nullptr) else if (mnemonic != nullptr)
strm.Printf("%s", mnemonic); strm.Printf("%s", mnemonic);
int right_pad = 1; int right_pad = 1;
window.PutCStringTruncated(strm.GetString().c_str(), right_pad); window.PutCStringTruncated(strm.GetData(), right_pad);
if (is_pc_line && frame_sp && if (is_pc_line && frame_sp &&
frame_sp->GetConcreteFrameIndex() == 0) { frame_sp->GetConcreteFrameIndex() == 0) {
StopInfoSP stop_info_sp; StopInfoSP stop_info_sp;
if (thread) if (thread)
stop_info_sp = thread->GetStopInfo(); stop_info_sp = thread->GetStopInfo();
if (stop_info_sp) { if (stop_info_sp) {
const char *stop_description = stop_info_sp->GetDescription(); const char *stop_description = stop_info_sp->GetDescription();
▲ Show 20 Lines • Show All 428 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Log.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
const Flags &Log::GetOptions() const { return m_options; } const Flags &Log::GetOptions() const { return m_options; }
Flags &Log::GetMask() { return m_mask_bits; } Flags &Log::GetMask() { return m_mask_bits; }
const Flags &Log::GetMask() const { return m_mask_bits; } const Flags &Log::GetMask() const { return m_mask_bits; }
void Log::PutCString(const char *cstr) { Printf("%s", cstr); } void Log::PutCString(const char *cstr) { Printf("%s", cstr); }
void Log::PutString(llvm::StringRef str) { PutCString(str.str().c_str()); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Simple variable argument logging with flags. // Simple variable argument logging with flags.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void Log::Printf(const char *format, ...) { void Log::Printf(const char *format, ...) {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
VAPrintf(format, args); VAPrintf(format, args);
▲ Show 20 Lines • Show All 390 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Module.cpp

Show First 20 Lines • Show All 310 Lines • ▼ Show 20 Lines if (process_sp) {
data_ap->GetByteSize(), readmem_error); data_ap->GetByteSize(), readmem_error);
if (bytes_read == size_to_read) { if (bytes_read == size_to_read) {
DataBufferSP data_sp(data_ap.release()); DataBufferSP data_sp(data_ap.release());
m_objfile_sp = ObjectFile::FindPlugin(shared_from_this(), process_sp, m_objfile_sp = ObjectFile::FindPlugin(shared_from_this(), process_sp,
header_addr, data_sp); header_addr, data_sp);
if (m_objfile_sp) { if (m_objfile_sp) {
StreamString s; StreamString s;
s.Printf("0x%16.16" PRIx64, header_addr); s.Printf("0x%16.16" PRIx64, header_addr);
m_object_name.SetCString(s.GetData()); m_object_name.SetString(s.GetString());
// Once we get the object file, update our module with the object // Once we get the object file, update our module with the object
// file's // file's
// architecture since it might differ in vendor/os if some parts were // architecture since it might differ in vendor/os if some parts were
// unknown. // unknown.
m_objfile_sp->GetArchitecture(m_arch); m_objfile_sp->GetArchitecture(m_arch);
} else { } else {
error.SetErrorString("unable to find suitable object file plug-in"); error.SetErrorString("unable to find suitable object file plug-in");
▲ Show 20 Lines • Show All 785 Lines • ▼ Show 20 Lines if (format && format[0]) {
va_end(args); va_end(args);
const int format_len = strlen(format); const int format_len = strlen(format);
if (format_len > 0) { if (format_len > 0) {
const char last_char = format[format_len - 1]; const char last_char = format[format_len - 1];
if (last_char != '\n' || last_char != '\r') if (last_char != '\n' || last_char != '\r')
strm.EOL(); strm.EOL();
} }
Host::SystemLog(Host::eSystemLogError, "%s", strm.GetString().c_str()); Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData());
} }
} }
bool Module::FileHasChanged() const { bool Module::FileHasChanged() const {
if (!m_file_has_changed) if (!m_file_has_changed)
m_file_has_changed = m_file_has_changed =
(FileSystem::GetModificationTime(m_file) != m_mod_time); (FileSystem::GetModificationTime(m_file) != m_mod_time);
return m_file_has_changed; return m_file_has_changed;
Show All 17 Lines if (FileHasChanged()) {
const int format_len = strlen(format); const int format_len = strlen(format);
if (format_len > 0) { if (format_len > 0) {
const char last_char = format[format_len - 1]; const char last_char = format[format_len - 1];
if (last_char != '\n' || last_char != '\r') if (last_char != '\n' || last_char != '\r')
strm.EOL(); strm.EOL();
} }
strm.PutCString("The debug session should be aborted as the original " strm.PutCString("The debug session should be aborted as the original "
"debug information has been overwritten.\n"); "debug information has been overwritten.\n");
Host::SystemLog(Host::eSystemLogError, "%s", strm.GetString().c_str()); Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData());
} }
} }
} }
} }
void Module::ReportWarning(const char *format, ...) { void Module::ReportWarning(const char *format, ...) {
if (format && format[0]) { if (format && format[0]) {
StreamString strm; StreamString strm;
strm.PutCString("warning: "); strm.PutCString("warning: ");
GetDescription(&strm, lldb::eDescriptionLevelFull); GetDescription(&strm, lldb::eDescriptionLevelFull);
strm.PutChar(' '); strm.PutChar(' ');
va_list args; va_list args;
va_start(args, format); va_start(args, format);
strm.PrintfVarArg(format, args); strm.PrintfVarArg(format, args);
va_end(args); va_end(args);
const int format_len = strlen(format); const int format_len = strlen(format);
if (format_len > 0) { if (format_len > 0) {
const char last_char = format[format_len - 1]; const char last_char = format[format_len - 1];
if (last_char != '\n' || last_char != '\r') if (last_char != '\n' || last_char != '\r')
strm.EOL(); strm.EOL();
} }
Host::SystemLog(Host::eSystemLogWarning, "%s", strm.GetString().c_str()); Host::SystemLog(Host::eSystemLogWarning, "%s", strm.GetData());
} }
} }
void Module::LogMessage(Log *log, const char *format, ...) { void Module::LogMessage(Log *log, const char *format, ...) {
if (log != nullptr) { if (log != nullptr) {
StreamString log_message; StreamString log_message;
GetDescription(&log_message, lldb::eDescriptionLevelFull); GetDescription(&log_message, lldb::eDescriptionLevelFull);
log_message.PutCString(": "); log_message.PutCString(": ");
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_message.PrintfVarArg(format, args); log_message.PrintfVarArg(format, args);
va_end(args); va_end(args);
log->PutCString(log_message.GetString().c_str()); log->PutCString(log_message.GetData());
} }
} }
void Module::LogMessageVerboseBacktrace(Log *log, const char *format, ...) { void Module::LogMessageVerboseBacktrace(Log *log, const char *format, ...) {
if (log != nullptr) { if (log != nullptr) {
StreamString log_message; StreamString log_message;
GetDescription(&log_message, lldb::eDescriptionLevelFull); GetDescription(&log_message, lldb::eDescriptionLevelFull);
log_message.PutCString(": "); log_message.PutCString(": ");
va_list args; va_list args;
va_start(args, format); va_start(args, format);
log_message.PrintfVarArg(format, args); log_message.PrintfVarArg(format, args);
va_end(args); va_end(args);
if (log->GetVerbose()) { if (log->GetVerbose()) {
std::string back_trace; std::string back_trace;
llvm::raw_string_ostream stream(back_trace); llvm::raw_string_ostream stream(back_trace);
llvm::sys::PrintStackTrace(stream); llvm::sys::PrintStackTrace(stream);
log_message.PutCString(back_trace); log_message.PutCString(back_trace);
} }
log->PutCString(log_message.GetString().c_str()); log->PutCString(log_message.GetData());
} }
} }
void Module::Dump(Stream *s) { void Module::Dump(Stream *s) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
// s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
s->Indent(); s->Indent();
s->Printf("Module %s%s%s%s\n", m_file.GetPath().c_str(), s->Printf("Module %s%s%s%s\n", m_file.GetPath().c_str(),
▲ Show 20 Lines • Show All 451 Lines • Show Last 20 Lines

lldb/trunk/source/Core/RegisterValue.cpp

Show All 40 Lines if (GetData(data)) {
// //
// prefix_with_name^prefix_with_alt_name is true // prefix_with_name^prefix_with_alt_name is true
// //
StreamString format_string; StreamString format_string;
if (reg_name_right_align_at && (prefix_with_name ^ prefix_with_alt_name)) if (reg_name_right_align_at && (prefix_with_name ^ prefix_with_alt_name))
format_string.Printf("%%%us", reg_name_right_align_at); format_string.Printf("%%%us", reg_name_right_align_at);
else else
format_string.Printf("%%s"); format_string.Printf("%%s");
const char *fmt = format_string.GetData(); std::string fmt = format_string.GetString();
if (prefix_with_name) { if (prefix_with_name) {
if (reg_info->name) { if (reg_info->name) {
s->Printf(fmt, reg_info->name); s->Printf(fmt.c_str(), reg_info->name);
name_printed = true; name_printed = true;
} else if (reg_info->alt_name) { } else if (reg_info->alt_name) {
s->Printf(fmt, reg_info->alt_name); s->Printf(fmt.c_str(), reg_info->alt_name);
prefix_with_alt_name = false; prefix_with_alt_name = false;
name_printed = true; name_printed = true;
} }
} }
if (prefix_with_alt_name) { if (prefix_with_alt_name) {
if (name_printed) if (name_printed)
s->PutChar('/'); s->PutChar('/');
if (reg_info->alt_name) { if (reg_info->alt_name) {
s->Printf(fmt, reg_info->alt_name); s->Printf(fmt.c_str(), reg_info->alt_name);
name_printed = true; name_printed = true;
} else if (!name_printed) { } else if (!name_printed) {
// No alternate name but we were asked to display a name, so show the // No alternate name but we were asked to display a name, so show the
// main name // main name
s->Printf(fmt, reg_info->name); s->Printf(fmt.c_str(), reg_info->name);
name_printed = true; name_printed = true;
} }
} }
if (name_printed) if (name_printed)
s->PutCString(" = "); s->PutCString(" = ");
if (format == eFormatDefault) if (format == eFormatDefault)
format = reg_info->format; format = reg_info->format;
▲ Show 20 Lines • Show All 882 Lines • Show Last 20 Lines

lldb/trunk/source/Core/StreamString.cpp

Show All 28 Linessize_t StreamString::Write(const void *s, size_t length) {
m_packet.append(reinterpret_cast<const char *>(s), length); m_packet.append(reinterpret_cast<const char *>(s), length);
return length; return length;
} }
void StreamString::Clear() { m_packet.clear(); } void StreamString::Clear() { m_packet.clear(); }
bool StreamString::Empty() const { return GetSize() == 0; } bool StreamString::Empty() const { return GetSize() == 0; }
const char *StreamString::GetData() const { return m_packet.c_str(); }
size_t StreamString::GetSize() const { return m_packet.size(); } size_t StreamString::GetSize() const { return m_packet.size(); }
size_t StreamString::GetSizeOfLastLine() const { size_t StreamString::GetSizeOfLastLine() const {
const size_t length = m_packet.size(); const size_t length = m_packet.size();
size_t last_line_begin_pos = m_packet.find_last_of("\r\n"); size_t last_line_begin_pos = m_packet.find_last_of("\r\n");
if (last_line_begin_pos == std::string::npos) { if (last_line_begin_pos == std::string::npos) {
return length; return length;
} else { } else {
++last_line_begin_pos; ++last_line_begin_pos;
return length - last_line_begin_pos; return length - last_line_begin_pos;
} }
} }
std::string &StreamString::GetString() { return m_packet; } llvm::StringRef StreamString::GetString() const { return m_packet; }
const std::string &StreamString::GetString() const { return m_packet; }
void StreamString::FillLastLineToColumn(uint32_t column, char fill_char) { void StreamString::FillLastLineToColumn(uint32_t column, char fill_char) {
const size_t length = m_packet.size(); const size_t length = m_packet.size();
size_t last_line_begin_pos = m_packet.find_last_of("\r\n"); size_t last_line_begin_pos = m_packet.find_last_of("\r\n");
if (last_line_begin_pos == std::string::npos) { if (last_line_begin_pos == std::string::npos) {
last_line_begin_pos = 0; last_line_begin_pos = 0;
} else { } else {
++last_line_begin_pos; ++last_line_begin_pos;
} }
const size_t line_columns = length - last_line_begin_pos; const size_t line_columns = length - last_line_begin_pos;
if (column > line_columns) { if (column > line_columns) {
m_packet.append(column - line_columns, fill_char); m_packet.append(column - line_columns, fill_char);
} }
} }

lldb/trunk/source/Core/StringList.cpp

Show First 20 Lines • Show All 198 Lines • ▼ Show 20 Linesstd::string StringList::CopyList(const char *item_preamble,
StreamString strm; StreamString strm;
for (size_t i = 0; i < GetSize(); i++) { for (size_t i = 0; i < GetSize(); i++) {
if (i && items_sep && items_sep[0]) if (i && items_sep && items_sep[0])
strm << items_sep; strm << items_sep;
if (item_preamble) if (item_preamble)
strm << item_preamble; strm << item_preamble;
strm << GetStringAtIndex(i); strm << GetStringAtIndex(i);
} }
return std::string(strm.GetData()); return strm.GetString();
} }
StringList &StringList::operator<<(const char *str) { StringList &StringList::operator<<(const char *str) {
AppendString(str); AppendString(str);
return *this; return *this;
} }
StringList &StringList::operator<<(const std::string &str) { StringList &StringList::operator<<(const std::string &str) {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

lldb/trunk/source/Core/StructuredData.cpp

//===---------------------StructuredData.cpp ---------------------*- C++ //===---------------------StructuredData.cpp ---------------------*- C++-*-===//
//-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 197 Lines • ▼ Show 20 LinesStructuredData::Object::GetObjectForDotSeparatedPath(llvm::StringRef path) {
} }
return this->shared_from_this(); return this->shared_from_this();
} }
void StructuredData::Object::DumpToStdout(bool pretty_print) const { void StructuredData::Object::DumpToStdout(bool pretty_print) const {
StreamString stream; StreamString stream;
Dump(stream, pretty_print); Dump(stream, pretty_print);
printf("%s\n", stream.GetString().c_str()); printf("%s\n", stream.GetData());
} }
void StructuredData::Array::Dump(Stream &s, bool pretty_print) const { void StructuredData::Array::Dump(Stream &s, bool pretty_print) const {
bool first = true; bool first = true;
s << "["; s << "[";
if (pretty_print) { if (pretty_print) {
s << "\n"; s << "\n";
s.IndentMore(); s.IndentMore();
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

lldb/trunk/source/Core/ValueObject.cpp

Show First 20 Lines • Show All 372 Lines • ▼ Show 20 Lines if (m_location_str.empty()) {
break; break;
case Value::eValueTypeLoadAddress: case Value::eValueTypeLoadAddress:
case Value::eValueTypeFileAddress: case Value::eValueTypeFileAddress:
case Value::eValueTypeHostAddress: { case Value::eValueTypeHostAddress: {
uint32_t addr_nibble_size = data.GetAddressByteSize() * 2; uint32_t addr_nibble_size = data.GetAddressByteSize() * 2;
sstr.Printf("0x%*.*llx", addr_nibble_size, addr_nibble_size, sstr.Printf("0x%*.*llx", addr_nibble_size, addr_nibble_size,
value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS)); value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS));
m_location_str.swap(sstr.GetString()); m_location_str = sstr.GetString();
} break; } break;
} }
} }
} }
return m_location_str.c_str(); return m_location_str.c_str();
} }
Value &ValueObject::GetValue() { return m_value; } Value &ValueObject::GetValue() { return m_value; }
▲ Show 20 Lines • Show All 549 Lines • ▼ Show 20 Linesbool ValueObject::SetData(DataExtractor &data, Error &error) {
// If we have reached this point, then we have successfully changed the value. // If we have reached this point, then we have successfully changed the value.
SetNeedsUpdate(); SetNeedsUpdate();
return true; return true;
} }
static bool CopyStringDataToBufferSP(const StreamString &source, static bool CopyStringDataToBufferSP(const StreamString &source,
lldb::DataBufferSP &destination) { lldb::DataBufferSP &destination) {
destination.reset(new DataBufferHeap(source.GetSize() + 1, 0)); destination.reset(new DataBufferHeap(source.GetSize() + 1, 0));
memcpy(destination->GetBytes(), source.GetString().c_str(), source.GetSize()); memcpy(destination->GetBytes(), source.GetString().data(), source.GetSize());
return true; return true;
} }
std::pair<size_t, bool> std::pair<size_t, bool>
ValueObject::ReadPointedString(lldb::DataBufferSP &buffer_sp, Error &error, ValueObject::ReadPointedString(lldb::DataBufferSP &buffer_sp, Error &error,
uint32_t max_length, bool honor_array, uint32_t max_length, bool honor_array,
Format item_format) { Format item_format) {
bool was_capped = false; bool was_capped = false;
▲ Show 20 Lines • Show All 176 Lines • ▼ Show 20 Lines if (compiler_type) {
if (compiler_type.IsIntegerType(is_signed) || if (compiler_type.IsIntegerType(is_signed) ||
compiler_type.IsPointerType()) { compiler_type.IsPointerType()) {
runtime = process->GetLanguageRuntime(eLanguageTypeObjC); runtime = process->GetLanguageRuntime(eLanguageTypeObjC);
} }
} }
} }
if (runtime && runtime->GetObjectDescription(s, *this)) { if (runtime && runtime->GetObjectDescription(s, *this)) {
m_object_desc_str.append(s.GetData()); m_object_desc_str.append(s.GetString());
} }
if (m_object_desc_str.empty()) if (m_object_desc_str.empty())
return NULL; return NULL;
else else
return m_object_desc_str.c_str(); return m_object_desc_str.c_str();
} }
▲ Show 20 Lines • Show All 260 Lines • ▼ Show 20 Linesbool ValueObject::DumpPrintableRepresentation(
} }
if (only_special) if (only_special)
return false; return false;
bool var_success = false; bool var_success = false;
{ {
const char *cstr = NULL; llvm::StringRef str;
// this is a local stream that we are using to ensure that the data pointed // this is a local stream that we are using to ensure that the data pointed
// to by cstr survives // to by cstr survives long enough for us to copy it to its destination - it
// long enough for us to copy it to its destination - it is necessary to // is necessary to have this temporary storage area for cases where our
// have this temporary storage // desired output is not backed by some other longer-term storage
// area for cases where our desired output is not backed by some other
// longer-term storage
StreamString strm; StreamString strm;
if (custom_format != eFormatInvalid) if (custom_format != eFormatInvalid)
SetFormat(custom_format); SetFormat(custom_format);
switch (val_obj_display) { switch (val_obj_display) {
case eValueObjectRepresentationStyleValue: case eValueObjectRepresentationStyleValue:
cstr = GetValueAsCString(); str = GetValueAsCString();
break; break;
case eValueObjectRepresentationStyleSummary: case eValueObjectRepresentationStyleSummary:
cstr = GetSummaryAsCString(); str = GetSummaryAsCString();
break; break;
case eValueObjectRepresentationStyleLanguageSpecific: case eValueObjectRepresentationStyleLanguageSpecific:
cstr = GetObjectDescription(); str = GetObjectDescription();
break; break;
case eValueObjectRepresentationStyleLocation: case eValueObjectRepresentationStyleLocation:
cstr = GetLocationAsCString(); str = GetLocationAsCString();
break; break;
case eValueObjectRepresentationStyleChildrenCount: case eValueObjectRepresentationStyleChildrenCount:
strm.Printf("%" PRIu64 "", (uint64_t)GetNumChildren()); strm.Printf("%" PRIu64 "", (uint64_t)GetNumChildren());
cstr = strm.GetString().c_str(); str = strm.GetString();
break; break;
case eValueObjectRepresentationStyleType: case eValueObjectRepresentationStyleType:
cstr = GetTypeName().AsCString(); str = GetTypeName().GetStringRef();
break; break;
case eValueObjectRepresentationStyleName: case eValueObjectRepresentationStyleName:
cstr = GetName().AsCString(); str = GetName().GetStringRef();
break; break;
case eValueObjectRepresentationStyleExpressionPath: case eValueObjectRepresentationStyleExpressionPath:
GetExpressionPath(strm, false); GetExpressionPath(strm, false);
cstr = strm.GetString().c_str(); str = strm.GetString();
break; break;
} }
if (!cstr) { if (str.empty()) {
if (val_obj_display == eValueObjectRepresentationStyleValue) if (val_obj_display == eValueObjectRepresentationStyleValue)
cstr = GetSummaryAsCString(); str = GetSummaryAsCString();
else if (val_obj_display == eValueObjectRepresentationStyleSummary) { else if (val_obj_display == eValueObjectRepresentationStyleSummary) {
if (!CanProvideValue()) { if (!CanProvideValue()) {
strm.Printf("%s @ %s", GetTypeName().AsCString(), strm.Printf("%s @ %s", GetTypeName().AsCString(),
GetLocationAsCString()); GetLocationAsCString());
cstr = strm.GetString().c_str(); str = strm.GetString();
} else } else
cstr = GetValueAsCString(); str = GetValueAsCString();
} }
} }
if (cstr) if (!str.empty())
s.PutCString(cstr); s << str;
else { else {
if (m_error.Fail()) { if (m_error.Fail()) {
if (do_dump_error) if (do_dump_error)
s.Printf("<%s>", m_error.AsCString()); s.Printf("<%s>", m_error.AsCString());
else else
return false; return false;
} else if (val_obj_display == eValueObjectRepresentationStyleSummary) } else if (val_obj_display == eValueObjectRepresentationStyleSummary)
s.PutCString("<no summary available>"); s.PutCString("<no summary available>");
▲ Show 20 Lines • Show All 1,858 Lines • ▼ Show 20 Lines if (m_deref_valobj) {
return m_deref_valobj->GetSP(); return m_deref_valobj->GetSP();
} else { } else {
StreamString strm; StreamString strm;
GetExpressionPath(strm, true); GetExpressionPath(strm, true);
if (is_pointer_or_reference_type) if (is_pointer_or_reference_type)
error.SetErrorStringWithFormat("dereference failed: (%s) %s", error.SetErrorStringWithFormat("dereference failed: (%s) %s",
GetTypeName().AsCString("<invalid type>"), GetTypeName().AsCString("<invalid type>"),
strm.GetString().c_str()); strm.GetData());
else else
error.SetErrorStringWithFormat("not a pointer or reference type: (%s) %s", error.SetErrorStringWithFormat("not a pointer or reference type: (%s) %s",
GetTypeName().AsCString("<invalid type>"), GetTypeName().AsCString("<invalid type>"),
strm.GetString().c_str()); strm.GetData());
return ValueObjectSP(); return ValueObjectSP();
} }
} }
ValueObjectSP ValueObject::AddressOf(Error &error) { ValueObjectSP ValueObject::AddressOf(Error &error) {
if (m_addr_of_valobj_sp) if (m_addr_of_valobj_sp)
return m_addr_of_valobj_sp; return m_addr_of_valobj_sp;
AddressType address_type = eAddressTypeInvalid; AddressType address_type = eAddressTypeInvalid;
const bool scalar_is_load_address = false; const bool scalar_is_load_address = false;
addr_t addr = GetAddressOf(scalar_is_load_address, &address_type); addr_t addr = GetAddressOf(scalar_is_load_address, &address_type);
error.Clear(); error.Clear();
if (addr != LLDB_INVALID_ADDRESS && address_type != eAddressTypeHost) { if (addr != LLDB_INVALID_ADDRESS && address_type != eAddressTypeHost) {
switch (address_type) { switch (address_type) {
case eAddressTypeInvalid: { case eAddressTypeInvalid: {
StreamString expr_path_strm; StreamString expr_path_strm;
GetExpressionPath(expr_path_strm, true); GetExpressionPath(expr_path_strm, true);
error.SetErrorStringWithFormat("'%s' is not in memory", error.SetErrorStringWithFormat("'%s' is not in memory",
expr_path_strm.GetString().c_str()); expr_path_strm.GetData());
} break; } break;
case eAddressTypeFile: case eAddressTypeFile:
case eAddressTypeLoad: { case eAddressTypeLoad: {
CompilerType compiler_type = GetCompilerType(); CompilerType compiler_type = GetCompilerType();
if (compiler_type) { if (compiler_type) {
std::string name(1, '&'); std::string name(1, '&');
name.append(m_name.AsCString("")); name.append(m_name.AsCString(""));
ExecutionContext exe_ctx(GetExecutionContextRef()); ExecutionContext exe_ctx(GetExecutionContextRef());
m_addr_of_valobj_sp = ValueObjectConstResult::Create( m_addr_of_valobj_sp = ValueObjectConstResult::Create(
exe_ctx.GetBestExecutionContextScope(), exe_ctx.GetBestExecutionContextScope(),
compiler_type.GetPointerType(), ConstString(name.c_str()), addr, compiler_type.GetPointerType(), ConstString(name.c_str()), addr,
eAddressTypeInvalid, m_data.GetAddressByteSize()); eAddressTypeInvalid, m_data.GetAddressByteSize());
} }
} break; } break;
default: default:
break; break;
} }
} else { } else {
StreamString expr_path_strm; StreamString expr_path_strm;
GetExpressionPath(expr_path_strm, true); GetExpressionPath(expr_path_strm, true);
error.SetErrorStringWithFormat("'%s' doesn't have a valid address", error.SetErrorStringWithFormat("'%s' doesn't have a valid address",
expr_path_strm.GetString().c_str()); expr_path_strm.GetData());
} }
return m_addr_of_valobj_sp; return m_addr_of_valobj_sp;
} }
ValueObjectSP ValueObject::Cast(const CompilerType &compiler_type) { ValueObjectSP ValueObject::Cast(const CompilerType &compiler_type) {
return ValueObjectCast::Create(*this, GetName(), compiler_type); return ValueObjectCast::Create(*this, GetName(), compiler_type);
} }
▲ Show 20 Lines • Show All 396 Lines • Show Last 20 Lines

lldb/trunk/source/DataFormatters/FormatManager.cpp

//===-- FormatManager.cpp -------------------------------------------*- C++ //===-- FormatManager.cpp ----------------------------------------*- C++-*-===//
//-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Linesvoid FormatManager::GetPossibleMatches(
lldb::DynamicValueType use_dynamic, FormattersMatchVector &entries, lldb::DynamicValueType use_dynamic, FormattersMatchVector &entries,
bool did_strip_ptr, bool did_strip_ref, bool did_strip_typedef, bool did_strip_ptr, bool did_strip_ref, bool did_strip_typedef,
bool root_level) { bool root_level) {
compiler_type = compiler_type.GetTypeForFormatters(); compiler_type = compiler_type.GetTypeForFormatters();
ConstString type_name(compiler_type.GetConstTypeName()); ConstString type_name(compiler_type.GetConstTypeName());
if (valobj.GetBitfieldBitSize() > 0) { if (valobj.GetBitfieldBitSize() > 0) {
StreamString sstring; StreamString sstring;
sstring.Printf("%s:%d", type_name.AsCString(), valobj.GetBitfieldBitSize()); sstring.Printf("%s:%d", type_name.AsCString(), valobj.GetBitfieldBitSize());
ConstString bitfieldname = ConstString(sstring.GetData()); ConstString bitfieldname(sstring.GetString());
entries.push_back( entries.push_back(
{bitfieldname, 0, did_strip_ptr, did_strip_ref, did_strip_typedef}); {bitfieldname, 0, did_strip_ptr, did_strip_ref, did_strip_typedef});
reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField; reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField;
} }
if (!compiler_type.IsMeaninglessWithoutDynamicResolution()) { if (!compiler_type.IsMeaninglessWithoutDynamicResolution()) {
entries.push_back( entries.push_back(
{type_name, reason, did_strip_ptr, did_strip_ref, did_strip_typedef}); {type_name, reason, did_strip_ptr, did_strip_ref, did_strip_typedef});
▲ Show 20 Lines • Show All 892 Lines • Show Last 20 Lines

lldb/trunk/source/DataFormatters/TypeCategory.cpp

//===-- TypeCategory.cpp -------------------------------------------*- C++ //===-- TypeCategory.cpp -----------------------------------------*- C++-*-===//
//-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 622 Lines • ▼ Show 20 Linesstd::string TypeCategoryImpl::GetDescription() {
for (size_t idx = 0; idx < GetNumLanguages(); idx++) { for (size_t idx = 0; idx < GetNumLanguages(); idx++) {
const lldb::LanguageType lang = GetLanguageAtIndex(idx); const lldb::LanguageType lang = GetLanguageAtIndex(idx);
if (lang != lldb::eLanguageTypeUnknown) if (lang != lldb::eLanguageTypeUnknown)
print_lang = true; print_lang = true;
lang_stream.Printf("%s%s", Language::GetNameForLanguageType(lang), lang_stream.Printf("%s%s", Language::GetNameForLanguageType(lang),
idx + 1 < GetNumLanguages() ? ", " : ""); idx + 1 < GetNumLanguages() ? ", " : "");
} }
if (print_lang) if (print_lang)
stream.Printf("%s", lang_stream.GetData()); stream.PutCString(lang_stream.GetString());
stream.PutChar(')'); stream.PutChar(')');
return stream.GetData(); return stream.GetString();
} }

lldb/trunk/source/DataFormatters/TypeFormat.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines if (context_type == Value::eContextTypeRegisterInfo) {
valobj->GetData(data, error); valobj->GetData(data, error);
if (error.Fail()) if (error.Fail())
return false; return false;
StreamString reg_sstr; StreamString reg_sstr;
data.Dump(&reg_sstr, 0, GetFormat(), reg_info->byte_size, 1, UINT32_MAX, data.Dump(&reg_sstr, 0, GetFormat(), reg_info->byte_size, 1, UINT32_MAX,
LLDB_INVALID_ADDRESS, 0, 0, LLDB_INVALID_ADDRESS, 0, 0,
exe_ctx.GetBestExecutionContextScope()); exe_ctx.GetBestExecutionContextScope());
dest.swap(reg_sstr.GetString()); dest = reg_sstr.GetString();
} }
} else { } else {
CompilerType compiler_type = value.GetCompilerType(); CompilerType compiler_type = value.GetCompilerType();
if (compiler_type) { if (compiler_type) {
// put custom bytes to display in the DataExtractor to override the // put custom bytes to display in the DataExtractor to override the
// default value logic // default value logic
if (GetFormat() == eFormatCString) { if (GetFormat() == eFormatCString) {
lldb_private::Flags type_flags(compiler_type.GetTypeInfo( lldb_private::Flags type_flags(compiler_type.GetTypeInfo(
Show All 35 Lines if (context_type == Value::eContextTypeRegisterInfo) {
valobj->GetBitfieldBitOffset(), // Bitfield bit offset valobj->GetBitfieldBitOffset(), // Bitfield bit offset
exe_scope); exe_scope);
// Given that we do not want to set the ValueObject's m_error // Given that we do not want to set the ValueObject's m_error
// for a formatting error (or else we wouldn't be able to reformat // for a formatting error (or else we wouldn't be able to reformat
// until a next update), an empty string is treated as a "false" // until a next update), an empty string is treated as a "false"
// return from here, but that's about as severe as we get // return from here, but that's about as severe as we get
// CompilerType::DumpTypeValue() should always return // CompilerType::DumpTypeValue() should always return
// something, even if that something is an error message // something, even if that something is an error message
if (sstr.GetString().empty()) dest = sstr.GetString();
dest.clear();
else
dest.swap(sstr.GetString());
} }
} }
return !dest.empty(); return !dest.empty();
} else } else
return false; return false;
} }
std::string TypeFormatImpl_Format::GetDescription() { std::string TypeFormatImpl_Format::GetDescription() {
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Linesbool TypeFormatImpl_EnumType::FormatObject(ValueObject *valobj,
if (error.Fail()) if (error.Fail())
return false; return false;
ExecutionContext exe_ctx(valobj->GetExecutionContextRef()); ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
StreamString sstr; StreamString sstr;
valobj_enum_type.DumpTypeValue(&sstr, lldb::eFormatEnum, data, 0, valobj_enum_type.DumpTypeValue(&sstr, lldb::eFormatEnum, data, 0,
data.GetByteSize(), 0, 0, data.GetByteSize(), 0, 0,
exe_ctx.GetBestExecutionContextScope()); exe_ctx.GetBestExecutionContextScope());
if (!sstr.GetString().empty()) if (!sstr.GetString().empty())
dest.swap(sstr.GetString()); dest = sstr.GetString();
return !dest.empty(); return !dest.empty();
} }
std::string TypeFormatImpl_EnumType::GetDescription() { std::string TypeFormatImpl_EnumType::GetDescription() {
StreamString sstr; StreamString sstr;
sstr.Printf("as type %s%s%s%s", m_enum_type.AsCString("<invalid type>"), sstr.Printf("as type %s%s%s%s", m_enum_type.AsCString("<invalid type>"),
Cascades() ? "" : " (not cascading)", Cascades() ? "" : " (not cascading)",
SkipsPointers() ? " (skip pointers)" : "", SkipsPointers() ? " (skip pointers)" : "",
SkipsReferences() ? " (skip references)" : ""); SkipsReferences() ? " (skip references)" : "");
return sstr.GetString(); return sstr.GetString();
} }

lldb/trunk/source/DataFormatters/TypeSummary.cpp

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Linesbool StringSummaryFormat::FormatObject(ValueObject *valobj, std::string &retval,
SymbolContext sc; SymbolContext sc;
StackFrame *frame = exe_ctx.GetFramePtr(); StackFrame *frame = exe_ctx.GetFramePtr();
if (frame) if (frame)
sc = frame->GetSymbolContext(lldb::eSymbolContextEverything); sc = frame->GetSymbolContext(lldb::eSymbolContextEverything);
if (IsOneLiner()) { if (IsOneLiner()) {
ValueObjectPrinter printer(valobj, &s, DumpValueObjectOptions()); ValueObjectPrinter printer(valobj, &s, DumpValueObjectOptions());
printer.PrintChildrenOneLiner(HideNames(valobj)); printer.PrintChildrenOneLiner(HideNames(valobj));
retval.assign(s.GetData()); retval = s.GetString();
return true; return true;
} else { } else {
if (FormatEntity::Format(m_format, s, &sc, &exe_ctx, if (FormatEntity::Format(m_format, s, &sc, &exe_ctx,
&sc.line_entry.range.GetBaseAddress(), valobj, &sc.line_entry.range.GetBaseAddress(), valobj,
false, false)) { false, false)) {
retval.assign(s.GetString()); retval.assign(s.GetString());
return true; return true;
} else { } else {
Show All 26 Lines
bool CXXFunctionSummaryFormat::FormatObject(ValueObject *valobj, bool CXXFunctionSummaryFormat::FormatObject(ValueObject *valobj,
std::string &dest, std::string &dest,
const TypeSummaryOptions &options) { const TypeSummaryOptions &options) {
dest.clear(); dest.clear();
StreamString stream; StreamString stream;
if (!m_impl || m_impl(*valobj, stream, options) == false) if (!m_impl || m_impl(*valobj, stream, options) == false)
return false; return false;
dest.assign(stream.GetData()); dest = stream.GetString();
return true; return true;
} }
std::string CXXFunctionSummaryFormat::GetDescription() { std::string CXXFunctionSummaryFormat::GetDescription() {
StreamString sstr; StreamString sstr;
sstr.Printf("%s%s%s%s%s%s%s %s", Cascades() ? "" : " (not cascading)", sstr.Printf("%s%s%s%s%s%s%s %s", Cascades() ? "" : " (not cascading)",
!DoesPrintChildren(nullptr) ? "" : " (show children)", !DoesPrintChildren(nullptr) ? "" : " (show children)",
!DoesPrintValue(nullptr) ? " (hide value)" : "", !DoesPrintValue(nullptr) ? " (hide value)" : "",
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

lldb/trunk/source/DataFormatters/ValueObjectPrinter.cpp

//===-- ValueObjectPrinter.cpp -------------------------------------*- C++ //===-- ValueObjectPrinter.cpp -----------------------------------*- C++-*-===//
//-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 286 Lines • ▼ Show 20 Lines lldb::LanguageType lang_type =
? m_valobj->GetPreferredDisplayLanguage() ? m_valobj->GetPreferredDisplayLanguage()
: m_options.m_varformat_language; : m_options.m_varformat_language;
if (Language *lang_plugin = Language::FindPlugin(lang_type)) { if (Language *lang_plugin = Language::FindPlugin(lang_type)) {
m_options.m_decl_printing_helper = lang_plugin->GetDeclPrintingHelper(); m_options.m_decl_printing_helper = lang_plugin->GetDeclPrintingHelper();
} }
} }
if (m_options.m_decl_printing_helper) { if (m_options.m_decl_printing_helper) {
ConstString type_name_cstr(typeName.GetData()); ConstString type_name_cstr(typeName.GetString());
ConstString var_name_cstr(varName.GetData()); ConstString var_name_cstr(varName.GetString());
StreamString dest_stream; StreamString dest_stream;
if (m_options.m_decl_printing_helper(type_name_cstr, var_name_cstr, if (m_options.m_decl_printing_helper(type_name_cstr, var_name_cstr,
m_options, dest_stream)) { m_options, dest_stream)) {
decl_printed = true; decl_printed = true;
m_stream->Printf("%s", dest_stream.GetData()); m_stream->PutCString(dest_stream.GetString());
} }
} }
// if the helper failed, or there is none, do a default thing // if the helper failed, or there is none, do a default thing
if (!decl_printed) { if (!decl_printed) {
if (typeName.GetSize()) if (!typeName.Empty())
m_stream->Printf("(%s) ", typeName.GetData()); m_stream->Printf("(%s) ", typeName.GetData());
if (varName.GetSize()) if (!varName.Empty())
m_stream->Printf("%s =", varName.GetData()); m_stream->Printf("%s =", varName.GetData());
else if (!m_options.m_hide_name) else if (!m_options.m_hide_name)
m_stream->Printf(" ="); m_stream->Printf(" =");
} }
} }
bool ValueObjectPrinter::CheckScopeIfNeeded() { bool ValueObjectPrinter::CheckScopeIfNeeded() {
if (m_options.m_scope_already_checked) if (m_options.m_scope_already_checked)
▲ Show 20 Lines • Show All 528 Lines • Show Last 20 Lines

lldb/trunk/source/DataFormatters/VectorType.cpp

Show First 20 Lines • Show All 205 Lines • ▼ Show 20 Lines lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
auto offset = idx * m_child_type.GetByteSize(nullptr); auto offset = idx * m_child_type.GetByteSize(nullptr);
ValueObjectSP child_sp( ValueObjectSP child_sp(
m_backend.GetSyntheticChildAtOffset(offset, m_child_type, true)); m_backend.GetSyntheticChildAtOffset(offset, m_child_type, true));
if (!child_sp) if (!child_sp)
return child_sp; return child_sp;
StreamString idx_name; StreamString idx_name;
idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
child_sp->SetName(ConstString(idx_name.GetData())); child_sp->SetName(ConstString(idx_name.GetString()));
child_sp->SetFormat(m_item_format); child_sp->SetFormat(m_item_format);
return child_sp; return child_sp;
} }
bool Update() override { bool Update() override {
m_parent_format = m_backend.GetFormat(); m_parent_format = m_backend.GetFormat();
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/IRExecutionUnit.cpp

Show First 20 Lines • Show All 421 Lines • ▼ Show 20 Lines for (const ConstString &failed_lookup : m_failed_lookups) {
ss.PutCString(" "); ss.PutCString(" ");
ss.PutCString(Mangled(failed_lookup) ss.PutCString(Mangled(failed_lookup)
.GetDemangledName(lldb::eLanguageTypeObjC_plus_plus) .GetDemangledName(lldb::eLanguageTypeObjC_plus_plus)
.AsCString()); .AsCString());
} }
m_failed_lookups.clear(); m_failed_lookups.clear();
error.SetErrorString(ss.GetData()); error.SetErrorString(ss.GetString());
return; return;
} }
m_function_load_addr = LLDB_INVALID_ADDRESS; m_function_load_addr = LLDB_INVALID_ADDRESS;
m_function_end_load_addr = LLDB_INVALID_ADDRESS; m_function_end_load_addr = LLDB_INVALID_ADDRESS;
for (JittedFunction &jitted_function : m_jitted_functions) { for (JittedFunction &jitted_function : m_jitted_functions) {
▲ Show 20 Lines • Show All 845 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/LLVMUserExpression.cpp

Show First 20 Lines • Show All 147 Lines • ▼ Show 20 Lines if (m_can_interpret) {
} }
lldb::ThreadPlanSP call_plan_sp(new ThreadPlanCallUserExpression( lldb::ThreadPlanSP call_plan_sp(new ThreadPlanCallUserExpression(
exe_ctx.GetThreadRef(), wrapper_address, args, options, exe_ctx.GetThreadRef(), wrapper_address, args, options,
shared_ptr_to_me)); shared_ptr_to_me));
StreamString ss; StreamString ss;
if (!call_plan_sp || !call_plan_sp->ValidatePlan(&ss)) { if (!call_plan_sp || !call_plan_sp->ValidatePlan(&ss)) {
diagnostic_manager.PutString(eDiagnosticSeverityError, ss.GetData()); diagnostic_manager.PutString(eDiagnosticSeverityError, ss.GetString());
return lldb::eExpressionSetupError; return lldb::eExpressionSetupError;
} }
ThreadPlanCallUserExpression *user_expression_plan = ThreadPlanCallUserExpression *user_expression_plan =
static_cast<ThreadPlanCallUserExpression *>(call_plan_sp.get()); static_cast<ThreadPlanCallUserExpression *>(call_plan_sp.get());
lldb::addr_t function_stack_pointer = lldb::addr_t function_stack_pointer =
user_expression_plan->GetFunctionStackPointer(); user_expression_plan->GetFunctionStackPointer();
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/Materializer.cpp

Show First 20 Lines • Show All 403 Lines • ▼ Show 20 Lines dump_stream.Printf("0x%" PRIx64 ": EntityPersistentVariable (%s)\n",
extractor.DumpHexBytes(&dump_stream, data.GetBytes(), extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
data.GetByteSize(), 16, target_address); data.GetByteSize(), 16, target_address);
dump_stream.PutChar('\n'); dump_stream.PutChar('\n');
} }
} }
} }
log->PutCString(dump_stream.GetData()); log->PutString(dump_stream.GetString());
} }
void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override {} void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override {}
private: private:
lldb::ExpressionVariableSP m_persistent_variable_sp; lldb::ExpressionVariableSP m_persistent_variable_sp;
Materializer::PersistentVariableDelegate *m_delegate; Materializer::PersistentVariableDelegate *m_delegate;
}; };
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Lines if (ptr == LLDB_INVALID_ADDRESS) {
extractor.DumpHexBytes(&dump_stream, data.GetBytes(), extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
data.GetByteSize(), 16, load_addr); data.GetByteSize(), 16, load_addr);
dump_stream.PutChar('\n'); dump_stream.PutChar('\n');
} }
} }
log->PutCString(dump_stream.GetData()); log->PutString(dump_stream.GetString());
} }
void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override { void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override {
if (m_temporary_allocation != LLDB_INVALID_ADDRESS) { if (m_temporary_allocation != LLDB_INVALID_ADDRESS) {
Error free_error; Error free_error;
map.Free(m_temporary_allocation, free_error); map.Free(m_temporary_allocation, free_error);
▲ Show 20 Lines • Show All 253 Lines • ▼ Show 20 Lines if (ptr == LLDB_INVALID_ADDRESS) {
extractor.DumpHexBytes(&dump_stream, data.GetBytes(), extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
data.GetByteSize(), 16, load_addr); data.GetByteSize(), 16, load_addr);
dump_stream.PutChar('\n'); dump_stream.PutChar('\n');
} }
} }
log->PutCString(dump_stream.GetData()); log->PutString(dump_stream.GetString());
} }
void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override { void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override {
if (!m_keep_in_memory && m_temporary_allocation != LLDB_INVALID_ADDRESS) { if (!m_keep_in_memory && m_temporary_allocation != LLDB_INVALID_ADDRESS) {
Error free_error; Error free_error;
map.Free(m_temporary_allocation, free_error); map.Free(m_temporary_allocation, free_error);
} }
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Lines dump_stream.Printf("0x%" PRIx64 ": EntitySymbol (%s)\n", load_addr,
extractor.DumpHexBytes(&dump_stream, data.GetBytes(), extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
data.GetByteSize(), 16, load_addr); data.GetByteSize(), 16, load_addr);
dump_stream.PutChar('\n'); dump_stream.PutChar('\n');
} }
} }
log->PutCString(dump_stream.GetData()); log->PutString(dump_stream.GetString());
} }
void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override {} void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override {}
private: private:
Symbol m_symbol; Symbol m_symbol;
}; };
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Lines dump_stream.Printf("0x%" PRIx64 ": EntityRegister (%s)\n", load_addr,
extractor.DumpHexBytes(&dump_stream, data.GetBytes(), extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
data.GetByteSize(), 16, load_addr); data.GetByteSize(), 16, load_addr);
dump_stream.PutChar('\n'); dump_stream.PutChar('\n');
} }
} }
log->PutCString(dump_stream.GetData()); log->PutString(dump_stream.GetString());
} }
void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override {} void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override {}
private: private:
RegisterInfo m_register_info; RegisterInfo m_register_info;
lldb::DataBufferSP m_register_contents; lldb::DataBufferSP m_register_contents;
}; };
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

lldb/trunk/source/Host/macosx/Host.mm

Show First 20 Lines • Show All 472 Lines • ▼ Show 20 Lines if (argv) {
command.Printf(" '%s'", exe_path); command.Printf(" '%s'", exe_path);
} }
command.PutCString(" ; echo Process exited with status $?"); command.PutCString(" ; echo Process exited with status $?");
if (launch_info.GetFlags().Test(lldb::eLaunchFlagCloseTTYOnExit)) if (launch_info.GetFlags().Test(lldb::eLaunchFlagCloseTTYOnExit))
command.PutCString(" ; exit"); command.PutCString(" ; exit");
StreamString applescript_source; StreamString applescript_source;
const char *tty_command = command.GetString().c_str();
// if (tty_name && tty_name[0]) // if (tty_name && tty_name[0])
// { // {
// applescript_source.Printf (applscript_in_existing_tty, // applescript_source.Printf (applscript_in_existing_tty,
// tty_command, // tty_command,
// tty_name); // tty_name);
// } // }
// else // else
// { // {
applescript_source.Printf(applscript_in_new_tty, tty_command); applescript_source.Printf(applscript_in_new_tty,
command.GetString().str().c_str());
// } // }
const char *script_source = applescript_source.GetString().c_str();
// puts (script_source); // puts (script_source);
NSAppleScript *applescript = [[NSAppleScript alloc] NSAppleScript *applescript = [[NSAppleScript alloc]
initWithSource:[NSString stringWithCString:script_source initWithSource:[NSString stringWithCString:applescript_source.GetString()
.str()
.c_str()
encoding:NSUTF8StringEncoding]]; encoding:NSUTF8StringEncoding]];
lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
Error lldb_error; Error lldb_error;
// Sleep and wait a bit for debugserver to start to listen... // Sleep and wait a bit for debugserver to start to listen...
ConnectionFileDescriptor file_conn; ConnectionFileDescriptor file_conn;
char connect_url[128]; char connect_url[128];
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
void Host::SetCrashDescriptionWithFormat(const char *format, ...) { void Host::SetCrashDescriptionWithFormat(const char *format, ...) {
static StreamString g_crash_description; static StreamString g_crash_description;
std::lock_guard<std::mutex> guard(GetCrashReporterMutex()); std::lock_guard<std::mutex> guard(GetCrashReporterMutex());
if (format) { if (format) {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
g_crash_description.GetString().clear(); g_crash_description.GetString() = llvm::StringRef("");
g_crash_description.PrintfVarArg(format, args); g_crash_description.PrintfVarArg(format, args);
va_end(args); va_end(args);
__crashreporter_info__ = g_crash_description.GetData(); __crashreporter_info__ = g_crash_description.GetData();
} else { } else {
__crashreporter_info__ = NULL; __crashreporter_info__ = NULL;
} }
} }
▲ Show 20 Lines • Show All 936 Lines • Show Last 20 Lines

lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp

Show First 20 Lines • Show All 788 Lines • ▼ Show 20 Linesvoid ConnectionFileDescriptor::InitializeSocket(Socket *socket) {
assert(socket->GetSocketProtocol() == Socket::ProtocolTcp); assert(socket->GetSocketProtocol() == Socket::ProtocolTcp);
TCPSocket *tcp_socket = static_cast<TCPSocket *>(socket); TCPSocket *tcp_socket = static_cast<TCPSocket *>(socket);
m_write_sp.reset(socket); m_write_sp.reset(socket);
m_read_sp = m_write_sp; m_read_sp = m_write_sp;
StreamString strm; StreamString strm;
strm.Printf("connect://%s:%u", tcp_socket->GetRemoteIPAddress().c_str(), strm.Printf("connect://%s:%u", tcp_socket->GetRemoteIPAddress().c_str(),
tcp_socket->GetRemotePortNumber()); tcp_socket->GetRemotePortNumber());
m_uri.swap(strm.GetString()); m_uri = strm.GetString();
} }

lldb/trunk/source/Host/windows/Host.cpp

Show First 20 Lines • Show All 224 Lines • ▼ Show 20 Lines if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments)) {
std::replace(quoted_cmd_string.begin(), quoted_cmd_string.end(), '\\', '/'); std::replace(quoted_cmd_string.begin(), quoted_cmd_string.end(), '\\', '/');
StreamString expand_command; StreamString expand_command;
expand_command.Printf("\"%s\" %s", expand_tool_spec.GetPath().c_str(), expand_command.Printf("\"%s\" %s", expand_tool_spec.GetPath().c_str(),
quoted_cmd_string.c_str()); quoted_cmd_string.c_str());
int status; int status;
std::string output; std::string output;
RunShellCommand(expand_command.GetData(), launch_info.GetWorkingDirectory(), std::string command = expand_command.GetString();
&status, nullptr, &output, 10); RunShellCommand(command.c_str(), launch_info.GetWorkingDirectory(), &status,
nullptr, &output, 10);
if (status != 0) { if (status != 0) {
error.SetErrorStringWithFormat("lldb-argdumper exited with error %d", error.SetErrorStringWithFormat("lldb-argdumper exited with error %d",
status); status);
return error; return error;
} }
auto data_sp = StructuredData::ParseJSON(output); auto data_sp = StructuredData::ParseJSON(output);
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/Args.cpp

Show First 20 Lines • Show All 797 Lines • ▼ Show 20 Lines if (this_enum.startswith(s))
return enum_values[i].value; return enum_values[i].value;
} }
StreamString strm; StreamString strm;
strm.PutCString("invalid enumeration value, valid values are: "); strm.PutCString("invalid enumeration value, valid values are: ");
for (int i = 0; enum_values[i].string_value != nullptr; i++) { for (int i = 0; enum_values[i].string_value != nullptr; i++) {
strm.Printf("%s\"%s\"", i > 0 ? ", " : "", enum_values[i].string_value); strm.Printf("%s\"%s\"", i > 0 ? ", " : "", enum_values[i].string_value);
} }
error.SetErrorString(strm.GetData()); error.SetErrorString(strm.GetString());
return fail_value; return fail_value;
} }
lldb::ScriptLanguage lldb::ScriptLanguage
Args::StringToScriptLanguage(llvm::StringRef s, lldb::ScriptLanguage fail_value, Args::StringToScriptLanguage(llvm::StringRef s, lldb::ScriptLanguage fail_value,
bool *success_ptr) { bool *success_ptr) {
if (success_ptr) if (success_ptr)
*success_ptr = true; *success_ptr = true;
Show All 39 Lines if (!FormatManager::GetFormatFromCString(s, partial_match_ok, format)) {
error_strm.Printf("\"%s\"", FormatManager::GetFormatAsCString(f)); error_strm.Printf("\"%s\"", FormatManager::GetFormatAsCString(f));
error_strm.EOL(); error_strm.EOL();
} }
if (byte_size_ptr) if (byte_size_ptr)
error_strm.PutCString( error_strm.PutCString(
"An optional byte size can precede the format character.\n"); "An optional byte size can precede the format character.\n");
error.SetErrorString(error_strm.GetString().c_str()); error.SetErrorString(error_strm.GetString());
} }
if (error.Fail()) if (error.Fail())
return error; return error;
} else { } else {
error.SetErrorStringWithFormat("%s option string", s ? "empty" : "invalid"); error.SetErrorStringWithFormat("%s option string", s ? "empty" : "invalid");
} }
return error; return error;
▲ Show 20 Lines • Show All 144 Lines • ▼ Show 20 Linesstd::string Args::ParseAliasOptions(Options &options,
} }
std::unique_lock<std::mutex> lock; std::unique_lock<std::mutex> lock;
OptionParser::Prepare(lock); OptionParser::Prepare(lock);
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
int val; int val;
while (1) { while (1) {
int long_options_index = -1; int long_options_index = -1;
val = val = OptionParser::Parse(GetArgumentCount(), GetArgumentVector(),
OptionParser::Parse(GetArgumentCount(), GetArgumentVector(), sstr.GetString(), long_options,
sstr.GetData(), long_options, &long_options_index); &long_options_index);
if (val == -1) if (val == -1)
break; break;
if (val == '?') { if (val == '?') {
result.AppendError("unknown or ambiguous option"); result.AppendError("unknown or ambiguous option");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
break; break;
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines default:
result.AppendErrorWithFormat("error with options table; invalid value " result.AppendErrorWithFormat("error with options table; invalid value "
"in has_arg field for option '%c'.\n", "in has_arg field for option '%c'.\n",
val); val);
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return result_string; return result_string;
} }
if (!option_arg) if (!option_arg)
option_arg = "<no-argument>"; option_arg = "<no-argument>";
option_arg_vector->emplace_back(option_str.GetData(), has_arg, option_arg); option_arg_vector->emplace_back(option_str.GetString(), has_arg,
option_arg);
// Find option in the argument list; also see if it was supposed to take // Find option in the argument list; also see if it was supposed to take
// an argument and if one was supplied. Remove option (and argument, if // an argument and if one was supplied. Remove option (and argument, if
// given) from the argument list. Also remove them from the // given) from the argument list. Also remove them from the
// raw_input_string, if one was passed in. // raw_input_string, if one was passed in.
size_t idx = FindArgumentIndexForOption(long_options, long_options_index); size_t idx = FindArgumentIndexForOption(long_options, long_options_index);
if (idx == size_t(-1)) if (idx == size_t(-1))
continue; continue;
▲ Show 20 Lines • Show All 402 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/CommandAlias.cpp

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines if (ProcessAliasOptionsArgs(cmd_sp, options_args, m_option_args_sp)) {
if (!help.empty()) { if (!help.empty()) {
StreamString sstr; StreamString sstr;
StreamString translation_and_help; StreamString translation_and_help;
GetAliasExpansion(sstr); GetAliasExpansion(sstr);
translation_and_help.Printf( translation_and_help.Printf(
"(%s) %s", sstr.GetData(), "(%s) %s", sstr.GetData(),
GetUnderlyingCommand()->GetHelp().str().c_str()); GetUnderlyingCommand()->GetHelp().str().c_str());
SetHelp(translation_and_help.GetData()); SetHelp(translation_and_help.GetString());
} }
} }
} }
bool CommandAlias::WantsRawCommandString() { bool CommandAlias::WantsRawCommandString() {
if (IsValid()) if (IsValid())
return m_underlying_command_sp->WantsRawCommandString(); return m_underlying_command_sp->WantsRawCommandString();
return false; return false;
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

Show First 20 Lines • Show All 346 Lines • ▼ Show 20 Lines#if defined(__APPLE__)
shell_option.append(" true"); shell_option.append(" true");
shell_option.append(" --"); shell_option.append(" --");
AddAlias("r", cmd_obj_sp, "--shell-expand-args true --"); AddAlias("r", cmd_obj_sp, "--shell-expand-args true --");
AddAlias("run", cmd_obj_sp, "--shell-expand-args true --"); AddAlias("run", cmd_obj_sp, "--shell-expand-args true --");
#else #else
StreamString defaultshell; StreamString defaultshell;
defaultshell.Printf("--shell=%s --", defaultshell.Printf("--shell=%s --",
HostInfo::GetDefaultShell().GetPath().c_str()); HostInfo::GetDefaultShell().GetPath().c_str());
AddAlias("r", cmd_obj_sp, defaultshell.GetData()); AddAlias("r", cmd_obj_sp, defaultshell.GetString());
AddAlias("run", cmd_obj_sp, defaultshell.GetData()); AddAlias("run", cmd_obj_sp, defaultshell.GetString());
#endif #endif
#endif #endif
} }
cmd_obj_sp = GetCommandSPExact("target symbols add", false); cmd_obj_sp = GetCommandSPExact("target symbols add", false);
if (cmd_obj_sp) { if (cmd_obj_sp) {
AddAlias("add-dsym", cmd_obj_sp); AddAlias("add-dsym", cmd_obj_sp);
} }
▲ Show 20 Lines • Show All 957 Lines • ▼ Show 20 LinesCommandObject *CommandInterpreter::BuildAliasResult(
std::string alias_name_str = alias_name; std::string alias_name_str = alias_name;
if ((cmd_args.GetArgumentCount() == 0) || if ((cmd_args.GetArgumentCount() == 0) ||
(alias_name_str.compare(cmd_args.GetArgumentAtIndex(0)) != 0)) (alias_name_str.compare(cmd_args.GetArgumentAtIndex(0)) != 0))
cmd_args.Unshift(alias_name_str); cmd_args.Unshift(alias_name_str);
result_str.Printf("%s", alias_cmd_obj->GetCommandName().str().c_str()); result_str.Printf("%s", alias_cmd_obj->GetCommandName().str().c_str());
if (!option_arg_vector_sp.get()) { if (!option_arg_vector_sp.get()) {
alias_result = result_str.GetData(); alias_result = result_str.GetString();
return alias_cmd_obj; return alias_cmd_obj;
} }
OptionArgVector *option_arg_vector = option_arg_vector_sp.get(); OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
int value_type; int value_type;
std::string option; std::string option;
std::string value; std::string value;
for (const auto &entry : *option_arg_vector) { for (const auto &entry : *option_arg_vector) {
Show All 24 Lines else if (static_cast<size_t>(index) >= cmd_args.GetArgumentCount()) {
size_t strpos = raw_input_string.find(cmd_args.GetArgumentAtIndex(index)); size_t strpos = raw_input_string.find(cmd_args.GetArgumentAtIndex(index));
if (strpos != std::string::npos) if (strpos != std::string::npos)
raw_input_string = raw_input_string.erase( raw_input_string = raw_input_string.erase(
strpos, strlen(cmd_args.GetArgumentAtIndex(index))); strpos, strlen(cmd_args.GetArgumentAtIndex(index)));
result_str.Printf("%s", cmd_args.GetArgumentAtIndex(index)); result_str.Printf("%s", cmd_args.GetArgumentAtIndex(index));
} }
} }
alias_result = result_str.GetData(); alias_result = result_str.GetString();
return alias_cmd_obj; return alias_cmd_obj;
} }
Error CommandInterpreter::PreprocessCommand(std::string &command) { Error CommandInterpreter::PreprocessCommand(std::string &command) {
// The command preprocessor needs to do things to the command // The command preprocessor needs to do things to the command
// line before any parsing of arguments or anything else is done. // line before any parsing of arguments or anything else is done.
// The only current stuff that gets preprocessed is anything enclosed // The only current stuff that gets preprocessed is anything enclosed
// in backtick ('`') characters is evaluated as an expression and // in backtick ('`') characters is evaluated as an expression and
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines if (start_backtick > 0 && command[start_backtick - 1] == '\\') {
expr_result_valobj_sp->GetDynamicValueType(), true); expr_result_valobj_sp->GetDynamicValueType(), true);
if (expr_result_valobj_sp->ResolveValue(scalar)) { if (expr_result_valobj_sp->ResolveValue(scalar)) {
command.erase(start_backtick, end_backtick - start_backtick + 1); command.erase(start_backtick, end_backtick - start_backtick + 1);
StreamString value_strm; StreamString value_strm;
const bool show_type = false; const bool show_type = false;
scalar.GetValue(&value_strm, show_type); scalar.GetValue(&value_strm, show_type);
size_t value_string_size = value_strm.GetSize(); size_t value_string_size = value_strm.GetSize();
if (value_string_size) { if (value_string_size) {
command.insert(start_backtick, value_strm.GetData(), command.insert(start_backtick, value_strm.GetString());
value_string_size);
pos = start_backtick + value_string_size; pos = start_backtick + value_string_size;
continue; continue;
} else { } else {
error.SetErrorStringWithFormat("expression value didn't result " error.SetErrorStringWithFormat("expression value didn't result "
"in a scalar value for the " "in a scalar value for the "
"expression '%s'", "expression '%s'",
expr_str.c_str()); expr_str.c_str());
} }
▲ Show 20 Lines • Show All 794 Lines • ▼ Show 20 Lines if (!options.GetAddToHistory())
m_command_source_depth--; m_command_source_depth--;
if (options.GetPrintResults()) { if (options.GetPrintResults()) {
if (tmp_result.Succeeded()) if (tmp_result.Succeeded())
result.AppendMessage(tmp_result.GetOutputData()); result.AppendMessage(tmp_result.GetOutputData());
} }
if (!success || !tmp_result.Succeeded()) { if (!success || !tmp_result.Succeeded()) {
const char *error_msg = tmp_result.GetErrorData(); llvm::StringRef error_msg = tmp_result.GetErrorData();
if (error_msg == nullptr || error_msg[0] == '\0') if (error_msg.empty())
error_msg = "<unknown error>.\n"; error_msg = "<unknown error>.\n";
if (options.GetStopOnError()) { if (options.GetStopOnError()) {
result.AppendErrorWithFormat( result.AppendErrorWithFormat(
"Aborting reading of commands after command #%" PRIu64 "Aborting reading of commands after command #%" PRIu64
": '%s' failed with %s", ": '%s' failed with %s",
(uint64_t)idx, cmd, error_msg); (uint64_t)idx, cmd, error_msg.str().c_str());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
m_debugger.SetAsyncExecution(old_async_execution); m_debugger.SetAsyncExecution(old_async_execution);
return; return;
} else if (options.GetPrintResults()) { } else if (options.GetPrintResults()) {
result.AppendMessageWithFormat("Command #%" PRIu64 result.AppendMessageWithFormat(
" '%s' failed with %s", "Command #%" PRIu64 " '%s' failed with %s", (uint64_t)idx + 1, cmd,
(uint64_t)idx + 1, cmd, error_msg); error_msg.str().c_str());
} }
} }
if (result.GetImmediateOutputStream()) if (result.GetImmediateOutputStream())
result.GetImmediateOutputStream()->Flush(); result.GetImmediateOutputStream()->Flush();
if (result.GetImmediateErrorStream()) if (result.GetImmediateErrorStream())
result.GetImmediateErrorStream()->Flush(); result.GetImmediateErrorStream()->Flush();
▲ Show 20 Lines • Show All 266 Lines • ▼ Show 20 Lines
void CommandInterpreter::OutputFormattedHelpText(Stream &strm, void CommandInterpreter::OutputFormattedHelpText(Stream &strm,
llvm::StringRef word_text, llvm::StringRef word_text,
llvm::StringRef separator, llvm::StringRef separator,
llvm::StringRef help_text, llvm::StringRef help_text,
size_t max_word_len) { size_t max_word_len) {
StreamString prefix_stream; StreamString prefix_stream;
prefix_stream.Printf(" %-*s %*s ", (int)max_word_len, word_text.data(), prefix_stream.Printf(" %-*s %*s ", (int)max_word_len, word_text.data(),
(int)separator.size(), separator.data()); (int)separator.size(), separator.data());
OutputFormattedHelpText(strm, prefix_stream.GetData(), help_text); OutputFormattedHelpText(strm, prefix_stream.GetString(), help_text);
}
LLVM_ATTRIBUTE_ALWAYS_INLINE
static size_t nextWordLength(llvm::StringRef S) {
size_t pos = S.find_first_of(' ');
if (pos == llvm::StringRef::npos)
return S.size();
return pos;
} }
void CommandInterpreter::OutputHelpText(Stream &strm, llvm::StringRef word_text, void CommandInterpreter::OutputHelpText(Stream &strm, llvm::StringRef word_text,
llvm::StringRef separator, llvm::StringRef separator,
llvm::StringRef help_text, llvm::StringRef help_text,
uint32_t max_word_len) { uint32_t max_word_len) {
int indent_size = max_word_len + separator.size() + 2; int indent_size = max_word_len + separator.size() + 2;
strm.IndentMore(indent_size); strm.IndentMore(indent_size);
StreamString text_strm; StreamString text_strm;
text_strm.Printf("%-*s ", (int)max_word_len, word_text.data()); text_strm.Printf("%-*s ", (int)max_word_len, word_text.data());
text_strm << separator << " " << help_text; text_strm << separator << " " << help_text;
const uint32_t max_columns = m_debugger.GetTerminalWidth(); const uint32_t max_columns = m_debugger.GetTerminalWidth();
size_t len = text_strm.GetSize(); llvm::StringRef text = text_strm.GetString();
const char *text = text_strm.GetData();
uint32_t chars_left = max_columns; uint32_t chars_left = max_columns;
for (uint32_t i = 0; i < len; i++) { while (!text.empty()) {
if ((text[i] == ' ' && ::strchr((text + i + 1), ' ') && if (text.front() == '\n' ||
chars_left < static_cast<uint32_t>(::strchr((text + i + 1), ' ') - (text.front() == ' ' && nextWordLength(text.ltrim(' ')) < chars_left)) {
(text + i))) ||
text[i] == '\n') {
chars_left = max_columns - indent_size;
strm.EOL(); strm.EOL();
strm.Indent(); strm.Indent();
chars_left = max_columns - indent_size;
if (text.front() == '\n')
text = text.drop_front();
else
text = text.ltrim(' ');
} else { } else {
strm.PutChar(text[i]); strm.PutChar(text.front());
chars_left--; --chars_left;
text = text.drop_front();
} }
} }
strm.EOL(); strm.EOL();
strm.IndentLess(indent_size); strm.IndentLess(indent_size);
} }
void CommandInterpreter::FindCommandsForApropos( void CommandInterpreter::FindCommandsForApropos(
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Linesvoid CommandInterpreter::IOHandlerInputComplete(IOHandler &io_handler,
HandleCommand(line.c_str(), eLazyBoolCalculate, result); HandleCommand(line.c_str(), eLazyBoolCalculate, result);
// Now emit the command output text from the command we just executed // Now emit the command output text from the command we just executed
if (io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) { if (io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) {
// Display any STDOUT/STDERR _prior_ to emitting the command result text // Display any STDOUT/STDERR _prior_ to emitting the command result text
GetProcessOutput(); GetProcessOutput();
if (!result.GetImmediateOutputStream()) { if (!result.GetImmediateOutputStream()) {
const char *output = result.GetOutputData(); llvm::StringRef output = result.GetOutputData();
if (output && output[0]) if (!output.empty())
io_handler.GetOutputStreamFile()->PutCString(output); io_handler.GetOutputStreamFile()->PutCString(output);
} }
// Now emit the command error text from the command we just executed // Now emit the command error text from the command we just executed
if (!result.GetImmediateErrorStream()) { if (!result.GetImmediateErrorStream()) {
const char *error = result.GetErrorData(); llvm::StringRef error = result.GetErrorData();
if (error && error[0]) if (!error.empty())
io_handler.GetErrorStreamFile()->PutCString(error); io_handler.GetErrorStreamFile()->PutCString(error);
} }
} }
switch (result.GetStatus()) { switch (result.GetStatus()) {
case eReturnStatusInvalid: case eReturnStatusInvalid:
case eReturnStatusSuccessFinishNoResult: case eReturnStatusSuccessFinishNoResult:
case eReturnStatusSuccessFinishResult: case eReturnStatusSuccessFinishResult:
▲ Show 20 Lines • Show All 261 Lines • ▼ Show 20 Lines if (cmd_obj == nullptr) {
if (matches.GetSize() > 1) { if (matches.GetSize() > 1) {
StreamString error_msg; StreamString error_msg;
error_msg.Printf("Ambiguous command '%s'. Possible matches:\n", error_msg.Printf("Ambiguous command '%s'. Possible matches:\n",
next_word.c_str()); next_word.c_str());
for (uint32_t i = 0; i < num_matches; ++i) { for (uint32_t i = 0; i < num_matches; ++i) {
error_msg.Printf("\t%s\n", matches.GetStringAtIndex(i)); error_msg.Printf("\t%s\n", matches.GetStringAtIndex(i));
} }
result.AppendRawError(error_msg.GetString().c_str()); result.AppendRawError(error_msg.GetString());
} else { } else {
// We didn't have only one match, otherwise we wouldn't get here. // We didn't have only one match, otherwise we wouldn't get here.
assert(num_matches == 0); assert(num_matches == 0);
result.AppendErrorWithFormat("'%s' is not a valid command.\n", result.AppendErrorWithFormat("'%s' is not a valid command.\n",
next_word.c_str()); next_word.c_str());
} }
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return nullptr; return nullptr;
Show All 19 Lines if (cmd_obj->IsMultiwordObject()) {
// GDB format suffixes // GDB format suffixes
{ {
Options *command_options = cmd_obj->GetOptions(); Options *command_options = cmd_obj->GetOptions();
if (command_options && if (command_options &&
command_options->SupportsLongOption("gdb-format")) { command_options->SupportsLongOption("gdb-format")) {
std::string gdb_format_option("--gdb-format="); std::string gdb_format_option("--gdb-format=");
gdb_format_option += (suffix.c_str() + 1); gdb_format_option += (suffix.c_str() + 1);
bool inserted = false; std::string cmd = revised_command_line.GetString();
std::string &cmd = revised_command_line.GetString();
size_t arg_terminator_idx = FindArgumentTerminator(cmd); size_t arg_terminator_idx = FindArgumentTerminator(cmd);
if (arg_terminator_idx != std::string::npos) { if (arg_terminator_idx != std::string::npos) {
// Insert the gdb format option before the "--" that terminates // Insert the gdb format option before the "--" that terminates
// options // options
gdb_format_option.append(1, ' '); gdb_format_option.append(1, ' ');
cmd.insert(arg_terminator_idx, gdb_format_option); cmd.insert(arg_terminator_idx, gdb_format_option);
inserted = true; revised_command_line.Clear();
} revised_command_line.PutCString(cmd);
} else
if (!inserted)
revised_command_line.Printf(" %s", gdb_format_option.c_str()); revised_command_line.Printf(" %s", gdb_format_option.c_str());
if (wants_raw_input && if (wants_raw_input &&
FindArgumentTerminator(cmd) == std::string::npos) FindArgumentTerminator(cmd) == std::string::npos)
revised_command_line.PutCString(" --"); revised_command_line.PutCString(" --");
} else { } else {
result.AppendErrorWithFormat( result.AppendErrorWithFormat(
"the '%s' command doesn't support the --gdb-format option\n", "the '%s' command doesn't support the --gdb-format option\n",
Show All 15 Lines while (!done) {
if (scratch_command.empty()) if (scratch_command.empty())
done = true; done = true;
} }
if (!scratch_command.empty()) if (!scratch_command.empty())
revised_command_line.Printf(" %s", scratch_command.c_str()); revised_command_line.Printf(" %s", scratch_command.c_str());
if (cmd_obj != NULL) if (cmd_obj != NULL)
command_line = revised_command_line.GetData(); command_line = revised_command_line.GetString();
return cmd_obj; return cmd_obj;
} }

lldb/trunk/source/Interpreter/CommandObject.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Linesllvm::StringRef CommandObject::GetSyntax() {
if (!m_arguments.empty()) { if (!m_arguments.empty()) {
syntax_str.PutCString(" "); syntax_str.PutCString(" ");
if (!IsDashDashCommand() && WantsRawCommandString() && GetOptions() && if (!IsDashDashCommand() && WantsRawCommandString() && GetOptions() &&
GetOptions()->NumCommandOptions()) GetOptions()->NumCommandOptions())
syntax_str.PutCString("-- "); syntax_str.PutCString("-- ");
GetFormattedCommandArguments(syntax_str); GetFormattedCommandArguments(syntax_str);
} }
m_cmd_syntax = syntax_str.GetData(); m_cmd_syntax = syntax_str.GetString();
return m_cmd_syntax; return m_cmd_syntax;
} }
llvm::StringRef CommandObject::GetCommandName() const { return m_cmd_name; } llvm::StringRef CommandObject::GetCommandName() const { return m_cmd_name; }
void CommandObject::SetCommandName(llvm::StringRef name) { m_cmd_name = name; } void CommandObject::SetCommandName(llvm::StringRef name) { m_cmd_name = name; }
▲ Show 20 Lines • Show All 301 Lines • ▼ Show 20 Lines if (!entry)
return; return;
StreamString name_str; StreamString name_str;
name_str.Printf("<%s>", entry->arg_name); name_str.Printf("<%s>", entry->arg_name);
if (entry->help_function) { if (entry->help_function) {
llvm::StringRef help_text = entry->help_function(); llvm::StringRef help_text = entry->help_function();
if (!entry->help_function.self_formatting) { if (!entry->help_function.self_formatting) {
interpreter.OutputFormattedHelpText(str, name_str.GetData(), "--", interpreter.OutputFormattedHelpText(str, name_str.GetString(), "--",
help_text, name_str.GetSize()); help_text, name_str.GetSize());
} else { } else {
interpreter.OutputHelpText(str, name_str.GetData(), "--", help_text, interpreter.OutputHelpText(str, name_str.GetString(), "--", help_text,
name_str.GetSize()); name_str.GetSize());
} }
} else } else
interpreter.OutputFormattedHelpText(str, name_str.GetData(), "--", interpreter.OutputFormattedHelpText(str, name_str.GetString(), "--",
entry->help_text, name_str.GetSize()); entry->help_text, name_str.GetSize());
} }
const char *CommandObject::GetArgumentName(CommandArgumentType arg_type) { const char *CommandObject::GetArgumentName(CommandArgumentType arg_type) {
const ArgumentTableEntry *entry = const ArgumentTableEntry *entry =
&(CommandObject::GetArgumentTable()[arg_type]); &(CommandObject::GetArgumentTable()[arg_type]);
// The table is *supposed* to be kept in arg_type order, but someone *could* // The table is *supposed* to be kept in arg_type order, but someone *could*
// have messed it up... // have messed it up...
if (entry->arg_type != arg_type) if (entry->arg_type != arg_type)
entry = CommandObject::FindArgumentDataByType(arg_type); entry = CommandObject::FindArgumentDataByType(arg_type);
if (entry) if (entry)
return entry->arg_name; return entry->arg_name;
StreamString str; return nullptr;
str << "Arg name for type (" << arg_type << ") not in arg table!";
return str.GetData();
} }
bool CommandObject::IsPairType(ArgumentRepetitionType arg_repeat_type) { bool CommandObject::IsPairType(ArgumentRepetitionType arg_repeat_type) {
if ((arg_repeat_type == eArgRepeatPairPlain) || if ((arg_repeat_type == eArgRepeatPairPlain) ||
(arg_repeat_type == eArgRepeatPairOptional) || (arg_repeat_type == eArgRepeatPairOptional) ||
(arg_repeat_type == eArgRepeatPairPlus) || (arg_repeat_type == eArgRepeatPairPlus) ||
(arg_repeat_type == eArgRepeatPairStar) || (arg_repeat_type == eArgRepeatPairStar) ||
(arg_repeat_type == eArgRepeatPairRange) || (arg_repeat_type == eArgRepeatPairRange) ||
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines if ((num_alternatives == 2) && IsPairType(arg_entry[0].arg_repetition)) {
} }
} else { } else {
StreamString names; StreamString names;
for (int j = 0; j < num_alternatives; ++j) { for (int j = 0; j < num_alternatives; ++j) {
if (j > 0) if (j > 0)
names.Printf(" | "); names.Printf(" | ");
names.Printf("%s", GetArgumentName(arg_entry[j].arg_type)); names.Printf("%s", GetArgumentName(arg_entry[j].arg_type));
} }
std::string name_str = names.GetString();
switch (arg_entry[0].arg_repetition) { switch (arg_entry[0].arg_repetition) {
case eArgRepeatPlain: case eArgRepeatPlain:
str.Printf("<%s>", names.GetData()); str.Printf("<%s>", name_str.c_str());
break; break;
case eArgRepeatPlus: case eArgRepeatPlus:
str.Printf("<%s> [<%s> [...]]", names.GetData(), names.GetData()); str.Printf("<%s> [<%s> [...]]", name_str.c_str(), name_str.c_str());
break; break;
case eArgRepeatStar: case eArgRepeatStar:
str.Printf("[<%s> [<%s> [...]]]", names.GetData(), names.GetData()); str.Printf("[<%s> [<%s> [...]]]", name_str.c_str(), name_str.c_str());
break; break;
case eArgRepeatOptional: case eArgRepeatOptional:
str.Printf("[<%s>]", names.GetData()); str.Printf("[<%s>]", name_str.c_str());
break; break;
case eArgRepeatRange: case eArgRepeatRange:
str.Printf("<%s_1> .. <%s_n>", names.GetData(), names.GetData()); str.Printf("<%s_1> .. <%s_n>", name_str.c_str(), name_str.c_str());
break; break;
// Explicitly test for all the rest of the cases, so if new types get // Explicitly test for all the rest of the cases, so if new types get
// added we will notice the // added we will notice the
// missing case statement(s). // missing case statement(s).
case eArgRepeatPairPlain: case eArgRepeatPairPlain:
case eArgRepeatPairOptional: case eArgRepeatPairOptional:
case eArgRepeatPairPlus: case eArgRepeatPairPlus:
case eArgRepeatPairStar: case eArgRepeatPairStar:
▲ Show 20 Lines • Show All 600 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/CommandReturnObject.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesvoid CommandReturnObject::AppendMessageWithFormat(const char *format, ...) {
if (!format) if (!format)
return; return;
va_list args; va_list args;
va_start(args, format); va_start(args, format);
StreamString sstrm; StreamString sstrm;
sstrm.PrintfVarArg(format, args); sstrm.PrintfVarArg(format, args);
va_end(args); va_end(args);
GetOutputStream().Printf("%s", sstrm.GetData()); GetOutputStream() << sstrm.GetString();
} }
void CommandReturnObject::AppendWarningWithFormat(const char *format, ...) { void CommandReturnObject::AppendWarningWithFormat(const char *format, ...) {
if (!format) if (!format)
return; return;
va_list args; va_list args;
va_start(args, format); va_start(args, format);
StreamString sstrm; StreamString sstrm;
sstrm.PrintfVarArg(format, args); sstrm.PrintfVarArg(format, args);
va_end(args); va_end(args);
GetErrorStream().Printf("warning: %s", sstrm.GetData()); GetErrorStream() << "warning: " << sstrm.GetString();
} }
void CommandReturnObject::AppendMessage(llvm::StringRef in_string) { void CommandReturnObject::AppendMessage(llvm::StringRef in_string) {
if (in_string.empty()) if (in_string.empty())
return; return;
GetOutputStream() << in_string << "\n"; GetOutputStream() << in_string << "\n";
} }
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueEnumeration.cpp

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Lines if (enumerator_entry) {
if (count) { if (count) {
error_strm.Printf(", valid values are: %s", error_strm.Printf(", valid values are: %s",
m_enumerations.GetCStringAtIndex(0).str().c_str()); m_enumerations.GetCStringAtIndex(0).str().c_str());
for (size_t i = 1; i < count; ++i) { for (size_t i = 1; i < count; ++i) {
error_strm.Printf(", %s", error_strm.Printf(", %s",
m_enumerations.GetCStringAtIndex(i).str().c_str()); m_enumerations.GetCStringAtIndex(i).str().c_str());
} }
} }
error.SetErrorString(error_strm.GetData()); error.SetErrorString(error_strm.GetString());
} }
break; break;
} }
case eVarSetOperationInsertBefore: case eVarSetOperationInsertBefore:
case eVarSetOperationInsertAfter: case eVarSetOperationInsertAfter:
case eVarSetOperationRemove: case eVarSetOperationRemove:
case eVarSetOperationAppend: case eVarSetOperationAppend:
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueLanguage.cpp

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines case eVarSetOperationAssign: {
} else { } else {
StreamString error_strm; StreamString error_strm;
error_strm.Printf("invalid language type '%s', ", value.str().c_str()); error_strm.Printf("invalid language type '%s', ", value.str().c_str());
error_strm.Printf("valid values are:\n"); error_strm.Printf("valid values are:\n");
for (lldb::LanguageType language : languages_for_types) { for (lldb::LanguageType language : languages_for_types) {
error_strm.Printf("%s%s%s", " ", error_strm.Printf("%s%s%s", " ",
Language::GetNameForLanguageType(language), "\n"); Language::GetNameForLanguageType(language), "\n");
} }
error.SetErrorString(error_strm.GetData()); error.SetErrorString(error_strm.GetString());
} }
} break; } break;
case eVarSetOperationInsertBefore: case eVarSetOperationInsertBefore:
case eVarSetOperationInsertAfter: case eVarSetOperationInsertAfter:
case eVarSetOperationRemove: case eVarSetOperationRemove:
case eVarSetOperationAppend: case eVarSetOperationAppend:
case eVarSetOperationInvalid: case eVarSetOperationInvalid:
Show All 9 Lines

lldb/trunk/source/Interpreter/Options.cpp

Show First 20 Lines • Show All 523 Lines • ▼ Show 20 Lines for (uint32_t opt_set = 0; opt_set < num_option_sets; ++opt_set) {
PrintOption(def, eDisplayBestOption, " ", nullptr, true, strm); PrintOption(def, eDisplayBestOption, " ", nullptr, true, strm);
} }
} }
if (args_str.GetSize() > 0) { if (args_str.GetSize() > 0) {
if (cmd->WantsRawCommandString() && !only_print_args) if (cmd->WantsRawCommandString() && !only_print_args)
strm.Printf(" --"); strm.Printf(" --");
strm.Printf(" %s", args_str.GetData()); strm << " " << args_str.GetString();
if (only_print_args) if (only_print_args)
break; break;
} }
} }
} }
if (cmd && (only_print_args || cmd->WantsRawCommandString()) && if (cmd && (only_print_args || cmd->WantsRawCommandString()) &&
arguments_str.GetSize() > 0) { arguments_str.GetSize() > 0) {
if (!only_print_args) if (!only_print_args)
strm.PutChar('\n'); strm.PutChar('\n');
strm.Indent(name); strm.Indent(name);
strm.Printf(" %s", arguments_str.GetData()); strm << " " << arguments_str.GetString();
} }
strm.Printf("\n\n"); strm.Printf("\n\n");
if (!only_print_args) { if (!only_print_args) {
// Now print out all the detailed information about the various options: // Now print out all the detailed information about the various options:
// long form, short form and help text: // long form, short form and help text:
// -short <argument> ( --long_name <argument> ) // -short <argument> ( --long_name <argument> )
▲ Show 20 Lines • Show All 400 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/Property.cpp

Show First 20 Lines • Show All 271 Lines • ▼ Show 20 Lines if (desc.empty())
return; return;
StreamString qualified_name; StreamString qualified_name;
const OptionValueProperties *sub_properties = m_value_sp->GetAsProperties(); const OptionValueProperties *sub_properties = m_value_sp->GetAsProperties();
if (sub_properties) { if (sub_properties) {
strm.EOL(); strm.EOL();
if (m_value_sp->DumpQualifiedName(qualified_name)) if (m_value_sp->DumpQualifiedName(qualified_name))
strm.Printf("'%s' variables:\n\n", qualified_name.GetString().c_str()); strm.Printf("'%s' variables:\n\n", qualified_name.GetData());
sub_properties->DumpAllDescriptions(interpreter, strm); sub_properties->DumpAllDescriptions(interpreter, strm);
} else { } else {
if (display_qualified_name) { if (display_qualified_name) {
StreamString qualified_name; StreamString qualified_name;
DumpQualifiedName(qualified_name); DumpQualifiedName(qualified_name);
interpreter.OutputFormattedHelpText( interpreter.OutputFormattedHelpText(strm, qualified_name.GetString(),
strm, qualified_name.GetString().c_str(), "--", desc, output_width); "--", desc, output_width);
} else { } else {
interpreter.OutputFormattedHelpText(strm, m_name.GetCString(), "--", desc, interpreter.OutputFormattedHelpText(strm, m_name.GetStringRef(), "--",
output_width); desc, output_width);
} }
} }
} }
void Property::SetValueChangedCallback(OptionValueChangedCallback callback, void Property::SetValueChangedCallback(OptionValueChangedCallback callback,
void *baton) { void *baton) {
if (m_value_sp) if (m_value_sp)
m_value_sp->SetValueChangedCallback(callback, baton); m_value_sp->SetValueChangedCallback(callback, baton);
} }

lldb/trunk/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

Show First 20 Lines • Show All 1,697 Lines • ▼ Show 20 Lines s.Printf("ABISysV_x86_64::PrepareTrivialCall (tid = 0x%" PRIx64
", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64 ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
", return_addr = 0x%" PRIx64, ", return_addr = 0x%" PRIx64,
thread.GetID(), (uint64_t)sp, (uint64_t)func_addr, thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
(uint64_t)return_addr); (uint64_t)return_addr);
for (size_t i = 0; i < args.size(); ++i) for (size_t i = 0; i < args.size(); ++i)
s.Printf(", arg%d = 0x%" PRIx64, static_cast<int>(i + 1), args[i]); s.Printf(", arg%d = 0x%" PRIx64, static_cast<int>(i + 1), args[i]);
s.PutCString(")"); s.PutCString(")");
log->PutCString(s.GetString().c_str()); log->PutString(s.GetString());
} }
const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber( const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA); eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
▲ Show 20 Lines • Show All 739 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp

Show First 20 Lines • Show All 1,700 Lines • ▼ Show 20 Lines s.Printf("ABISysV_x86_64::PrepareTrivialCall (tid = 0x%" PRIx64
", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64 ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
", return_addr = 0x%" PRIx64, ", return_addr = 0x%" PRIx64,
thread.GetID(), (uint64_t)sp, (uint64_t)func_addr, thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
(uint64_t)return_addr); (uint64_t)return_addr);
for (size_t i = 0; i < args.size(); ++i) for (size_t i = 0; i < args.size(); ++i)
s.Printf(", arg%d = 0x%" PRIx64, static_cast<int>(i + 1), args[i]); s.Printf(", arg%d = 0x%" PRIx64, static_cast<int>(i + 1), args[i]);
s.PutCString(")"); s.PutCString(")");
log->PutCString(s.GetString().c_str()); log->PutString(s.GetString());
} }
// x0 - x7 contain first 8 simple args // x0 - x7 contain first 8 simple args
if (args.size() > 8) if (args.size() > 8)
return false; return false;
for (size_t i = 0; i < args.size(); ++i) { for (size_t i = 0; i < args.size(); ++i) {
const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo( const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
▲ Show 20 Lines • Show All 709 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp

Show First 20 Lines • Show All 581 Lines • ▼ Show 20 Lines s.Printf("ABISysV_mips::PrepareTrivialCall (tid = 0x%" PRIx64
", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64 ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
", return_addr = 0x%" PRIx64, ", return_addr = 0x%" PRIx64,
thread.GetID(), (uint64_t)sp, (uint64_t)func_addr, thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
(uint64_t)return_addr); (uint64_t)return_addr);
for (size_t i = 0; i < args.size(); ++i) for (size_t i = 0; i < args.size(); ++i)
s.Printf(", arg%zd = 0x%" PRIx64, i + 1, args[i]); s.Printf(", arg%zd = 0x%" PRIx64, i + 1, args[i]);
s.PutCString(")"); s.PutCString(")");
log->PutCString(s.GetString().c_str()); log->PutString(s.GetString());
} }
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return false; return false;
const RegisterInfo *reg_info = nullptr; const RegisterInfo *reg_info = nullptr;
▲ Show 20 Lines • Show All 481 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp

Show First 20 Lines • Show All 581 Lines • ▼ Show 20 Lines s.Printf("ABISysV_mips64::PrepareTrivialCall (tid = 0x%" PRIx64
", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64 ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
", return_addr = 0x%" PRIx64, ", return_addr = 0x%" PRIx64,
thread.GetID(), (uint64_t)sp, (uint64_t)func_addr, thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
(uint64_t)return_addr); (uint64_t)return_addr);
for (size_t i = 0; i < args.size(); ++i) for (size_t i = 0; i < args.size(); ++i)
s.Printf(", arg%zd = 0x%" PRIx64, i + 1, args[i]); s.Printf(", arg%zd = 0x%" PRIx64, i + 1, args[i]);
s.PutCString(")"); s.PutCString(")");
log->PutCString(s.GetString().c_str()); log->PutString(s.GetString());
} }
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return false; return false;
const RegisterInfo *reg_info = nullptr; const RegisterInfo *reg_info = nullptr;
▲ Show 20 Lines • Show All 630 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp

Show First 20 Lines • Show All 244 Lines • ▼ Show 20 Lines s.Printf("ABISysV_ppc::PrepareTrivialCall (tid = 0x%" PRIx64
", return_addr = 0x%" PRIx64, ", return_addr = 0x%" PRIx64,
thread.GetID(), (uint64_t)sp, (uint64_t)func_addr, thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
(uint64_t)return_addr); (uint64_t)return_addr);
for (size_t i = 0; i < args.size(); ++i) for (size_t i = 0; i < args.size(); ++i)
s.Printf(", arg%" PRIu64 " = 0x%" PRIx64, static_cast<uint64_t>(i + 1), s.Printf(", arg%" PRIu64 " = 0x%" PRIx64, static_cast<uint64_t>(i + 1),
args[i]); args[i]);
s.PutCString(")"); s.PutCString(")");
log->PutCString(s.GetString().c_str()); log->PutString(s.GetString());
} }
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return false; return false;
const RegisterInfo *reg_info = nullptr; const RegisterInfo *reg_info = nullptr;
▲ Show 20 Lines • Show All 762 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

Show First 20 Lines • Show All 244 Lines • ▼ Show 20 Lines s.Printf("ABISysV_ppc64::PrepareTrivialCall (tid = 0x%" PRIx64
", return_addr = 0x%" PRIx64, ", return_addr = 0x%" PRIx64,
thread.GetID(), (uint64_t)sp, (uint64_t)func_addr, thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
(uint64_t)return_addr); (uint64_t)return_addr);
for (size_t i = 0; i < args.size(); ++i) for (size_t i = 0; i < args.size(); ++i)
s.Printf(", arg%" PRIu64 " = 0x%" PRIx64, static_cast<uint64_t>(i + 1), s.Printf(", arg%" PRIu64 " = 0x%" PRIx64, static_cast<uint64_t>(i + 1),
args[i]); args[i]);
s.PutCString(")"); s.PutCString(")");
log->PutCString(s.GetString().c_str()); log->PutString(s.GetString());
} }
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return false; return false;
const RegisterInfo *reg_info = nullptr; const RegisterInfo *reg_info = nullptr;
▲ Show 20 Lines • Show All 766 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp

Show First 20 Lines • Show All 226 Lines • ▼ Show 20 Lines s.Printf("ABISysV_s390x::PrepareTrivialCall (tid = 0x%" PRIx64
", return_addr = 0x%" PRIx64, ", return_addr = 0x%" PRIx64,
thread.GetID(), (uint64_t)sp, (uint64_t)func_addr, thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
(uint64_t)return_addr); (uint64_t)return_addr);
for (size_t i = 0; i < args.size(); ++i) for (size_t i = 0; i < args.size(); ++i)
s.Printf(", arg%" PRIu64 " = 0x%" PRIx64, static_cast<uint64_t>(i + 1), s.Printf(", arg%" PRIu64 " = 0x%" PRIx64, static_cast<uint64_t>(i + 1),
args[i]); args[i]);
s.PutCString(")"); s.PutCString(")");
log->PutCString(s.GetString().c_str()); log->PutString(s.GetString());
} }
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return false; return false;
const RegisterInfo *pc_reg_info = const RegisterInfo *pc_reg_info =
reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
▲ Show 20 Lines • Show All 510 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

Show First 20 Lines • Show All 1,114 Lines • ▼ Show 20 Lines s.Printf("ABISysV_x86_64::PrepareTrivialCall (tid = 0x%" PRIx64
", return_addr = 0x%" PRIx64, ", return_addr = 0x%" PRIx64,
thread.GetID(), (uint64_t)sp, (uint64_t)func_addr, thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
(uint64_t)return_addr); (uint64_t)return_addr);
for (size_t i = 0; i < args.size(); ++i) for (size_t i = 0; i < args.size(); ++i)
s.Printf(", arg%" PRIu64 " = 0x%" PRIx64, static_cast<uint64_t>(i + 1), s.Printf(", arg%" PRIu64 " = 0x%" PRIx64, static_cast<uint64_t>(i + 1),
args[i]); args[i]);
s.PutCString(")"); s.PutCString(")");
log->PutCString(s.GetString().c_str()); log->PutString(s.GetString());
} }
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return false; return false;
const RegisterInfo *reg_info = nullptr; const RegisterInfo *reg_info = nullptr;
▲ Show 20 Lines • Show All 850 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp

Show First 20 Lines • Show All 353 Lines • ▼ Show 20 Lines if (m_opcode.GetData(data)) {
m_opcode_name.assign(".byte"); m_opcode_name.assign(".byte");
m_opcode.SetOpcodeBytes(bytes, inst_size); m_opcode.SetOpcodeBytes(bytes, inst_size);
mnemonic_strm.Printf("0x%2.2x", bytes[0]); mnemonic_strm.Printf("0x%2.2x", bytes[0]);
for (uint32_t i = 1; i < inst_size; ++i) for (uint32_t i = 1; i < inst_size; ++i)
mnemonic_strm.Printf(" 0x%2.2x", bytes[i]); mnemonic_strm.Printf(" 0x%2.2x", bytes[i]);
} }
break; break;
} }
m_mnemonics.swap(mnemonic_strm.GetString()); m_mnemonics = mnemonic_strm.GetString();
return; return;
} else { } else {
if (m_does_branch == eLazyBoolCalculate) { if (m_does_branch == eLazyBoolCalculate) {
const bool can_branch = mc_disasm_ptr->CanBranch(inst); const bool can_branch = mc_disasm_ptr->CanBranch(inst);
if (can_branch) if (can_branch)
m_does_branch = eLazyBoolYes; m_does_branch = eLazyBoolYes;
else else
m_does_branch = eLazyBoolNo; m_does_branch = eLazyBoolNo;
▲ Show 20 Lines • Show All 458 Lines • ▼ Show 20 Lines if (Log *log =
ss.Printf("[%s] expands to %zu operands:\n", operands_string, ss.Printf("[%s] expands to %zu operands:\n", operands_string,
operands.size()); operands.size());
for (const Operand &operand : operands) { for (const Operand &operand : operands) {
ss.PutCString(" "); ss.PutCString(" ");
DumpOperand(operand, ss); DumpOperand(operand, ss);
ss.PutCString("\n"); ss.PutCString("\n");
} }
log->PutCString(ss.GetData()); log->PutString(ss.GetString());
} }
return true; return true;
} }
bool IsCall() override { bool IsCall() override {
if (m_is_call == eLazyBoolCalculate) { if (m_is_call == eLazyBoolCalculate) {
std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler()); std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
▲ Show 20 Lines • Show All 500 Lines • ▼ Show 20 Lines if (m_exe_ctx && m_inst) {
Address::DumpStyleSectionNameOffset); Address::DumpStyleSectionNameOffset);
} }
if (!ss.GetString().empty()) { if (!ss.GetString().empty()) {
// If Address::Dump returned a multi-line description, most commonly // If Address::Dump returned a multi-line description, most commonly
// seen when we // seen when we
// have multiple levels of inlined functions at an address, only show // have multiple levels of inlined functions at an address, only show
// the first line. // the first line.
std::string &str(ss.GetString()); std::string str = ss.GetString();
size_t first_eol_char = str.find_first_of("\r\n"); size_t first_eol_char = str.find_first_of("\r\n");
if (first_eol_char != std::string::npos) { if (first_eol_char != std::string::npos) {
str.erase(first_eol_char); str.erase(first_eol_char);
} }
m_inst->AppendComment(ss.GetString()); m_inst->AppendComment(str);
} }
} }
} }
} }
*type_ptr = LLVMDisassembler_ReferenceType_InOut_None; *type_ptr = LLVMDisassembler_ReferenceType_InOut_None;
*name = NULL; *name = NULL;
return NULL; return NULL;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// PluginInterface protocol // PluginInterface protocol
//------------------------------------------------------------------ //------------------------------------------------------------------
ConstString DisassemblerLLVMC::GetPluginName() { return GetPluginNameStatic(); } ConstString DisassemblerLLVMC::GetPluginName() { return GetPluginNameStatic(); }
uint32_t DisassemblerLLVMC::GetPluginVersion() { return 1; } uint32_t DisassemblerLLVMC::GetPluginVersion() { return 1; }

lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

Show First 20 Lines • Show All 676 Lines • ▼ Show 20 Lines auto error = platform_sp->ResolveExecutable(
!executable_search_paths.IsEmpty() ? &executable_search_paths : nullptr); !executable_search_paths.IsEmpty() ? &executable_search_paths : nullptr);
if (error.Fail()) { if (error.Fail()) {
StreamString stream; StreamString stream;
module_spec.Dump(stream); module_spec.Dump(stream);
if (log) if (log)
log->Printf("DynamicLoaderPOSIXDYLD::%s - failed to resolve executable " log->Printf("DynamicLoaderPOSIXDYLD::%s - failed to resolve executable "
"with module spec \"%s\": %s", "with module spec \"%s\": %s",
__FUNCTION__, stream.GetString().c_str(), error.AsCString()); __FUNCTION__, stream.GetData(), error.AsCString());
return; return;
} }
target.SetExecutableModule(module_sp, false); target.SetExecutableModule(module_sp, false);
} }
bool DynamicLoaderPOSIXDYLD::AlwaysRelyOnEHUnwindInfo( bool DynamicLoaderPOSIXDYLD::AlwaysRelyOnEHUnwindInfo(
lldb_private::SymbolContext &sym_ctx) { lldb_private::SymbolContext &sym_ctx) {
Show All 11 Lines

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

//===-- ClangASTSource.cpp ---------------------------------------*- C++ //===-- ClangASTSource.cpp ---------------------------------------*- C++-*-===//
//-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 1,026 Lines • ▼ Show 20 Lines if (decl_name.isObjCZeroArgSelector()) {
for (unsigned i = 0, e = sel.getNumArgs(); i != e; ++i) { for (unsigned i = 0, e = sel.getNumArgs(); i != e; ++i) {
llvm::StringRef r = sel.getNameForSlot(i); llvm::StringRef r = sel.getNameForSlot(i);
ss.Printf("%s:", r.str().c_str()); ss.Printf("%s:", r.str().c_str());
} }
} }
ss.Flush(); ss.Flush();
if (strstr(ss.GetData(), "$__lldb")) if (ss.GetString().contains("$__lldb"))
return; // we don't need any results return; // we don't need any results
ConstString selector_name(ss.GetData()); ConstString selector_name(ss.GetString());
if (log) if (log)
log->Printf("ClangASTSource::FindObjCMethodDecls[%d] on (ASTContext*)%p " log->Printf("ClangASTSource::FindObjCMethodDecls[%d] on (ASTContext*)%p "
"for selector [%s %s]", "for selector [%s %s]",
current_id, static_cast<void *>(m_ast_context), current_id, static_cast<void *>(m_ast_context),
interface_decl->getNameAsString().c_str(), interface_decl->getNameAsString().c_str(),
selector_name.AsCString()); selector_name.AsCString());
SymbolContextList sc_list; SymbolContextList sc_list;
const bool include_symbols = false; const bool include_symbols = false;
const bool include_inlines = false; const bool include_inlines = false;
const bool append = false; const bool append = false;
std::string interface_name = interface_decl->getNameAsString(); std::string interface_name = interface_decl->getNameAsString();
do { do {
StreamString ms; StreamString ms;
ms.Printf("-[%s %s]", interface_name.c_str(), selector_name.AsCString()); ms.Printf("-[%s %s]", interface_name.c_str(), selector_name.AsCString());
ms.Flush(); ms.Flush();
ConstString instance_method_name(ms.GetData()); ConstString instance_method_name(ms.GetString());
m_target->GetImages().FindFunctions( m_target->GetImages().FindFunctions(
instance_method_name, lldb::eFunctionNameTypeFull, include_symbols, instance_method_name, lldb::eFunctionNameTypeFull, include_symbols,
include_inlines, append, sc_list); include_inlines, append, sc_list);
if (sc_list.GetSize()) if (sc_list.GetSize())
break; break;
ms.Clear(); ms.Clear();
ms.Printf("+[%s %s]", interface_name.c_str(), selector_name.AsCString()); ms.Printf("+[%s %s]", interface_name.c_str(), selector_name.AsCString());
ms.Flush(); ms.Flush();
ConstString class_method_name(ms.GetData()); ConstString class_method_name(ms.GetString());
m_target->GetImages().FindFunctions( m_target->GetImages().FindFunctions(
class_method_name, lldb::eFunctionNameTypeFull, include_symbols, class_method_name, lldb::eFunctionNameTypeFull, include_symbols,
include_inlines, append, sc_list); include_inlines, append, sc_list);
if (sc_list.GetSize()) if (sc_list.GetSize())
break; break;
▲ Show 20 Lines • Show All 924 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Lines void moduleImport(SourceLocation import_location, clang::ModuleIdPath path,
for (ClangModulesDeclVendor::ModuleID module : exported_modules) { for (ClangModulesDeclVendor::ModuleID module : exported_modules) {
m_persistent_vars.AddHandLoadedClangModule(module); m_persistent_vars.AddHandLoadedClangModule(module);
} }
} }
bool hasErrors() { return m_has_errors; } bool hasErrors() { return m_has_errors; }
const std::string &getErrorString() { return m_error_stream.GetString(); } llvm::StringRef getErrorString() { return m_error_stream.GetString(); }
}; };
class ClangDiagnosticManagerAdapter : public clang::DiagnosticConsumer { class ClangDiagnosticManagerAdapter : public clang::DiagnosticConsumer {
public: public:
ClangDiagnosticManagerAdapter() ClangDiagnosticManagerAdapter()
: m_passthrough(new clang::TextDiagnosticBuffer) {} : m_passthrough(new clang::TextDiagnosticBuffer) {}
ClangDiagnosticManagerAdapter( ClangDiagnosticManagerAdapter(
▲ Show 20 Lines • Show All 475 Lines • ▼ Show 20 Linesunsigned ClangExpressionParser::Parse(DiagnosticManager &diagnostic_manager) {
unsigned num_errors = diag_buf->getNumErrors(); unsigned num_errors = diag_buf->getNumErrors();
if (m_pp_callbacks && m_pp_callbacks->hasErrors()) { if (m_pp_callbacks && m_pp_callbacks->hasErrors()) {
num_errors++; num_errors++;
diagnostic_manager.PutString(eDiagnosticSeverityError, diagnostic_manager.PutString(eDiagnosticSeverityError,
"while importing modules:"); "while importing modules:");
diagnostic_manager.AppendMessageToDiagnostic( diagnostic_manager.AppendMessageToDiagnostic(
m_pp_callbacks->getErrorString().c_str()); m_pp_callbacks->getErrorString());
} }
if (!num_errors) { if (!num_errors) {
if (type_system_helper->DeclMap() && if (type_system_helper->DeclMap() &&
!type_system_helper->DeclMap()->ResolveUnknownTypes()) { !type_system_helper->DeclMap()->ResolveUnknownTypes()) {
diagnostic_manager.Printf(eDiagnosticSeverityError, diagnostic_manager.Printf(eDiagnosticSeverityError,
"Couldn't infer the type of a variable"); "Couldn't infer the type of a variable");
num_errors++; num_errors++;
▲ Show 20 Lines • Show All 349 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Instruction/ARM/EmulationStateARM.cpp

Show First 20 Lines • Show All 317 Lines • ▼ Show 20 Linesbool EmulationStateARM::LoadStateFromDictionary(
// Load General Registers // Load General Registers
OptionValueDictionary *reg_dict = value_sp->GetAsDictionary(); OptionValueDictionary *reg_dict = value_sp->GetAsDictionary();
StreamString sstr; StreamString sstr;
for (int i = 0; i < 16; ++i) { for (int i = 0; i < 16; ++i) {
sstr.Clear(); sstr.Clear();
sstr.Printf("r%d", i); sstr.Printf("r%d", i);
ConstString reg_name(sstr.GetData()); ConstString reg_name(sstr.GetString());
value_sp = reg_dict->GetValueForKey(reg_name); value_sp = reg_dict->GetValueForKey(reg_name);
if (value_sp.get() == NULL) if (value_sp.get() == NULL)
return false; return false;
uint64_t reg_value = value_sp->GetUInt64Value(); uint64_t reg_value = value_sp->GetUInt64Value();
StorePseudoRegisterValue(dwarf_r0 + i, reg_value); StorePseudoRegisterValue(dwarf_r0 + i, reg_value);
} }
static ConstString cpsr_name("cpsr"); static ConstString cpsr_name("cpsr");
value_sp = reg_dict->GetValueForKey(cpsr_name); value_sp = reg_dict->GetValueForKey(cpsr_name);
if (value_sp.get() == NULL) if (value_sp.get() == NULL)
return false; return false;
StorePseudoRegisterValue(dwarf_cpsr, value_sp->GetUInt64Value()); StorePseudoRegisterValue(dwarf_cpsr, value_sp->GetUInt64Value());
// Load s/d Registers // Load s/d Registers
for (int i = 0; i < 32; ++i) { for (int i = 0; i < 32; ++i) {
sstr.Clear(); sstr.Clear();
sstr.Printf("s%d", i); sstr.Printf("s%d", i);
ConstString reg_name(sstr.GetData()); ConstString reg_name(sstr.GetString());
value_sp = reg_dict->GetValueForKey(reg_name); value_sp = reg_dict->GetValueForKey(reg_name);
if (value_sp.get() == NULL) if (value_sp.get() == NULL)
return false; return false;
uint64_t reg_value = value_sp->GetUInt64Value(); uint64_t reg_value = value_sp->GetUInt64Value();
StorePseudoRegisterValue(dwarf_s0 + i, reg_value); StorePseudoRegisterValue(dwarf_s0 + i, reg_value);
} }
return true; return true;
} }

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxx.cpp

Show First 20 Lines • Show All 147 Lines • ▼ Show 20 Lineslldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetChildAtIndex(
DataBufferSP buffer_sp( DataBufferSP buffer_sp(
new DataBufferHeap(m_bool_type.GetByteSize(nullptr), 0)); new DataBufferHeap(m_bool_type.GetByteSize(nullptr), 0));
if (bit_set && buffer_sp && buffer_sp->GetBytes()) if (bit_set && buffer_sp && buffer_sp->GetBytes())
*(buffer_sp->GetBytes()) = *(buffer_sp->GetBytes()) =
1; // regardless of endianness, anything non-zero is true 1; // regardless of endianness, anything non-zero is true
StreamString name; StreamString name;
name.Printf("[%" PRIu64 "]", (uint64_t)idx); name.Printf("[%" PRIu64 "]", (uint64_t)idx);
ValueObjectSP retval_sp(CreateValueObjectFromData( ValueObjectSP retval_sp(CreateValueObjectFromData(
name.GetData(), DataExtractor(buffer_sp, process_sp->GetByteOrder(), name.GetString(), DataExtractor(buffer_sp, process_sp->GetByteOrder(),
process_sp->GetAddressByteSize()), process_sp->GetAddressByteSize()),
m_exe_ctx_ref, m_bool_type)); m_exe_ctx_ref, m_bool_type));
if (retval_sp) if (retval_sp)
m_children[idx] = retval_sp; m_children[idx] = retval_sp;
return retval_sp; return retval_sp;
} }
/*(std::__1::vector<std::__1::allocator<bool> >) vBool = { /*(std::__1::vector<std::__1::allocator<bool> >) vBool = {
__begin_ = 0x00000001001000e0 __begin_ = 0x00000001001000e0
▲ Show 20 Lines • Show All 569 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lineslldb::ValueObjectSP lldb_private::formatters::
LibcxxInitializerListSyntheticFrontEnd::GetChildAtIndex(size_t idx) { LibcxxInitializerListSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
if (!m_start) if (!m_start)
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
uint64_t offset = idx * m_element_size; uint64_t offset = idx * m_element_size;
offset = offset + m_start->GetValueAsUnsigned(0); offset = offset + m_start->GetValueAsUnsigned(0);
StreamString name; StreamString name;
name.Printf("[%" PRIu64 "]", (uint64_t)idx); name.Printf("[%" PRIu64 "]", (uint64_t)idx);
return CreateValueObjectFromAddress(name.GetData(), offset, return CreateValueObjectFromAddress(name.GetString(), offset,
m_backend.GetExecutionContextRef(), m_backend.GetExecutionContextRef(),
m_element_type); m_element_type);
} }
bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd:: bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
Update() { Update() {
static ConstString g___begin_("__begin_"); static ConstString g___begin_("__begin_");
Show All 35 Lines

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxList.cpp

Show First 20 Lines • Show All 292 Lines • ▼ Show 20 Lineslldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetChildAtIndex(
DataExtractor data; DataExtractor data;
Error error; Error error;
current_sp->GetData(data, error); current_sp->GetData(data, error);
if (error.Fail()) if (error.Fail())
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
StreamString name; StreamString name;
name.Printf("[%" PRIu64 "]", (uint64_t)idx); name.Printf("[%" PRIu64 "]", (uint64_t)idx);
return CreateValueObjectFromData( return CreateValueObjectFromData(name.GetString(), data,
name.GetData(), data, m_backend.GetExecutionContextRef(), m_element_type); m_backend.GetExecutionContextRef(),
m_element_type);
} }
bool lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::Update() { bool lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::Update() {
m_iterators.clear(); m_iterators.clear();
m_head = m_tail = nullptr; m_head = m_tail = nullptr;
m_node_address = 0; m_node_address = 0;
m_count = UINT32_MAX; m_count = UINT32_MAX;
m_loop_detected = 0; m_loop_detected = 0;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

Show First 20 Lines • Show All 393 Lines • ▼ Show 20 Lineslldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex(
iterated_sp->GetData(data, error); iterated_sp->GetData(data, error);
if (error.Fail()) { if (error.Fail()) {
m_tree = nullptr; m_tree = nullptr;
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
} }
StreamString name; StreamString name;
name.Printf("[%" PRIu64 "]", (uint64_t)idx); name.Printf("[%" PRIu64 "]", (uint64_t)idx);
auto potential_child_sp = CreateValueObjectFromData( auto potential_child_sp = CreateValueObjectFromData(
name.GetData(), data, m_backend.GetExecutionContextRef(), m_element_type); name.GetString(), data, m_backend.GetExecutionContextRef(),
m_element_type);
if (potential_child_sp) { if (potential_child_sp) {
switch (potential_child_sp->GetNumChildren()) { switch (potential_child_sp->GetNumChildren()) {
case 1: { case 1: {
auto child0_sp = potential_child_sp->GetChildAtIndex(0, true); auto child0_sp = potential_child_sp->GetChildAtIndex(0, true);
if (child0_sp && child0_sp->GetName() == g___cc) if (child0_sp && child0_sp->GetName() == g___cc)
potential_child_sp = child0_sp; potential_child_sp = child0_sp;
break; break;
} }
case 2: { case 2: {
auto child0_sp = potential_child_sp->GetChildAtIndex(0, true); auto child0_sp = potential_child_sp->GetChildAtIndex(0, true);
auto child1_sp = potential_child_sp->GetChildAtIndex(1, true); auto child1_sp = potential_child_sp->GetChildAtIndex(1, true);
if (child0_sp && child0_sp->GetName() == g___cc && child1_sp && if (child0_sp && child0_sp->GetName() == g___cc && child1_sp &&
child1_sp->GetName() == g___nc) child1_sp->GetName() == g___nc)
potential_child_sp = child0_sp; potential_child_sp = child0_sp;
break; break;
} }
} }
potential_child_sp->SetName(ConstString(name.GetData())); potential_child_sp->SetName(ConstString(name.GetString()));
} }
m_iterators[idx] = iterator; m_iterators[idx] = iterator;
return potential_child_sp; return potential_child_sp;
} }
bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::Update() { bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::Update() {
static ConstString g___tree_("__tree_"); static ConstString g___tree_("__tree_");
static ConstString g___begin_node_("__begin_node_"); static ConstString g___begin_node_("__begin_node_");
Show All 25 Lines

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp

Show First 20 Lines • Show All 133 Lines • ▼ Show 20 Lineslldb::ValueObjectSP lldb_private::formatters::
DataExtractor data; DataExtractor data;
Error error; Error error;
val_hash.first->GetData(data, error); val_hash.first->GetData(data, error);
if (error.Fail()) if (error.Fail())
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
const bool thread_and_frame_only_if_stopped = true; const bool thread_and_frame_only_if_stopped = true;
ExecutionContext exe_ctx = val_hash.first->GetExecutionContextRef().Lock( ExecutionContext exe_ctx = val_hash.first->GetExecutionContextRef().Lock(
thread_and_frame_only_if_stopped); thread_and_frame_only_if_stopped);
return CreateValueObjectFromData(stream.GetData(), data, exe_ctx, return CreateValueObjectFromData(stream.GetString(), data, exe_ctx,
val_hash.first->GetCompilerType()); val_hash.first->GetCompilerType());
} }
bool lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd:: bool lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::
Update() { Update() {
m_num_elements = UINT32_MAX; m_num_elements = UINT32_MAX;
m_next_element = nullptr; m_next_element = nullptr;
m_elements_cache.clear(); m_elements_cache.clear();
Show All 39 Lines

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lineslldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetChildAtIndex(
size_t idx) { size_t idx) {
if (!m_start || !m_finish) if (!m_start || !m_finish)
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
uint64_t offset = idx * m_element_size; uint64_t offset = idx * m_element_size;
offset = offset + m_start->GetValueAsUnsigned(0); offset = offset + m_start->GetValueAsUnsigned(0);
StreamString name; StreamString name;
name.Printf("[%" PRIu64 "]", (uint64_t)idx); name.Printf("[%" PRIu64 "]", (uint64_t)idx);
return CreateValueObjectFromAddress(name.GetData(), offset, return CreateValueObjectFromAddress(name.GetString(), offset,
m_backend.GetExecutionContextRef(), m_backend.GetExecutionContextRef(),
m_element_type); m_element_type);
} }
bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() { bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() {
m_start = m_finish = nullptr; m_start = m_finish = nullptr;
ValueObjectSP data_type_finder_sp( ValueObjectSP data_type_finder_sp(
m_backend.GetChildMemberWithName(ConstString("__end_cap_"), true)); m_backend.GetChildMemberWithName(ConstString("__end_cap_"), true));
Show All 37 Lines

lldb/trunk/source/Plugins/Language/CPlusPlus/LibStdcppTuple.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines for (size_t i = 0; i < child_count; ++i) {
if (name_str.startswith("std::_Tuple_impl<")) { if (name_str.startswith("std::_Tuple_impl<")) {
next_child_sp = child_sp; next_child_sp = child_sp;
} else if (name_str.startswith("std::_Head_base<")) { } else if (name_str.startswith("std::_Head_base<")) {
ValueObjectSP value_sp = ValueObjectSP value_sp =
child_sp->GetChildMemberWithName(ConstString("_M_head_impl"), true); child_sp->GetChildMemberWithName(ConstString("_M_head_impl"), true);
if (value_sp) { if (value_sp) {
StreamString name; StreamString name;
name.Printf("[%zd]", m_members.size()); name.Printf("[%zd]", m_members.size());
value_sp->SetName(ConstString(name.GetData())); value_sp->SetName(ConstString(name.GetString()));
m_members.push_back(value_sp); m_members.push_back(value_sp);
} }
} }
} }
} }
return false; return false;
Show All 25 Lines

lldb/trunk/source/Plugins/Language/Go/GoFormatterFunctions.cpp

Show All 36 Lines lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
if (idx < m_len) { if (idx < m_len) {
ValueObjectSP &cached = m_children[idx]; ValueObjectSP &cached = m_children[idx];
if (!cached) { if (!cached) {
StreamString idx_name; StreamString idx_name;
idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
lldb::addr_t object_at_idx = m_base_data_address; lldb::addr_t object_at_idx = m_base_data_address;
object_at_idx += idx * m_type.GetByteSize(nullptr); object_at_idx += idx * m_type.GetByteSize(nullptr);
cached = CreateValueObjectFromAddress( cached = CreateValueObjectFromAddress(
idx_name.GetData(), object_at_idx, idx_name.GetString(), object_at_idx,
m_backend.GetExecutionContextRef(), m_type); m_backend.GetExecutionContextRef(), m_type);
} }
return cached; return cached;
} }
return ValueObjectSP(); return ValueObjectSP();
} }
bool Update() override { bool Update() override {
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Language/Java/JavaFormatterFunctions.cpp

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
if (error.Fail() || byte_size != bytes_read) if (error.Fail() || byte_size != bytes_read)
return nullptr; return nullptr;
StreamString name; StreamString name;
name.Printf("[%" PRIu64 "]", (uint64_t)idx); name.Printf("[%" PRIu64 "]", (uint64_t)idx);
DataExtractor data(buffer_sp, process_sp->GetByteOrder(), DataExtractor data(buffer_sp, process_sp->GetByteOrder(),
process_sp->GetAddressByteSize()); process_sp->GetAddressByteSize());
return CreateValueObjectFromData( return CreateValueObjectFromData(
name.GetData(), data, valobj->GetExecutionContextRef(), element_type); name.GetString(), data, valobj->GetExecutionContextRef(), element_type);
} }
bool Update() override { return false; } bool Update() override { return false; }
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(const ConstString &name) override {
return ExtractIndexFromString(name.GetCString()); return ExtractIndexFromString(name.GetCString());
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Language/ObjC/NSArray.cpp

Show First 20 Lines • Show All 344 Lines • ▼ Show 20 Lineslldb_private::formatters::NSArrayMSyntheticFrontEnd::GetChildAtIndex(
lldb::addr_t object_at_idx = GetDataAddress(); lldb::addr_t object_at_idx = GetDataAddress();
size_t pyhs_idx = idx; size_t pyhs_idx = idx;
pyhs_idx += GetOffset(); pyhs_idx += GetOffset();
if (GetSize() <= pyhs_idx) if (GetSize() <= pyhs_idx)
pyhs_idx -= GetSize(); pyhs_idx -= GetSize();
object_at_idx += (pyhs_idx * m_ptr_size); object_at_idx += (pyhs_idx * m_ptr_size);
StreamString idx_name; StreamString idx_name;
idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
return CreateValueObjectFromAddress(idx_name.GetData(), object_at_idx, return CreateValueObjectFromAddress(idx_name.GetString(), object_at_idx,
m_exe_ctx_ref, m_id_type); m_exe_ctx_ref, m_id_type);
} }
bool lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::Update() { bool lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::Update() {
ValueObjectSP valobj_sp = m_backend.GetSP(); ValueObjectSP valobj_sp = m_backend.GetSP();
m_ptr_size = 0; m_ptr_size = 0;
delete m_data_32; delete m_data_32;
m_data_32 = nullptr; m_data_32 = nullptr;
▲ Show 20 Lines • Show All 204 Lines • ▼ Show 20 Lineslldb_private::formatters::NSArrayISyntheticFrontEnd::GetChildAtIndex(
ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP(); ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
if (!process_sp) if (!process_sp)
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
Error error; Error error;
if (error.Fail()) if (error.Fail())
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
StreamString idx_name; StreamString idx_name;
idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
return CreateValueObjectFromAddress(idx_name.GetData(), object_at_idx, return CreateValueObjectFromAddress(idx_name.GetString(), object_at_idx,
m_exe_ctx_ref, m_id_type); m_exe_ctx_ref, m_id_type);
} }
lldb_private::formatters::NSArray0SyntheticFrontEnd::NSArray0SyntheticFrontEnd( lldb_private::formatters::NSArray0SyntheticFrontEnd::NSArray0SyntheticFrontEnd(
lldb::ValueObjectSP valobj_sp) lldb::ValueObjectSP valobj_sp)
: SyntheticChildrenFrontEnd(*valobj_sp) {} : SyntheticChildrenFrontEnd(*valobj_sp) {}
size_t size_t
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Language/ObjC/NSDictionary.cpp

Show First 20 Lines • Show All 493 Lines • ▼ Show 20 Lines if (m_ptr_size == 8) {
uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes(); uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
*data_ptr = dict_item.key_ptr; *data_ptr = dict_item.key_ptr;
*(data_ptr + 1) = dict_item.val_ptr; *(data_ptr + 1) = dict_item.val_ptr;
} }
StreamString idx_name; StreamString idx_name;
idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
DataExtractor data(buffer_sp, m_order, m_ptr_size); DataExtractor data(buffer_sp, m_order, m_ptr_size);
dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetData(), data, dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetString(), data,
m_exe_ctx_ref, m_pair_type); m_exe_ctx_ref, m_pair_type);
} }
return dict_item.valobj_sp; return dict_item.valobj_sp;
} }
lldb_private::formatters::NSDictionary1SyntheticFrontEnd:: lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
NSDictionary1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) NSDictionary1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
: SyntheticChildrenFrontEnd(*valobj_sp.get()), m_pair(nullptr) {} : SyntheticChildrenFrontEnd(*valobj_sp.get()), m_pair(nullptr) {}
▲ Show 20 Lines • Show All 213 Lines • ▼ Show 20 Lines if (m_ptr_size == 8) {
uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes(); uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
*data_ptr = dict_item.key_ptr; *data_ptr = dict_item.key_ptr;
*(data_ptr + 1) = dict_item.val_ptr; *(data_ptr + 1) = dict_item.val_ptr;
} }
StreamString idx_name; StreamString idx_name;
idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
DataExtractor data(buffer_sp, m_order, m_ptr_size); DataExtractor data(buffer_sp, m_order, m_ptr_size);
dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetData(), data, dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetString(), data,
m_exe_ctx_ref, m_pair_type); m_exe_ctx_ref, m_pair_type);
} }
return dict_item.valobj_sp; return dict_item.valobj_sp;
} }
template bool lldb_private::formatters::NSDictionarySummaryProvider<true>( template bool lldb_private::formatters::NSDictionarySummaryProvider<true>(
ValueObject &, Stream &, const TypeSummaryOptions &); ValueObject &, Stream &, const TypeSummaryOptions &);
template bool lldb_private::formatters::NSDictionarySummaryProvider<false>( template bool lldb_private::formatters::NSDictionarySummaryProvider<false>(
ValueObject &, Stream &, const TypeSummaryOptions &); ValueObject &, Stream &, const TypeSummaryOptions &);

lldb/trunk/source/Plugins/Language/ObjC/NSIndexPath.cpp

Show First 20 Lines • Show All 204 Lines • ▼ Show 20 Lines public:
v = Value(scalar); v = Value(scalar);
} }
v.SetCompilerType(desired_type); v.SetCompilerType(desired_type);
StreamString idx_name; StreamString idx_name;
idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
return ValueObjectConstResult::Create(m_process, v, return ValueObjectConstResult::Create(
ConstString(idx_name.GetData())); m_process, v, ConstString(idx_name.GetString()));
} }
void Clear() { void Clear() {
m_indexes = 0; m_indexes = 0;
m_count = 0; m_count = 0;
m_ptr_size = 0; m_ptr_size = 0;
m_process = nullptr; m_process = nullptr;
} }
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Language/ObjC/NSSet.cpp

Show First 20 Lines • Show All 429 Lines • ▼ Show 20 Lines if (!set_item.valobj_sp) {
StreamString idx_name; StreamString idx_name;
idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
DataExtractor data(buffer.GetBytes(), buffer.GetByteSize(), DataExtractor data(buffer.GetBytes(), buffer.GetByteSize(),
process_sp->GetByteOrder(), process_sp->GetByteOrder(),
process_sp->GetAddressByteSize()); process_sp->GetAddressByteSize());
set_item.valobj_sp = CreateValueObjectFromData( set_item.valobj_sp = CreateValueObjectFromData(
idx_name.GetData(), data, m_exe_ctx_ref, idx_name.GetString(), data, m_exe_ctx_ref,
m_backend.GetCompilerType().GetBasicTypeFromAST( m_backend.GetCompilerType().GetBasicTypeFromAST(
lldb::eBasicTypeObjCID)); lldb::eBasicTypeObjCID));
} }
return set_item.valobj_sp; return set_item.valobj_sp;
} }
lldb_private::formatters::NSSetMSyntheticFrontEnd::NSSetMSyntheticFrontEnd( lldb_private::formatters::NSSetMSyntheticFrontEnd::NSSetMSyntheticFrontEnd(
lldb::ValueObjectSP valobj_sp) lldb::ValueObjectSP valobj_sp)
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines if (!set_item.valobj_sp) {
StreamString idx_name; StreamString idx_name;
idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx); idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
DataExtractor data(buffer.GetBytes(), buffer.GetByteSize(), DataExtractor data(buffer.GetBytes(), buffer.GetByteSize(),
process_sp->GetByteOrder(), process_sp->GetByteOrder(),
process_sp->GetAddressByteSize()); process_sp->GetAddressByteSize());
set_item.valobj_sp = CreateValueObjectFromData( set_item.valobj_sp = CreateValueObjectFromData(
idx_name.GetData(), data, m_exe_ctx_ref, idx_name.GetString(), data, m_exe_ctx_ref,
m_backend.GetCompilerType().GetBasicTypeFromAST( m_backend.GetCompilerType().GetBasicTypeFromAST(
lldb::eBasicTypeObjCID)); lldb::eBasicTypeObjCID));
} }
return set_item.valobj_sp; return set_item.valobj_sp;
} }
template bool lldb_private::formatters::NSSetSummaryProvider<true>( template bool lldb_private::formatters::NSSetSummaryProvider<true>(
ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options); ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options);
template bool lldb_private::formatters::NSSetSummaryProvider<false>( template bool lldb_private::formatters::NSSetSummaryProvider<false>(
ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options); ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options);

lldb/trunk/source/Plugins/Language/ObjC/ObjCLanguage.cpp

Show First 20 Lines • Show All 211 Lines • ▼ Show 20 Lines if (IsValid(false)) {
if (HasCategory()) { if (HasCategory()) {
StreamString strm; StreamString strm;
if (m_type == eTypeClassMethod) if (m_type == eTypeClassMethod)
strm.PutChar('+'); strm.PutChar('+');
else if (m_type == eTypeInstanceMethod) else if (m_type == eTypeInstanceMethod)
strm.PutChar('-'); strm.PutChar('-');
strm.Printf("[%s %s]", GetClassName().GetCString(), strm.Printf("[%s %s]", GetClassName().GetCString(),
GetSelector().GetCString()); GetSelector().GetCString());
return ConstString(strm.GetString().c_str()); return ConstString(strm.GetString());
} }
if (!empty_if_no_category) { if (!empty_if_no_category) {
// Just return the full name since it doesn't have a category // Just return the full name since it doesn't have a category
return GetFullName(); return GetFullName();
} }
} }
return ConstString(); return ConstString();
} }
size_t ObjCLanguage::MethodName::GetFullNames(std::vector<ConstString> &names, size_t ObjCLanguage::MethodName::GetFullNames(std::vector<ConstString> &names,
bool append) { bool append) {
if (!append) if (!append)
names.clear(); names.clear();
if (IsValid(false)) { if (IsValid(false)) {
StreamString strm; StreamString strm;
const bool is_class_method = m_type == eTypeClassMethod; const bool is_class_method = m_type == eTypeClassMethod;
const bool is_instance_method = m_type == eTypeInstanceMethod; const bool is_instance_method = m_type == eTypeInstanceMethod;
const ConstString &category = GetCategory(); const ConstString &category = GetCategory();
if (is_class_method || is_instance_method) { if (is_class_method || is_instance_method) {
names.push_back(m_full); names.push_back(m_full);
if (category) { if (category) {
strm.Printf("%c[%s %s]", is_class_method ? '+' : '-', strm.Printf("%c[%s %s]", is_class_method ? '+' : '-',
GetClassName().GetCString(), GetSelector().GetCString()); GetClassName().GetCString(), GetSelector().GetCString());
names.push_back(ConstString(strm.GetString().c_str())); names.emplace_back(strm.GetString());
} }
} else { } else {
const ConstString &class_name = GetClassName(); const ConstString &class_name = GetClassName();
const ConstString &selector = GetSelector(); const ConstString &selector = GetSelector();
strm.Printf("+[%s %s]", class_name.GetCString(), selector.GetCString()); strm.Printf("+[%s %s]", class_name.GetCString(), selector.GetCString());
names.push_back(ConstString(strm.GetString().c_str())); names.emplace_back(strm.GetString());
strm.Clear(); strm.Clear();
strm.Printf("-[%s %s]", class_name.GetCString(), selector.GetCString()); strm.Printf("-[%s %s]", class_name.GetCString(), selector.GetCString());
names.push_back(ConstString(strm.GetString().c_str())); names.emplace_back(strm.GetString());
strm.Clear(); strm.Clear();
if (category) { if (category) {
strm.Printf("+[%s(%s) %s]", class_name.GetCString(), strm.Printf("+[%s(%s) %s]", class_name.GetCString(),
category.GetCString(), selector.GetCString()); category.GetCString(), selector.GetCString());
names.push_back(ConstString(strm.GetString().c_str())); names.emplace_back(strm.GetString());
strm.Clear(); strm.Clear();
strm.Printf("-[%s(%s) %s]", class_name.GetCString(), strm.Printf("-[%s(%s) %s]", class_name.GetCString(),
category.GetCString(), selector.GetCString()); category.GetCString(), selector.GetCString());
names.push_back(ConstString(strm.GetString().c_str())); names.emplace_back(strm.GetString());
} }
} }
} }
return names.size(); return names.size();
} }
static void LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) { static void LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) {
if (!objc_category_sp) if (!objc_category_sp)
▲ Show 20 Lines • Show All 823 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp

Show First 20 Lines • Show All 141 Lines • ▼ Show 20 Linesclang::QualType AppleObjCTypeEncodingParser::BuildAggregate(
if (union_type) { if (union_type) {
ClangASTContext::StartTagDeclarationDefinition(union_type); ClangASTContext::StartTagDeclarationDefinition(union_type);
unsigned int count = 0; unsigned int count = 0;
for (auto element : elements) { for (auto element : elements) {
if (element.name.empty()) { if (element.name.empty()) {
StreamString elem_name; StreamString elem_name;
elem_name.Printf("__unnamed_%u", count); elem_name.Printf("__unnamed_%u", count);
element.name = std::string(elem_name.GetData()); element.name = elem_name.GetString();
} }
ClangASTContext::AddFieldToRecordType( ClangASTContext::AddFieldToRecordType(
union_type, element.name.c_str(), union_type, element.name.c_str(),
CompilerType(&ast_ctx, element.type), lldb::eAccessPublic, CompilerType(&ast_ctx, element.type), lldb::eAccessPublic,
element.bitfield); element.bitfield);
++count; ++count;
} }
ClangASTContext::CompleteTagDeclarationDefinition(union_type); ClangASTContext::CompleteTagDeclarationDefinition(union_type);
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

Show First 20 Lines • Show All 1,560 Lines • ▼ Show 20 Lines if (res_name.size() > 0) {
StreamString strm; StreamString strm;
strm.Printf("librs.%s.so", res_name.c_str()); strm.Printf("librs.%s.so", res_name.c_str());
ScriptDetails *script = LookUpScript(addr_t(args[eRsScript]), true); ScriptDetails *script = LookUpScript(addr_t(args[eRsScript]), true);
if (script) { if (script) {
script->type = ScriptDetails::eScriptC; script->type = ScriptDetails::eScriptC;
script->cache_dir = cache_dir; script->cache_dir = cache_dir;
script->res_name = res_name; script->res_name = res_name;
script->shared_lib = strm.GetData(); script->shared_lib = strm.GetString();
script->context = addr_t(args[eRsContext]); script->context = addr_t(args[eRsContext]);
} }
if (log) if (log)
log->Printf("%s - '%s' tagged with context 0x%" PRIx64 log->Printf("%s - '%s' tagged with context 0x%" PRIx64
" and script 0x%" PRIx64 ".", " and script 0x%" PRIx64 ".",
__FUNCTION__, strm.GetData(), uint64_t(args[eRsContext]), __FUNCTION__, strm.GetData(), uint64_t(args[eRsContext]),
uint64_t(args[eRsScript])); uint64_t(args[eRsScript]));
▲ Show 20 Lines • Show All 3,430 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/MemoryHistory/asan/MemoryHistoryASan.cpp

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 LinesHistoryThreads MemoryHistoryASan::GetHistoryThreads(lldb::addr_t address) {
options.SetStopOthers(true); options.SetStopOthers(true);
options.SetIgnoreBreakpoints(true); options.SetIgnoreBreakpoints(true);
options.SetTimeoutUsec(GET_STACK_FUNCTION_TIMEOUT_USEC); options.SetTimeoutUsec(GET_STACK_FUNCTION_TIMEOUT_USEC);
options.SetPrefix(memory_history_asan_command_prefix); options.SetPrefix(memory_history_asan_command_prefix);
options.SetAutoApplyFixIts(false); options.SetAutoApplyFixIts(false);
options.SetLanguage(eLanguageTypeObjC_plus_plus); options.SetLanguage(eLanguageTypeObjC_plus_plus);
ExpressionResults expr_result = UserExpression::Evaluate( ExpressionResults expr_result = UserExpression::Evaluate(
exe_ctx, options, expr.GetData(), "", return_value_sp, eval_error); exe_ctx, options, expr.GetString(), "", return_value_sp, eval_error);
if (expr_result != eExpressionCompleted) { if (expr_result != eExpressionCompleted) {
process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf( process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
"Warning: Cannot evaluate AddressSanitizer expression:\n%s\n", "Warning: Cannot evaluate AddressSanitizer expression:\n%s\n",
eval_error.AsCString()); eval_error.AsCString());
return result; return result;
} }
if (!return_value_sp) if (!return_value_sp)
Show All 9 Lines

lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

Show First 20 Lines • Show All 5,990 Lines • ▼ Show 20 Lines if (target_triple.getVendor() == llvm::Triple::Apple &&
file_offset += segment.filesize; file_offset += segment.filesize;
} }
// Write out all of the LC_THREAD load commands // Write out all of the LC_THREAD load commands
for (const auto &LC_THREAD_data : LC_THREAD_datas) { for (const auto &LC_THREAD_data : LC_THREAD_datas) {
const size_t LC_THREAD_data_size = LC_THREAD_data.GetSize(); const size_t LC_THREAD_data_size = LC_THREAD_data.GetSize();
buffer.PutHex32(LC_THREAD); buffer.PutHex32(LC_THREAD);
buffer.PutHex32(8 + LC_THREAD_data_size); // cmd + cmdsize + data buffer.PutHex32(8 + LC_THREAD_data_size); // cmd + cmdsize + data
buffer.Write(LC_THREAD_data.GetData(), LC_THREAD_data_size); buffer.Write(LC_THREAD_data.GetString().data(),
LC_THREAD_data_size);
} }
// Write out all of the segment load commands // Write out all of the segment load commands
for (const auto &segment : segment_load_commands) { for (const auto &segment : segment_load_commands) {
printf("0x%8.8x 0x%8.8x [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 printf("0x%8.8x 0x%8.8x [0x%16.16" PRIx64 " - 0x%16.16" PRIx64
") [0x%16.16" PRIx64 " 0x%16.16" PRIx64 ") [0x%16.16" PRIx64 " 0x%16.16" PRIx64
") 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x]\n", ") 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x]\n",
segment.cmd, segment.cmdsize, segment.vmaddr, segment.cmd, segment.cmdsize, segment.vmaddr,
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

//===-- OperatingSystemPython.cpp --------------------------------*- C++ //===-- OperatingSystemPython.cpp --------------------------------*- C++-*-===//
//-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 181 Lines • ▼ Show 20 Linesbool OperatingSystemPython::UpdateThreadList(ThreadList &old_thread_list,
// Make a map so we can keep track of which cores were used from the // Make a map so we can keep track of which cores were used from the
// core_thread list. Any real threads/cores that weren't used should // core_thread list. Any real threads/cores that weren't used should
// later be put back into the "new_thread_list". // later be put back into the "new_thread_list".
std::vector<bool> core_used_map(num_cores, false); std::vector<bool> core_used_map(num_cores, false);
if (threads_list) { if (threads_list) {
if (log) { if (log) {
StreamString strm; StreamString strm;
threads_list->Dump(strm); threads_list->Dump(strm);
log->Printf("threads_list = %s", strm.GetString().c_str()); log->Printf("threads_list = %s", strm.GetData());
} }
const uint32_t num_threads = threads_list->GetSize(); const uint32_t num_threads = threads_list->GetSize();
for (uint32_t i = 0; i < num_threads; ++i) { for (uint32_t i = 0; i < num_threads; ++i) {
StructuredData::ObjectSP thread_dict_obj = StructuredData::ObjectSP thread_dict_obj =
threads_list->GetItemAtIndex(i); threads_list->GetItemAtIndex(i);
if (auto thread_dict = thread_dict_obj->GetAsDictionary()) { if (auto thread_dict = thread_dict_obj->GetAsDictionary()) {
ThreadSP thread_sp( ThreadSP thread_sp(
▲ Show 20 Lines • Show All 210 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/Android/AdbClient.cpp

Show First 20 Lines • Show All 354 Lines • ▼ Show 20 LinesError AdbClient::internalShell(const char *command, uint32_t timeout_ms,
output_buf.clear(); output_buf.clear();
auto error = SwitchDeviceTransport(); auto error = SwitchDeviceTransport();
if (error.Fail()) if (error.Fail())
return Error("Failed to switch to device transport: %s", error.AsCString()); return Error("Failed to switch to device transport: %s", error.AsCString());
StreamString adb_command; StreamString adb_command;
adb_command.Printf("shell:%s", command); adb_command.Printf("shell:%s", command);
error = SendMessage(adb_command.GetData(), false); error = SendMessage(adb_command.GetString(), false);
if (error.Fail()) if (error.Fail())
return error; return error;
error = ReadResponseStatus(); error = ReadResponseStatus();
if (error.Fail()) if (error.Fail())
return error; return error;
error = ReadMessageStream(output_buf, timeout_ms); error = ReadMessageStream(output_buf, timeout_ms);
▲ Show 20 Lines • Show All 278 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

Show First 20 Lines • Show All 221 Lines • ▼ Show 20 Lines if (resolved_module_spec.GetArchitecture().IsValid()) {
resolved_module_spec.GetArchitecture().GetArchitectureName()); resolved_module_spec.GetArchitecture().GetArchitectureName());
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetData());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} }
} }
▲ Show 20 Lines • Show All 373 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/Kalimba/PlatformKalimba.cpp

Show First 20 Lines • Show All 157 Lines • ▼ Show 20 Lines if (resolved_module_spec.GetArchitecture().IsValid()) {
resolved_module_spec.GetArchitecture().GetArchitectureName()); resolved_module_spec.GetArchitecture().GetArchitectureName());
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetData());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} }
} }
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp

Show First 20 Lines • Show All 311 Lines • ▼ Show 20 Lines if (resolved_module_spec.GetArchitecture().IsValid()) {
resolved_module_spec.GetArchitecture().GetArchitectureName()); resolved_module_spec.GetArchitecture().GetArchitectureName());
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetData());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} }
} }
▲ Show 20 Lines • Show All 299 Lines • ▼ Show 20 Lines log->Printf(
"PlatformLinux::%s launching process with the following file actions:", "PlatformLinux::%s launching process with the following file actions:",
__FUNCTION__); __FUNCTION__);
StreamString stream; StreamString stream;
size_t i = 0; size_t i = 0;
const FileAction *file_action; const FileAction *file_action;
while ((file_action = launch_info.GetFileActionAtIndex(i++)) != nullptr) { while ((file_action = launch_info.GetFileActionAtIndex(i++)) != nullptr) {
file_action->Dump(stream); file_action->Dump(stream);
log->PutCString(stream.GetString().c_str()); log->PutCString(stream.GetData());
stream.Clear(); stream.Clear();
} }
} }
// Do the launch. // Do the launch.
error = process_sp->Launch(launch_info); error = process_sp->Launch(launch_info);
if (error.Success()) { if (error.Success()) {
// Handle the hijacking of process events. // Handle the hijacking of process events.
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
} }
ConstString PlatformLinux::GetFullNameForDylib(ConstString basename) { ConstString PlatformLinux::GetFullNameForDylib(ConstString basename) {
if (basename.IsEmpty()) if (basename.IsEmpty())
return basename; return basename;
StreamString stream; StreamString stream;
stream.Printf("lib%s.so", basename.GetCString()); stream.Printf("lib%s.so", basename.GetCString());
return ConstString(stream.GetData()); return ConstString(stream.GetString());
} }

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp

Show First 20 Lines • Show All 224 Lines • ▼ Show 20 Lines for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
} }
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetString().str().c_str());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} else { } else {
error.SetErrorStringWithFormat("'%s' does not exist", error.SetErrorStringWithFormat("'%s' does not exist",
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp

Show First 20 Lines • Show All 226 Lines • ▼ Show 20 Lines for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
} }
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetString().str().c_str());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} else { } else {
error.SetErrorStringWithFormat("'%s' does not exist", error.SetErrorStringWithFormat("'%s' does not exist",
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

Show First 20 Lines • Show All 127 Lines • ▼ Show 20 Lines if (module_spec) {
// and see if the file exists // and see if the file exists
path_string.Printf("%s/../Python/%s.py", path_string.Printf("%s/../Python/%s.py",
symfile_spec.GetDirectory().GetCString(), symfile_spec.GetDirectory().GetCString(),
module_basename.c_str()); module_basename.c_str());
original_path_string.Printf( original_path_string.Printf(
"%s/../Python/%s.py", "%s/../Python/%s.py",
symfile_spec.GetDirectory().GetCString(), symfile_spec.GetDirectory().GetCString(),
original_module_basename.c_str()); original_module_basename.c_str());
FileSpec script_fspec(path_string.GetData(), true); FileSpec script_fspec(path_string.GetString(), true);
FileSpec orig_script_fspec(original_path_string.GetData(), FileSpec orig_script_fspec(original_path_string.GetString(),
true); true);
// if we did some replacements of reserved characters, and a // if we did some replacements of reserved characters, and a
// file with the untampered name // file with the untampered name
// exists, then warn the user that the file as-is shall not be // exists, then warn the user that the file as-is shall not be
// loaded // loaded
if (feedback_stream) { if (feedback_stream) {
if (module_basename != original_module_basename && if (module_basename != original_module_basename &&
▲ Show 20 Lines • Show All 144 Lines • ▼ Show 20 Lines if (resolved_module_spec.GetArchitecture().IsValid()) {
resolved_module_spec.GetArchitecture().GetArchitectureName()); resolved_module_spec.GetArchitecture().GetArchitectureName());
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetData());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} }
} }
▲ Show 20 Lines • Show All 1,467 Lines • ▼ Show 20 Lines
} }
ConstString PlatformDarwin::GetFullNameForDylib(ConstString basename) { ConstString PlatformDarwin::GetFullNameForDylib(ConstString basename) {
if (basename.IsEmpty()) if (basename.IsEmpty())
return basename; return basename;
StreamString stream; StreamString stream;
stream.Printf("lib%s.dylib", basename.GetCString()); stream.Printf("lib%s.dylib", basename.GetCString());
return ConstString(stream.GetData()); return ConstString(stream.GetString());
} }
bool PlatformDarwin::GetOSVersion(uint32_t &major, uint32_t &minor, bool PlatformDarwin::GetOSVersion(uint32_t &major, uint32_t &minor,
uint32_t &update, Process *process) { uint32_t &update, Process *process) {
if (process && strstr(GetPluginName().GetCString(), "-simulator")) { if (process && strstr(GetPluginName().GetCString(), "-simulator")) {
lldb_private::ProcessInstanceInfo proc_info; lldb_private::ProcessInstanceInfo proc_info;
if (Host::GetProcessInfo(process->GetID(), proc_info)) { if (Host::GetProcessInfo(process->GetID(), proc_info)) {
Args &env = proc_info.GetEnvironmentEntries(); Args &env = proc_info.GetEnvironmentEntries();
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

Show First 20 Lines • Show All 216 Lines • ▼ Show 20 Lines if (objfile) {
if (!xcode_contents_path.empty()) { if (!xcode_contents_path.empty()) {
StreamString sdk_path; StreamString sdk_path;
sdk_path.Printf("%sDeveloper/Platforms/MacOSX.platform/Developer/" sdk_path.Printf("%sDeveloper/Platforms/MacOSX.platform/Developer/"
"SDKs/MacOSX%u.%u.sdk", "SDKs/MacOSX%u.%u.sdk",
xcode_contents_path.c_str(), versions[0], xcode_contents_path.c_str(), versions[0],
versions[1]); versions[1]);
fspec.SetFile(sdk_path.GetString(), false); fspec.SetFile(sdk_path.GetString(), false);
if (fspec.Exists()) if (fspec.Exists())
return ConstString(sdk_path.GetString().c_str()); return ConstString(sdk_path.GetString());
} }
if (!default_xcode_sdk.empty()) { if (!default_xcode_sdk.empty()) {
fspec.SetFile(default_xcode_sdk, false); fspec.SetFile(default_xcode_sdk, false);
if (fspec.Exists()) if (fspec.Exists())
return ConstString(default_xcode_sdk.c_str()); return ConstString(default_xcode_sdk);
} }
} }
} }
} }
return ConstString(); return ConstString();
} }
Error PlatformMacOSX::GetSymbolFile(const FileSpec &platform_file, Error PlatformMacOSX::GetSymbolFile(const FileSpec &platform_file,
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.cpp

Show First 20 Lines • Show All 226 Lines • ▼ Show 20 Lines for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
resolved_module_spec.GetArchitecture().GetArchitectureName()); resolved_module_spec.GetArchitecture().GetArchitectureName());
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetData());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
▲ Show 20 Lines • Show All 653 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.cpp

Show First 20 Lines • Show All 236 Lines • ▼ Show 20 Lines for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
resolved_module_spec.GetArchitecture().GetArchitectureName()); resolved_module_spec.GetArchitecture().GetArchitectureName());
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetData());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
▲ Show 20 Lines • Show All 706 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp

Show First 20 Lines • Show All 231 Lines • ▼ Show 20 Lines for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
resolved_module_spec.GetArchitecture().GetArchitectureName()); resolved_module_spec.GetArchitecture().GetArchitectureName());
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetData());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
▲ Show 20 Lines • Show All 592 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

Show First 20 Lines • Show All 230 Lines • ▼ Show 20 Lines for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
} }
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetString().str().c_str());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} else { } else {
error.SetErrorStringWithFormat("'%s' does not exist", error.SetErrorStringWithFormat("'%s' does not exist",
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

Show First 20 Lines • Show All 213 Lines • ▼ Show 20 Lines if (resolved_module_spec.GetArchitecture().IsValid()) {
resolved_module_spec.GetArchitecture().GetArchitectureName()); resolved_module_spec.GetArchitecture().GetArchitectureName());
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetData());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} }
} }
▲ Show 20 Lines • Show All 319 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

Show First 20 Lines • Show All 429 Lines • ▼ Show 20 Linesstd::string PlatformPOSIX::GetPlatformSpecificConnectionInformation() {
if (GetSupportsSSH()) { if (GetSupportsSSH()) {
stream.PutCString("ssh"); stream.PutCString("ssh");
if (GetSSHOpts() && *GetSSHOpts()) if (GetSSHOpts() && *GetSSHOpts())
stream.Printf(", options: '%s' ", GetSSHOpts()); stream.Printf(", options: '%s' ", GetSSHOpts());
} }
if (GetLocalCacheDirectory() && *GetLocalCacheDirectory()) if (GetLocalCacheDirectory() && *GetLocalCacheDirectory())
stream.Printf("cache dir: %s", GetLocalCacheDirectory()); stream.Printf("cache dir: %s", GetLocalCacheDirectory());
if (stream.GetSize()) if (stream.GetSize())
return stream.GetData(); return stream.GetString();
else else
return ""; return "";
} }
bool PlatformPOSIX::CalculateMD5(const FileSpec &file_spec, uint64_t &low, bool PlatformPOSIX::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
uint64_t &high) { uint64_t &high) {
if (IsHost()) if (IsHost())
return Platform::CalculateMD5(file_spec, low, high); return Platform::CalculateMD5(file_spec, low, high);
▲ Show 20 Lines • Show All 420 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.cpp

Show First 20 Lines • Show All 259 Lines • ▼ Show 20 Lines if (resolved_module_spec.GetArchitecture().IsValid()) {
resolved_module_spec.GetArchitecture().GetArchitectureName()); resolved_module_spec.GetArchitecture().GetArchitectureName());
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetData());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} }
} }
▲ Show 20 Lines • Show All 321 Lines • ▼ Show 20 Lines
} }
ConstString PlatformWindows::GetFullNameForDylib(ConstString basename) { ConstString PlatformWindows::GetFullNameForDylib(ConstString basename) {
if (basename.IsEmpty()) if (basename.IsEmpty())
return basename; return basename;
StreamString stream; StreamString stream;
stream.Printf("%s.dll", basename.GetCString()); stream.Printf("%s.dll", basename.GetCString());
return ConstString(stream.GetData()); return ConstString(stream.GetString());
} }

lldb/trunk/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

Show First 20 Lines • Show All 141 Lines • ▼ Show 20 Lines for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
resolved_module_spec.GetArchitecture().GetArchitectureName()); resolved_module_spec.GetArchitecture().GetArchitectureName());
} }
if (error.Fail() || !exe_module_sp) { if (error.Fail() || !exe_module_sp) {
if (resolved_module_spec.GetFileSpec().Readable()) { if (resolved_module_spec.GetFileSpec().Readable()) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' doesn't contain any '%s' platform architectures: %s", "'%s' doesn't contain any '%s' platform architectures: %s",
resolved_module_spec.GetFileSpec().GetPath().c_str(), resolved_module_spec.GetFileSpec().GetPath().c_str(),
GetPluginName().GetCString(), arch_names.GetString().c_str()); GetPluginName().GetCString(), arch_names.GetData());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"'%s' is not readable", "'%s' is not readable",
resolved_module_spec.GetFileSpec().GetPath().c_str()); resolved_module_spec.GetFileSpec().GetPath().c_str());
} }
} }
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
Show All 21 Linesbool PlatformRemoteGDBServer::GetModuleSpec(const FileSpec &module_file_spec,
} }
if (log) { if (log) {
StreamString stream; StreamString stream;
module_spec.Dump(stream); module_spec.Dump(stream);
log->Printf( log->Printf(
"PlatformRemoteGDBServer::%s - got module info for (%s:%s) : %s", "PlatformRemoteGDBServer::%s - got module info for (%s:%s) : %s",
__FUNCTION__, module_path.c_str(), arch.GetTriple().getTriple().c_str(), __FUNCTION__, module_path.c_str(), arch.GetTriple().getTriple().c_str(),
stream.GetString().c_str()); stream.GetData());
} }
return true; return true;
} }
Error PlatformRemoteGDBServer::GetFileWithUUID(const FileSpec &platform_file, Error PlatformRemoteGDBServer::GetFileWithUUID(const FileSpec &platform_file,
const UUID *uuid_ptr, const UUID *uuid_ptr,
FileSpec &local_file) { FileSpec &local_file) {
▲ Show 20 Lines • Show All 693 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

Show First 20 Lines • Show All 959 Lines • ▼ Show 20 Lines if (argc == 0) {
payload_bytes.size(), reply, error); payload_bytes.size(), reply, error);
if (error.Success()) { if (error.Success()) {
// Copy the binary bytes into a hex ASCII string for the result // Copy the binary bytes into a hex ASCII string for the result
StreamString packet; StreamString packet;
packet.PutBytesAsRawHex8( packet.PutBytesAsRawHex8(
reply.GetDataStart(), reply.GetByteSize(), reply.GetDataStart(), reply.GetByteSize(),
endian::InlHostByteOrder(), endian::InlHostByteOrder()); endian::InlHostByteOrder(), endian::InlHostByteOrder());
result.AppendMessage(packet.GetString().c_str()); result.AppendMessage(packet.GetString());
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
return true; return true;
} else { } else {
const char *error_cstr = error.AsCString(); const char *error_cstr = error.AsCString();
if (error_cstr && error_cstr[0]) if (error_cstr && error_cstr[0])
result.AppendError(error_cstr); result.AppendError(error_cstr);
else else
result.AppendErrorWithFormat("unknown error 0x%8.8x", result.AppendErrorWithFormat("unknown error 0x%8.8x",
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/Utility/RegisterContextLLDB.cpp

Show First 20 Lines • Show All 212 Lines • ▼ Show 20 Lines if (m_full_unwind_plan_sp &&
m_full_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) { m_full_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
active_row = active_row =
m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset); m_full_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
row_register_kind = m_full_unwind_plan_sp->GetRegisterKind(); row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
if (active_row.get() && log) { if (active_row.get() && log) {
StreamString active_row_strm; StreamString active_row_strm;
active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(), &m_thread, active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(), &m_thread,
m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr())); m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
UnwindLogMsg("%s", active_row_strm.GetString().c_str()); UnwindLogMsg("%s", active_row_strm.GetData());
} }
} }
if (!active_row.get()) { if (!active_row.get()) {
UnwindLogMsg("could not find an unwindplan row for this frame's pc"); UnwindLogMsg("could not find an unwindplan row for this frame's pc");
m_frame_type = eNotAValidFrame; m_frame_type = eNotAValidFrame;
return; return;
} }
▲ Show 20 Lines • Show All 329 Lines • ▼ Show 20 Lines if (m_fast_unwind_plan_sp &&
m_fast_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) { m_fast_unwind_plan_sp->PlanValidAtAddress(m_current_pc)) {
active_row = active_row =
m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset); m_fast_unwind_plan_sp->GetRowForFunctionOffset(m_current_offset);
row_register_kind = m_fast_unwind_plan_sp->GetRegisterKind(); row_register_kind = m_fast_unwind_plan_sp->GetRegisterKind();
if (active_row.get() && log) { if (active_row.get() && log) {
StreamString active_row_strm; StreamString active_row_strm;
active_row->Dump(active_row_strm, m_fast_unwind_plan_sp.get(), &m_thread, active_row->Dump(active_row_strm, m_fast_unwind_plan_sp.get(), &m_thread,
m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr())); m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
UnwindLogMsg("active row: %s", active_row_strm.GetString().c_str()); UnwindLogMsg("active row: %s", active_row_strm.GetData());
} }
} else { } else {
m_full_unwind_plan_sp = GetFullUnwindPlanForFrame(); m_full_unwind_plan_sp = GetFullUnwindPlanForFrame();
int valid_offset = -1; int valid_offset = -1;
if (IsUnwindPlanValidForCurrentPC(m_full_unwind_plan_sp, valid_offset)) { if (IsUnwindPlanValidForCurrentPC(m_full_unwind_plan_sp, valid_offset)) {
active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset(valid_offset); active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset(valid_offset);
row_register_kind = m_full_unwind_plan_sp->GetRegisterKind(); row_register_kind = m_full_unwind_plan_sp->GetRegisterKind();
if (active_row.get() && log) { if (active_row.get() && log) {
StreamString active_row_strm; StreamString active_row_strm;
active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(), active_row->Dump(active_row_strm, m_full_unwind_plan_sp.get(),
&m_thread, &m_thread,
m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr())); m_start_pc.GetLoadAddress(exe_ctx.GetTargetPtr()));
UnwindLogMsg("active row: %s", active_row_strm.GetString().c_str()); UnwindLogMsg("active row: %s", active_row_strm.GetData());
} }
} }
} }
if (!active_row.get()) { if (!active_row.get()) {
m_frame_type = eNotAValidFrame; m_frame_type = eNotAValidFrame;
UnwindLogMsg("could not find unwind row for this pc"); UnwindLogMsg("could not find unwind row for this pc");
return; return;
▲ Show 20 Lines • Show All 1,511 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/Utility/StopInfoMachException.cpp

Show First 20 Lines • Show All 300 Lines • ▼ Show 20 Lines if (m_exc_data_count >= 2) {
strm.Printf(", %s=%s", subcode_label, subcode_desc); strm.Printf(", %s=%s", subcode_label, subcode_desc);
else else
strm.Printf(", %s=0x%" PRIx64, subcode_label, m_exc_subcode); strm.Printf(", %s=0x%" PRIx64, subcode_label, m_exc_subcode);
} }
if (m_exc_data_count > 0) if (m_exc_data_count > 0)
strm.PutChar(')'); strm.PutChar(')');
m_description.swap(strm.GetString()); m_description = strm.GetString();
} }
return m_description.c_str(); return m_description.c_str();
} }
StopInfoSP StopInfoMachException::CreateStopReasonWithMachException( StopInfoSP StopInfoMachException::CreateStopReasonWithMachException(
Thread &thread, uint32_t exc_type, uint32_t exc_data_count, Thread &thread, uint32_t exc_type, uint32_t exc_data_count,
uint64_t exc_code, uint64_t exc_sub_code, uint64_t exc_sub_sub_code, uint64_t exc_code, uint64_t exc_sub_code, uint64_t exc_sub_sub_code,
bool pc_already_adjusted, bool adjust_pc_if_needed) { bool pc_already_adjusted, bool adjust_pc_if_needed) {
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

Show First 20 Lines • Show All 194 Lines • ▼ Show 20 Lines if (IsConnected()) {
packet.PutChar('$'); packet.PutChar('$');
packet.Write(payload.data(), payload.size()); packet.Write(payload.data(), payload.size());
packet.PutChar('#'); packet.PutChar('#');
packet.PutHex8(CalculcateChecksum(payload)); packet.PutHex8(CalculcateChecksum(payload));
Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PACKETS)); Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PACKETS));
ConnectionStatus status = eConnectionStatusSuccess; ConnectionStatus status = eConnectionStatusSuccess;
const char *packet_data = packet.GetData(); // TODO: Don't shimmy through a std::string, just use StringRef.
std::string packet_str = packet.GetString();
const char *packet_data = packet_str.c_str();
const size_t packet_length = packet.GetSize(); const size_t packet_length = packet.GetSize();
size_t bytes_written = Write(packet_data, packet_length, status, NULL); size_t bytes_written = Write(packet_data, packet_length, status, NULL);
if (log) { if (log) {
size_t binary_start_offset = 0; size_t binary_start_offset = 0;
if (strncmp(packet_data, "$vFile:pwrite:", strlen("$vFile:pwrite:")) == if (strncmp(packet_data, "$vFile:pwrite:", strlen("$vFile:pwrite:")) ==
0) { 0) {
const char *first_comma = strchr(packet_data, ','); const char *first_comma = strchr(packet_data, ',');
if (first_comma) { if (first_comma) {
Show All 19 Lines if (log) {
(int)binary_start_offset, packet_data); (int)binary_start_offset, packet_data);
const uint8_t *p; const uint8_t *p;
// Print binary data exactly as sent // Print binary data exactly as sent
for (p = (const uint8_t *)packet_data + binary_start_offset; *p != '#'; for (p = (const uint8_t *)packet_data + binary_start_offset; *p != '#';
++p) ++p)
strm.Printf("\\x%2.2x", *p); strm.Printf("\\x%2.2x", *p);
// Print the checksum // Print the checksum
strm.Printf("%*s", (int)3, p); strm.Printf("%*s", (int)3, p);
log->PutCString(strm.GetString().c_str()); log->PutString(strm.GetString());
} else } else
log->Printf("<%4" PRIu64 "> send packet: %.*s", (uint64_t)bytes_written, log->Printf("<%4" PRIu64 "> send packet: %.*s", (uint64_t)bytes_written,
(int)packet_length, packet_data); (int)packet_length, packet_data);
} }
m_history.AddPacket(packet.GetString(), packet_length, m_history.AddPacket(packet.GetString(), packet_length,
History::ePacketTypeSend, bytes_written); History::ePacketTypeSend, bytes_written);
▲ Show 20 Lines • Show All 614 Lines • ▼ Show 20 Lines if (content_length == std::string::npos) {
strm.Printf("%2.2x", escapee); strm.Printf("%2.2x", escapee);
} else { } else {
strm.Printf("%2.2x", (uint8_t)ch); strm.Printf("%2.2x", (uint8_t)ch);
} }
} }
// Packet footer... // Packet footer...
strm.Printf("%c%c%c", m_bytes[total_length - 3], strm.Printf("%c%c%c", m_bytes[total_length - 3],
m_bytes[total_length - 2], m_bytes[total_length - 1]); m_bytes[total_length - 2], m_bytes[total_length - 1]);
log->PutCString(strm.GetString().c_str()); log->PutString(strm.GetString());
} else { } else {
if (CompressionIsEnabled()) if (CompressionIsEnabled())
log->Printf("<%4" PRIu64 ":%" PRIu64 "> read packet: %.*s", log->Printf("<%4" PRIu64 ":%" PRIu64 "> read packet: %.*s",
(uint64_t)original_packet_size, (uint64_t)total_length, (uint64_t)original_packet_size, (uint64_t)total_length,
(int)(total_length), m_bytes.c_str()); (int)(total_length), m_bytes.c_str());
else else
log->Printf("<%4" PRIu64 "> read packet: %.*s", log->Printf("<%4" PRIu64 "> read packet: %.*s",
(uint64_t)total_length, (int)(total_length), (uint64_t)total_length, (int)(total_length),
▲ Show 20 Lines • Show All 366 Lines • ▼ Show 20 Lines#endif
launch_info.AppendSuppressFileAction(STDOUT_FILENO, false, true); launch_info.AppendSuppressFileAction(STDOUT_FILENO, false, true);
launch_info.AppendSuppressFileAction(STDERR_FILENO, false, true); launch_info.AppendSuppressFileAction(STDERR_FILENO, false, true);
if (log) { if (log) {
StreamString string_stream; StreamString string_stream;
Platform *const platform = nullptr; Platform *const platform = nullptr;
launch_info.Dump(string_stream, platform); launch_info.Dump(string_stream, platform);
log->Printf("launch info for gdb-remote stub:\n%s", log->Printf("launch info for gdb-remote stub:\n%s",
string_stream.GetString().c_str()); string_stream.GetData());
} }
error = Host::LaunchProcess(launch_info); error = Host::LaunchProcess(launch_info);
if (error.Success() && if (error.Success() &&
(launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) && (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) &&
pass_comm_fd == -1) { pass_comm_fd == -1) {
if (named_pipe_path.size() > 0) { if (named_pipe_path.size() > 0) {
error = socket_pipe.OpenAsReader(named_pipe_path, false); error = socket_pipe.OpenAsReader(named_pipe_path, false);
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

Show First 20 Lines • Show All 343 Lines • ▼ Show 20 Linesvoid GDBRemoteCommunicationClient::GetRemoteQSupported() {
StreamString packet; StreamString packet;
packet.PutCString("qSupported"); packet.PutCString("qSupported");
for (uint32_t i = 0; i < features.size(); ++i) { for (uint32_t i = 0; i < features.size(); ++i) {
packet.PutCString(i == 0 ? ":" : ";"); packet.PutCString(i == 0 ? ":" : ";");
packet.PutCString(features[i]); packet.PutCString(features[i]);
} }
StringExtractorGDBRemote response; StringExtractorGDBRemote response;
if (SendPacketAndWaitForResponse(packet.GetData(), response, if (SendPacketAndWaitForResponse(packet.GetString(), response,
/*send_async=*/false) == /*send_async=*/false) ==
PacketResult::Success) { PacketResult::Success) {
const char *response_cstr = response.GetStringRef().c_str(); const char *response_cstr = response.GetStringRef().c_str();
// Hang on to the qSupported packet, so that platforms can do custom // Hang on to the qSupported packet, so that platforms can do custom
// configuration of the transport before attaching/launching the // configuration of the transport before attaching/launching the
// process. // process.
m_qSupported_response = response_cstr; m_qSupported_response = response_cstr;
▲ Show 20 Lines • Show All 152 Lines • ▼ Show 20 LinesGDBRemoteCommunicationClient::SendThreadSpecificPacketAndWaitForResponse(
lldb::tid_t tid, StreamString &&payload, StringExtractorGDBRemote &response, lldb::tid_t tid, StreamString &&payload, StringExtractorGDBRemote &response,
bool send_async) { bool send_async) {
Lock lock(*this, send_async); Lock lock(*this, send_async);
if (!lock) { if (!lock) {
if (Log *log = ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet( if (Log *log = ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(
GDBR_LOG_PROCESS | GDBR_LOG_PACKETS)) GDBR_LOG_PROCESS | GDBR_LOG_PACKETS))
log->Printf("GDBRemoteCommunicationClient::%s: Didn't get sequence mutex " log->Printf("GDBRemoteCommunicationClient::%s: Didn't get sequence mutex "
"for %s packet.", "for %s packet.",
__FUNCTION__, payload.GetString().c_str()); __FUNCTION__, payload.GetData());
return PacketResult::ErrorNoSequenceLock; return PacketResult::ErrorNoSequenceLock;
} }
if (GetThreadSuffixSupported()) if (GetThreadSuffixSupported())
payload.Printf(";thread:%4.4" PRIx64 ";", tid); payload.Printf(";thread:%4.4" PRIx64 ";", tid);
else { else {
if (!SetCurrentThread(tid)) if (!SetCurrentThread(tid))
return PacketResult::ErrorSendFailed; return PacketResult::ErrorSendFailed;
▲ Show 20 Lines • Show All 2,150 Lines • ▼ Show 20 Lines
Error GDBRemoteCommunicationClient::MakeDirectory(const FileSpec &file_spec, Error GDBRemoteCommunicationClient::MakeDirectory(const FileSpec &file_spec,
uint32_t file_permissions) { uint32_t file_permissions) {
std::string path{file_spec.GetPath(false)}; std::string path{file_spec.GetPath(false)};
lldb_private::StreamString stream; lldb_private::StreamString stream;
stream.PutCString("qPlatform_mkdir:"); stream.PutCString("qPlatform_mkdir:");
stream.PutHex32(file_permissions); stream.PutHex32(file_permissions);
stream.PutChar(','); stream.PutChar(',');
stream.PutCStringAsRawHex8(path.c_str()); stream.PutCStringAsRawHex8(path.c_str());
const char *packet = stream.GetData(); llvm::StringRef packet = stream.GetString();
StringExtractorGDBRemote response; StringExtractorGDBRemote response;
if (SendPacketAndWaitForResponse(packet, response, false) != if (SendPacketAndWaitForResponse(packet, response, false) !=
PacketResult::Success) PacketResult::Success)
return Error("failed to send '%s' packet", packet); return Error("failed to send '%s' packet", packet.str().c_str());
if (response.GetChar() != 'F') if (response.GetChar() != 'F')
return Error("invalid response to '%s' packet", packet); return Error("invalid response to '%s' packet", packet.str().c_str());
return Error(response.GetU32(UINT32_MAX), eErrorTypePOSIX); return Error(response.GetU32(UINT32_MAX), eErrorTypePOSIX);
} }
Error GDBRemoteCommunicationClient::SetFilePermissions( Error GDBRemoteCommunicationClient::SetFilePermissions(
const FileSpec &file_spec, uint32_t file_permissions) { const FileSpec &file_spec, uint32_t file_permissions) {
std::string path{file_spec.GetPath(false)}; std::string path{file_spec.GetPath(false)};
lldb_private::StreamString stream; lldb_private::StreamString stream;
stream.PutCString("qPlatform_chmod:"); stream.PutCString("qPlatform_chmod:");
stream.PutHex32(file_permissions); stream.PutHex32(file_permissions);
stream.PutChar(','); stream.PutChar(',');
stream.PutCStringAsRawHex8(path.c_str()); stream.PutCStringAsRawHex8(path.c_str());
const char *packet = stream.GetData(); llvm::StringRef packet = stream.GetString();
StringExtractorGDBRemote response; StringExtractorGDBRemote response;
if (SendPacketAndWaitForResponse(packet, response, false) != if (SendPacketAndWaitForResponse(packet, response, false) !=
PacketResult::Success) PacketResult::Success)
return Error("failed to send '%s' packet", packet); return Error("failed to send '%s' packet", stream.GetData());
if (response.GetChar() != 'F') if (response.GetChar() != 'F')
return Error("invalid response to '%s' packet", packet); return Error("invalid response to '%s' packet", stream.GetData());
return Error(response.GetU32(UINT32_MAX), eErrorTypePOSIX); return Error(response.GetU32(UINT32_MAX), eErrorTypePOSIX);
} }
static uint64_t ParseHostIOPacketResponse(StringExtractorGDBRemote &response, static uint64_t ParseHostIOPacketResponse(StringExtractorGDBRemote &response,
uint64_t fail_result, Error &error) { uint64_t fail_result, Error &error) {
response.SetFilePos(0); response.SetFilePos(0);
if (response.GetChar() != 'F') if (response.GetChar() != 'F')
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 LinesError GDBRemoteCommunicationClient::GetFilePermissions(
lldb_private::StreamString stream; lldb_private::StreamString stream;
stream.PutCString("vFile:mode:"); stream.PutCString("vFile:mode:");
stream.PutCStringAsRawHex8(path.c_str()); stream.PutCStringAsRawHex8(path.c_str());
StringExtractorGDBRemote response; StringExtractorGDBRemote response;
if (SendPacketAndWaitForResponse(stream.GetString(), response, false) == if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
PacketResult::Success) { PacketResult::Success) {
if (response.GetChar() != 'F') { if (response.GetChar() != 'F') {
error.SetErrorStringWithFormat("invalid response to '%s' packet", error.SetErrorStringWithFormat("invalid response to '%s' packet",
stream.GetString().c_str()); stream.GetData());
} else { } else {
const uint32_t mode = response.GetS32(-1); const uint32_t mode = response.GetS32(-1);
if (static_cast<int32_t>(mode) == -1) { if (static_cast<int32_t>(mode) == -1) {
if (response.GetChar() == ',') { if (response.GetChar() == ',') {
int response_errno = response.GetS32(-1); int response_errno = response.GetS32(-1);
if (response_errno > 0) if (response_errno > 0)
error.SetError(response_errno, lldb::eErrorTypePOSIX); error.SetError(response_errno, lldb::eErrorTypePOSIX);
else else
error.SetErrorToGenericError(); error.SetErrorToGenericError();
} else } else
error.SetErrorToGenericError(); error.SetErrorToGenericError();
} else { } else {
file_permissions = mode & (S_IRWXU | S_IRWXG | S_IRWXO); file_permissions = mode & (S_IRWXU | S_IRWXG | S_IRWXO);
} }
} }
} else { } else {
error.SetErrorStringWithFormat("failed to send '%s' packet", error.SetErrorStringWithFormat("failed to send '%s' packet",
stream.GetString().c_str()); stream.GetData());
} }
return error; return error;
} }
uint64_t GDBRemoteCommunicationClient::ReadFile(lldb::user_id_t fd, uint64_t GDBRemoteCommunicationClient::ReadFile(lldb::user_id_t fd,
uint64_t offset, void *dst, uint64_t offset, void *dst,
uint64_t dst_len, uint64_t dst_len,
Error &error) { Error &error) {
▲ Show 20 Lines • Show All 423 Lines • ▼ Show 20 Lines module_sp->SetObject(
"file", std::make_shared<JSONString>(module_file_spec.GetPath())); "file", std::make_shared<JSONString>(module_file_spec.GetPath()));
module_sp->SetObject("triple", module_sp->SetObject("triple",
std::make_shared<JSONString>(triple.getTriple())); std::make_shared<JSONString>(triple.getTriple()));
} }
StreamString unescaped_payload; StreamString unescaped_payload;
unescaped_payload.PutCString("jModulesInfo:"); unescaped_payload.PutCString("jModulesInfo:");
module_array_sp->Write(unescaped_payload); module_array_sp->Write(unescaped_payload);
StreamGDBRemote payload; StreamGDBRemote payload;
payload.PutEscapedBytes(unescaped_payload.GetData(), payload.PutEscapedBytes(unescaped_payload.GetString().data(),
unescaped_payload.GetSize()); unescaped_payload.GetSize());
StringExtractorGDBRemote response; StringExtractorGDBRemote response;
if (SendPacketAndWaitForResponse(payload.GetString(), response, false) != if (SendPacketAndWaitForResponse(payload.GetString(), response, false) !=
PacketResult::Success || PacketResult::Success ||
response.IsErrorResponse()) response.IsErrorResponse())
return llvm::None; return llvm::None;
▲ Show 20 Lines • Show All 294 Lines • ▼ Show 20 Lines if (SendPacketAndWaitForResponse("qStructuredDataPlugins", response,
__FUNCTION__); __FUNCTION__);
} }
if (log && m_supported_async_json_packets_sp) { if (log && m_supported_async_json_packets_sp) {
StreamString stream; StreamString stream;
m_supported_async_json_packets_sp->Dump(stream); m_supported_async_json_packets_sp->Dump(stream);
log->Printf("GDBRemoteCommunicationClient::%s(): supported async " log->Printf("GDBRemoteCommunicationClient::%s(): supported async "
"JSON packets: %s", "JSON packets: %s",
__FUNCTION__, stream.GetString().c_str()); __FUNCTION__, stream.GetData());
} }
} }
return m_supported_async_json_packets_sp return m_supported_async_json_packets_sp
? m_supported_async_json_packets_sp->GetAsArray() ? m_supported_async_json_packets_sp->GetAsArray()
: nullptr; : nullptr;
} }
Show All 14 LinesError GDBRemoteCommunicationClient::ConfigureRemoteStructuredData(
stream.PutChar(':'); stream.PutChar(':');
if (config_sp) { if (config_sp) {
// Gather the plain-text version of the configuration data. // Gather the plain-text version of the configuration data.
StreamString unescaped_stream; StreamString unescaped_stream;
config_sp->Dump(unescaped_stream); config_sp->Dump(unescaped_stream);
unescaped_stream.Flush(); unescaped_stream.Flush();
// Add it to the stream in escaped fashion. // Add it to the stream in escaped fashion.
stream.PutEscapedBytes(unescaped_stream.GetData(), stream.PutEscapedBytes(unescaped_stream.GetString().data(),
unescaped_stream.GetSize()); unescaped_stream.GetSize());
} }
stream.Flush(); stream.Flush();
// Send the packet. // Send the packet.
const bool send_async = false; const bool send_async = false;
StringExtractorGDBRemote response; StringExtractorGDBRemote response;
auto result = auto result =
Show All 26 Lines

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

Show First 20 Lines • Show All 1,168 Lines • ▼ Show 20 Lines for (size_t i = 0; i < packet_array->GetSize(); ++i) {
response->SetObject("file_offset", response->SetObject("file_offset",
std::make_shared<JSONNumber>(file_offset)); std::make_shared<JSONNumber>(file_offset));
response->SetObject("file_size", std::make_shared<JSONNumber>(file_size)); response->SetObject("file_size", std::make_shared<JSONNumber>(file_size));
} }
StreamString response; StreamString response;
response_array_sp->Write(response); response_array_sp->Write(response);
StreamGDBRemote escaped_response; StreamGDBRemote escaped_response;
escaped_response.PutEscapedBytes(response.GetData(), response.GetSize()); escaped_response.PutEscapedBytes(response.GetString().data(),
response.GetSize());
return SendPacketNoLock(escaped_response.GetString()); return SendPacketNoLock(escaped_response.GetString());
} }
void GDBRemoteCommunicationServerCommon::CreateProcessInfoResponse( void GDBRemoteCommunicationServerCommon::CreateProcessInfoResponse(
const ProcessInstanceInfo &proc_info, StreamString &response) { const ProcessInstanceInfo &proc_info, StreamString &response) {
response.Printf( response.Printf(
"pid:%" PRIu64 ";ppid:%" PRIu64 ";uid:%i;gid:%i;euid:%i;egid:%i;", "pid:%" PRIu64 ";ppid:%" PRIu64 ";uid:%i;gid:%i;euid:%i;egid:%i;",
proc_info.GetProcessID(), proc_info.GetParentProcessID(), proc_info.GetProcessID(), proc_info.GetParentProcessID(),
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

Show First 20 Lines • Show All 240 Lines • ▼ Show 20 LinesGDBRemoteCommunicationServerPlatform::Handle_qQueryGDBServer(
JSONArray server_list; JSONArray server_list;
server_list.AppendObject(server_sp); server_list.AppendObject(server_sp);
StreamGDBRemote response; StreamGDBRemote response;
server_list.Write(response); server_list.Write(response);
StreamGDBRemote escaped_response; StreamGDBRemote escaped_response;
escaped_response.PutEscapedBytes(response.GetData(), response.GetSize()); escaped_response.PutEscapedBytes(response.GetString().data(),
response.GetSize());
return SendPacketNoLock(escaped_response.GetString()); return SendPacketNoLock(escaped_response.GetString());
} }
GDBRemoteCommunication::PacketResult GDBRemoteCommunication::PacketResult
GDBRemoteCommunicationServerPlatform::Handle_qKillSpawnedProcess( GDBRemoteCommunicationServerPlatform::Handle_qKillSpawnedProcess(
StringExtractorGDBRemote &packet) { StringExtractorGDBRemote &packet) {
packet.SetFilePos(::strlen("qKillSpawnedProcess:")); packet.SetFilePos(::strlen("qKillSpawnedProcess:"));
▲ Show 20 Lines • Show All 313 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

Show First 20 Lines • Show All 1,220 Lines • ▼ Show 20 Lines if (error.Success()) {
packet.PutCString("vAttachName"); packet.PutCString("vAttachName");
packet.PutChar(';'); packet.PutChar(';');
packet.PutBytesAsRawHex8(process_name, strlen(process_name), packet.PutBytesAsRawHex8(process_name, strlen(process_name),
endian::InlHostByteOrder(), endian::InlHostByteOrder(),
endian::InlHostByteOrder()); endian::InlHostByteOrder());
m_async_broadcaster.BroadcastEvent( m_async_broadcaster.BroadcastEvent(
eBroadcastBitAsyncContinue, eBroadcastBitAsyncContinue,
new EventDataBytes(packet.GetData(), packet.GetSize())); new EventDataBytes(packet.GetString().data(), packet.GetSize()));
} else } else
SetExitStatus(-1, error.AsCString()); SetExitStatus(-1, error.AsCString());
} }
return error; return error;
} }
void ProcessGDBRemote::DidExit() { void ProcessGDBRemote::DidExit() {
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines if (m_gdb_comm.HasAnyVContSupport()) {
s_pos != s_end; ++s_pos) s_pos != s_end; ++s_pos)
continue_packet.Printf(";S%2.2x:%4.4" PRIx64, s_pos->second, continue_packet.Printf(";S%2.2x:%4.4" PRIx64, s_pos->second,
s_pos->first); s_pos->first);
} else } else
continue_packet_error = true; continue_packet_error = true;
} }
if (continue_packet_error) if (continue_packet_error)
continue_packet.GetString().clear(); continue_packet.Clear();
} }
} else } else
continue_packet_error = true; continue_packet_error = true;
if (continue_packet_error) { if (continue_packet_error) {
// Either no vCont support, or we tried to use part of the vCont // Either no vCont support, or we tried to use part of the vCont
// packet that wasn't supported by the remote GDB server. // packet that wasn't supported by the remote GDB server.
// We need to try and make a simple packet that can do our continue // We need to try and make a simple packet that can do our continue
▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Lines if (continue_packet_error) {
if (log) if (log)
log->Printf("ProcessGDBRemote::DoResume: Trying to resume but the " log->Printf("ProcessGDBRemote::DoResume: Trying to resume but the "
"async thread is dead."); "async thread is dead.");
return error; return error;
} }
m_async_broadcaster.BroadcastEvent( m_async_broadcaster.BroadcastEvent(
eBroadcastBitAsyncContinue, eBroadcastBitAsyncContinue,
new EventDataBytes(continue_packet.GetData(), new EventDataBytes(continue_packet.GetString().data(),
continue_packet.GetSize())); continue_packet.GetSize()));
if (listener_sp->WaitForEvent(std::chrono::seconds(5), event_sp) == if (listener_sp->WaitForEvent(std::chrono::seconds(5), event_sp) ==
false) { false) {
error.SetErrorString("Resume timed out."); error.SetErrorString("Resume timed out.");
if (log) if (log)
log->Printf("ProcessGDBRemote::DoResume: Resume timed out."); log->Printf("ProcessGDBRemote::DoResume: Resume timed out.");
} else if (event_sp->BroadcasterIs(&m_async_broadcaster)) { } else if (event_sp->BroadcasterIs(&m_async_broadcaster)) {
▲ Show 20 Lines • Show All 1,340 Lines • ▼ Show 20 Lines if (response.IsOKResponse()) {
error.SetErrorStringWithFormat("memory write failed for 0x%" PRIx64, error.SetErrorStringWithFormat("memory write failed for 0x%" PRIx64,
addr); addr);
else if (response.IsUnsupportedResponse()) else if (response.IsUnsupportedResponse())
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"GDB server does not support writing memory"); "GDB server does not support writing memory");
else else
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"unexpected response to GDB server memory write packet '%s': '%s'", "unexpected response to GDB server memory write packet '%s': '%s'",
packet.GetString().c_str(), response.GetStringRef().c_str()); packet.GetData(), response.GetStringRef().c_str());
} else { } else {
error.SetErrorStringWithFormat("failed to send packet: '%s'", error.SetErrorStringWithFormat("failed to send packet: '%s'",
packet.GetString().c_str()); packet.GetData());
} }
return 0; return 0;
} }
lldb::addr_t ProcessGDBRemote::DoAllocateMemory(size_t size, lldb::addr_t ProcessGDBRemote::DoAllocateMemory(size_t size,
uint32_t permissions, uint32_t permissions,
Error &error) { Error &error) {
Log *log( Log *log(
▲ Show 20 Lines • Show All 1,211 Lines • ▼ Show 20 Lines if (!m_gdb_comm.GetModuleInfo(module_file_spec, arch, module_spec)) {
return false; return false;
} }
if (log) { if (log) {
StreamString stream; StreamString stream;
module_spec.Dump(stream); module_spec.Dump(stream);
log->Printf("ProcessGDBRemote::%s - got module info for (%s:%s) : %s", log->Printf("ProcessGDBRemote::%s - got module info for (%s:%s) : %s",
__FUNCTION__, module_file_spec.GetPath().c_str(), __FUNCTION__, module_file_spec.GetPath().c_str(),
arch.GetTriple().getTriple().c_str(), arch.GetTriple().getTriple().c_str(), stream.GetData());
stream.GetString().c_str());
} }
m_cached_module_specs[key] = module_spec; m_cached_module_specs[key] = module_spec;
return true; return true;
} }
void ProcessGDBRemote::PrefetchModuleSpecs( void ProcessGDBRemote::PrefetchModuleSpecs(
llvm::ArrayRef<FileSpec> module_file_specs, const llvm::Triple &triple) { llvm::ArrayRef<FileSpec> module_file_specs, const llvm::Triple &triple) {
▲ Show 20 Lines • Show All 775 Lines • ▼ Show 20 LinesParseStructuredDataPacket(llvm::StringRef packet) {
StructuredData::ObjectSP json_sp = StructuredData::ParseJSON(packet); StructuredData::ObjectSP json_sp = StructuredData::ParseJSON(packet);
if (log) { if (log) {
if (json_sp) { if (json_sp) {
StreamString json_str; StreamString json_str;
json_sp->Dump(json_str); json_sp->Dump(json_str);
json_str.Flush(); json_str.Flush();
log->Printf("ProcessGDBRemote::%s() " log->Printf("ProcessGDBRemote::%s() "
"received Async StructuredData packet: %s", "received Async StructuredData packet: %s",
__FUNCTION__, json_str.GetString().c_str()); __FUNCTION__, json_str.GetData());
} else { } else {
log->Printf("ProcessGDBRemote::%s" log->Printf("ProcessGDBRemote::%s"
"() received StructuredData packet:" "() received StructuredData packet:"
" parse failure", " parse failure",
__FUNCTION__); __FUNCTION__);
} }
} }
return json_sp; return json_sp;
▲ Show 20 Lines • Show All 230 Lines • ▼ Show 20 Lines if (process) {
packet.PutBytesAsRawHex8(command, strlen(command)); packet.PutBytesAsRawHex8(command, strlen(command));
bool send_async = true; bool send_async = true;
StringExtractorGDBRemote response; StringExtractorGDBRemote response;
process->GetGDBRemote().SendPacketAndWaitForResponse( process->GetGDBRemote().SendPacketAndWaitForResponse(
packet.GetString(), response, send_async); packet.GetString(), response, send_async);
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
Stream &output_strm = result.GetOutputStream(); Stream &output_strm = result.GetOutputStream();
output_strm.Printf(" packet: %s\n", packet.GetString().c_str()); output_strm.Printf(" packet: %s\n", packet.GetData());
const std::string &response_str = response.GetStringRef(); const std::string &response_str = response.GetStringRef();
if (response_str.empty()) if (response_str.empty())
output_strm.PutCString("response: \nerror: UNIMPLEMENTED\n"); output_strm.PutCString("response: \nerror: UNIMPLEMENTED\n");
else else
output_strm.Printf("response: %s\n", response.GetStringRef().c_str()); output_strm.Printf("response: %s\n", response.GetStringRef().c_str());
} }
return true; return true;
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

Show First 20 Lines • Show All 1,432 Lines • ▼ Show 20 Linesbool ScriptInterpreterPython::GenerateTypeSynthClass(StringList &user_input,
std::string auto_generated_class_name(GenerateUniqueName( std::string auto_generated_class_name(GenerateUniqueName(
"lldb_autogen_python_type_synth_class", num_created_classes, name_token)); "lldb_autogen_python_type_synth_class", num_created_classes, name_token));
StringList auto_generated_class; StringList auto_generated_class;
// Create the function name & definition string. // Create the function name & definition string.
sstr.Printf("class %s:", auto_generated_class_name.c_str()); sstr.Printf("class %s:", auto_generated_class_name.c_str());
auto_generated_class.AppendString(sstr.GetData()); auto_generated_class.AppendString(sstr.GetString());
// Wrap everything up inside the class, increasing the indentation. // Wrap everything up inside the class, increasing the indentation.
// we don't need to play any fancy indentation tricks here because there is no // we don't need to play any fancy indentation tricks here because there is no
// surrounding code whose indentation we need to honor // surrounding code whose indentation we need to honor
for (int i = 0; i < num_lines; ++i) { for (int i = 0; i < num_lines; ++i) {
sstr.Clear(); sstr.Clear();
sstr.Printf(" %s", user_input.GetStringAtIndex(i)); sstr.Printf(" %s", user_input.GetStringAtIndex(i));
auto_generated_class.AppendString(sstr.GetData()); auto_generated_class.AppendString(sstr.GetString());
} }
// Verify that the results are valid Python. // Verify that the results are valid Python.
// (even though the method is ExportFunctionDefinitionToInterpreter, a class // (even though the method is ExportFunctionDefinitionToInterpreter, a class
// will actually be exported) // will actually be exported)
// (TODO: rename that method to ExportDefinitionToInterpreter) // (TODO: rename that method to ExportDefinitionToInterpreter)
if (!ExportFunctionDefinitionToInterpreter(auto_generated_class).Success()) if (!ExportFunctionDefinitionToInterpreter(auto_generated_class).Success())
return false; return false;
▲ Show 20 Lines • Show All 1,410 Lines • ▼ Show 20 Lines if (ExecuteOneLineWithReturn(
ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false))) { ScriptInterpreter::ExecuteScriptOptions().SetEnableIO(false))) {
if (result_ptr) if (result_ptr)
dest.assign(result_ptr); dest.assign(result_ptr);
return true; return true;
} else { } else {
StreamString str_stream; StreamString str_stream;
str_stream.Printf( str_stream.Printf(
"Function %s was not found. Containing module might be missing.", item); "Function %s was not found. Containing module might be missing.", item);
dest.assign(str_stream.GetData()); dest = str_stream.GetString();
return false; return false;
} }
} }
bool ScriptInterpreterPython::GetShortHelpForCommandObject( bool ScriptInterpreterPython::GetShortHelpForCommandObject(
StructuredData::GenericSP cmd_obj_sp, std::string &dest) { StructuredData::GenericSP cmd_obj_sp, std::string &dest) {
bool got_string = false; bool got_string = false;
dest.clear(); dest.clear();
▲ Show 20 Lines • Show All 315 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

Show First 20 Lines • Show All 790 Lines • ▼ Show 20 Lines void AppendStrictSourcesWarning(CommandReturnObject &result,
stream.Printf("darwin-log source settings specify to exclude " stream.Printf("darwin-log source settings specify to exclude "
"%s messages, but setting " "%s messages, but setting "
"'plugin.structured-data.darwin-log." "'plugin.structured-data.darwin-log."
"strict-sources' is disabled. This process will " "strict-sources' is disabled. This process will "
"automatically have %s messages included. Enable" "automatically have %s messages included. Enable"
" the property and relaunch the target binary to have" " the property and relaunch the target binary to have"
" these messages excluded.", " these messages excluded.",
source_name, source_name); source_name, source_name);
result.AppendWarning(stream.GetString().c_str()); result.AppendWarning(stream.GetString());
} }
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
// First off, set the global sticky state of enable/disable // First off, set the global sticky state of enable/disable
// based on this command execution. // based on this command execution.
s_is_explicitly_enabled = m_enable; s_is_explicitly_enabled = m_enable;
// Next, if this is an enable, save off the option data. // Next, if this is an enable, save off the option data.
▲ Show 20 Lines • Show All 294 Lines • ▼ Show 20 Linesbool RunEnableCommand(CommandInterpreter &interpreter) {
auto enable_options = GetGlobalProperties()->GetAutoEnableOptions(); auto enable_options = GetGlobalProperties()->GetAutoEnableOptions();
if (enable_options && (strlen(enable_options) > 0)) { if (enable_options && (strlen(enable_options) > 0)) {
command_stream << ' '; command_stream << ' ';
command_stream << enable_options; command_stream << enable_options;
} }
// Run the command. // Run the command.
CommandReturnObject return_object; CommandReturnObject return_object;
interpreter.HandleCommand(command_stream.GetString().c_str(), eLazyBoolNo, interpreter.HandleCommand(command_stream.GetData(), eLazyBoolNo,
return_object); return_object);
return return_object.Succeeded(); return return_object.Succeeded();
} }
} }
using namespace sddarwinlog_private; using namespace sddarwinlog_private;
#pragma mark - #pragma mark -
#pragma mark Public static API #pragma mark Public static API
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesvoid StructuredDataDarwinLog::HandleArrivalOfStructuredData(
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
if (log) { if (log) {
StreamString json_stream; StreamString json_stream;
if (object_sp) if (object_sp)
object_sp->Dump(json_stream); object_sp->Dump(json_stream);
else else
json_stream.PutCString("<null>"); json_stream.PutCString("<null>");
log->Printf("StructuredDataDarwinLog::%s() called with json: %s", log->Printf("StructuredDataDarwinLog::%s() called with json: %s",
__FUNCTION__, json_stream.GetString().c_str()); __FUNCTION__, json_stream.GetData());
} }
// Ignore empty structured data. // Ignore empty structured data.
if (!object_sp) { if (!object_sp) {
if (log) if (log)
log->Printf("StructuredDataDarwinLog::%s() StructuredData object " log->Printf("StructuredDataDarwinLog::%s() StructuredData object "
"is null", "is null",
__FUNCTION__); __FUNCTION__);
Show All 32 Lines if (!message) {
error.SetErrorString("Internal error: message not set."); error.SetErrorString("Internal error: message not set.");
return; return;
} }
StreamString object_stream; StreamString object_stream;
object.Dump(object_stream); object.Dump(object_stream);
object_stream.Flush(); object_stream.Flush();
error.SetErrorStringWithFormat("%s: %s", message, error.SetErrorStringWithFormat("%s: %s", message, object_stream.GetData());
object_stream.GetString().c_str());
} }
Error StructuredDataDarwinLog::GetDescription( Error StructuredDataDarwinLog::GetDescription(
const StructuredData::ObjectSP &object_sp, lldb_private::Stream &stream) { const StructuredData::ObjectSP &object_sp, lldb_private::Stream &stream) {
Error error; Error error;
if (!object_sp) { if (!object_sp) {
error.SetErrorString("No structured data."); error.SetErrorString("No structured data.");
▲ Show 20 Lines • Show All 622 Lines • ▼ Show 20 Lines if (event.GetValueForKeyAsString("category", category) &&
stream.PutChar(','); stream.PutChar(',');
stream.PutCString("category="); stream.PutCString("category=");
stream.PutCString(category); stream.PutCString(category);
++header_count; ++header_count;
} }
} }
stream.PutCString("] "); stream.PutCString("] ");
auto &result = stream.GetString(); output_stream.PutCString(stream.GetString());
output_stream.PutCString(result);
return result.size(); return stream.GetSize();
} }
size_t StructuredDataDarwinLog::HandleDisplayOfEvent( size_t StructuredDataDarwinLog::HandleDisplayOfEvent(
const StructuredData::Dictionary &event, Stream &stream) { const StructuredData::Dictionary &event, Stream &stream) {
// Check the type of the event. // Check the type of the event.
ConstString event_type; ConstString event_type;
if (!event.GetValueForKeyAsString("type", event_type)) { if (!event.GetValueForKeyAsString("type", event_type)) {
// Hmm, we expected to get events that describe // Hmm, we expected to get events that describe
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

Show First 20 Lines • Show All 2,595 Lines • ▼ Show 20 Lines if (func_range.GetBaseAddress().IsValid()) {
sstr << param_types[i].GetTypeName(); sstr << param_types[i].GetTypeName();
} }
if (is_variadic) if (is_variadic)
sstr << ", ..."; sstr << ", ...";
sstr << ")"; sstr << ")";
if (type_quals & clang::Qualifiers::Const) if (type_quals & clang::Qualifiers::Const)
sstr << " const"; sstr << " const";
func_name.SetValue(ConstString(sstr.GetData()), false); func_name.SetValue(ConstString(sstr.GetString()), false);
} else } else
func_name.SetValue(ConstString(name), false); func_name.SetValue(ConstString(name), false);
FunctionSP func_sp; FunctionSP func_sp;
std::unique_ptr<Declaration> decl_ap; std::unique_ptr<Declaration> decl_ap;
if (decl_file != 0 || decl_line != 0 || decl_column != 0) if (decl_file != 0 || decl_line != 0 || decl_column != 0)
decl_ap.reset(new Declaration( decl_ap.reset(new Declaration(
sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file), sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
▲ Show 20 Lines • Show All 197 Lines • ▼ Show 20 Lines case DW_TAG_APPLE_property: {
prop_getter_name = prop_name; prop_getter_name = prop_name;
} }
if (!prop_setter_name && prop_name[0] && if (!prop_setter_name && prop_name[0] &&
!(prop_attributes & DW_APPLE_PROPERTY_readonly)) { !(prop_attributes & DW_APPLE_PROPERTY_readonly)) {
StreamString ss; StreamString ss;
ss.Printf("set%c%s:", toupper(prop_name[0]), &prop_name[1]); ss.Printf("set%c%s:", toupper(prop_name[0]), &prop_name[1]);
fixed_setter.SetCString(ss.GetData()); fixed_setter.SetString(ss.GetString());
prop_setter_name = fixed_setter.GetCString(); prop_setter_name = fixed_setter.GetCString();
} }
} }
// Clang has a DWARF generation bug where sometimes it // Clang has a DWARF generation bug where sometimes it
// represents fields that are references with bad byte size // represents fields that are references with bad byte size
// and bit size/offset information such as: // and bit size/offset information such as:
// //
▲ Show 20 Lines • Show All 1,265 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

Show First 20 Lines • Show All 259 Lines • ▼ Show 20 Lines Log *verbose_log(
LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO | DWARF_LOG_VERBOSE)); LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO | DWARF_LOG_VERBOSE));
if (verbose_log) { if (verbose_log) {
StreamString strm; StreamString strm;
Dump(&strm); Dump(&strm);
if (m_die_array.empty()) if (m_die_array.empty())
strm.Printf("error: no DIE for compile unit"); strm.Printf("error: no DIE for compile unit");
else else
m_die_array[0].Dump(m_dwarf2Data, this, strm, UINT32_MAX); m_die_array[0].Dump(m_dwarf2Data, this, strm, UINT32_MAX);
verbose_log->PutCString(strm.GetString().c_str()); verbose_log->PutString(strm.GetString());
} }
if (!m_dwo_symbol_file) if (!m_dwo_symbol_file)
return m_die_array.size(); return m_die_array.size();
DWARFCompileUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit(); DWARFCompileUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit();
size_t dwo_die_count = dwo_cu->ExtractDIEsIfNeeded(cu_die_only); size_t dwo_die_count = dwo_cu->ExtractDIEsIfNeeded(cu_die_only);
return m_die_array.size() + dwo_die_count - return m_die_array.size() + dwo_die_count -
▲ Show 20 Lines • Show All 854 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

Show First 20 Lines • Show All 3,912 Lines • ▼ Show 20 Lines if (num_attributes > 0) {
if (!location_is_const_value_data) { if (!location_is_const_value_data) {
location_DW_OP_addr = location.GetLocation_DW_OP_addr(0, op_error); location_DW_OP_addr = location.GetLocation_DW_OP_addr(0, op_error);
if (op_error) { if (op_error) {
StreamString strm; StreamString strm;
location.DumpLocationForAddress(&strm, eDescriptionLevelFull, 0, 0, location.DumpLocationForAddress(&strm, eDescriptionLevelFull, 0, 0,
NULL); NULL);
GetObjectFile()->GetModule()->ReportError( GetObjectFile()->GetModule()->ReportError(
"0x%8.8x: %s has an invalid location: %s", die.GetOffset(), "0x%8.8x: %s has an invalid location: %s", die.GetOffset(),
die.GetTagAsCString(), strm.GetString().c_str()); die.GetTagAsCString(), strm.GetData());
} }
} }
SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile(); SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
if (location_DW_OP_addr != LLDB_INVALID_ADDRESS) { if (location_DW_OP_addr != LLDB_INVALID_ADDRESS) {
if (is_external) if (is_external)
scope = eValueTypeVariableGlobal; scope = eValueTypeVariableGlobal;
else else
▲ Show 20 Lines • Show All 348 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

//===-- UnwindAssemblyInstEmulation.cpp --------------------------*- C++ //===-- UnwindAssemblyInstEmulation.cpp --------------------------*- C++-*-===//
//-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 205 Lines • ▼ Show 20 Lines if (disasm_sp) {
} }
if (log && log->GetVerbose()) { if (log && log->GetVerbose()) {
StreamString strm; StreamString strm;
lldb_private::FormatEntity::Entry format; lldb_private::FormatEntity::Entry format;
FormatEntity::Parse("${frame.pc}: ", format); FormatEntity::Parse("${frame.pc}: ", format);
inst->Dump(&strm, inst_list.GetMaxOpcocdeByteSize(), show_address, inst->Dump(&strm, inst_list.GetMaxOpcocdeByteSize(), show_address,
show_bytes, NULL, NULL, NULL, &format, 0); show_bytes, NULL, NULL, NULL, &format, 0);
log->PutCString(strm.GetData()); log->PutString(strm.GetString());
} }
last_condition = m_inst_emulator_ap->GetInstructionCondition(); last_condition = m_inst_emulator_ap->GetInstructionCondition();
m_inst_emulator_ap->EvaluateInstruction( m_inst_emulator_ap->EvaluateInstruction(
eEmulateInstructionOptionIgnoreConditions); eEmulateInstructionOptionIgnoreConditions);
// If the current instruction is a branch forward then save the // If the current instruction is a branch forward then save the
Show All 38 Lines if (range.GetByteSize() > 0 && range.GetBaseAddress().IsValid() &&
} }
if (log && log->GetVerbose()) { if (log && log->GetVerbose()) {
StreamString strm; StreamString strm;
lldb::addr_t base_addr = range.GetBaseAddress().GetFileAddress(); lldb::addr_t base_addr = range.GetBaseAddress().GetFileAddress();
strm.Printf("Resulting unwind rows for [0x%" PRIx64 " - 0x%" PRIx64 "):", strm.Printf("Resulting unwind rows for [0x%" PRIx64 " - 0x%" PRIx64 "):",
base_addr, base_addr + range.GetByteSize()); base_addr, base_addr + range.GetByteSize());
unwind_plan.Dump(strm, nullptr, base_addr); unwind_plan.Dump(strm, nullptr, base_addr);
log->PutCString(strm.GetData()); log->PutString(strm.GetString());
} }
return unwind_plan.GetRowCount() > 0; return unwind_plan.GetRowCount() > 0;
} }
return false; return false;
} }
bool UnwindAssemblyInstEmulation::AugmentUnwindPlanFromCallSite( bool UnwindAssemblyInstEmulation::AugmentUnwindPlanFromCallSite(
AddressRange &func, Thread &thread, UnwindPlan &unwind_plan) { AddressRange &func, Thread &thread, UnwindPlan &unwind_plan) {
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Linessize_t UnwindAssemblyInstEmulation::ReadMemory(
if (log && log->GetVerbose()) { if (log && log->GetVerbose()) {
StreamString strm; StreamString strm;
strm.Printf( strm.Printf(
"UnwindAssemblyInstEmulation::ReadMemory (addr = 0x%16.16" PRIx64 "UnwindAssemblyInstEmulation::ReadMemory (addr = 0x%16.16" PRIx64
", dst = %p, dst_len = %" PRIu64 ", context = ", ", dst = %p, dst_len = %" PRIu64 ", context = ",
addr, dst, (uint64_t)dst_len); addr, dst, (uint64_t)dst_len);
context.Dump(strm, instruction); context.Dump(strm, instruction);
log->PutCString(strm.GetData()); log->PutString(strm.GetString());
} }
memset(dst, 0, dst_len); memset(dst, 0, dst_len);
return dst_len; return dst_len;
} }
size_t UnwindAssemblyInstEmulation::WriteMemory( size_t UnwindAssemblyInstEmulation::WriteMemory(
EmulateInstruction *instruction, void *baton, EmulateInstruction *instruction, void *baton,
const EmulateInstruction::Context &context, lldb::addr_t addr, const EmulateInstruction::Context &context, lldb::addr_t addr,
Show All 15 Linessize_t UnwindAssemblyInstEmulation::WriteMemory(
if (log && log->GetVerbose()) { if (log && log->GetVerbose()) {
StreamString strm; StreamString strm;
strm.PutCString("UnwindAssemblyInstEmulation::WriteMemory ("); strm.PutCString("UnwindAssemblyInstEmulation::WriteMemory (");
data.Dump(&strm, 0, eFormatBytes, 1, dst_len, UINT32_MAX, addr, 0, 0); data.Dump(&strm, 0, eFormatBytes, 1, dst_len, UINT32_MAX, addr, 0, 0);
strm.PutCString(", context = "); strm.PutCString(", context = ");
context.Dump(strm, instruction); context.Dump(strm, instruction);
log->PutCString(strm.GetData()); log->PutString(strm.GetString());
} }
const bool cant_replace = false; const bool cant_replace = false;
switch (context.type) { switch (context.type) {
default: default:
case EmulateInstruction::eContextInvalid: case EmulateInstruction::eContextInvalid:
case EmulateInstruction::eContextReadOpcode: case EmulateInstruction::eContextReadOpcode:
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Linesbool UnwindAssemblyInstEmulation::ReadRegister(EmulateInstruction *instruction,
if (log && log->GetVerbose()) { if (log && log->GetVerbose()) {
StreamString strm; StreamString strm;
strm.Printf("UnwindAssemblyInstEmulation::ReadRegister (name = \"%s\") => " strm.Printf("UnwindAssemblyInstEmulation::ReadRegister (name = \"%s\") => "
"synthetic_value = %i, value = ", "synthetic_value = %i, value = ",
reg_info->name, synthetic); reg_info->name, synthetic);
reg_value.Dump(&strm, reg_info, false, false, eFormatDefault); reg_value.Dump(&strm, reg_info, false, false, eFormatDefault);
log->PutCString(strm.GetData()); log->PutString(strm.GetString());
} }
return true; return true;
} }
bool UnwindAssemblyInstEmulation::WriteRegister( bool UnwindAssemblyInstEmulation::WriteRegister(
EmulateInstruction *instruction, void *baton, EmulateInstruction *instruction, void *baton,
const EmulateInstruction::Context &context, const RegisterInfo *reg_info, const EmulateInstruction::Context &context, const RegisterInfo *reg_info,
const RegisterValue &reg_value) { const RegisterValue &reg_value) {
Show All 11 Lines if (log && log->GetVerbose()) {
StreamString strm; StreamString strm;
strm.Printf( strm.Printf(
"UnwindAssemblyInstEmulation::WriteRegister (name = \"%s\", value = ", "UnwindAssemblyInstEmulation::WriteRegister (name = \"%s\", value = ",
reg_info->name); reg_info->name);
reg_value.Dump(&strm, reg_info, false, false, eFormatDefault); reg_value.Dump(&strm, reg_info, false, false, eFormatDefault);
strm.PutCString(", context = "); strm.PutCString(", context = ");
context.Dump(strm, instruction); context.Dump(strm, instruction);
log->PutCString(strm.GetData()); log->PutString(strm.GetString());
} }
SetRegisterValue(*reg_info, reg_value); SetRegisterValue(*reg_info, reg_value);
switch (context.type) { switch (context.type) {
case EmulateInstruction::eContextInvalid: case EmulateInstruction::eContextInvalid:
case EmulateInstruction::eContextReadOpcode: case EmulateInstruction::eContextReadOpcode:
case EmulateInstruction::eContextImmediate: case EmulateInstruction::eContextImmediate:
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/ObjectFile.cpp

Show First 20 Lines • Show All 640 Lines • ▼ Show 20 LinesObjectFile::GetSymbolTypeFromName(llvm::StringRef name,
return symbol_type_hint; return symbol_type_hint;
} }
ConstString ObjectFile::GetNextSyntheticSymbolName() { ConstString ObjectFile::GetNextSyntheticSymbolName() {
StreamString ss; StreamString ss;
ConstString file_name = GetModule()->GetFileSpec().GetFilename(); ConstString file_name = GetModule()->GetFileSpec().GetFilename();
ss.Printf("___lldb_unnamed_symbol%u$$%s", ++m_synthetic_symbol_idx, ss.Printf("___lldb_unnamed_symbol%u$$%s", ++m_synthetic_symbol_idx,
file_name.GetCString()); file_name.GetCString());
return ConstString(ss.GetData()); return ConstString(ss.GetString());
} }

lldb/trunk/source/Target/Process.cpp

Show First 20 Lines • Show All 382 Lines • ▼ Show 20 Lines if (verbose) {
cstr = platform->GetGroupName(m_egid); cstr = platform->GetGroupName(m_egid);
if (cstr && if (cstr &&
cstr[0]) // Watch for empty string that indicates lookup failed cstr[0]) // Watch for empty string that indicates lookup failed
s.Printf("%-10s ", cstr); s.Printf("%-10s ", cstr);
else else
s.Printf("%-10u ", m_egid); s.Printf("%-10u ", m_egid);
s.Printf("%-24s ", arch_strm.GetString().c_str()); s.Printf("%-24s ", arch_strm.GetData());
} else { } else {
s.Printf("%-10s %-24s ", platform->GetUserName(m_euid), s.Printf("%-10s %-24s ", platform->GetUserName(m_euid),
arch_strm.GetString().c_str()); arch_strm.GetData());
} }
if (verbose || show_args) { if (verbose || show_args) {
const uint32_t argc = m_arguments.GetArgumentCount(); const uint32_t argc = m_arguments.GetArgumentCount();
if (argc > 0) { if (argc > 0) {
for (uint32_t i = 0; i < argc; i++) { for (uint32_t i = 0; i < argc; i++) {
if (i > 0) if (i > 0)
s.PutChar(' '); s.PutChar(' ');
▲ Show 20 Lines • Show All 5,132 Lines • ▼ Show 20 Lines if (backup_private_state_thread.IsJoinable()) {
m_public_state.SetValueNoLock(old_state); m_public_state.SetValueNoLock(old_state);
} }
if (return_value != eExpressionCompleted && log) { if (return_value != eExpressionCompleted && log) {
// Print a backtrace into the log so we can figure out where we are: // Print a backtrace into the log so we can figure out where we are:
StreamString s; StreamString s;
s.PutCString("Thread state after unsuccessful completion: \n"); s.PutCString("Thread state after unsuccessful completion: \n");
thread->GetStackFrameStatus(s, 0, UINT32_MAX, true, UINT32_MAX); thread->GetStackFrameStatus(s, 0, UINT32_MAX, true, UINT32_MAX);
log->PutCString(s.GetData()); log->PutString(s.GetString());
} }
// Restore the thread state if we are going to discard the plan execution. // Restore the thread state if we are going to discard the plan execution.
// There are three cases where this // There are three cases where this
// could happen: // could happen:
// 1) The execution successfully completed // 1) The execution successfully completed
// 2) We hit a breakpoint, and ignore_breakpoints was true // 2) We hit a breakpoint, and ignore_breakpoints was true
// 3) We got some other error, and discard_on_error was true // 3) We got some other error, and discard_on_error was true
bool should_unwind = (return_value == eExpressionInterrupted && bool should_unwind = (return_value == eExpressionInterrupted &&
▲ Show 20 Lines • Show All 732 Lines • Show Last 20 Lines

lldb/trunk/source/Target/StackFrame.cpp

Show First 20 Lines • Show All 633 Lines • ▼ Show 20 Lines if (variable_list) {
if (actual_is_ptr != expr_is_ptr) { if (actual_is_ptr != expr_is_ptr) {
// Incorrect use of "." with a pointer, or "->" with // Incorrect use of "." with a pointer, or "->" with
// a class/union/struct instance or reference. // a class/union/struct instance or reference.
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
if (actual_is_ptr) if (actual_is_ptr)
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"\"%s\" is a pointer and . was used to attempt to access " "\"%s\" is a pointer and . was used to attempt to access "
"\"%s\". Did you mean \"%s->%s\"?", "\"%s\". Did you mean \"%s->%s\"?",
var_expr_path_strm.GetString().c_str(), var_expr_path_strm.GetData(), child_name.GetCString(),
child_name.GetCString(), var_expr_path_strm.GetData(), var_path.c_str());
var_expr_path_strm.GetString().c_str(), var_path.c_str());
else else
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"\"%s\" is not a pointer and -> was used to attempt to " "\"%s\" is not a pointer and -> was used to attempt to "
"access \"%s\". Did you mean \"%s.%s\"?", "access \"%s\". Did you mean \"%s.%s\"?",
var_expr_path_strm.GetString().c_str(), var_expr_path_strm.GetData(), child_name.GetCString(),
child_name.GetCString(), var_expr_path_strm.GetData(), var_path.c_str());
var_expr_path_strm.GetString().c_str(), var_path.c_str());
return ValueObjectSP(); return ValueObjectSP();
} }
} }
child_valobj_sp = child_valobj_sp =
valobj_sp->GetChildMemberWithName(child_name, true); valobj_sp->GetChildMemberWithName(child_name, true);
if (!child_valobj_sp) { if (!child_valobj_sp) {
if (!no_synth_child) { if (!no_synth_child) {
child_valobj_sp = valobj_sp->GetSyntheticValue(); child_valobj_sp = valobj_sp->GetSyntheticValue();
Show All 16 Lines if (variable_list) {
name_const_string.GetCString()); name_const_string.GetCString());
} else { } else {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
if (child_name) { if (child_name) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"\"%s\" is not a member of \"(%s) %s\"", "\"%s\" is not a member of \"(%s) %s\"",
child_name.GetCString(), child_name.GetCString(),
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"incomplete expression path after \"%s\" in \"%s\"", "incomplete expression path after \"%s\" in \"%s\"",
var_expr_path_strm.GetString().c_str(), var_expr_cstr); var_expr_path_strm.GetData(), var_expr_cstr);
} }
} }
return ValueObjectSP(); return ValueObjectSP();
} }
} }
synthetically_added_instance_object = false; synthetically_added_instance_object = false;
// Remove the child name from the path // Remove the child name from the path
var_path.erase(0, child_name.GetLength()); var_path.erase(0, child_name.GetLength());
Show All 24 Lines if (variable_list) {
// would be done by saying ptr[low], without a deref * sign // would be done by saying ptr[low], without a deref * sign
Error error; Error error;
ValueObjectSP temp(valobj_sp->Dereference(error)); ValueObjectSP temp(valobj_sp->Dereference(error));
if (error.Fail()) { if (error.Fail()) {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"could not dereference \"(%s) %s\"", "could not dereference \"(%s) %s\"",
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
return ValueObjectSP(); return ValueObjectSP();
} }
valobj_sp = temp; valobj_sp = temp;
deref = false; deref = false;
} else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() && } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() &&
deref) { deref) {
// what we have is *arr[low]. the most similar C++ syntax is // what we have is *arr[low]. the most similar C++ syntax is
// to get arr[0] // to get arr[0]
// (an operation that is equivalent to deref-ing arr) // (an operation that is equivalent to deref-ing arr)
// and extract bit low out of it. reading array item low // and extract bit low out of it. reading array item low
// would be done by saying arr[low], without a deref * sign // would be done by saying arr[low], without a deref * sign
Error error; Error error;
ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true)); ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
if (error.Fail()) { if (error.Fail()) {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"could not get item 0 for \"(%s) %s\"", "could not get item 0 for \"(%s) %s\"",
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
return ValueObjectSP(); return ValueObjectSP();
} }
valobj_sp = temp; valobj_sp = temp;
deref = false; deref = false;
} }
bool is_incomplete_array = false; bool is_incomplete_array = false;
if (valobj_sp->IsPointerType()) { if (valobj_sp->IsPointerType()) {
bool is_objc_pointer = true; bool is_objc_pointer = true;
if (valobj_sp->GetCompilerType().GetMinimumLanguage() != if (valobj_sp->GetCompilerType().GetMinimumLanguage() !=
eLanguageTypeObjC) eLanguageTypeObjC)
is_objc_pointer = false; is_objc_pointer = false;
else if (!valobj_sp->GetCompilerType().IsPointerType()) else if (!valobj_sp->GetCompilerType().IsPointerType())
is_objc_pointer = false; is_objc_pointer = false;
if (no_synth_child && is_objc_pointer) { if (no_synth_child && is_objc_pointer) {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"\"(%s) %s\" is an Objective-C pointer, and cannot be " "\"(%s) %s\" is an Objective-C pointer, and cannot be "
"subscripted", "subscripted",
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
return ValueObjectSP(); return ValueObjectSP();
} else if (is_objc_pointer) { } else if (is_objc_pointer) {
// dereferencing ObjC variables is not valid.. so let's try // dereferencing ObjC variables is not valid.. so let's try
// and recur to synthetic children // and recur to synthetic children
ValueObjectSP synthetic = valobj_sp->GetSyntheticValue(); ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
if (!synthetic /* no synthetic */ if (!synthetic /* no synthetic */
|| synthetic == valobj_sp) /* synthetic is the same as || synthetic == valobj_sp) /* synthetic is the same as
the original object */ the original object */
{ {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"\"(%s) %s\" is not an array type", "\"(%s) %s\" is not an array type",
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
} else if ( } else if (
static_cast<uint32_t>(child_index) >= static_cast<uint32_t>(child_index) >=
synthetic synthetic
->GetNumChildren() /* synthetic does not have that many values */) { ->GetNumChildren() /* synthetic does not have that many values */) {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"array index %ld is not valid for \"(%s) %s\"", "array index %ld is not valid for \"(%s) %s\"",
child_index, child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
} else { } else {
child_valobj_sp = child_valobj_sp =
synthetic->GetChildAtIndex(child_index, true); synthetic->GetChildAtIndex(child_index, true);
if (!child_valobj_sp) { if (!child_valobj_sp) {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"array index %ld is not valid for \"(%s) %s\"", "array index %ld is not valid for \"(%s) %s\"",
child_index, valobj_sp->GetTypeName().AsCString( child_index, valobj_sp->GetTypeName().AsCString(
"<invalid type>"), "<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
} }
} }
} else { } else {
child_valobj_sp = child_valobj_sp =
valobj_sp->GetSyntheticArrayMember(child_index, true); valobj_sp->GetSyntheticArrayMember(child_index, true);
if (!child_valobj_sp) { if (!child_valobj_sp) {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"failed to use pointer as array for index %ld for " "failed to use pointer as array for index %ld for "
"\"(%s) %s\"", "\"(%s) %s\"",
child_index, child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
} }
} }
} else if (valobj_sp->GetCompilerType().IsArrayType( } else if (valobj_sp->GetCompilerType().IsArrayType(
nullptr, nullptr, &is_incomplete_array)) { nullptr, nullptr, &is_incomplete_array)) {
// Pass false to dynamic_value here so we can tell the // Pass false to dynamic_value here so we can tell the
// difference between // difference between
// no dynamic value and no member of this type... // no dynamic value and no member of this type...
child_valobj_sp = child_valobj_sp =
valobj_sp->GetChildAtIndex(child_index, true); valobj_sp->GetChildAtIndex(child_index, true);
if (!child_valobj_sp && if (!child_valobj_sp &&
(is_incomplete_array || !no_synth_child)) (is_incomplete_array || !no_synth_child))
child_valobj_sp = child_valobj_sp =
valobj_sp->GetSyntheticArrayMember(child_index, true); valobj_sp->GetSyntheticArrayMember(child_index, true);
if (!child_valobj_sp) { if (!child_valobj_sp) {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"array index %ld is not valid for \"(%s) %s\"", "array index %ld is not valid for \"(%s) %s\"",
child_index, child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
} }
} else if (valobj_sp->GetCompilerType().IsScalarType()) { } else if (valobj_sp->GetCompilerType().IsScalarType()) {
// this is a bitfield asking to display just one bit // this is a bitfield asking to display just one bit
child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild( child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(
child_index, child_index, true); child_index, child_index, true);
if (!child_valobj_sp) { if (!child_valobj_sp) {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"bitfield range %ld-%ld is not valid for \"(%s) %s\"", "bitfield range %ld-%ld is not valid for \"(%s) %s\"",
child_index, child_index, child_index, child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
} }
} else { } else {
ValueObjectSP synthetic = valobj_sp->GetSyntheticValue(); ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
if (no_synth_child /* synthetic is forbidden */ || if (no_synth_child /* synthetic is forbidden */ ||
!synthetic /* no synthetic */ !synthetic /* no synthetic */
|| synthetic == valobj_sp) /* synthetic is the same as the || synthetic == valobj_sp) /* synthetic is the same as the
original object */ original object */
{ {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"\"(%s) %s\" is not an array type", "\"(%s) %s\" is not an array type",
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
} else if ( } else if (
static_cast<uint32_t>(child_index) >= static_cast<uint32_t>(child_index) >=
synthetic synthetic
->GetNumChildren() /* synthetic does not have that many values */) { ->GetNumChildren() /* synthetic does not have that many values */) {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"array index %ld is not valid for \"(%s) %s\"", "array index %ld is not valid for \"(%s) %s\"",
child_index, child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
} else { } else {
child_valobj_sp = child_valobj_sp =
synthetic->GetChildAtIndex(child_index, true); synthetic->GetChildAtIndex(child_index, true);
if (!child_valobj_sp) { if (!child_valobj_sp) {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"array index %ld is not valid for \"(%s) %s\"", "array index %ld is not valid for \"(%s) %s\"",
child_index, child_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
} }
} }
} }
if (!child_valobj_sp) { if (!child_valobj_sp) {
// Invalid array index... // Invalid array index...
return ValueObjectSP(); return ValueObjectSP();
} }
Show All 34 Lines if (variable_list) {
// sign // sign
Error error; Error error;
ValueObjectSP temp(valobj_sp->Dereference(error)); ValueObjectSP temp(valobj_sp->Dereference(error));
if (error.Fail()) { if (error.Fail()) {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"could not dereference \"(%s) %s\"", "could not dereference \"(%s) %s\"",
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
return ValueObjectSP(); return ValueObjectSP();
} }
valobj_sp = temp; valobj_sp = temp;
deref = false; deref = false;
} else if (valobj_sp->GetCompilerType() } else if (valobj_sp->GetCompilerType()
.IsArrayOfScalarType() && .IsArrayOfScalarType() &&
deref) { deref) {
// what we have is *arr[low-high]. the most similar C++ // what we have is *arr[low-high]. the most similar C++
// syntax is to get arr[0] // syntax is to get arr[0]
// (an operation that is equivalent to deref-ing arr) // (an operation that is equivalent to deref-ing arr)
// and extract bits low thru high out of it. reading array // and extract bits low thru high out of it. reading array
// items low thru high // items low thru high
// would be done by saying arr[low-high], without a deref * // would be done by saying arr[low-high], without a deref *
// sign // sign
Error error; Error error;
ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true)); ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
if (error.Fail()) { if (error.Fail()) {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"could not get item 0 for \"(%s) %s\"", "could not get item 0 for \"(%s) %s\"",
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
return ValueObjectSP(); return ValueObjectSP();
} }
valobj_sp = temp; valobj_sp = temp;
deref = false; deref = false;
} }
/*else if (valobj_sp->IsArrayType() || /*else if (valobj_sp->IsArrayType() ||
valobj_sp->IsPointerType()) valobj_sp->IsPointerType())
{ {
child_valobj_sp = child_valobj_sp =
valobj_sp->GetSyntheticArrayRangeChild(child_index, valobj_sp->GetSyntheticArrayRangeChild(child_index,
final_index, true); final_index, true);
expand_bitfield = false; expand_bitfield = false;
if (!child_valobj_sp) if (!child_valobj_sp)
{ {
valobj_sp->GetExpressionPath (var_expr_path_strm, valobj_sp->GetExpressionPath (var_expr_path_strm,
false); false);
error.SetErrorStringWithFormat ("array range %i-%i is error.SetErrorStringWithFormat ("array range %i-%i is
not valid for \"(%s) %s\"", not valid for \"(%s) %s\"",
child_index, child_index,
final_index, final_index,
valobj_sp->GetTypeName().AsCString("<invalid valobj_sp->GetTypeName().AsCString("<invalid
type>"), type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.c_str());
} }
}*/ }*/
if (expand_bitfield) { if (expand_bitfield) {
child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild( child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(
child_index, final_index, true); child_index, final_index, true);
if (!child_valobj_sp) { if (!child_valobj_sp) {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"bitfield range %ld-%ld is not valid for \"(%s) %s\"", "bitfield range %ld-%ld is not valid for \"(%s) %s\"",
child_index, final_index, child_index, final_index,
valobj_sp->GetTypeName().AsCString("<invalid type>"), valobj_sp->GetTypeName().AsCString("<invalid type>"),
var_expr_path_strm.GetString().c_str()); var_expr_path_strm.GetData());
} }
} }
} }
if (!child_valobj_sp) { if (!child_valobj_sp) {
// Invalid bitfield range... // Invalid bitfield range...
return ValueObjectSP(); return ValueObjectSP();
} }
Show All 10 Lines if (variable_list) {
} }
// Break out early from the switch since we were // Break out early from the switch since we were
// able to find the child member // able to find the child member
break; break;
} }
} else { } else {
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"invalid square bracket encountered after \"%s\" in \"%s\"", "invalid square bracket encountered after \"%s\" in \"%s\"",
var_expr_path_strm.GetString().c_str(), var_path.c_str()); var_expr_path_strm.GetData(), var_path.c_str());
} }
return ValueObjectSP(); return ValueObjectSP();
default: default:
// Failure... // Failure...
{ {
valobj_sp->GetExpressionPath(var_expr_path_strm, false); valobj_sp->GetExpressionPath(var_expr_path_strm, false);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"unexpected char '%c' encountered after \"%s\" in \"%s\"", "unexpected char '%c' encountered after \"%s\" in \"%s\"",
separator_type, var_expr_path_strm.GetString().c_str(), separator_type, var_expr_path_strm.GetData(),
var_path.c_str()); var_path.c_str());
return ValueObjectSP(); return ValueObjectSP();
} }
} }
if (child_valobj_sp) if (child_valobj_sp)
valobj_sp = child_valobj_sp; valobj_sp = child_valobj_sp;
▲ Show 20 Lines • Show All 709 Lines • ▼ Show 20 Lines if (frame_marker)
s.PutCString(frame_marker); s.PutCString(frame_marker);
const FormatEntity::Entry *frame_format = nullptr; const FormatEntity::Entry *frame_format = nullptr;
Target *target = exe_ctx.GetTargetPtr(); Target *target = exe_ctx.GetTargetPtr();
if (target) if (target)
frame_format = target->GetDebugger().GetFrameFormat(); frame_format = target->GetDebugger().GetFrameFormat();
if (frame_format && FormatEntity::Format(*frame_format, s, &m_sc, &exe_ctx, if (frame_format && FormatEntity::Format(*frame_format, s, &m_sc, &exe_ctx,
nullptr, nullptr, false, false)) { nullptr, nullptr, false, false)) {
strm->Write(s.GetData(), s.GetSize()); strm->PutCString(s.GetString());
} else { } else {
Dump(strm, true, false); Dump(strm, true, false);
strm->EOL(); strm->EOL();
} }
} }
void StackFrame::Dump(Stream *strm, bool show_frame_index, void StackFrame::Dump(Stream *strm, bool show_frame_index,
bool show_fullpaths) { bool show_fullpaths) {
Show All 20 Lines
} }
void StackFrame::UpdateCurrentFrameFromPreviousFrame(StackFrame &prev_frame) { void StackFrame::UpdateCurrentFrameFromPreviousFrame(StackFrame &prev_frame) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
assert(GetStackID() == assert(GetStackID() ==
prev_frame.GetStackID()); // TODO: remove this after some testing prev_frame.GetStackID()); // TODO: remove this after some testing
m_variable_list_sp = prev_frame.m_variable_list_sp; m_variable_list_sp = prev_frame.m_variable_list_sp;
m_variable_list_value_objects.Swap(prev_frame.m_variable_list_value_objects); m_variable_list_value_objects.Swap(prev_frame.m_variable_list_value_objects);
if (!m_disassembly.GetString().empty()) if (!m_disassembly.GetString().empty()) {
m_disassembly.GetString().swap(m_disassembly.GetString()); m_disassembly.Clear();
m_disassembly.PutCString(prev_frame.m_disassembly.GetString());
}
} }
void StackFrame::UpdatePreviousFrameFromCurrentFrame(StackFrame &curr_frame) { void StackFrame::UpdatePreviousFrameFromCurrentFrame(StackFrame &curr_frame) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
assert(GetStackID() == assert(GetStackID() ==
curr_frame.GetStackID()); // TODO: remove this after some testing curr_frame.GetStackID()); // TODO: remove this after some testing
m_id.SetPC(curr_frame.m_id.GetPC()); // Update the Stack ID PC value m_id.SetPC(curr_frame.m_id.GetPC()); // Update the Stack ID PC value
assert(GetThread() == curr_frame.GetThread()); assert(GetThread() == curr_frame.GetThread());
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

lldb/trunk/source/Target/StopInfo.cpp

Show First 20 Lines • Show All 210 Lines • ▼ Show 20 Lines if (m_description.empty()) {
m_description.assign(kind); m_description.assign(kind);
return kind; return kind;
} }
} }
} }
strm.Printf("breakpoint "); strm.Printf("breakpoint ");
bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief); bp_site_sp->GetDescription(&strm, eDescriptionLevelBrief);
m_description.swap(strm.GetString()); m_description = strm.GetString();
} else { } else {
StreamString strm; StreamString strm;
if (m_break_id != LLDB_INVALID_BREAK_ID) { if (m_break_id != LLDB_INVALID_BREAK_ID) {
BreakpointSP break_sp = BreakpointSP break_sp =
thread_sp->GetProcess()->GetTarget().GetBreakpointByID( thread_sp->GetProcess()->GetTarget().GetBreakpointByID(
m_break_id); m_break_id);
if (break_sp) { if (break_sp) {
if (break_sp->IsInternal()) { if (break_sp->IsInternal()) {
Show All 16 Lines if (m_description.empty()) {
strm.Printf("breakpoint site %" PRIi64 strm.Printf("breakpoint site %" PRIi64
" which has been deleted - unknown address", " which has been deleted - unknown address",
m_value); m_value);
else else
strm.Printf("breakpoint site %" PRIi64 strm.Printf("breakpoint site %" PRIi64
" which has been deleted - was at 0x%" PRIx64, " which has been deleted - was at 0x%" PRIx64,
m_value, m_address); m_value, m_address);
m_description.swap(strm.GetString()); m_description = strm.GetString();
} }
} }
} }
return m_description.c_str(); return m_description.c_str();
} }
protected: protected:
bool ShouldStop(Event *event_ptr) override { bool ShouldStop(Event *event_ptr) override {
▲ Show 20 Lines • Show All 344 Lines • ▼ Show 20 Linespublic:
~StopInfoWatchpoint() override = default; ~StopInfoWatchpoint() override = default;
StopReason GetStopReason() const override { return eStopReasonWatchpoint; } StopReason GetStopReason() const override { return eStopReasonWatchpoint; }
const char *GetDescription() override { const char *GetDescription() override {
if (m_description.empty()) { if (m_description.empty()) {
StreamString strm; StreamString strm;
strm.Printf("watchpoint %" PRIi64, m_value); strm.Printf("watchpoint %" PRIi64, m_value);
m_description.swap(strm.GetString()); m_description = strm.GetString();
} }
return m_description.c_str(); return m_description.c_str();
} }
protected: protected:
bool ShouldStopSynchronous(Event *event_ptr) override { bool ShouldStopSynchronous(Event *event_ptr) override {
// ShouldStop() method is idempotent and should not affect hit count. // ShouldStop() method is idempotent and should not affect hit count.
// See Process::RunPrivateStateThread()->Process()->HandlePrivateEvent() // See Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Lines if (m_description.empty()) {
StreamString strm; StreamString strm;
const char *signal_name = const char *signal_name =
thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString( thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
m_value); m_value);
if (signal_name) if (signal_name)
strm.Printf("signal %s", signal_name); strm.Printf("signal %s", signal_name);
else else
strm.Printf("signal %" PRIi64, m_value); strm.Printf("signal %" PRIi64, m_value);
m_description.swap(strm.GetString()); m_description = strm.GetString();
} }
} }
return m_description.c_str(); return m_description.c_str();
} }
}; };
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// StopInfoTrace // StopInfoTrace
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linespublic:
~StopInfoThreadPlan() override = default; ~StopInfoThreadPlan() override = default;
StopReason GetStopReason() const override { return eStopReasonPlanComplete; } StopReason GetStopReason() const override { return eStopReasonPlanComplete; }
const char *GetDescription() override { const char *GetDescription() override {
if (m_description.empty()) { if (m_description.empty()) {
StreamString strm; StreamString strm;
m_plan_sp->GetDescription(&strm, eDescriptionLevelBrief); m_plan_sp->GetDescription(&strm, eDescriptionLevelBrief);
m_description.swap(strm.GetString()); m_description = strm.GetString();
} }
return m_description.c_str(); return m_description.c_str();
} }
ValueObjectSP GetReturnValueObject() { return m_return_valobj_sp; } ValueObjectSP GetReturnValueObject() { return m_return_valobj_sp; }
ExpressionVariableSP GetExpressionVariable() { ExpressionVariableSP GetExpressionVariable() {
return m_expression_variable_sp; return m_expression_variable_sp;
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

lldb/trunk/source/Target/Target.cpp

Show First 20 Lines • Show All 3,103 Lines • ▼ Show 20 Lines if (m_specifier_sp) {
s->SetIndentLevel(indent_level + 2); s->SetIndentLevel(indent_level + 2);
} }
if (m_thread_spec_ap) { if (m_thread_spec_ap) {
StreamString tmp; StreamString tmp;
s->Indent("Thread:\n"); s->Indent("Thread:\n");
m_thread_spec_ap->GetDescription(&tmp, level); m_thread_spec_ap->GetDescription(&tmp, level);
s->SetIndentLevel(indent_level + 4); s->SetIndentLevel(indent_level + 4);
s->Indent(tmp.GetData()); s->Indent(tmp.GetString());
s->PutCString("\n"); s->PutCString("\n");
s->SetIndentLevel(indent_level + 2); s->SetIndentLevel(indent_level + 2);
} }
s->Indent("Commands: \n"); s->Indent("Commands: \n");
s->SetIndentLevel(indent_level + 4); s->SetIndentLevel(indent_level + 4);
uint32_t num_commands = m_commands.GetSize(); uint32_t num_commands = m_commands.GetSize();
for (uint32_t i = 0; i < num_commands; i++) { for (uint32_t i = 0; i < num_commands; i++) {
▲ Show 20 Lines • Show All 998 Lines • Show Last 20 Lines

lldb/trunk/source/Target/TargetList.cpp

Show First 20 Lines • Show All 146 Lines • ▼ Show 20 Lines if (num_specs > 0) {
StreamString module_arch_strm; StreamString module_arch_strm;
platform_arch.DumpTriple(platform_arch_strm); platform_arch.DumpTriple(platform_arch_strm);
matching_module_spec.GetArchitecture().DumpTriple( matching_module_spec.GetArchitecture().DumpTriple(
module_arch_strm); module_arch_strm);
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"the specified architecture '%s' is not compatible with '%s' " "the specified architecture '%s' is not compatible with '%s' "
"in '%s'", "in '%s'",
platform_arch_strm.GetString().c_str(), platform_arch_strm.GetData(), module_arch_strm.GetData(),
module_arch_strm.GetString().c_str(),
module_spec.GetFileSpec().GetPath().c_str()); module_spec.GetFileSpec().GetPath().c_str());
return error; return error;
} }
} else { } else {
// Only one arch and none was specified // Only one arch and none was specified
prefer_platform_arch = true; prefer_platform_arch = true;
platform_arch = matching_module_spec.GetArchitecture(); platform_arch = matching_module_spec.GetArchitecture();
} }
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines if (num_specs > 0) {
if (!platform_set.empty()) if (!platform_set.empty())
error_strm.PutCString(", "); error_strm.PutCString(", ");
error_strm.PutCString(the_platform_sp->GetName().GetCString()); error_strm.PutCString(the_platform_sp->GetName().GetCString());
platform_set.insert(the_platform_sp.get()); platform_set.insert(the_platform_sp.get());
} }
} }
error_strm.Printf( error_strm.Printf(
"), use the --platform option to specify a platform"); "), use the --platform option to specify a platform");
error.SetErrorString(error_strm.GetString().c_str()); error.SetErrorString(error_strm.GetString());
return error; return error;
} }
} }
} }
} }
} }
// If we have a valid architecture, make sure the current platform is // If we have a valid architecture, make sure the current platform is
▲ Show 20 Lines • Show All 364 Lines • Show Last 20 Lines

lldb/trunk/source/Target/Thread.cpp

Show First 20 Lines • Show All 1,741 Lines • ▼ Show 20 Lines if (outside_function.empty()) {
file.GetFilename().AsCString(), line); file.GetFilename().AsCString(), line);
} else if (outside_function.size() == 1) { } else if (outside_function.size() == 1) {
return Error("%s:%i is outside the current function.", return Error("%s:%i is outside the current function.",
file.GetFilename().AsCString(), line); file.GetFilename().AsCString(), line);
} else { } else {
StreamString sstr; StreamString sstr;
DumpAddressList(sstr, outside_function, target); DumpAddressList(sstr, outside_function, target);
return Error("%s:%i has multiple candidate locations:\n%s", return Error("%s:%i has multiple candidate locations:\n%s",
file.GetFilename().AsCString(), line, file.GetFilename().AsCString(), line, sstr.GetData());
sstr.GetString().c_str());
} }
} }
// Accept the first location, warn about any others. // Accept the first location, warn about any others.
Address dest = candidates[0]; Address dest = candidates[0];
if (warnings && candidates.size() > 1) { if (warnings && candidates.size() > 1) {
StreamString sstr; StreamString sstr;
sstr.Printf("%s:%i appears multiple times in this function, selecting the " sstr.Printf("%s:%i appears multiple times in this function, selecting the "
▲ Show 20 Lines • Show All 422 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanCallFunction.cpp

Show First 20 Lines • Show All 186 Lines • ▼ Show 20 Lines if (log) {
for (uint32_t reg_idx = 0, num_registers = reg_ctx->GetRegisterCount(); for (uint32_t reg_idx = 0, num_registers = reg_ctx->GetRegisterCount();
reg_idx < num_registers; ++reg_idx) { reg_idx < num_registers; ++reg_idx) {
const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_idx); const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_idx);
if (reg_ctx->ReadRegister(reg_info, reg_value)) { if (reg_ctx->ReadRegister(reg_info, reg_value)) {
reg_value.Dump(&strm, reg_info, true, false, eFormatDefault); reg_value.Dump(&strm, reg_info, true, false, eFormatDefault);
strm.EOL(); strm.EOL();
} }
} }
log->PutCString(strm.GetData()); log->PutString(strm.GetString());
} }
} }
void ThreadPlanCallFunction::DoTakedown(bool success) { void ThreadPlanCallFunction::DoTakedown(bool success) {
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STEP)); Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STEP));
if (!m_valid) { if (!m_valid) {
// Don't call DoTakedown if we were never valid to begin with. // Don't call DoTakedown if we were never valid to begin with.
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines s->Printf("Thread plan to call 0x%" PRIx64,
m_function_addr.GetLoadAddress(target_sp.get())); m_function_addr.GetLoadAddress(target_sp.get()));
} }
} }
bool ThreadPlanCallFunction::ValidatePlan(Stream *error) { bool ThreadPlanCallFunction::ValidatePlan(Stream *error) {
if (!m_valid) { if (!m_valid) {
if (error) { if (error) {
if (m_constructor_errors.GetSize() > 0) if (m_constructor_errors.GetSize() > 0)
error->PutCString(m_constructor_errors.GetData()); error->PutCString(m_constructor_errors.GetString());
else else
error->PutCString("Unknown error"); error->PutCString("Unknown error");
} }
return false; return false;
} }
return true; return true;
} }
▲ Show 20 Lines • Show All 247 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanCallUserExpression.cpp

//===-- ThreadPlanCallUserExpression.cpp ------------------------------*- C++ //===-- ThreadPlanCallUserExpression.cpp -------------------------*- C++-*-===//
//-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanStepOverRange.cpp

Show First 20 Lines • Show All 416 Lines • ▼ Show 20 Lines if (resume_state == eStateStepping && current_plan) {
.AsCString(); .AsCString();
else else
name = "<unknown-notinlined>"; name = "<unknown-notinlined>";
s.Printf( s.Printf(
"Stepping over inlined function \"%s\" in inlined stack: ", "Stepping over inlined function \"%s\" in inlined stack: ",
name); name);
DumpRanges(&s); DumpRanges(&s);
log->PutCString(s.GetData()); log->PutString(s.GetString());
} }
} }
} }
} }
} }
} }
return true; return true;
} }

lldb/trunk/tools/argdumper/argdumper.cpp

//===-- argdumper.cpp --------------------------------------------*- C++ //===-- argdumper.cpp --------------------------------------------*- C++-*-===//
//-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 24 Lines

lldb/trunk/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

Show First 20 Lines • Show All 249 Lines • ▼ Show 20 Lines#else
PythonString python_unicode(PyRefType::Owned, py_unicode); PythonString python_unicode(PyRefType::Owned, py_unicode);
EXPECT_EQ(PyObjectType::String, python_unicode.GetObjectType()); EXPECT_EQ(PyObjectType::String, python_unicode.GetObjectType());
EXPECT_STREQ(test_string, python_unicode.GetString().data()); EXPECT_STREQ(test_string, python_unicode.GetString().data());
#endif #endif
// Test that creating a `PythonString` object works correctly with the // Test that creating a `PythonString` object works correctly with the
// string constructor // string constructor
PythonString constructed_string(test_string2); PythonString constructed_string(test_string2);
EXPECT_STREQ(test_string2, constructed_string.GetString().str().c_str()); EXPECT_STREQ(test_string2, constructed_string.c_str());
} }
TEST_F(PythonDataObjectsTest, TestPythonStringToStr) { TEST_F(PythonDataObjectsTest, TestPythonStringToStr) {
const char *c_str = "PythonDataObjectsTest::TestPythonStringToStr"; const char *c_str = "PythonDataObjectsTest::TestPythonStringToStr";
PythonString str(c_str); PythonString str(c_str);
EXPECT_STREQ(c_str, str.GetString().str().c_str()); EXPECT_STREQ(c_str, str.c_str());
PythonString str_str = str.Str(); PythonString str_str = str.Str();
EXPECT_STREQ(c_str, str_str.GetString().str().c_str()); EXPECT_STREQ(c_str, str_str.c_str());
} }
TEST_F(PythonDataObjectsTest, TestPythonIntegerToStr) {} TEST_F(PythonDataObjectsTest, TestPythonIntegerToStr) {}
TEST_F(PythonDataObjectsTest, TestPythonIntegerToStructuredInteger) { TEST_F(PythonDataObjectsTest, TestPythonIntegerToStructuredInteger) {
PythonInteger integer(7); PythonInteger integer(7);
auto int_sp = integer.CreateStructuredInteger(); auto int_sp = integer.CreateStructuredInteger();
EXPECT_EQ(7U, int_sp->GetValue()); EXPECT_EQ(7U, int_sp->GetValue());
Show All 33 LinesTEST_F(PythonDataObjectsTest, TestPythonListValueEquality) {
PythonObject chk_value2 = list.GetItemAtIndex(1); PythonObject chk_value2 = list.GetItemAtIndex(1);
EXPECT_TRUE(PythonInteger::Check(chk_value1.get())); EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
EXPECT_TRUE(PythonString::Check(chk_value2.get())); EXPECT_TRUE(PythonString::Check(chk_value2.get()));
PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get()); PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
PythonString chk_str(PyRefType::Borrowed, chk_value2.get()); PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
EXPECT_EQ(long_value0, chk_int.GetInteger()); EXPECT_EQ(long_value0, chk_int.GetInteger());
EXPECT_STREQ(string_value1, chk_str.GetString().str().c_str()); EXPECT_STREQ(string_value1, chk_str.c_str());
} }
TEST_F(PythonDataObjectsTest, TestPythonListManipulation) { TEST_F(PythonDataObjectsTest, TestPythonListManipulation) {
// Test that manipulation of a PythonList behaves correctly when // Test that manipulation of a PythonList behaves correctly when
// wrapped by a PythonDictionary. // wrapped by a PythonDictionary.
static const long long_value0 = 5; static const long long_value0 = 5;
static const char *const string_value1 = "String Index 1"; static const char *const string_value1 = "String Index 1";
Show All 11 LinesTEST_F(PythonDataObjectsTest, TestPythonListManipulation) {
PythonObject chk_value2 = list.GetItemAtIndex(1); PythonObject chk_value2 = list.GetItemAtIndex(1);
EXPECT_TRUE(PythonInteger::Check(chk_value1.get())); EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
EXPECT_TRUE(PythonString::Check(chk_value2.get())); EXPECT_TRUE(PythonString::Check(chk_value2.get()));
PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get()); PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
PythonString chk_str(PyRefType::Borrowed, chk_value2.get()); PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
EXPECT_EQ(long_value0, chk_int.GetInteger()); EXPECT_EQ(long_value0, chk_int.GetInteger());
EXPECT_STREQ(string_value1, chk_str.GetString().str().c_str()); EXPECT_STREQ(string_value1, chk_str.c_str());
} }
TEST_F(PythonDataObjectsTest, TestPythonListToStructuredList) { TEST_F(PythonDataObjectsTest, TestPythonListToStructuredList) {
static const long long_value0 = 5; static const long long_value0 = 5;
static const char *const string_value1 = "String Index 1"; static const char *const string_value1 = "String Index 1";
PythonList list(PyInitialValue::Empty); PythonList list(PyInitialValue::Empty);
list.AppendItem(PythonInteger(long_value0)); list.AppendItem(PythonInteger(long_value0));
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 LinesTEST_F(PythonDataObjectsTest, TestPythonDictionaryValueEquality) {
PythonObject chk_value2 = dict.GetItemForKey(py_keys[1]); PythonObject chk_value2 = dict.GetItemForKey(py_keys[1]);
EXPECT_TRUE(PythonInteger::Check(chk_value1.get())); EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
EXPECT_TRUE(PythonString::Check(chk_value2.get())); EXPECT_TRUE(PythonString::Check(chk_value2.get()));
PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get()); PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
PythonString chk_str(PyRefType::Borrowed, chk_value2.get()); PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
EXPECT_EQ(value_0, chk_int.GetInteger()); EXPECT_EQ(value_0, chk_int.GetInteger());
EXPECT_STREQ(value_1, chk_str.GetString().str().c_str()); EXPECT_STREQ(value_1, chk_str.c_str());
} }
TEST_F(PythonDataObjectsTest, TestPythonDictionaryManipulation) { TEST_F(PythonDataObjectsTest, TestPythonDictionaryManipulation) {
// Test that manipulation of a dictionary behaves correctly when wrapped // Test that manipulation of a dictionary behaves correctly when wrapped
// by a PythonDictionary. // by a PythonDictionary.
static const unsigned dict_entries = 2; static const unsigned dict_entries = 2;
const char *const key_0 = "Key 0"; const char *const key_0 = "Key 0";
Show All 20 LinesTEST_F(PythonDataObjectsTest, TestPythonDictionaryManipulation) {
PythonObject chk_value2 = dict.GetItemForKey(keys[1]); PythonObject chk_value2 = dict.GetItemForKey(keys[1]);
EXPECT_TRUE(PythonInteger::Check(chk_value1.get())); EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
EXPECT_TRUE(PythonString::Check(chk_value2.get())); EXPECT_TRUE(PythonString::Check(chk_value2.get()));
PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get()); PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
PythonString chk_str(PyRefType::Borrowed, chk_value2.get()); PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
EXPECT_EQ(value_0, chk_int.GetInteger()); EXPECT_EQ(value_0, chk_int.GetInteger());
EXPECT_STREQ(value_1, chk_str.GetString().str().c_str()); EXPECT_STREQ(value_1, chk_str.c_str());
} }
TEST_F(PythonDataObjectsTest, TestPythonDictionaryToStructuredDictionary) { TEST_F(PythonDataObjectsTest, TestPythonDictionaryToStructuredDictionary) {
static const char *const string_key0 = "String Key 0"; static const char *const string_key0 = "String Key 0";
static const char *const string_key1 = "String Key 1"; static const char *const string_key1 = "String Key 1";
static const char *const string_value0 = "String Value 0"; static const char *const string_value0 = "String Value 0";
static const long int_value1 = 7; static const long int_value1 = 7;
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines