upstream/opnsense-src
1
0
Fork 0
mirror of https://github.com/opnsense/src.git synced 2026-06-09 08:43:19 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Vendor import of lldb trunk r303197:

Browse source 
https://llvm.org/svn/llvm-project/lldb/trunk@303197
This commit is contained in:
Dimitry Andric 2017-05-16 19:47:58 +00:00
parent 8b4000f13b
commit b76161e41b
693 changed files with 6528 additions and 6085 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
include/lldb/API/SBError.h
View file

@ -68,18 +68,18 @@ protected:
friend class SBBreakpoint;
friend class SBBreakpointLocation;
lldb_private::Error *get();
lldb_private::Status *get();
lldb_private::Error *operator->();
lldb_private::Status *operator->();
const lldb_private::Error &operator*() const;
const lldb_private::Status &operator*() const;
lldb_private::Error &ref();
lldb_private::Status &ref();
void SetError(const lldb_private::Error &lldb_error);
void SetError(const lldb_private::Status &lldb_error);
private:
std::unique_ptr<lldb_private::Error> m_opaque_ap;
std::unique_ptr<lldb_private::Status> m_opaque_ap;
void CreateIfNeeded();
};

3
include/lldb/API/SBPlatform.h
View file

@ -156,7 +156,8 @@ protected:
void SetSP(const lldb::PlatformSP &platform_sp);
SBError ExecuteConnected(
const std::function<lldb_private::Error(const lldb::PlatformSP &)> &func);
const std::function<lldb_private::Status(const lldb::PlatformSP &)>
&func);
lldb::PlatformSP m_opaque_sp;
};

2
include/lldb/API/SBTarget.h
View file

@ -544,7 +544,7 @@ public:
/// into this call
///
/// @param[out] error
/// Error information is written here if the memory read fails.
/// Status information is written here if the memory read fails.
///
/// @return
/// The amount of data read in host bytes.

6
include/lldb/Breakpoint/Breakpoint.h
View file

@ -169,7 +169,7 @@ public:
virtual bool EvaluatePrecondition(StoppointCallbackContext &context);
virtual Error ConfigurePrecondition(Args &options);
virtual Status ConfigurePrecondition(Args &options);
virtual void GetDescription(Stream &stream, lldb::DescriptionLevel level);
};
@ -178,7 +178,7 @@ public:
// Saving & restoring breakpoints:
static lldb::BreakpointSP CreateFromStructuredData(
Target &target, StructuredData::ObjectSP &data_object_sp, Error &error);
Target &target, StructuredData::ObjectSP &data_object_sp, Status &error);
static bool
SerializedBreakpointMatchesNames(StructuredData::ObjectSP &bkpt_object_sp,
@ -613,7 +613,7 @@ public:
lldb::SearchFilterSP GetSearchFilter() { return m_filter_sp; }
bool AddName(const char *new_name, Error &error);
bool AddName(llvm::StringRef new_name, Status &error);
void RemoveName(const char *name_to_remove) {
if (name_to_remove)

2
include/lldb/Breakpoint/BreakpointID.h
View file

@ -84,7 +84,7 @@ public:
/// \b true if the name is a breakpoint name (as opposed to an ID or
/// range) false otherwise.
//------------------------------------------------------------------
static bool StringIsBreakpointName(llvm::StringRef str, Error &error);
static bool StringIsBreakpointName(llvm::StringRef str, Status &error);
//------------------------------------------------------------------
/// Takes a breakpoint ID and the breakpoint location id and returns

2
include/lldb/Breakpoint/BreakpointLocation.h
View file

@ -161,7 +161,7 @@ public:
//------------------------------------------------------------------
const char *GetConditionText(size_t *hash = nullptr) const;
bool ConditionSaysStop(ExecutionContext &exe_ctx, Error &error);
bool ConditionSaysStop(ExecutionContext &exe_ctx, Status &error);
//------------------------------------------------------------------
/// Set the valid thread to be checked when the breakpoint is hit.

4
include/lldb/Breakpoint/BreakpointOptions.h
View file

@ -50,7 +50,7 @@ public:
static std::unique_ptr<CommandData>
CreateFromStructuredData(const StructuredData::Dictionary &options_dict,
Error &error);
Status &error);
StringList user_source;
std::string script_source;
@ -119,7 +119,7 @@ public:
static std::unique_ptr<BreakpointOptions>
CreateFromStructuredData(Target &target,
const StructuredData::Dictionary &data_dict,
Error &error);
Status &error);
virtual StructuredData::ObjectSP SerializeToStructuredData();

4
include/lldb/Breakpoint/BreakpointResolver.h
View file

@ -140,7 +140,7 @@ public:
static lldb::BreakpointResolverSP
CreateFromStructuredData(const StructuredData::Dictionary &resolver_dict,
Error &error);
Status &error);
virtual StructuredData::ObjectSP SerializeToStructuredData() {
return StructuredData::ObjectSP();
@ -192,7 +192,7 @@ public:
static const char *ResolverTyToName(enum ResolverTy);
static ResolverTy NameToResolverTy(const char *name);
static ResolverTy NameToResolverTy(llvm::StringRef name);
virtual lldb::BreakpointResolverSP
CopyForBreakpoint(Breakpoint &breakpoint) = 0;

2
include/lldb/Breakpoint/BreakpointResolverAddress.h
View file

@ -39,7 +39,7 @@ public:
static BreakpointResolver *
CreateFromStructuredData(Breakpoint *bkpt,
const StructuredData::Dictionary &options_dict,
Error &error);
Status &error);
StructuredData::ObjectSP SerializeToStructuredData() override;

2
include/lldb/Breakpoint/BreakpointResolverFileLine.h
View file

@ -36,7 +36,7 @@ public:
static BreakpointResolver *
CreateFromStructuredData(Breakpoint *bkpt,
const StructuredData::Dictionary &data_dict,
Error &error);
Status &error);
StructuredData::ObjectSP SerializeToStructuredData() override;

2
include/lldb/Breakpoint/BreakpointResolverFileRegex.h
View file

@ -38,7 +38,7 @@ public:
static BreakpointResolver *
CreateFromStructuredData(Breakpoint *bkpt,
const StructuredData::Dictionary &options_dict,
Error &error);
Status &error);
StructuredData::ObjectSP SerializeToStructuredData() override;

2
include/lldb/Breakpoint/BreakpointResolverName.h
View file

@ -57,7 +57,7 @@ public:
static BreakpointResolver *
CreateFromStructuredData(Breakpoint *bkpt,
const StructuredData::Dictionary &data_dict,
Error &error);
Status &error);
StructuredData::ObjectSP SerializeToStructuredData() override;

6
include/lldb/Breakpoint/Watchpoint.h
View file

@ -100,7 +100,7 @@ public:
void DumpSnapshots(Stream *s, const char *prefix = nullptr) const;
void DumpWithLevel(Stream *s, lldb::DescriptionLevel description_level) const;
Target &GetTarget() { return m_target; }
const Error &GetError() { return m_error; }
const Status &GetError() { return m_error; }
//------------------------------------------------------------------
/// Returns the WatchpointOptions structure set for this watchpoint.
@ -213,8 +213,8 @@ private:
lldb::ValueObjectSP m_old_value_sp;
lldb::ValueObjectSP m_new_value_sp;
CompilerType m_type;
Error m_error; // An error object describing errors associated with this
// watchpoint.
Status m_error; // An error object describing errors associated with this
// watchpoint.
WatchpointOptions
m_options; // Settable watchpoint options, which is a delegate to handle
// the callback machinery.

24
include/lldb/Core/Communication.h
View file

@ -33,7 +33,7 @@ namespace lldb_private {
class ConstString;
}
namespace lldb_private {
class Error;
class Status;
}
namespace lldb_private {
@ -71,7 +71,7 @@ namespace lldb_private {
/// reads data and caches any received bytes. To start the read thread
/// clients call:
///
/// bool Communication::StartReadThread (Error *);
/// bool Communication::StartReadThread (Status *);
///
/// If true is returned a read thread has been spawned that will
/// continually execute a call to the pure virtual DoRead function:
@ -154,10 +154,10 @@ public:
/// internal error object should be filled in with an
/// appropriate value based on the result of this function.
///
/// @see Error& Communication::GetError ();
/// @see Status& Communication::GetError ();
/// @see bool Connection::Connect (const char *url);
//------------------------------------------------------------------
lldb::ConnectionStatus Connect(const char *url, Error *error_ptr);
lldb::ConnectionStatus Connect(const char *url, Status *error_ptr);
//------------------------------------------------------------------
/// Disconnect the communications connection if one is currently
@ -168,10 +168,10 @@ public:
/// internal error object should be filled in with an
/// appropriate value based on the result of this function.
///
/// @see Error& Communication::GetError ();
/// @see Status& Communication::GetError ();
/// @see bool Connection::Disconnect ();
//------------------------------------------------------------------
lldb::ConnectionStatus Disconnect(Error *error_ptr = nullptr);
lldb::ConnectionStatus Disconnect(Status *error_ptr = nullptr);
//------------------------------------------------------------------
/// Check if the connection is valid.
@ -217,7 +217,7 @@ public:
/// @see size_t Connection::Read (void *, size_t);
//------------------------------------------------------------------
size_t Read(void *dst, size_t dst_len, const Timeout<std::micro> &timeout,
lldb::ConnectionStatus &status, Error *error_ptr);
lldb::ConnectionStatus &status, Status *error_ptr);
//------------------------------------------------------------------
/// The actual write function that attempts to write to the
@ -237,7 +237,7 @@ public:
/// The number of bytes actually Written.
//------------------------------------------------------------------
size_t Write(const void *src, size_t src_len, lldb::ConnectionStatus &status,
Error *error_ptr);
Status *error_ptr);
//------------------------------------------------------------------
/// Sets the connection that it to be used by this class.
@ -280,7 +280,7 @@ public:
/// @see void Communication::AppendBytesToCache (const uint8_t * bytes, size_t
/// len, bool broadcast);
//------------------------------------------------------------------
virtual bool StartReadThread(Error *error_ptr = nullptr);
virtual bool StartReadThread(Status *error_ptr = nullptr);
//------------------------------------------------------------------
/// Stops the read thread by cancelling it.
@ -289,9 +289,9 @@ public:
/// \b True if the read thread was successfully canceled, \b
/// false otherwise.
//------------------------------------------------------------------
virtual bool StopReadThread(Error *error_ptr = nullptr);
virtual bool StopReadThread(Status *error_ptr = nullptr);
virtual bool JoinReadThread(Error *error_ptr = nullptr);
virtual bool JoinReadThread(Status *error_ptr = nullptr);
//------------------------------------------------------------------
/// Checks if there is a currently running read thread.
///
@ -361,7 +361,7 @@ protected:
size_t ReadFromConnection(void *dst, size_t dst_len,
const Timeout<std::micro> &timeout,
lldb::ConnectionStatus &status, Error *error_ptr);
lldb::ConnectionStatus &status, Status *error_ptr);
//------------------------------------------------------------------
/// Append new bytes that get read from the read thread into the

14
include/lldb/Core/Connection.h
View file

@ -22,7 +22,7 @@
#include <stddef.h> // for size_t
namespace lldb_private {
class Error;
class Status;
}
namespace lldb_private {
template <typename Ratio> class Timeout;
@ -75,10 +75,10 @@ public:
/// internal error object should be filled in with an
/// appropriate value based on the result of this function.
///
/// @see Error& Communication::GetError ();
/// @see Status& Communication::GetError ();
//------------------------------------------------------------------
virtual lldb::ConnectionStatus Connect(llvm::StringRef url,
Error *error_ptr) = 0;
Status *error_ptr) = 0;
//------------------------------------------------------------------
/// Disconnect the communications connection if one is currently
@ -94,9 +94,9 @@ public:
/// internal error object should be filled in with an
/// appropriate value based on the result of this function.
///
/// @see Error& Communication::GetError ();
/// @see Status& Communication::GetError ();
//------------------------------------------------------------------
virtual lldb::ConnectionStatus Disconnect(Error *error_ptr) = 0;
virtual lldb::ConnectionStatus Disconnect(Status *error_ptr) = 0;
//------------------------------------------------------------------
/// Check if the connection is valid.
@ -137,7 +137,7 @@ public:
//------------------------------------------------------------------
virtual size_t Read(void *dst, size_t dst_len,
const Timeout<std::micro> &timeout,
lldb::ConnectionStatus &status, Error *error_ptr) = 0;
lldb::ConnectionStatus &status, Status *error_ptr) = 0;
//------------------------------------------------------------------
/// The actual write function that attempts to write to the
@ -162,7 +162,7 @@ public:
/// The number of bytes actually Written.
//------------------------------------------------------------------
virtual size_t Write(const void *dst, size_t dst_len,
lldb::ConnectionStatus &status, Error *error_ptr) = 0;
lldb::ConnectionStatus &status, Status *error_ptr) = 0;
//------------------------------------------------------------------
/// Returns a URI that describes this connection object

12
include/lldb/Core/Debugger.h
View file

@ -30,8 +30,8 @@
#include "lldb/Target/Platform.h"
#include "lldb/Target/TargetList.h"
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/Error.h" // for Error
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/Utility/Status.h" // for Status
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for ScriptLanguage, Langua...
@ -239,9 +239,9 @@ public:
eStopDisassemblyTypeAlways
};
Error SetPropertyValue(const ExecutionContext *exe_ctx,
VarSetOperationType op, llvm::StringRef property_path,
llvm::StringRef value) override;
Status SetPropertyValue(const ExecutionContext *exe_ctx,
VarSetOperationType op, llvm::StringRef property_path,
llvm::StringRef value) override;
bool GetAutoConfirm() const;
@ -306,7 +306,7 @@ public:
const ConstString &GetInstanceName() { return m_instance_name; }
bool LoadPlugin(const FileSpec &spec, Error &error);
bool LoadPlugin(const FileSpec &spec, Status &error);
void ExecuteIOHandlers();
@ -318,7 +318,7 @@ public:
bool IsHandlingEvents() const { return m_event_handler_thread.IsJoinable(); }
Error RunREPL(lldb::LanguageType language, const char *repl_options);
Status RunREPL(lldb::LanguageType language, const char *repl_options);
// This is for use in the command interpreter, when you either want the
// selected target, or if no target

16
include/lldb/Core/FormatEntity.h
View file

@ -10,8 +10,8 @@
#ifndef liblldb_FormatEntity_h_
#define liblldb_FormatEntity_h_
#include "lldb/Utility/Error.h"
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/Utility/Status.h"
#include "lldb/lldb-enumerations.h" // for Format::eFormatDefault, Format
#include "lldb/lldb-types.h" // for addr_t
#include <algorithm> // for min
@ -205,11 +205,11 @@ public:
const Address *addr, ValueObject *valobj,
bool function_changed, bool initial_function);
static Error Parse(const llvm::StringRef &format, Entry &entry);
static Status Parse(const llvm::StringRef &format, Entry &entry);
static Error ExtractVariableInfo(llvm::StringRef &format_str,
llvm::StringRef &variable_name,
llvm::StringRef &variable_format);
static Status ExtractVariableInfo(llvm::StringRef &format_str,
llvm::StringRef &variable_name,
llvm::StringRef &variable_format);
static size_t AutoComplete(llvm::StringRef s, int match_start_point,
int max_return_elements, bool &word_complete,
@ -228,8 +228,8 @@ public:
llvm::StringRef element_format);
protected:
static Error ParseInternal(llvm::StringRef &format, Entry &parent_entry,
uint32_t depth);
static Status ParseInternal(llvm::StringRef &format, Entry &parent_entry,
uint32_t depth);
};
} // namespace lldb_private

4
include/lldb/Core/MappedHash.h
View file

@ -326,7 +326,7 @@ public:
1u, // Bucket hash data collision, but key didn't match
eResultEndOfHashData = 2u, // The chain of items for this hash data in
// this bucket is terminated, search no more
eResultError = 3u // Error parsing the hash data, abort
eResultError = 3u // Status parsing the hash data, abort
};
struct Pair {
@ -409,7 +409,7 @@ public:
// searching
return false;
case eResultError:
// Error parsing the hash data, abort
// Status parsing the hash data, abort
return false;
}
}

8
include/lldb/Core/Module.h
View file

@ -17,8 +17,8 @@
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Target/PathMappingList.h"
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/Error.h" // for Error
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h" // for Status
#include "lldb/Utility/UUID.h"
#include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
#include "lldb/lldb-enumerations.h" // for LanguageType, SymbolType
@ -652,7 +652,7 @@ public:
//------------------------------------------------------------------
bool IsLoadedInTarget(Target *target);
bool LoadScriptingResourceInTarget(Target *target, Error &error,
bool LoadScriptingResourceInTarget(Target *target, Status &error,
Stream *feedback_stream = nullptr);
//------------------------------------------------------------------
@ -728,7 +728,7 @@ public:
/// failed (see the `error` for more information in that case).
//------------------------------------------------------------------
ObjectFile *GetMemoryObjectFile(const lldb::ProcessSP &process_sp,
lldb::addr_t header_addr, Error &error,
lldb::addr_t header_addr, Status &error,
size_t size_to_read = 512);
//------------------------------------------------------------------
/// Get the symbol vendor interface for the current architecture.
@ -1033,7 +1033,7 @@ public:
///
/// @return
//------------------------------------------------------------------
Error LoadInMemory(Target &target, bool set_pc);
Status LoadInMemory(Target &target, bool set_pc);
//----------------------------------------------------------------------
/// @class LookupInfo Module.h "lldb/Core/Module.h"

16
include/lldb/Core/ModuleList.h
View file

@ -12,9 +12,9 @@
#include "lldb/Core/Address.h" // for Address
#include "lldb/Core/ModuleSpec.h" // for ModuleSpec
#include "lldb/Utility/Error.h" // for Error
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/Utility/Iterable.h"
#include "lldb/Utility/Status.h" // for Status
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
@ -530,18 +530,18 @@ public:
//------------------------------------------------------------------
size_t GetSize() const;
bool LoadScriptingResourcesInTarget(Target *target, std::list<Error> &errors,
bool LoadScriptingResourcesInTarget(Target *target, std::list<Status> &errors,
Stream *feedback_stream = nullptr,
bool continue_on_error = true);
static bool ModuleIsInCache(const Module *module_ptr);
static Error GetSharedModule(const ModuleSpec &module_spec,
lldb::ModuleSP &module_sp,
const FileSpecList *module_search_paths_ptr,
lldb::ModuleSP *old_module_sp_ptr,
bool *did_create_ptr,
bool always_create = false);
static Status GetSharedModule(const ModuleSpec &module_spec,
lldb::ModuleSP &module_sp,
const FileSpecList *module_search_paths_ptr,
lldb::ModuleSP *old_module_sp_ptr,
bool *did_create_ptr,
bool always_create = false);
static bool RemoveSharedModule(lldb::ModuleSP &module_sp);

6
include/lldb/Core/PluginManager.h
View file

@ -10,8 +10,8 @@
#ifndef liblldb_PluginManager_h_
#define liblldb_PluginManager_h_
#include "lldb/Utility/Error.h" // for Error
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h" // for Status
#include "lldb/lldb-enumerations.h" // for ScriptLanguage
#include "lldb/lldb-forward.h" // for OptionValuePropertiesSP
#include "lldb/lldb-private-interfaces.h" // for DebuggerInitializeCallback
@ -202,8 +202,8 @@ public:
static ObjectFileCreateMemoryInstance
GetObjectFileCreateMemoryCallbackForPluginName(const ConstString &name);
static Error SaveCore(const lldb::ProcessSP &process_sp,
const FileSpec &outfile);
static Status SaveCore(const lldb::ProcessSP &process_sp,
const FileSpec &outfile);
//------------------------------------------------------------------
// ObjectContainer

18
include/lldb/Core/RegisterValue.h
View file

@ -12,7 +12,7 @@
#include "lldb/Core/Scalar.h"
#include "lldb/Utility/Endian.h"
#include "lldb/Utility/Error.h" // for Error
#include "lldb/Utility/Status.h" // for Status
#include "lldb/lldb-enumerations.h" // for ByteOrder, Format
#include "lldb/lldb-types.h" // for offset_t
@ -105,11 +105,11 @@ public:
// into "dst".
uint32_t GetAsMemoryData(const RegisterInfo *reg_info, void *dst,
uint32_t dst_len, lldb::ByteOrder dst_byte_order,
Error &error) const;
Status &error) const;
uint32_t SetFromMemoryData(const RegisterInfo *reg_info, const void *src,
uint32_t src_len, lldb::ByteOrder src_byte_order,
Error &error);
Status &error);
bool GetScalarValue(Scalar &scalar) const;
@ -241,13 +241,13 @@ public:
bool SignExtend(uint32_t sign_bitpos);
Error SetValueFromString(const RegisterInfo *reg_info,
llvm::StringRef value_str);
Error SetValueFromString(const RegisterInfo *reg_info,
const char *value_str) = delete;
Status SetValueFromString(const RegisterInfo *reg_info,
llvm::StringRef value_str);
Status SetValueFromString(const RegisterInfo *reg_info,
const char *value_str) = delete;
Error SetValueFromData(const RegisterInfo *reg_info, DataExtractor &data,
lldb::offset_t offset, bool partial_data_ok);
Status SetValueFromData(const RegisterInfo *reg_info, DataExtractor &data,
lldb::offset_t offset, bool partial_data_ok);
// The default value of 0 for reg_name_right_align_at means no alignment at
// all.

12
include/lldb/Core/Scalar.h
View file

@ -10,7 +10,7 @@
#ifndef liblldb_Scalar_h_
#define liblldb_Scalar_h_
#include "lldb/Utility/Error.h" // for Error
#include "lldb/Utility/Status.h" // for Status
#include "lldb/lldb-enumerations.h" // for Encoding, ByteOrder
#include "lldb/lldb-private-types.h" // for type128
@ -146,7 +146,7 @@ public:
bool GetData(DataExtractor &data, size_t limit_byte_size = UINT32_MAX) const;
size_t GetAsMemoryData(void *dst, size_t dst_len,
lldb::ByteOrder dst_byte_order, Error &error) const;
lldb::ByteOrder dst_byte_order, Status &error) const;
bool IsZero() const;
@ -272,11 +272,11 @@ public:
long double LongDouble(long double fail_value = 0.0) const;
Error SetValueFromCString(const char *s, lldb::Encoding encoding,
size_t byte_size);
Status SetValueFromCString(const char *s, lldb::Encoding encoding,
size_t byte_size);
Error SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
size_t byte_size);
Status SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
size_t byte_size);
static bool UIntValueIsValidForSize(uint64_t uval64, size_t total_byte_size) {
if (total_byte_size > 8)

14
include/lldb/Core/SearchFilter.h
View file

@ -28,7 +28,7 @@ namespace lldb_private {
class CompileUnit;
}
namespace lldb_private {
class Error;
class Status;
}
namespace lldb_private {
class Function;
@ -250,7 +250,7 @@ public:
static lldb::SearchFilterSP
CreateFromStructuredData(Target &target,
const StructuredData::Dictionary &data_dict,
Error &error);
Status &error);
virtual StructuredData::ObjectSP SerializeToStructuredData() {
return StructuredData::ObjectSP();
@ -285,7 +285,7 @@ public:
static const char *FilterTyToName(enum FilterTy);
static FilterTy NameToFilterTy(const char *name);
static FilterTy NameToFilterTy(llvm::StringRef name);
protected:
// Serialization of SearchFilter options:
@ -351,7 +351,7 @@ public:
static lldb::SearchFilterSP
CreateFromStructuredData(Target &target,
const StructuredData::Dictionary &data_dict,
Error &error);
Status &error);
StructuredData::ObjectSP SerializeToStructuredData() override;
@ -405,7 +405,7 @@ public:
static lldb::SearchFilterSP
CreateFromStructuredData(Target &target,
const StructuredData::Dictionary &data_dict,
Error &error);
Status &error);
StructuredData::ObjectSP SerializeToStructuredData() override;
@ -462,7 +462,7 @@ public:
static lldb::SearchFilterSP
CreateFromStructuredData(Target &target,
const StructuredData::Dictionary &data_dict,
Error &error);
Status &error);
StructuredData::ObjectSP SerializeToStructuredData() override;
@ -515,7 +515,7 @@ public:
static lldb::SearchFilterSP
CreateFromStructuredData(Target &target,
const StructuredData::Dictionary &data_dict,
Error &error);
Status &error);
StructuredData::ObjectSP SerializeToStructuredData() override;

40
include/lldb/Core/StructuredData.h
View file

@ -28,7 +28,7 @@
#include <stdint.h> // for uint64_t
namespace lldb_private {
class Error;
class Status;
}
namespace lldb_private {
class Stream;
@ -143,15 +143,12 @@ public:
: nullptr);
}
std::string GetStringValue(const char *fail_value = nullptr) {
llvm::StringRef GetStringValue(const char *fail_value = nullptr) {
String *s = GetAsString();
if (s)
return s->GetValue();
if (fail_value && fail_value[0])
return std::string(fail_value);
return std::string();
return fail_value;
}
Generic *GetAsGeneric() {
@ -220,7 +217,7 @@ public:
return success;
}
bool GetItemAtIndexAsString(size_t idx, std::string &result) const {
bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result) const {
ObjectSP value_sp = GetItemAtIndex(idx);
if (value_sp.get()) {
if (auto string_value = value_sp->GetAsString()) {
@ -231,8 +228,8 @@ public:
return false;
}
bool GetItemAtIndexAsString(size_t idx, std::string &result,
const std::string &default_val) const {
bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result,
llvm::StringRef default_val) const {
bool success = GetItemAtIndexAsString(idx, result);
if (!success)
result = default_val;
@ -339,18 +336,13 @@ public:
class String : public Object {
public:
String(const char *cstr = nullptr) : Object(Type::eTypeString), m_value() {
if (cstr)
m_value = cstr;
}
String() : Object(Type::eTypeString) {}
explicit String(llvm::StringRef S)
: Object(Type::eTypeString), m_value(S) {}
String(const std::string &s) : Object(Type::eTypeString), m_value(s) {}
void SetValue(llvm::StringRef S) { m_value = S; }
String(const std::string &&s) : Object(Type::eTypeString), m_value(s) {}
void SetValue(const std::string &string) { m_value = string; }
const std::string &GetValue() { return m_value; }
llvm::StringRef GetValue() { return m_value; }
void Dump(Stream &s, bool pretty_print = true) const override;
@ -430,7 +422,7 @@ public:
}
bool GetValueForKeyAsString(llvm::StringRef key,
std::string &result) const {
llvm::StringRef &result) const {
ObjectSP value_sp = GetValueForKey(key);
if (value_sp.get()) {
if (auto string_value = value_sp->GetAsString()) {
@ -441,14 +433,14 @@ public:
return false;
}
bool GetValueForKeyAsString(llvm::StringRef key, std::string &result,
bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result,
const char *default_val) const {
bool success = GetValueForKeyAsString(key, result);
if (!success) {
if (default_val)
result = default_val;
else
result.clear();
result = llvm::StringRef();
}
return success;
}
@ -513,7 +505,7 @@ public:
AddItem(key, std::make_shared<Float>(value));
}
void AddStringItem(llvm::StringRef key, std::string value) {
void AddStringItem(llvm::StringRef key, llvm::StringRef value) {
AddItem(key, std::make_shared<String>(std::move(value)));
}
@ -558,7 +550,7 @@ public:
static ObjectSP ParseJSON(std::string json_text);
static ObjectSP ParseJSONFromFile(const FileSpec &file, Error &error);
static ObjectSP ParseJSONFromFile(const FileSpec &file, Status &error);
};
} // namespace lldb_private

12
include/lldb/Core/StructuredDataImpl.h
View file

@ -12,9 +12,9 @@
#include "lldb/Core/Event.h"
#include "lldb/Core/StructuredData.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Target/StructuredDataPlugin.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-forward.h"
#pragma mark--
@ -45,8 +45,8 @@ public:
m_data_sp.reset();
}
Error GetAsJSON(Stream &stream) const {
Error error;
Status GetAsJSON(Stream &stream) const {
Status error;
if (!m_data_sp) {
error.SetErrorString("No structured data.");
@ -57,8 +57,8 @@ public:
return error;
}
Error GetDescription(Stream &stream) const {
Error error;
Status GetDescription(Stream &stream) const {
Status error;
if (!m_data_sp) {
error.SetErrorString("Cannot pretty print structured data: "

17
include/lldb/Core/Timer.h
View file

@ -37,10 +37,23 @@ namespace lldb_private {
class Timer {
public:
class Category {
public:
explicit Category(const char *category_name);
private:
friend class Timer;
const char *m_name;
std::atomic<uint64_t> m_nanos;
std::atomic<Category *> m_next;
DISALLOW_COPY_AND_ASSIGN(Category);
};
//--------------------------------------------------------------
/// Default constructor.
//--------------------------------------------------------------
Timer(const char *category, const char *format, ...)
Timer(Category &category, const char *format, ...)
__attribute__((format(printf, 3, 4)));
//--------------------------------------------------------------
@ -62,7 +75,7 @@ protected:
using TimePoint = std::chrono::steady_clock::time_point;
void ChildDuration(TimePoint::duration dur) { m_child_duration += dur; }
const char *m_category;
Category &m_category;
TimePoint m_total_start;
TimePoint::duration m_child_duration{0};

17
include/lldb/Core/UserSettingsController.h
View file

@ -10,7 +10,7 @@
#ifndef liblldb_UserSettingsController_h_
#define liblldb_UserSettingsController_h_
#include "lldb/Utility/Error.h" // for Error
#include "lldb/Utility/Status.h" // for Status
#include "lldb/lldb-forward.h" // for OptionValuePropertiesSP
#include "lldb/lldb-private-enumerations.h" // for VarSetOperationType
@ -57,15 +57,16 @@ public:
virtual lldb::OptionValueSP GetPropertyValue(const ExecutionContext *exe_ctx,
llvm::StringRef property_path,
bool will_modify,
Error &error) const;
Status &error) const;
virtual Error SetPropertyValue(const ExecutionContext *exe_ctx,
VarSetOperationType op,
llvm::StringRef property_path, llvm::StringRef value);
virtual Status SetPropertyValue(const ExecutionContext *exe_ctx,
VarSetOperationType op,
llvm::StringRef property_path,
llvm::StringRef value);
virtual Error DumpPropertyValue(const ExecutionContext *exe_ctx, Stream &strm,
llvm::StringRef property_path,
uint32_t dump_mask);
virtual Status DumpPropertyValue(const ExecutionContext *exe_ctx,
Stream &strm, llvm::StringRef property_path,
uint32_t dump_mask);
virtual void DumpAllPropertyValues(const ExecutionContext *exe_ctx,
Stream &strm, uint32_t dump_mask);

10
include/lldb/Core/Value.h
View file

@ -13,7 +13,7 @@
#include "lldb/Core/Scalar.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-enumerations.h" // for ByteOrder, ByteOrder::eB...
#include "lldb/lldb-private-enumerations.h" // for AddressType
#include "lldb/lldb-private-types.h" // for type128, RegisterInfo
@ -219,11 +219,11 @@ public:
lldb::Format GetValueDefaultFormat();
uint64_t GetValueByteSize(Error *error_ptr, ExecutionContext *exe_ctx);
uint64_t GetValueByteSize(Status *error_ptr, ExecutionContext *exe_ctx);
Error GetValueAsData(ExecutionContext *exe_ctx, DataExtractor &data,
uint32_t data_offset,
Module *module); // Can be nullptr
Status GetValueAsData(ExecutionContext *exe_ctx, DataExtractor &data,
uint32_t data_offset,
Module *module); // Can be nullptr
static const char *GetValueTypeAsCString(ValueType context_type);

23
include/lldb/Core/ValueObject.h
View file

@ -18,8 +18,8 @@
#include "lldb/Target/Process.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/SharedCluster.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-defines.h" // for LLDB_INVALID...
#include "lldb/lldb-enumerations.h" // for DynamicValue...
@ -462,7 +462,7 @@ public:
virtual int64_t GetValueAsSigned(int64_t fail_value, bool *success = nullptr);
virtual bool SetValueFromCString(const char *value_str, Error &error);
virtual bool SetValueFromCString(const char *value_str, Status &error);
// Return the module associated with this value object in case the
// value is from an executable file and might have its data in
@ -482,7 +482,7 @@ public:
//------------------------------------------------------------------
// The functions below should NOT be modified by subclasses
//------------------------------------------------------------------
const Error &GetError();
const Status &GetError();
const ConstString &GetName() const;
@ -520,7 +520,7 @@ public:
// return 'false' whenever you set the error, otherwise
// callers may assume true means everything is OK - this will
// break breakpoint conditions among potentially a few others
virtual bool IsLogicalTrue(Error &error);
virtual bool IsLogicalTrue(Status &error);
virtual const char *GetLocationAsCString();
@ -620,7 +620,7 @@ public:
virtual lldb::ValueObjectSP CreateConstantValue(const ConstString &name);
virtual lldb::ValueObjectSP Dereference(Error &error);
virtual lldb::ValueObjectSP Dereference(Status &error);
// Creates a copy of the ValueObject with a new name and setting the current
// ValueObject as its parent. It should be used when we want to change the
@ -628,7 +628,7 @@ public:
// (e.g. sythetic child provider).
virtual lldb::ValueObjectSP Clone(const ConstString &new_name);
virtual lldb::ValueObjectSP AddressOf(Error &error);
virtual lldb::ValueObjectSP AddressOf(Status &error);
virtual lldb::addr_t GetLiveAddress() { return LLDB_INVALID_ADDRESS; }
@ -700,16 +700,16 @@ public:
bool IsCStringContainer(bool check_pointer = false);
std::pair<size_t, bool>
ReadPointedString(lldb::DataBufferSP &buffer_sp, Error &error,
ReadPointedString(lldb::DataBufferSP &buffer_sp, Status &error,
uint32_t max_length = 0, bool honor_array = true,
lldb::Format item_format = lldb::eFormatCharArray);
virtual size_t GetPointeeData(DataExtractor &data, uint32_t item_idx = 0,
uint32_t item_count = 1);
virtual uint64_t GetData(DataExtractor &data, Error &error);
virtual uint64_t GetData(DataExtractor &data, Status &error);
virtual bool SetData(DataExtractor &data, Error &error);
virtual bool SetData(DataExtractor &data, Status &error);
virtual bool GetIsConstant() const { return m_update_point.IsConstant(); }
@ -880,8 +880,9 @@ protected:
DataExtractor
m_data; // A data extractor that can be used to extract the value.
Value m_value;
Error m_error; // An error object that can describe any errors that occur when
// updating values.
Status
m_error; // An error object that can describe any errors that occur when
// updating values.
std::string m_value_str; // Cached value string that will get cleared if/when
// the value is updated.
std::string m_old_value_str; // Cached old value string from the last time the

10
include/lldb/Core/ValueObjectConstResult.h
View file

@ -15,7 +15,7 @@
#include "lldb/Core/ValueObjectConstResultImpl.h"
#include "lldb/Symbol/CompilerType.h" // for CompilerType
#include "lldb/Utility/ConstString.h" // for ConstString
#include "lldb/Utility/Error.h" // for Error
#include "lldb/Utility/Status.h" // for Status
#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
#include "lldb/lldb-enumerations.h" // for ByteOrder, Dynamic...
#include "lldb/lldb-forward.h" // for ValueObjectSP, Dat...
@ -69,7 +69,7 @@ public:
// When an expression fails to evaluate, we return an error
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
const Error &error);
const Status &error);
uint64_t GetByteSize() override;
@ -85,7 +85,7 @@ public:
void SetByteSize(size_t size);
lldb::ValueObjectSP Dereference(Error &error) override;
lldb::ValueObjectSP Dereference(Status &error) override;
ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member,
int32_t synthetic_index) override;
@ -94,7 +94,7 @@ public:
uint32_t offset, const CompilerType &type, bool can_create,
ConstString name_const_str = ConstString()) override;
lldb::ValueObjectSP AddressOf(Error &error) override;
lldb::ValueObjectSP AddressOf(Status &error) override;
lldb::addr_t GetAddressOf(bool scalar_is_load_address = true,
AddressType *address_type = nullptr) override;
@ -153,7 +153,7 @@ private:
ValueObjectConstResult(ExecutionContextScope *exe_scope, const Value &value,
const ConstString &name, Module *module = nullptr);
ValueObjectConstResult(ExecutionContextScope *exe_scope, const Error &error);
ValueObjectConstResult(ExecutionContextScope *exe_scope, const Status &error);
DISALLOW_COPY_AND_ASSIGN(ValueObjectConstResult);
};

6
include/lldb/Core/ValueObjectConstResultCast.h
View file

@ -25,7 +25,7 @@ namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Error;
class Status;
}
namespace lldb_private {
class ValueObject;
@ -41,7 +41,7 @@ public:
~ValueObjectConstResultCast() override;
lldb::ValueObjectSP Dereference(Error &error) override;
lldb::ValueObjectSP Dereference(Status &error) override;
ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member,
int32_t synthetic_index) override;
@ -54,7 +54,7 @@ public:
uint32_t offset, const CompilerType &type, bool can_create,
ConstString name_const_str = ConstString()) override;
lldb::ValueObjectSP AddressOf(Error &error) override;
lldb::ValueObjectSP AddressOf(Status &error) override;
size_t GetPointeeData(DataExtractor &data, uint32_t item_idx = 0,
uint32_t item_count = 1) override;

6
include/lldb/Core/ValueObjectConstResultChild.h
View file

@ -24,7 +24,7 @@ namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Error;
class Status;
}
namespace lldb_private {
class ValueObject;
@ -48,7 +48,7 @@ public:
~ValueObjectConstResultChild() override;
lldb::ValueObjectSP Dereference(Error &error) override;
lldb::ValueObjectSP Dereference(Status &error) override;
ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member,
int32_t synthetic_index) override;
@ -61,7 +61,7 @@ public:
uint32_t offset, const CompilerType &type, bool can_create,
ConstString name_const_str = ConstString()) override;
lldb::ValueObjectSP AddressOf(Error &error) override;
lldb::ValueObjectSP AddressOf(Status &error) override;
size_t GetPointeeData(DataExtractor &data, uint32_t item_idx = 0,
uint32_t item_count = 1) override;

6
include/lldb/Core/ValueObjectConstResultImpl.h
View file

@ -25,7 +25,7 @@ namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Error;
class Status;
}
namespace lldb_private {
class ValueObject;
@ -45,7 +45,7 @@ public:
virtual ~ValueObjectConstResultImpl() = default;
lldb::ValueObjectSP Dereference(Error &error);
lldb::ValueObjectSP Dereference(Status &error);
ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member,
int32_t synthetic_index);
@ -55,7 +55,7 @@ public:
bool can_create,
ConstString name_const_str = ConstString());
lldb::ValueObjectSP AddressOf(Error &error);
lldb::ValueObjectSP AddressOf(Status &error);
lldb::addr_t GetLiveAddress() { return m_live_address; }

6
include/lldb/Core/ValueObjectDynamicValue.h
View file

@ -32,7 +32,7 @@ namespace lldb_private {
class Declaration;
}
namespace lldb_private {
class Error;
class Status;
}
namespace lldb_private {
@ -86,9 +86,9 @@ public:
m_owning_valobj_sp = owning_sp;
}
bool SetValueFromCString(const char *value_str, Error &error) override;
bool SetValueFromCString(const char *value_str, Status &error) override;
bool SetData(DataExtractor &data, Error &error) override;
bool SetData(DataExtractor &data, Status &error) override;
TypeImpl GetTypeImpl() override;

6
include/lldb/Core/ValueObjectRegister.h
View file

@ -26,7 +26,7 @@ namespace lldb_private {
class DataExtractor;
}
namespace lldb_private {
class Error;
class Status;
}
namespace lldb_private {
class ExecutionContextScope;
@ -148,9 +148,9 @@ public:
size_t CalculateNumChildren(uint32_t max) override;
bool SetValueFromCString(const char *value_str, Error &error) override;
bool SetValueFromCString(const char *value_str, Status &error) override;
bool SetData(DataExtractor &data, Error &error) override;
bool SetData(DataExtractor &data, Status &error) override;
bool ResolveValue(Scalar &scalar) override;

4
include/lldb/Core/ValueObjectSyntheticFilter.h
View file

@ -29,7 +29,7 @@ namespace lldb_private {
class Declaration;
}
namespace lldb_private {
class Error;
class Status;
}
namespace lldb_private {
class SyntheticChildrenFrontEnd;
@ -110,7 +110,7 @@ public:
bool GetIsConstant() const override { return false; }
bool SetValueFromCString(const char *value_str, Error &error) override;
bool SetValueFromCString(const char *value_str, Status &error) override;
void SetFormat(lldb::Format format) override;

6
include/lldb/Core/ValueObjectVariable.h
View file

@ -29,7 +29,7 @@ namespace lldb_private {
class Declaration;
}
namespace lldb_private {
class Error;
class Status;
}
namespace lldb_private {
class ExecutionContextScope;
@ -73,9 +73,9 @@ public:
const char *GetLocationAsCString() override;
bool SetValueFromCString(const char *value_str, Error &error) override;
bool SetValueFromCString(const char *value_str, Status &error) override;
bool SetData(DataExtractor &data, Error &error) override;
bool SetData(DataExtractor &data, Status &error) override;
virtual lldb::VariableSP GetVariable() override { return m_variable_sp; }

4
include/lldb/DataFormatters/TypeSummary.h
View file

@ -25,7 +25,7 @@
#include "lldb/Core/FormatEntity.h"
#include "lldb/Core/StructuredData.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
namespace lldb_private {
class TypeSummaryOptions {
@ -286,7 +286,7 @@ private:
struct StringSummaryFormat : public TypeSummaryImpl {
std::string m_format_str;
FormatEntity::Entry m_format;
Error m_error;
Status m_error;
StringSummaryFormat(const TypeSummaryImpl::Flags &flags, const char *f);

8
include/lldb/Expression/DWARFExpression.h
View file

@ -14,7 +14,7 @@
#include "lldb/Core/Disassembler.h"
#include "lldb/Core/Scalar.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-private.h"
#include <functional>
@ -266,7 +266,7 @@ public:
ClangExpressionDeclMap *decl_map,
lldb::addr_t loclist_base_load_addr,
const Value *initial_value_ptr, const Value *object_address_ptr,
Value &result, Error *error_ptr) const;
Value &result, Status *error_ptr) const;
//------------------------------------------------------------------
/// Wrapper for the static evaluate function that uses member
@ -277,7 +277,7 @@ public:
ClangExpressionDeclMap *decl_map, RegisterContext *reg_ctx,
lldb::addr_t loclist_base_load_addr,
const Value *initial_value_ptr, const Value *object_address_ptr,
Value &result, Error *error_ptr) const;
Value &result, Status *error_ptr) const;
//------------------------------------------------------------------
/// Evaluate a DWARF location expression in a particular context
@ -345,7 +345,7 @@ public:
DWARFCompileUnit *dwarf_cu, const lldb::offset_t offset,
const lldb::offset_t length, const lldb::RegisterKind reg_set,
const Value *initial_value_ptr, const Value *object_address_ptr,
Value &result, Error *error_ptr);
Value &result, Status *error_ptr);
//------------------------------------------------------------------
/// Loads a ClangExpressionVariableList into the object

4
include/lldb/Expression/ExpressionParser.h
View file

@ -10,7 +10,7 @@
#ifndef liblldb_ExpressionParser_h_
#define liblldb_ExpressionParser_h_
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-public.h"
namespace lldb_private {
@ -108,7 +108,7 @@ public:
/// An error code indicating the success or failure of the operation.
/// Test with Success().
//------------------------------------------------------------------
virtual Error
virtual Status
PrepareForExecution(lldb::addr_t &func_addr, lldb::addr_t &func_end,
std::shared_ptr<IRExecutionUnit> &execution_unit_sp,
ExecutionContext &exe_ctx, bool &can_interpret,

10
include/lldb/Expression/IRExecutionUnit.h
View file

@ -39,7 +39,7 @@ class ObjectCache;
namespace lldb_private {
class Error;
class Status;
//----------------------------------------------------------------------
/// @class IRExecutionUnit IRExecutionUnit.h "lldb/Expression/IRExecutionUnit.h"
@ -86,7 +86,7 @@ public:
: nullptr);
}
void GetRunnableInfo(Error &error, lldb::addr_t &func_addr,
void GetRunnableInfo(Status &error, lldb::addr_t &func_addr,
lldb::addr_t &func_end);
//------------------------------------------------------------------
@ -95,7 +95,7 @@ public:
/// IRExecutionUnit unless the client explicitly chooses to free it.
//------------------------------------------------------------------
lldb::addr_t WriteNow(const uint8_t *bytes, size_t size, Error &error);
lldb::addr_t WriteNow(const uint8_t *bytes, size_t size, Status &error);
void FreeNow(lldb::addr_t allocation);
@ -240,7 +240,7 @@ private:
//------------------------------------------------------------------
bool WriteData(lldb::ProcessSP &process_sp);
Error DisassembleFunction(Stream &stream, lldb::ProcessSP &process_sp);
Status DisassembleFunction(Stream &stream, lldb::ProcessSP &process_sp);
struct SearchSpec;
@ -391,7 +391,7 @@ private:
void dump(Log *log);
};
bool CommitOneAllocation(lldb::ProcessSP &process_sp, Error &error,
bool CommitOneAllocation(lldb::ProcessSP &process_sp, Status &error,
AllocationRecord &record);
typedef std::vector<AllocationRecord> RecordVector;

6
include/lldb/Expression/IRInterpreter.h
View file

@ -39,20 +39,20 @@ class IRMemoryMap;
class IRInterpreter {
public:
static bool CanInterpret(llvm::Module &module, llvm::Function &function,
lldb_private::Error &error,
lldb_private::Status &error,
const bool support_function_calls);
static bool Interpret(llvm::Module &module, llvm::Function &function,
llvm::ArrayRef<lldb::addr_t> args,
lldb_private::IRExecutionUnit &execution_unit,
lldb_private::Error &error,
lldb_private::Status &error,
lldb::addr_t stack_frame_bottom,
lldb::addr_t stack_frame_top,
lldb_private::ExecutionContext &exe_ctx);
private:
static bool supportsFunction(llvm::Function &llvm_function,
lldb_private::Error &err);
lldb_private::Status &err);
};
#endif

20
include/lldb/Expression/IRMemoryMap.h
View file

@ -54,25 +54,25 @@ public:
};
lldb::addr_t Malloc(size_t size, uint8_t alignment, uint32_t permissions,
AllocationPolicy policy, bool zero_memory, Error &error);
void Leak(lldb::addr_t process_address, Error &error);
void Free(lldb::addr_t process_address, Error &error);
AllocationPolicy policy, bool zero_memory, Status &error);
void Leak(lldb::addr_t process_address, Status &error);
void Free(lldb::addr_t process_address, Status &error);
void WriteMemory(lldb::addr_t process_address, const uint8_t *bytes,
size_t size, Error &error);
size_t size, Status &error);
void WriteScalarToMemory(lldb::addr_t process_address, Scalar &scalar,
size_t size, Error &error);
size_t size, Status &error);
void WritePointerToMemory(lldb::addr_t process_address, lldb::addr_t address,
Error &error);
Status &error);
void ReadMemory(uint8_t *bytes, lldb::addr_t process_address, size_t size,
Error &error);
Status &error);
void ReadScalarFromMemory(Scalar &scalar, lldb::addr_t process_address,
size_t size, Error &error);
size_t size, Status &error);
void ReadPointerFromMemory(lldb::addr_t *address,
lldb::addr_t process_address, Error &error);
lldb::addr_t process_address, Status &error);
bool GetAllocSize(lldb::addr_t address, size_t &size);
void GetMemoryData(DataExtractor &extractor, lldb::addr_t process_address,
size_t size, Error &error);
size_t size, Status &error);
lldb::ByteOrder GetByteOrder();
uint32_t GetAddressByteSize();

2
include/lldb/Expression/LLVMUserExpression.h
View file

@ -81,7 +81,7 @@ protected:
lldb::ExpressionVariableSP &result) override;
virtual void ScanContext(ExecutionContext &exe_ctx,
lldb_private::Error &err) = 0;
lldb_private::Status &err) = 0;
bool PrepareToExecuteJITExpression(DiagnosticManager &diagnostic_manager,
ExecutionContext &exe_ctx,

20
include/lldb/Expression/Materializer.h
View file

@ -20,7 +20,7 @@
#include "lldb/Expression/IRMemoryMap.h"
#include "lldb/Symbol/TaggedASTType.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-private-types.h"
namespace lldb_private {
@ -38,7 +38,7 @@ public:
~Dematerializer() { Wipe(); }
void Dematerialize(Error &err, lldb::addr_t frame_top,
void Dematerialize(Status &err, lldb::addr_t frame_top,
lldb::addr_t frame_bottom);
void Wipe();
@ -72,7 +72,7 @@ public:
typedef std::weak_ptr<Dematerializer> DematerializerWP;
DematerializerSP Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
lldb::addr_t process_address, Error &err);
lldb::addr_t process_address, Status &err);
class PersistentVariableDelegate {
public:
@ -83,13 +83,13 @@ public:
uint32_t
AddPersistentVariable(lldb::ExpressionVariableSP &persistent_variable_sp,
PersistentVariableDelegate *delegate, Error &err);
uint32_t AddVariable(lldb::VariableSP &variable_sp, Error &err);
PersistentVariableDelegate *delegate, Status &err);
uint32_t AddVariable(lldb::VariableSP &variable_sp, Status &err);
uint32_t AddResultVariable(const CompilerType &type, bool is_lvalue,
bool keep_in_memory,
PersistentVariableDelegate *delegate, Error &err);
uint32_t AddSymbol(const Symbol &symbol_sp, Error &err);
uint32_t AddRegister(const RegisterInfo &register_info, Error &err);
PersistentVariableDelegate *delegate, Status &err);
uint32_t AddSymbol(const Symbol &symbol_sp, Status &err);
uint32_t AddRegister(const RegisterInfo &register_info, Status &err);
uint32_t GetStructAlignment() { return m_struct_alignment; }
@ -102,11 +102,11 @@ public:
virtual ~Entity() = default;
virtual void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
lldb::addr_t process_address, Error &err) = 0;
lldb::addr_t process_address, Status &err) = 0;
virtual void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
lldb::addr_t process_address,
lldb::addr_t frame_top,
lldb::addr_t frame_bottom, Error &err) = 0;
lldb::addr_t frame_bottom, Status &err) = 0;
virtual void DumpToLog(IRMemoryMap &map, lldb::addr_t process_address,
Log *log) = 0;
virtual void Wipe(IRMemoryMap &map, lldb::addr_t process_address) = 0;

6
include/lldb/Expression/REPL.h
View file

@ -60,7 +60,7 @@ public:
/// @return
/// The range of the containing object in the target process.
//------------------------------------------------------------------
static lldb::REPLSP Create(Error &Error, lldb::LanguageType language,
static lldb::REPLSP Create(Status &Status, lldb::LanguageType language,
Debugger *debugger, Target *target,
const char *repl_options);
@ -85,7 +85,7 @@ public:
lldb::IOHandlerSP GetIOHandler();
Error RunLoop();
Status RunLoop();
//------------------------------------------------------------------
// IOHandler::Delegate functions
@ -126,7 +126,7 @@ protected:
// Subclasses should override these functions to implement a functional REPL.
//----------------------------------------------------------------------
virtual Error DoInitialization() = 0;
virtual Status DoInitialization() = 0;
virtual ConstString GetSourceFileBasename() = 0;

8
include/lldb/Expression/UserExpression.h
View file

@ -259,13 +259,13 @@ public:
static lldb::ExpressionResults
Evaluate(ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options,
llvm::StringRef expr_cstr, llvm::StringRef expr_prefix,
lldb::ValueObjectSP &result_valobj_sp, Error &error,
lldb::ValueObjectSP &result_valobj_sp, Status &error,
uint32_t line_offset = 0, std::string *fixed_expression = nullptr,
lldb::ModuleSP *jit_module_sp_ptr = nullptr);
static const Error::ValueType kNoResult =
static const Status::ValueType kNoResult =
0x1001; ///< ValueObject::GetError() returns this if there is no result
///from the expression.
/// from the expression.
const char *GetFixedText() {
if (m_fixed_text.empty())
@ -281,7 +281,7 @@ protected:
lldb::ExpressionVariableSP &result) = 0;
static lldb::addr_t GetObjectPointer(lldb::StackFrameSP frame_sp,
ConstString &object_name, Error &err);
ConstString &object_name, Status &err);
//------------------------------------------------------------------
/// Populate m_in_cplusplus_method and m_in_objectivec_method based on the

2
include/lldb/Expression/UtilityFunction.h
View file

@ -123,7 +123,7 @@ public:
FunctionCaller *MakeFunctionCaller(const CompilerType &return_type,
const ValueList &arg_value_list,
lldb::ThreadSP compilation_thread,
Error &error);
Status &error);
// This one retrieves the function caller that is already made. If you
// haven't made it yet, this returns nullptr

42
include/lldb/Host/File.h
View file

@ -12,7 +12,7 @@
#include "lldb/Host/IOObject.h"
#include "lldb/Host/PosixApi.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-private.h"
#include <stdarg.h>
@ -164,7 +164,7 @@ public:
/// @return
/// A reference to the file specification object.
//------------------------------------------------------------------
Error GetFileSpec(FileSpec &file_spec) const;
Status GetFileSpec(FileSpec &file_spec) const;
//------------------------------------------------------------------
/// Open a file for read/writing with the specified options.
@ -181,10 +181,10 @@ public:
/// @param[in] permissions
/// Options to use when opening (see File::Permissions)
//------------------------------------------------------------------
Error Open(const char *path, uint32_t options,
uint32_t permissions = lldb::eFilePermissionsFileDefault);
Status Open(const char *path, uint32_t options,
uint32_t permissions = lldb::eFilePermissionsFileDefault);
Error Close() override;
Status Close() override;
void Clear();
@ -216,7 +216,7 @@ public:
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
Error Read(void *buf, size_t &num_bytes) override;
Status Read(void *buf, size_t &num_bytes) override;
//------------------------------------------------------------------
/// Write bytes to a file at the current file position.
@ -237,7 +237,7 @@ public:
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
Error Write(const void *buf, size_t &num_bytes) override;
Status Write(const void *buf, size_t &num_bytes) override;
//------------------------------------------------------------------
/// Seek to an offset relative to the beginning of the file.
@ -253,13 +253,13 @@ public:
/// beginning of the file.
///
/// @param[in] error_ptr
/// A pointer to a lldb_private::Error object that will be
/// A pointer to a lldb_private::Status object that will be
/// filled in if non-nullptr.
///
/// @return
/// The resulting seek offset, or -1 on error.
//------------------------------------------------------------------
off_t SeekFromStart(off_t offset, Error *error_ptr = nullptr);
off_t SeekFromStart(off_t offset, Status *error_ptr = nullptr);
//------------------------------------------------------------------
/// Seek to an offset relative to the current file position.
@ -275,13 +275,13 @@ public:
/// current file position.
///
/// @param[in] error_ptr
/// A pointer to a lldb_private::Error object that will be
/// A pointer to a lldb_private::Status object that will be
/// filled in if non-nullptr.
///
/// @return
/// The resulting seek offset, or -1 on error.
//------------------------------------------------------------------
off_t SeekFromCurrent(off_t offset, Error *error_ptr = nullptr);
off_t SeekFromCurrent(off_t offset, Status *error_ptr = nullptr);
//------------------------------------------------------------------
/// Seek to an offset relative to the end of the file.
@ -298,13 +298,13 @@ public:
/// absolute file offset.
///
/// @param[in] error_ptr
/// A pointer to a lldb_private::Error object that will be
/// A pointer to a lldb_private::Status object that will be
/// filled in if non-nullptr.
///
/// @return
/// The resulting seek offset, or -1 on error.
//------------------------------------------------------------------
off_t SeekFromEnd(off_t offset, Error *error_ptr = nullptr);
off_t SeekFromEnd(off_t offset, Status *error_ptr = nullptr);
//------------------------------------------------------------------
/// Read bytes from a file from the specified file offset.
@ -329,7 +329,7 @@ public:
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
Error Read(void *dst, size_t &num_bytes, off_t &offset);
Status Read(void *dst, size_t &num_bytes, off_t &offset);
//------------------------------------------------------------------
/// Read bytes from a file from the specified file offset.
@ -360,8 +360,8 @@ public:
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
Error Read(size_t &num_bytes, off_t &offset, bool null_terminate,
lldb::DataBufferSP &data_buffer_sp);
Status Read(size_t &num_bytes, off_t &offset, bool null_terminate,
lldb::DataBufferSP &data_buffer_sp);
//------------------------------------------------------------------
/// Write bytes to a file at the specified file offset.
@ -388,7 +388,7 @@ public:
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
Error Write(const void *src, size_t &num_bytes, off_t &offset);
Status Write(const void *src, size_t &num_bytes, off_t &offset);
//------------------------------------------------------------------
/// Flush the current stream
@ -397,7 +397,7 @@ public:
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
Error Flush();
Status Flush();
//------------------------------------------------------------------
/// Sync to disk.
@ -406,7 +406,7 @@ public:
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
Error Sync();
Status Sync();
//------------------------------------------------------------------
/// Get the permissions for a this file.
@ -415,9 +415,9 @@ public:
/// Bits logical OR'ed together from the permission bits defined
/// in lldb_private::File::Permissions.
//------------------------------------------------------------------
uint32_t GetPermissions(Error &error) const;
uint32_t GetPermissions(Status &error) const;
static uint32_t GetPermissions(const FileSpec &file_spec, Error &error);
static uint32_t GetPermissions(const FileSpec &file_spec, Status &error);
//------------------------------------------------------------------
/// Return true if this file is interactive.

10
include/lldb/Host/FileCache.h
View file

@ -15,8 +15,8 @@
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h"
namespace lldb_private {
class FileCache {
@ -29,13 +29,13 @@ public:
static FileCache &GetInstance();
lldb::user_id_t OpenFile(const FileSpec &file_spec, uint32_t flags,
uint32_t mode, Error &error);
bool CloseFile(lldb::user_id_t fd, Error &error);
uint32_t mode, Status &error);
bool CloseFile(lldb::user_id_t fd, Status &error);
uint64_t WriteFile(lldb::user_id_t fd, uint64_t offset, const void *src,
uint64_t src_len, Error &error);
uint64_t src_len, Status &error);
uint64_t ReadFile(lldb::user_id_t fd, uint64_t offset, void *dst,
uint64_t dst_len, Error &error);
uint64_t dst_len, Status &error);
private:
static FileCache *m_instance;

8
include/lldb/Host/FileSystem.h
View file

@ -10,8 +10,8 @@
#ifndef liblldb_Host_FileSystem_h
#define liblldb_Host_FileSystem_h
#include "lldb/Utility/Error.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h"
#include "llvm/Support/Chrono.h"
#include "lldb/lldb-types.h"
@ -26,10 +26,10 @@ public:
static const char *DEV_NULL;
static const char *PATH_CONVERSION_ERROR;
static Error Symlink(const FileSpec &src, const FileSpec &dst);
static Error Readlink(const FileSpec &src, FileSpec &dst);
static Status Symlink(const FileSpec &src, const FileSpec &dst);
static Status Readlink(const FileSpec &src, FileSpec &dst);
static Error ResolveSymbolicLink(const FileSpec &src, FileSpec &dst);
static Status ResolveSymbolicLink(const FileSpec &src, FileSpec &dst);
/// Wraps ::fopen in a platform-independent way. Once opened, FILEs can be
/// manipulated and closed with the normal ::fread, ::fclose, etc. functions.

16
include/lldb/Host/Host.h
View file

@ -190,19 +190,19 @@ public:
static short GetPosixspawnFlags(const ProcessLaunchInfo &launch_info);
static Error LaunchProcessPosixSpawn(const char *exe_path,
const ProcessLaunchInfo &launch_info,
lldb::pid_t &pid);
static Status LaunchProcessPosixSpawn(const char *exe_path,
const ProcessLaunchInfo &launch_info,
lldb::pid_t &pid);
static bool AddPosixSpawnFileAction(void *file_actions,
const FileAction *info, Log *log,
Error &error);
Status &error);
#endif
static const lldb::UnixSignalsSP &GetUnixSignals();
static Error LaunchProcess(ProcessLaunchInfo &launch_info);
static Status LaunchProcess(ProcessLaunchInfo &launch_info);
//------------------------------------------------------------------
/// Perform expansion of the command-line for this launch info
@ -211,10 +211,10 @@ public:
// argument magic the platform defines as part of its typical
// user experience
//------------------------------------------------------------------
static Error ShellExpandArguments(ProcessLaunchInfo &launch_info);
static Status ShellExpandArguments(ProcessLaunchInfo &launch_info);
// TODO: Convert this function to take a StringRef.
static Error RunShellCommand(
static Status RunShellCommand(
const char *command, // Shouldn't be NULL
const FileSpec &working_dir, // Pass empty FileSpec to use the current
// working directory
@ -226,7 +226,7 @@ public:
uint32_t timeout_sec,
bool run_in_default_shell = true);
static Error RunShellCommand(
static Status RunShellCommand(
const Args &args,
const FileSpec &working_dir, // Pass empty FileSpec to use the current
// working directory

6
include/lldb/Host/HostNativeProcessBase.h
View file

@ -11,7 +11,7 @@
#define lldb_Host_HostNativeProcessBase_h_
#include "lldb/Host/HostProcess.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-types.h"
@ -28,8 +28,8 @@ public:
: m_process(process) {}
virtual ~HostNativeProcessBase() {}
virtual Error Terminate() = 0;
virtual Error GetMainModule(FileSpec &file_spec) const = 0;
virtual Status Terminate() = 0;
virtual Status GetMainModule(FileSpec &file_spec) const = 0;
virtual lldb::pid_t GetProcessId() const = 0;
virtual bool IsRunning() const = 0;

6
include/lldb/Host/HostNativeThreadBase.h
View file

@ -10,7 +10,7 @@
#ifndef lldb_Host_HostNativeThreadBase_h_
#define lldb_Host_HostNativeThreadBase_h_
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-types.h"
@ -31,8 +31,8 @@ public:
explicit HostNativeThreadBase(lldb::thread_t thread);
virtual ~HostNativeThreadBase() {}
virtual Error Join(lldb::thread_result_t *result) = 0;
virtual Error Cancel() = 0;
virtual Status Join(lldb::thread_result_t *result) = 0;
virtual Status Cancel() = 0;
virtual bool IsJoinable() const;
virtual void Reset();
lldb::thread_t Release();

4
include/lldb/Host/HostProcess.h
View file

@ -40,8 +40,8 @@ public:
HostProcess(lldb::process_t process);
~HostProcess();
Error Terminate();
Error GetMainModule(FileSpec &file_spec) const;
Status Terminate();
Status GetMainModule(FileSpec &file_spec) const;
lldb::pid_t GetProcessId() const;
bool IsRunning() const;

6
include/lldb/Host/HostThread.h
View file

@ -11,7 +11,7 @@
#define lldb_Host_HostThread_h_
#include "lldb/Host/HostNativeThreadForward.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-types.h"
#include <memory>
@ -34,8 +34,8 @@ public:
HostThread();
HostThread(lldb::thread_t thread);
Error Join(lldb::thread_result_t *result);
Error Cancel();
Status Join(lldb::thread_result_t *result);
Status Cancel();
void Reset();
lldb::thread_t Release();

6
include/lldb/Host/IOObject.h
View file

@ -34,10 +34,10 @@ public:
: m_fd_type(type), m_should_close_fd(should_close) {}
virtual ~IOObject() {}
virtual Error Read(void *buf, size_t &num_bytes) = 0;
virtual Error Write(const void *buf, size_t &num_bytes) = 0;
virtual Status Read(void *buf, size_t &num_bytes) = 0;
virtual Status Write(const void *buf, size_t &num_bytes) = 0;
virtual bool IsValid() const = 0;
virtual Error Close() = 0;
virtual Status Close() = 0;
FDType GetFdType() const { return m_fd_type; }

26
include/lldb/Host/LockFileBase.h
View file

@ -10,7 +10,7 @@
#ifndef liblldb_Host_LockFileBase_h_
#define liblldb_Host_LockFileBase_h_
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include <functional>
@ -22,30 +22,30 @@ public:
bool IsLocked() const;
Error WriteLock(const uint64_t start, const uint64_t len);
Error TryWriteLock(const uint64_t start, const uint64_t len);
Status WriteLock(const uint64_t start, const uint64_t len);
Status TryWriteLock(const uint64_t start, const uint64_t len);
Error ReadLock(const uint64_t start, const uint64_t len);
Error TryReadLock(const uint64_t start, const uint64_t len);
Status ReadLock(const uint64_t start, const uint64_t len);
Status TryReadLock(const uint64_t start, const uint64_t len);
Error Unlock();
Status Unlock();
protected:
using Locker = std::function<Error(const uint64_t, const uint64_t)>;
using Locker = std::function<Status(const uint64_t, const uint64_t)>;
LockFileBase(int fd);
virtual bool IsValidFile() const;
virtual Error DoWriteLock(const uint64_t start, const uint64_t len) = 0;
virtual Error DoTryWriteLock(const uint64_t start, const uint64_t len) = 0;
virtual Status DoWriteLock(const uint64_t start, const uint64_t len) = 0;
virtual Status DoTryWriteLock(const uint64_t start, const uint64_t len) = 0;
virtual Error DoReadLock(const uint64_t start, const uint64_t len) = 0;
virtual Error DoTryReadLock(const uint64_t start, const uint64_t len) = 0;
virtual Status DoReadLock(const uint64_t start, const uint64_t len) = 0;
virtual Status DoTryReadLock(const uint64_t start, const uint64_t len) = 0;
virtual Error DoUnlock() = 0;
virtual Status DoUnlock() = 0;
Error DoLock(const Locker &locker, const uint64_t start, const uint64_t len);
Status DoLock(const Locker &locker, const uint64_t start, const uint64_t len);
int m_fd; // not owned.
bool m_locked;

6
include/lldb/Host/MainLoop.h
View file

@ -47,7 +47,7 @@ public:
ReadHandleUP RegisterReadObject(const lldb::IOObjectSP &object_sp,
const Callback &callback,
Error &error) override;
Status &error) override;
// Listening for signals from multiple MainLoop instances is perfectly safe as
// long as they don't try to listen for the same signal. The callback function
@ -57,9 +57,9 @@ public:
// However, since the callback is not invoked synchronously, you cannot use
// this mechanism to handle SIGSEGV and the like.
SignalHandleUP RegisterSignal(int signo, const Callback &callback,
Error &error);
Status &error);
Error Run() override;
Status Run() override;
// This should only be performed from a callback. Do not attempt to terminate
// the processing from another thread.

6
include/lldb/Host/MainLoopBase.h
View file

@ -15,7 +15,7 @@
#include "llvm/Support/ErrorHandling.h"
#include "lldb/Host/IOObject.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
namespace lldb_private {
@ -49,14 +49,14 @@ public:
virtual ReadHandleUP RegisterReadObject(const lldb::IOObjectSP &object_sp,
const Callback &callback,
Error &error) {
Status &error) {
llvm_unreachable("Not implemented");
}
// Waits for registered events and invoke the proper callbacks. Returns when
// all callbacks
// deregister themselves or when someone requests termination.
virtual Error Run() { llvm_unreachable("Not implemented"); }
virtual Status Run() { llvm_unreachable("Not implemented"); }
// Requests the exit of the Run() function.
virtual void RequestTermination() { llvm_unreachable("Not implemented"); }

2
include/lldb/Host/MonitoringProcessLauncher.h
View file

@ -25,7 +25,7 @@ public:
std::unique_ptr<ProcessLauncher> delegate_launcher);
HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info,
Error &error) override;
Status &error) override;
private:
std::unique_ptr<ProcessLauncher> m_delegate_launcher;

33
include/lldb/Host/PipeBase.h
View file

@ -14,7 +14,7 @@
#include <chrono>
#include <string>
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
@ -23,17 +23,18 @@ class PipeBase {
public:
virtual ~PipeBase();
virtual Error CreateNew(bool child_process_inherit) = 0;
virtual Error CreateNew(llvm::StringRef name, bool child_process_inherit) = 0;
virtual Error CreateWithUniqueName(llvm::StringRef prefix,
bool child_process_inherit,
llvm::SmallVectorImpl<char> &name) = 0;
virtual Status CreateNew(bool child_process_inherit) = 0;
virtual Status CreateNew(llvm::StringRef name,
bool child_process_inherit) = 0;
virtual Status CreateWithUniqueName(llvm::StringRef prefix,
bool child_process_inherit,
llvm::SmallVectorImpl<char> &name) = 0;
virtual Error OpenAsReader(llvm::StringRef name,
bool child_process_inherit) = 0;
virtual Status OpenAsReader(llvm::StringRef name,
bool child_process_inherit) = 0;
Error OpenAsWriter(llvm::StringRef name, bool child_process_inherit);
virtual Error
Status OpenAsWriter(llvm::StringRef name, bool child_process_inherit);
virtual Status
OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inherit,
const std::chrono::microseconds &timeout) = 0;
@ -51,13 +52,13 @@ public:
virtual void Close() = 0;
// Delete named pipe.
virtual Error Delete(llvm::StringRef name) = 0;
virtual Status Delete(llvm::StringRef name) = 0;
virtual Error Write(const void *buf, size_t size, size_t &bytes_written) = 0;
virtual Error ReadWithTimeout(void *buf, size_t size,
const std::chrono::microseconds &timeout,
size_t &bytes_read) = 0;
Error Read(void *buf, size_t size, size_t &bytes_read);
virtual Status Write(const void *buf, size_t size, size_t &bytes_written) = 0;
virtual Status ReadWithTimeout(void *buf, size_t size,
const std::chrono::microseconds &timeout,
size_t &bytes_read) = 0;
Status Read(void *buf, size_t size, size_t &bytes_read);
};
}

4
include/lldb/Host/ProcessLauncher.h
View file

@ -13,14 +13,14 @@
namespace lldb_private {
class ProcessLaunchInfo;
class Error;
class Status;
class HostProcess;
class ProcessLauncher {
public:
virtual ~ProcessLauncher() {}
virtual HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info,
Error &error) = 0;
Status &error) = 0;
};
}

57
include/lldb/Host/Socket.h
View file

@ -18,7 +18,7 @@
#include "lldb/Host/IOObject.h"
#include "lldb/Host/Predicate.h"
#include "lldb/Host/SocketAddress.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#ifdef _WIN32
#include "lldb/Host/windows/windows.h"
@ -53,34 +53,35 @@ public:
static std::unique_ptr<Socket> Create(const SocketProtocol protocol,
bool child_processes_inherit,
Error &error);
Status &error);
virtual Error Connect(llvm::StringRef name) = 0;
virtual Error Listen(llvm::StringRef name, int backlog) = 0;
virtual Error Accept(Socket *&socket) = 0;
virtual Status Connect(llvm::StringRef name) = 0;
virtual Status Listen(llvm::StringRef name, int backlog) = 0;
virtual Status Accept(Socket *&socket) = 0;
// Initialize a Tcp Socket object in listening mode. listen and accept are
// implemented
// separately because the caller may wish to manipulate or query the socket
// after it is
// initialized, but before entering a blocking accept.
static Error TcpListen(llvm::StringRef host_and_port,
bool child_processes_inherit, Socket *&socket,
Predicate<uint16_t> *predicate, int backlog = 5);
static Error TcpConnect(llvm::StringRef host_and_port,
bool child_processes_inherit, Socket *&socket);
static Error UdpConnect(llvm::StringRef host_and_port,
bool child_processes_inherit, Socket *&socket);
static Error UnixDomainConnect(llvm::StringRef host_and_port,
bool child_processes_inherit, Socket *&socket);
static Error UnixDomainAccept(llvm::StringRef host_and_port,
bool child_processes_inherit, Socket *&socket);
static Error UnixAbstractConnect(llvm::StringRef host_and_port,
bool child_processes_inherit,
Socket *&socket);
static Error UnixAbstractAccept(llvm::StringRef host_and_port,
static Status TcpListen(llvm::StringRef host_and_port,
bool child_processes_inherit, Socket *&socket,
Predicate<uint16_t> *predicate, int backlog = 5);
static Status TcpConnect(llvm::StringRef host_and_port,
bool child_processes_inherit, Socket *&socket);
static Status UdpConnect(llvm::StringRef host_and_port,
bool child_processes_inherit, Socket *&socket);
static Status UnixDomainConnect(llvm::StringRef host_and_port,
bool child_processes_inherit,
Socket *&socket);
static Status UnixDomainAccept(llvm::StringRef host_and_port,
bool child_processes_inherit, Socket *&socket);
static Status UnixAbstractConnect(llvm::StringRef host_and_port,
bool child_processes_inherit,
Socket *&socket);
static Status UnixAbstractAccept(llvm::StringRef host_and_port,
bool child_processes_inherit,
Socket *&socket);
int GetOption(int level, int option_name, int &option_value);
int SetOption(int level, int option_name, int option_value);
@ -88,18 +89,18 @@ public:
NativeSocket GetNativeSocket() const { return m_socket; }
SocketProtocol GetSocketProtocol() const { return m_protocol; }
Error Read(void *buf, size_t &num_bytes) override;
Error Write(const void *buf, size_t &num_bytes) override;
Status Read(void *buf, size_t &num_bytes) override;
Status Write(const void *buf, size_t &num_bytes) override;
virtual Error PreDisconnect();
Error Close() override;
virtual Status PreDisconnect();
Status Close() override;
bool IsValid() const override { return m_socket != kInvalidSocketValue; }
WaitableHandle GetWaitableHandle() override;
static bool DecodeHostAndPort(llvm::StringRef host_and_port,
std::string &host_str, std::string &port_str,
int32_t &port, Error *error_ptr);
int32_t &port, Status *error_ptr);
protected:
Socket(SocketProtocol protocol, bool should_close,
@ -107,13 +108,13 @@ protected:
virtual size_t Send(const void *buf, const size_t num_bytes);
static void SetLastError(Error &error);
static void SetLastError(Status &error);
static NativeSocket CreateSocket(const int domain, const int type,
const int protocol,
bool child_processes_inherit, Error &error);
bool child_processes_inherit, Status &error);
static NativeSocket AcceptSocket(NativeSocket sockfd, struct sockaddr *addr,
socklen_t *addrlen,
bool child_processes_inherit, Error &error);
bool child_processes_inherit, Status &error);
SocketProtocol m_protocol;
NativeSocket m_socket;

4
include/lldb/Host/ThreadLauncher.h
View file

@ -12,7 +12,7 @@
#define lldb_Host_ThreadLauncher_h_
#include "lldb/Host/HostThread.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-types.h"
#include "llvm/ADT/StringRef.h"
@ -23,7 +23,7 @@ class ThreadLauncher {
public:
static HostThread
LaunchThread(llvm::StringRef name, lldb::thread_func_t thread_function,
lldb::thread_arg_t thread_arg, Error *error_ptr,
lldb::thread_arg_t thread_arg, Status *error_ptr,
size_t min_stack_byte_size = 0); // Minimum stack size in bytes,
// set stack size to zero for
// default platform thread stack

8
include/lldb/Host/common/NativeBreakpoint.h
View file

@ -24,9 +24,9 @@ public:
virtual ~NativeBreakpoint();
Error Enable();
Status Enable();
Error Disable();
Status Disable();
lldb::addr_t GetAddress() const { return m_addr; }
@ -38,9 +38,9 @@ protected:
const lldb::addr_t m_addr;
int32_t m_ref_count;
virtual Error DoEnable() = 0;
virtual Status DoEnable() = 0;
virtual Error DoDisable() = 0;
virtual Status DoDisable() = 0;
private:
bool m_enabled;

21
include/lldb/Host/common/NativeBreakpointList.h
View file

@ -10,7 +10,7 @@
#ifndef liblldb_NativeBreakpointList_h_
#define liblldb_NativeBreakpointList_h_
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-private-forward.h"
// #include "lldb/Host/NativeBreakpoint.h"
@ -29,24 +29,25 @@ using HardwareBreakpointMap = std::map<lldb::addr_t, HardwareBreakpoint>;
class NativeBreakpointList {
public:
typedef std::function<Error(lldb::addr_t addr, size_t size_hint,
bool hardware, NativeBreakpointSP &breakpoint_sp)>
typedef std::function<Status(lldb::addr_t addr, size_t size_hint,
bool hardware,
NativeBreakpointSP &breakpoint_sp)>
CreateBreakpointFunc;
NativeBreakpointList();
Error AddRef(lldb::addr_t addr, size_t size_hint, bool hardware,
CreateBreakpointFunc create_func);
Status AddRef(lldb::addr_t addr, size_t size_hint, bool hardware,
CreateBreakpointFunc create_func);
Error DecRef(lldb::addr_t addr);
Status DecRef(lldb::addr_t addr);
Error EnableBreakpoint(lldb::addr_t addr);
Status EnableBreakpoint(lldb::addr_t addr);
Error DisableBreakpoint(lldb::addr_t addr);
Status DisableBreakpoint(lldb::addr_t addr);
Error GetBreakpoint(lldb::addr_t addr, NativeBreakpointSP &breakpoint_sp);
Status GetBreakpoint(lldb::addr_t addr, NativeBreakpointSP &breakpoint_sp);
Error RemoveTrapsFromBuffer(lldb::addr_t addr, void *buf, size_t size) const;
Status RemoveTrapsFromBuffer(lldb::addr_t addr, void *buf, size_t size) const;
private:
typedef std::map<lldb::addr_t, NativeBreakpointSP> BreakpointMap;

82
include/lldb/Host/common/NativeProcessProtocol.h
View file

@ -11,7 +11,7 @@
#define liblldb_NativeProcessProtocol_h_
#include "lldb/Host/MainLoop.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-private-forward.h"
#include "lldb/lldb-types.h"
#include "llvm/ADT/ArrayRef.h"
@ -37,11 +37,11 @@ class NativeProcessProtocol
public:
virtual ~NativeProcessProtocol() {}
virtual Error Resume(const ResumeActionList &resume_actions) = 0;
virtual Status Resume(const ResumeActionList &resume_actions) = 0;
virtual Error Halt() = 0;
virtual Status Halt() = 0;
virtual Error Detach() = 0;
virtual Status Detach() = 0;
//------------------------------------------------------------------
/// Sends a process a UNIX signal \a signal.
@ -49,7 +49,7 @@ public:
/// @return
/// Returns an error object.
//------------------------------------------------------------------
virtual Error Signal(int signo) = 0;
virtual Status Signal(int signo) = 0;
//------------------------------------------------------------------
/// Tells a process to interrupt all operations as if by a Ctrl-C.
@ -61,36 +61,36 @@ public:
/// @return
/// Returns an error object.
//------------------------------------------------------------------
virtual Error Interrupt();
virtual Status Interrupt();
virtual Error Kill() = 0;
virtual Status Kill() = 0;
//------------------------------------------------------------------
// Tells a process not to stop the inferior on given signals
// and just reinject them back.
//------------------------------------------------------------------
virtual Error IgnoreSignals(llvm::ArrayRef<int> signals);
virtual Status IgnoreSignals(llvm::ArrayRef<int> signals);
//----------------------------------------------------------------------
// Memory and memory region functions
//----------------------------------------------------------------------
virtual Error GetMemoryRegionInfo(lldb::addr_t load_addr,
MemoryRegionInfo &range_info);
virtual Status GetMemoryRegionInfo(lldb::addr_t load_addr,
MemoryRegionInfo &range_info);
virtual Error ReadMemory(lldb::addr_t addr, void *buf, size_t size,
size_t &bytes_read) = 0;
virtual Status ReadMemory(lldb::addr_t addr, void *buf, size_t size,
size_t &bytes_read) = 0;
virtual Error ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf, size_t size,
size_t &bytes_read) = 0;
virtual Status ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf,
size_t size, size_t &bytes_read) = 0;
virtual Error WriteMemory(lldb::addr_t addr, const void *buf, size_t size,
size_t &bytes_written) = 0;
virtual Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size,
size_t &bytes_written) = 0;
virtual Error AllocateMemory(size_t size, uint32_t permissions,
lldb::addr_t &addr) = 0;
virtual Status AllocateMemory(size_t size, uint32_t permissions,
lldb::addr_t &addr) = 0;
virtual Error DeallocateMemory(lldb::addr_t addr) = 0;
virtual Status DeallocateMemory(lldb::addr_t addr) = 0;
virtual lldb::addr_t GetSharedLibraryInfoAddress() = 0;
@ -103,23 +103,23 @@ public:
//----------------------------------------------------------------------
// Breakpoint functions
//----------------------------------------------------------------------
virtual Error SetBreakpoint(lldb::addr_t addr, uint32_t size,
bool hardware) = 0;
virtual Status SetBreakpoint(lldb::addr_t addr, uint32_t size,
bool hardware) = 0;
virtual Error RemoveBreakpoint(lldb::addr_t addr, bool hardware = false);
virtual Status RemoveBreakpoint(lldb::addr_t addr, bool hardware = false);
virtual Error EnableBreakpoint(lldb::addr_t addr);
virtual Status EnableBreakpoint(lldb::addr_t addr);
virtual Error DisableBreakpoint(lldb::addr_t addr);
virtual Status DisableBreakpoint(lldb::addr_t addr);
//----------------------------------------------------------------------
// Hardware Breakpoint functions
//----------------------------------------------------------------------
virtual const HardwareBreakpointMap &GetHardwareBreakpointMap() const;
virtual Error SetHardwareBreakpoint(lldb::addr_t addr, size_t size);
virtual Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size);
virtual Error RemoveHardwareBreakpoint(lldb::addr_t addr);
virtual Status RemoveHardwareBreakpoint(lldb::addr_t addr);
//----------------------------------------------------------------------
// Watchpoint functions
@ -129,10 +129,10 @@ public:
virtual llvm::Optional<std::pair<uint32_t, uint32_t>>
GetHardwareDebugSupportInfo() const;
virtual Error SetWatchpoint(lldb::addr_t addr, size_t size,
uint32_t watch_flags, bool hardware);
virtual Status SetWatchpoint(lldb::addr_t addr, size_t size,
uint32_t watch_flags, bool hardware);
virtual Error RemoveWatchpoint(lldb::addr_t addr);
virtual Status RemoveWatchpoint(lldb::addr_t addr);
//----------------------------------------------------------------------
// Accessors
@ -239,11 +239,11 @@ public:
//------------------------------------------------------------------
bool UnregisterNativeDelegate(NativeDelegate &native_delegate);
virtual Error GetLoadedModuleFileSpec(const char *module_path,
FileSpec &file_spec) = 0;
virtual Status GetLoadedModuleFileSpec(const char *module_path,
FileSpec &file_spec) = 0;
virtual Error GetFileLoadAddress(const llvm::StringRef &file_name,
lldb::addr_t &load_addr) = 0;
virtual Status GetFileLoadAddress(const llvm::StringRef &file_name,
lldb::addr_t &load_addr) = 0;
//------------------------------------------------------------------
/// Launch a process for debugging. This method will create an concrete
@ -273,9 +273,9 @@ public:
/// An error object indicating if the operation succeeded,
/// and if not, what error occurred.
//------------------------------------------------------------------
static Error Launch(ProcessLaunchInfo &launch_info,
NativeDelegate &native_delegate, MainLoop &mainloop,
NativeProcessProtocolSP &process_sp);
static Status Launch(ProcessLaunchInfo &launch_info,
NativeDelegate &native_delegate, MainLoop &mainloop,
NativeProcessProtocolSP &process_sp);
//------------------------------------------------------------------
/// Attach to an existing process. This method will create an concrete
@ -305,8 +305,8 @@ public:
/// An error object indicating if the operation succeeded,
/// and if not, what error occurred.
//------------------------------------------------------------------
static Error Attach(lldb::pid_t pid, NativeDelegate &native_delegate,
MainLoop &mainloop, NativeProcessProtocolSP &process_sp);
static Status Attach(lldb::pid_t pid, NativeDelegate &native_delegate,
MainLoop &mainloop, NativeProcessProtocolSP &process_sp);
protected:
lldb::pid_t m_pid;
@ -356,9 +356,9 @@ protected:
// -----------------------------------------------------------
// Internal interface for software breakpoints
// -----------------------------------------------------------
Error SetSoftwareBreakpoint(lldb::addr_t addr, uint32_t size_hint);
Status SetSoftwareBreakpoint(lldb::addr_t addr, uint32_t size_hint);
virtual Error
virtual Status
GetSoftwareBreakpointTrapOpcode(size_t trap_opcode_size_hint,
size_t &actual_opcode_size,
const uint8_t *&trap_opcode_bytes) = 0;
@ -376,7 +376,7 @@ protected:
// -----------------------------------------------------------
// Static helper methods for derived classes.
// -----------------------------------------------------------
static Error ResolveProcessArchitecture(lldb::pid_t pid, ArchSpec &arch);
static Status ResolveProcessArchitecture(lldb::pid_t pid, ArchSpec &arch);
private:
void SynchronouslyNotifyProcessStateChanged(lldb::StateType state);

42
include/lldb/Host/common/NativeRegisterContext.h
View file

@ -53,15 +53,15 @@ public:
virtual const RegisterSet *GetRegisterSet(uint32_t set_index) const = 0;
virtual Error ReadRegister(const RegisterInfo *reg_info,
RegisterValue &reg_value) = 0;
virtual Status ReadRegister(const RegisterInfo *reg_info,
RegisterValue &reg_value) = 0;
virtual Error WriteRegister(const RegisterInfo *reg_info,
const RegisterValue &reg_value) = 0;
virtual Status WriteRegister(const RegisterInfo *reg_info,
const RegisterValue &reg_value) = 0;
virtual Error ReadAllRegisterValues(lldb::DataBufferSP &data_sp) = 0;
virtual Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) = 0;
virtual Error WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) = 0;
virtual Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) = 0;
uint32_t ConvertRegisterKindToRegisterNumber(uint32_t kind,
uint32_t num) const;
@ -75,10 +75,10 @@ public:
virtual bool ClearHardwareBreakpoint(uint32_t hw_idx);
virtual Error ClearAllHardwareBreakpoints();
virtual Status ClearAllHardwareBreakpoints();
virtual Error GetHardwareBreakHitIndex(uint32_t &bp_index,
lldb::addr_t trap_addr);
virtual Status GetHardwareBreakHitIndex(uint32_t &bp_index,
lldb::addr_t trap_addr);
virtual uint32_t NumSupportedHardwareWatchpoints();
@ -87,14 +87,14 @@ public:
virtual bool ClearHardwareWatchpoint(uint32_t hw_index);
virtual Error ClearAllHardwareWatchpoints();
virtual Status ClearAllHardwareWatchpoints();
virtual Error IsWatchpointHit(uint32_t wp_index, bool &is_hit);
virtual Status IsWatchpointHit(uint32_t wp_index, bool &is_hit);
virtual Error GetWatchpointHitIndex(uint32_t &wp_index,
lldb::addr_t trap_addr);
virtual Status GetWatchpointHitIndex(uint32_t &wp_index,
lldb::addr_t trap_addr);
virtual Error IsWatchpointVacant(uint32_t wp_index, bool &is_vacant);
virtual Status IsWatchpointVacant(uint32_t wp_index, bool &is_vacant);
virtual lldb::addr_t GetWatchpointAddress(uint32_t wp_index);
@ -114,12 +114,12 @@ public:
virtual bool HardwareSingleStep(bool enable);
virtual Error
virtual Status
ReadRegisterValueFromMemory(const lldb_private::RegisterInfo *reg_info,
lldb::addr_t src_addr, size_t src_len,
RegisterValue &reg_value);
virtual Error
virtual Status
WriteRegisterValueToMemory(const lldb_private::RegisterInfo *reg_info,
lldb::addr_t dst_addr, size_t dst_len,
const RegisterValue &reg_value);
@ -141,15 +141,15 @@ public:
virtual lldb::addr_t
GetPCfromBreakpointLocation(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS);
Error SetPC(lldb::addr_t pc);
Status SetPC(lldb::addr_t pc);
lldb::addr_t GetSP(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS);
Error SetSP(lldb::addr_t sp);
Status SetSP(lldb::addr_t sp);
lldb::addr_t GetFP(lldb::addr_t fail_value = LLDB_INVALID_ADDRESS);
Error SetFP(lldb::addr_t fp);
Status SetFP(lldb::addr_t fp);
const char *GetRegisterName(uint32_t reg);
@ -162,9 +162,9 @@ public:
lldb::addr_t ReadRegisterAsUnsigned(const RegisterInfo *reg_info,
lldb::addr_t fail_value);
Error WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval);
Status WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval);
Error WriteRegisterFromUnsigned(const RegisterInfo *reg_info, uint64_t uval);
Status WriteRegisterFromUnsigned(const RegisterInfo *reg_info, uint64_t uval);
// uint32_t
// GetStopID () const

18
include/lldb/Host/common/NativeThreadProtocol.h
View file

@ -33,13 +33,13 @@ public:
virtual NativeRegisterContextSP GetRegisterContext() = 0;
virtual Error ReadRegister(uint32_t reg, RegisterValue &reg_value);
virtual Status ReadRegister(uint32_t reg, RegisterValue &reg_value);
virtual Error WriteRegister(uint32_t reg, const RegisterValue &reg_value);
virtual Status WriteRegister(uint32_t reg, const RegisterValue &reg_value);
virtual Error SaveAllRegisters(lldb::DataBufferSP &data_sp);
virtual Status SaveAllRegisters(lldb::DataBufferSP &data_sp);
virtual Error RestoreAllRegisters(lldb::DataBufferSP &data_sp);
virtual Status RestoreAllRegisters(lldb::DataBufferSP &data_sp);
virtual bool GetStopReason(ThreadStopInfo &stop_info,
std::string &description) = 0;
@ -51,17 +51,17 @@ public:
// ---------------------------------------------------------------------
// Thread-specific watchpoints
// ---------------------------------------------------------------------
virtual Error SetWatchpoint(lldb::addr_t addr, size_t size,
uint32_t watch_flags, bool hardware) = 0;
virtual Status SetWatchpoint(lldb::addr_t addr, size_t size,
uint32_t watch_flags, bool hardware) = 0;
virtual Error RemoveWatchpoint(lldb::addr_t addr) = 0;
virtual Status RemoveWatchpoint(lldb::addr_t addr) = 0;
// ---------------------------------------------------------------------
// Thread-specific Hardware Breakpoint routines
// ---------------------------------------------------------------------
virtual Error SetHardwareBreakpoint(lldb::addr_t addr, size_t size) = 0;
virtual Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size) = 0;
virtual Error RemoveHardwareBreakpoint(lldb::addr_t addr) = 0;
virtual Status RemoveHardwareBreakpoint(lldb::addr_t addr) = 0;
protected:
NativeProcessProtocolWP m_process_wp;

8
include/lldb/Host/common/NativeWatchpointList.h
View file

@ -10,7 +10,7 @@
#ifndef liblldb_NativeWatchpointList_h_
#define liblldb_NativeWatchpointList_h_
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-private-forward.h"
#include <map>
@ -25,10 +25,10 @@ struct NativeWatchpoint {
class NativeWatchpointList {
public:
Error Add(lldb::addr_t addr, size_t size, uint32_t watch_flags,
bool hardware);
Status Add(lldb::addr_t addr, size_t size, uint32_t watch_flags,
bool hardware);
Error Remove(lldb::addr_t addr);
Status Remove(lldb::addr_t addr);
using WatchpointMap = std::map<lldb::addr_t, NativeWatchpoint>;

20
include/lldb/Host/common/SoftwareBreakpoint.h
View file

@ -18,18 +18,18 @@ class SoftwareBreakpoint : public NativeBreakpoint {
friend class NativeBreakpointList;
public:
static Error CreateSoftwareBreakpoint(NativeProcessProtocol &process,
lldb::addr_t addr, size_t size_hint,
NativeBreakpointSP &breakpoint_spn);
static Status CreateSoftwareBreakpoint(NativeProcessProtocol &process,
lldb::addr_t addr, size_t size_hint,
NativeBreakpointSP &breakpoint_spn);
SoftwareBreakpoint(NativeProcessProtocol &process, lldb::addr_t addr,
const uint8_t *saved_opcodes, const uint8_t *trap_opcodes,
size_t opcode_size);
protected:
Error DoEnable() override;
Status DoEnable() override;
Error DoDisable() override;
Status DoDisable() override;
bool IsSoftwareBreakpoint() const override;
@ -42,11 +42,11 @@ private:
uint8_t m_trap_opcodes[MAX_TRAP_OPCODE_SIZE];
const size_t m_opcode_size;
static Error EnableSoftwareBreakpoint(NativeProcessProtocol &process,
lldb::addr_t addr,
size_t bp_opcode_size,
const uint8_t *bp_opcode_bytes,
uint8_t *saved_opcode_bytes);
static Status EnableSoftwareBreakpoint(NativeProcessProtocol &process,
lldb::addr_t addr,
size_t bp_opcode_size,
const uint8_t *bp_opcode_bytes,
uint8_t *saved_opcode_bytes);
};
}

8
include/lldb/Host/common/TCPSocket.h
View file

@ -39,11 +39,11 @@ public:
int SetOptionNoDelay();
int SetOptionReuseAddress();
Error Connect(llvm::StringRef name) override;
Error Listen(llvm::StringRef name, int backlog) override;
Error Accept(Socket *&conn_socket) override;
Status Connect(llvm::StringRef name) override;
Status Listen(llvm::StringRef name, int backlog) override;
Status Accept(Socket *&conn_socket) override;
Error CreateSocket(int domain);
Status CreateSocket(int domain);
bool IsValid() const override;

10
include/lldb/Host/common/UDPSocket.h
View file

@ -17,16 +17,16 @@ class UDPSocket : public Socket {
public:
UDPSocket(bool should_close, bool child_processes_inherit);
static Error Connect(llvm::StringRef name, bool child_processes_inherit,
Socket *&socket);
static Status Connect(llvm::StringRef name, bool child_processes_inherit,
Socket *&socket);
private:
UDPSocket(NativeSocket socket);
size_t Send(const void *buf, const size_t num_bytes) override;
Error Connect(llvm::StringRef name) override;
Error Listen(llvm::StringRef name, int backlog) override;
Error Accept(Socket *&socket) override;
Status Connect(llvm::StringRef name) override;
Status Listen(llvm::StringRef name, int backlog) override;
Status Accept(Socket *&socket) override;
SocketAddress m_sockaddr;
};

24
include/lldb/Host/posix/ConnectionFileDescriptorPosix.h
View file

@ -26,7 +26,7 @@
namespace lldb_private {
class Error;
class Status;
class Socket;
class SocketAddress;
@ -53,20 +53,20 @@ public:
bool IsConnected() const override;
lldb::ConnectionStatus Connect(llvm::StringRef s, Error *error_ptr) override;
lldb::ConnectionStatus Connect(llvm::StringRef s, Status *error_ptr) override;
lldb::ConnectionStatus Disconnect(Error *error_ptr) override;
lldb::ConnectionStatus Disconnect(Status *error_ptr) override;
size_t Read(void *dst, size_t dst_len, const Timeout<std::micro> &timeout,
lldb::ConnectionStatus &status, Error *error_ptr) override;
lldb::ConnectionStatus &status, Status *error_ptr) override;
size_t Write(const void *src, size_t src_len, lldb::ConnectionStatus &status,
Error *error_ptr) override;
Status *error_ptr) override;
std::string GetURI() override;
lldb::ConnectionStatus BytesAvailable(const Timeout<std::micro> &timeout,
Error *error_ptr);
Status *error_ptr);
bool InterruptRead() override;
@ -83,21 +83,21 @@ protected:
void CloseCommandPipe();
lldb::ConnectionStatus SocketListenAndAccept(llvm::StringRef host_and_port,
Error *error_ptr);
Status *error_ptr);
lldb::ConnectionStatus ConnectTCP(llvm::StringRef host_and_port,
Error *error_ptr);
Status *error_ptr);
lldb::ConnectionStatus ConnectUDP(llvm::StringRef args, Error *error_ptr);
lldb::ConnectionStatus ConnectUDP(llvm::StringRef args, Status *error_ptr);
lldb::ConnectionStatus NamedSocketConnect(llvm::StringRef socket_name,
Error *error_ptr);
Status *error_ptr);
lldb::ConnectionStatus NamedSocketAccept(llvm::StringRef socket_name,
Error *error_ptr);
Status *error_ptr);
lldb::ConnectionStatus UnixAbstractSocketConnect(llvm::StringRef socket_name,
Error *error_ptr);
Status *error_ptr);
lldb::IOObjectSP m_read_sp;
lldb::IOObjectSP m_write_sp;

6
include/lldb/Host/posix/DomainSocket.h
View file

@ -17,9 +17,9 @@ class DomainSocket : public Socket {
public:
DomainSocket(bool should_close, bool child_processes_inherit);
Error Connect(llvm::StringRef name) override;
Error Listen(llvm::StringRef name, int backlog) override;
Error Accept(Socket *&socket) override;
Status Connect(llvm::StringRef name) override;
Status Listen(llvm::StringRef name, int backlog) override;
Status Accept(Socket *&socket) override;
protected:
DomainSocket(SocketProtocol protocol, bool child_processes_inherit);

10
include/lldb/Host/posix/HostProcessPosix.h
View file

@ -15,7 +15,7 @@
// Other libraries and framework includes
// Project includes
#include "lldb/Host/HostNativeProcessBase.h"
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-types.h"
namespace lldb_private {
@ -28,11 +28,11 @@ public:
HostProcessPosix(lldb::process_t process);
~HostProcessPosix() override;
virtual Error Signal(int signo) const;
static Error Signal(lldb::process_t process, int signo);
virtual Status Signal(int signo) const;
static Status Signal(lldb::process_t process, int signo);
Error Terminate() override;
Error GetMainModule(FileSpec &file_spec) const override;
Status Terminate() override;
Status GetMainModule(FileSpec &file_spec) const override;
lldb::pid_t GetProcessId() const override;
bool IsRunning() const override;

6
include/lldb/Host/posix/HostThreadPosix.h
View file

@ -22,10 +22,10 @@ public:
HostThreadPosix(lldb::thread_t thread);
~HostThreadPosix() override;
Error Join(lldb::thread_result_t *result) override;
Error Cancel() override;
Status Join(lldb::thread_result_t *result) override;
Status Cancel() override;
Error Detach();
Status Detach();
};
} // namespace lldb_private

10
include/lldb/Host/posix/LockFilePosix.h
View file

@ -20,15 +20,15 @@ public:
~LockFilePosix() override;
protected:
Error DoWriteLock(const uint64_t start, const uint64_t len) override;
Status DoWriteLock(const uint64_t start, const uint64_t len) override;
Error DoTryWriteLock(const uint64_t start, const uint64_t len) override;
Status DoTryWriteLock(const uint64_t start, const uint64_t len) override;
Error DoReadLock(const uint64_t start, const uint64_t len) override;
Status DoReadLock(const uint64_t start, const uint64_t len) override;
Error DoTryReadLock(const uint64_t start, const uint64_t len) override;
Status DoTryReadLock(const uint64_t start, const uint64_t len) override;
Error DoUnlock() override;
Status DoUnlock() override;
};
} // namespace lldb_private

24
include/lldb/Host/posix/PipePosix.h
View file

@ -35,12 +35,14 @@ public:
~PipePosix() override;
Error CreateNew(bool child_process_inherit) override;
Error CreateNew(llvm::StringRef name, bool child_process_inherit) override;
Error CreateWithUniqueName(llvm::StringRef prefix, bool child_process_inherit,
llvm::SmallVectorImpl<char> &name) override;
Error OpenAsReader(llvm::StringRef name, bool child_process_inherit) override;
Error
Status CreateNew(bool child_process_inherit) override;
Status CreateNew(llvm::StringRef name, bool child_process_inherit) override;
Status CreateWithUniqueName(llvm::StringRef prefix,
bool child_process_inherit,
llvm::SmallVectorImpl<char> &name) override;
Status OpenAsReader(llvm::StringRef name,
bool child_process_inherit) override;
Status
OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inherit,
const std::chrono::microseconds &timeout) override;
@ -57,12 +59,12 @@ public:
// Close both descriptors
void Close() override;
Error Delete(llvm::StringRef name) override;
Status Delete(llvm::StringRef name) override;
Error Write(const void *buf, size_t size, size_t &bytes_written) override;
Error ReadWithTimeout(void *buf, size_t size,
const std::chrono::microseconds &timeout,
size_t &bytes_read) override;
Status Write(const void *buf, size_t size, size_t &bytes_written) override;
Status ReadWithTimeout(void *buf, size_t size,
const std::chrono::microseconds &timeout,
size_t &bytes_read) override;
private:
int m_fds[2];

2
include/lldb/Host/posix/ProcessLauncherPosix.h
View file

@ -17,7 +17,7 @@ namespace lldb_private {
class ProcessLauncherPosix : public ProcessLauncher {
public:
HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info,
Error &error) override;
Status &error) override;
};
}

2
include/lldb/Host/posix/ProcessLauncherPosixFork.h
View file

@ -17,7 +17,7 @@ namespace lldb_private {
class ProcessLauncherPosixFork : public ProcessLauncher {
public:
HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info,
Error &error) override;
Status &error) override;
};
} // end of namespace lldb_private

10
include/lldb/Host/windows/ConnectionGenericFileWindows.h
View file

@ -16,7 +16,7 @@
namespace lldb_private {
class Error;
class Status;
class ConnectionGenericFile : public lldb_private::Connection {
public:
@ -28,15 +28,15 @@ public:
bool IsConnected() const override;
lldb::ConnectionStatus Connect(llvm::StringRef s, Error *error_ptr) override;
lldb::ConnectionStatus Connect(llvm::StringRef s, Status *error_ptr) override;
lldb::ConnectionStatus Disconnect(Error *error_ptr) override;
lldb::ConnectionStatus Disconnect(Status *error_ptr) override;
size_t Read(void *dst, size_t dst_len, const Timeout<std::micro> &timeout,
lldb::ConnectionStatus &status, Error *error_ptr) override;
lldb::ConnectionStatus &status, Status *error_ptr) override;
size_t Write(const void *src, size_t src_len, lldb::ConnectionStatus &status,
Error *error_ptr) override;
Status *error_ptr) override;
std::string GetURI() override;

4
include/lldb/Host/windows/HostProcessWindows.h
View file

@ -25,8 +25,8 @@ public:
void SetOwnsHandle(bool owns);
Error Terminate() override;
Error GetMainModule(FileSpec &file_spec) const override;
Status Terminate() override;
Status GetMainModule(FileSpec &file_spec) const override;
lldb::pid_t GetProcessId() const override;
bool IsRunning() const override;

4
include/lldb/Host/windows/HostThreadWindows.h
View file

@ -26,8 +26,8 @@ public:
void SetOwnsHandle(bool owns);
virtual Error Join(lldb::thread_result_t *result);
virtual Error Cancel();
virtual Status Join(lldb::thread_result_t *result);
virtual Status Cancel();
virtual void Reset();
lldb::tid_t GetThreadId() const;

10
include/lldb/Host/windows/LockFileWindows.h
View file

@ -21,15 +21,15 @@ public:
~LockFileWindows();
protected:
Error DoWriteLock(const uint64_t start, const uint64_t len) override;
Status DoWriteLock(const uint64_t start, const uint64_t len) override;
Error DoTryWriteLock(const uint64_t start, const uint64_t len) override;
Status DoTryWriteLock(const uint64_t start, const uint64_t len) override;
Error DoReadLock(const uint64_t start, const uint64_t len) override;
Status DoReadLock(const uint64_t start, const uint64_t len) override;
Error DoTryReadLock(const uint64_t start, const uint64_t len) override;
Status DoTryReadLock(const uint64_t start, const uint64_t len) override;
Error DoUnlock() override;
Status DoUnlock() override;
bool IsValidFile() const override;

28
include/lldb/Host/windows/PipeWindows.h
View file

@ -27,12 +27,14 @@ public:
PipeWindows();
~PipeWindows() override;
Error CreateNew(bool child_process_inherit) override;
Error CreateNew(llvm::StringRef name, bool child_process_inherit) override;
Error CreateWithUniqueName(llvm::StringRef prefix, bool child_process_inherit,
llvm::SmallVectorImpl<char> &name) override;
Error OpenAsReader(llvm::StringRef name, bool child_process_inherit) override;
Error
Status CreateNew(bool child_process_inherit) override;
Status CreateNew(llvm::StringRef name, bool child_process_inherit) override;
Status CreateWithUniqueName(llvm::StringRef prefix,
bool child_process_inherit,
llvm::SmallVectorImpl<char> &name) override;
Status OpenAsReader(llvm::StringRef name,
bool child_process_inherit) override;
Status
OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inherit,
const std::chrono::microseconds &timeout) override;
@ -48,12 +50,12 @@ public:
void Close() override;
Error Delete(llvm::StringRef name) override;
Status Delete(llvm::StringRef name) override;
Error Write(const void *buf, size_t size, size_t &bytes_written) override;
Error ReadWithTimeout(void *buf, size_t size,
const std::chrono::microseconds &timeout,
size_t &bytes_read) override;
Status Write(const void *buf, size_t size, size_t &bytes_written) override;
Status ReadWithTimeout(void *buf, size_t size,
const std::chrono::microseconds &timeout,
size_t &bytes_read) override;
// PipeWindows specific methods. These allow access to the underlying OS
// handle.
@ -61,8 +63,8 @@ public:
HANDLE GetWriteNativeHandle();
private:
Error OpenNamedPipe(llvm::StringRef name, bool child_process_inherit,
bool is_read);
Status OpenNamedPipe(llvm::StringRef name, bool child_process_inherit,
bool is_read);
HANDLE m_read;
HANDLE m_write;

2
include/lldb/Host/windows/ProcessLauncherWindows.h
View file

@ -20,7 +20,7 @@ class ProcessLaunchInfo;
class ProcessLauncherWindows : public ProcessLauncher {
public:
virtual HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info,
Error &error);
Status &error);
protected:
HANDLE GetStdioHandle(const ProcessLaunchInfo &launch_info, int fd);

18
include/lldb/Interpreter/Args.h
View file

@ -21,7 +21,7 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
// Project includes
#include "lldb/Utility/Error.h"
#include "lldb/Utility/Status.h"
#include "lldb/lldb-private-types.h"
#include "lldb/lldb-types.h"
@ -322,8 +322,8 @@ public:
///
/// @see class Options
//------------------------------------------------------------------
Error ParseOptions(Options &options, ExecutionContext *execution_context,
lldb::PlatformSP platform_sp, bool require_validation);
Status ParseOptions(Options &options, ExecutionContext *execution_context,
lldb::PlatformSP platform_sp, bool require_validation);
bool IsPositionalArgument(const char *arg);
@ -377,7 +377,7 @@ public:
static lldb::addr_t StringToAddress(const ExecutionContext *exe_ctx,
llvm::StringRef s,
lldb::addr_t fail_value, Error *error);
lldb::addr_t fail_value, Status *error);
static bool StringToBoolean(llvm::StringRef s, bool fail_value,
bool *success_ptr);
@ -387,17 +387,17 @@ public:
static int64_t StringToOptionEnum(llvm::StringRef s,
OptionEnumValueElement *enum_values,
int32_t fail_value, Error &error);
int32_t fail_value, Status &error);
static lldb::ScriptLanguage
StringToScriptLanguage(llvm::StringRef s, lldb::ScriptLanguage fail_value,
bool *success_ptr);
// TODO: Use StringRef
static Error StringToFormat(const char *s, lldb::Format &format,
size_t *byte_size_ptr); // If non-NULL, then a
// byte size can precede
// the format character
static Status StringToFormat(const char *s, lldb::Format &format,
size_t *byte_size_ptr); // If non-NULL, then a
// byte size can precede
// the format character
static lldb::Encoding
StringToEncoding(llvm::StringRef s,

2
include/lldb/Interpreter/CommandInterpreter.h
View file

@ -510,7 +510,7 @@ protected:
StringList *matches = nullptr) const;
private:
Error PreprocessCommand(std::string &command);
Status PreprocessCommand(std::string &command);
// Completely resolves aliases and abbreviations, returning a pointer to the
// final command object and updating command_line to the fully substituted

2
include/lldb/Interpreter/CommandReturnObject.h
View file

@ -129,7 +129,7 @@ public:
AppendError(llvm::formatv(format, std::forward<Args>(args)...).str());
}
void SetError(const Error &error, const char *fallback_error_cstr = nullptr);
void SetError(const Status &error, const char *fallback_error_cstr = nullptr);
void SetError(llvm::StringRef error_cstr);

4
include/lldb/Interpreter/OptionGroupArchitecture.h
View file

@ -31,8 +31,8 @@ public:
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
void OptionParsingStarting(ExecutionContext *execution_context) override;

6
include/lldb/Interpreter/OptionGroupBoolean.h
View file

@ -38,9 +38,9 @@ public:
return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
}
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;

12
include/lldb/Interpreter/OptionGroupFile.h
View file

@ -37,9 +37,9 @@ public:
return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
}
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
@ -70,9 +70,9 @@ public:
return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
}
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;

6
include/lldb/Interpreter/OptionGroupFormat.h
View file

@ -43,9 +43,9 @@ public:
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;

6
include/lldb/Interpreter/OptionGroupOutputFile.h
View file

@ -31,9 +31,9 @@ public:
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;

8
include/lldb/Interpreter/OptionGroupPlatform.h
View file

@ -36,15 +36,15 @@ public:
llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;
lldb::PlatformSP CreatePlatformWithOptions(CommandInterpreter &interpreter,
const ArchSpec &arch,
bool make_selected, Error &error,
bool make_selected, Status &error,
ArchSpec &platform_arch) const;
bool PlatformWasSpecified() const { return !m_platform_name.empty(); }

6
include/lldb/Interpreter/OptionGroupString.h
View file

@ -35,9 +35,9 @@ public:
return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
}
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;

6
include/lldb/Interpreter/OptionGroupUInt64.h
View file

@ -36,9 +36,9 @@ public:
return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
}
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override;
Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
void OptionParsingStarting(ExecutionContext *execution_context) override;

Some files were not shown because too many files have changed in this diff Show more