Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2024-11-24 06:10:12 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Rename Error -> Status.

Browse Source 
This renames the LLDB error class to Status, as discussed
on the lldb-dev mailing list.

A change of this magnitude cannot easily be done without
find and replace, but that has potential to catch unwanted
occurrences of common strings such as "Error".  Every effort
was made to find all the obvious things such as the word "Error"
appearing in a string, etc, but it's possible there are still
some lingering occurences left around.  Hopefully nothing too
serious.

llvm-svn: 302872
This commit is contained in:
Zachary Turner 2017-05-12 04:51:55 +00:00
parent 3086b45a2f
commit 97206d5727
655 changed files with 5888 additions and 5773 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
lldb/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
lldb/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
lldb/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
lldb/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(const char *new_name, Status &error);
void RemoveName(const char *name_to_remove) {
if (name_to_remove)

2
lldb/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
lldb/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
lldb/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();

2
lldb/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();

2
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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)

12
lldb/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();
@ -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;

4
lldb/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;
@ -558,7 +558,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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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
lldb/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;

6
lldb/include/lldb/Interpreter/OptionGroupUUID.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;

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