maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Fixed the LLDB build so that we can have private types, private enums and 

public types and public enums. This was done to keep the SWIG stuff from
parsing all sorts of enums and types that weren't needed, and allows us to
abstract our API better.

llvm-svn: 128239
This commit is contained in:
Greg Clayton 2011-03-24 21:19:54 +00:00
parent dd9eb21c3f
commit e0d378b334
157 changed files with 1045 additions and 1160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lldb/include/lldb/Core/Address.h
View File

@ -246,7 +246,7 @@ public:
DumpStyle fallback_style = DumpStyleInvalid,
uint32_t addr_byte_size = UINT32_MAX) const;
lldb::AddressClass
AddressClass
GetAddressClass () const;
//------------------------------------------------------------------

4
lldb/include/lldb/Core/ArchSpec.h
View File

@ -119,7 +119,7 @@ public:
/// Constructs an ArchSpec with properties consistent with the given
/// object type and architecture name.
//------------------------------------------------------------------
ArchSpec (lldb::ArchitectureType arch_type,
ArchSpec (ArchitectureType arch_type,
uint32_t cpu_type,
uint32_t cpu_subtype);
@ -236,7 +236,7 @@ public:
/// @return True if the object and CPU type were sucessfully set.
//------------------------------------------------------------------
bool
SetArchitecture (lldb::ArchitectureType arch_type,
SetArchitecture (ArchitectureType arch_type,
uint32_t cpu,
uint32_t sub);

2
lldb/include/lldb/Core/Baton.h
View File

@ -14,7 +14,7 @@
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
namespace lldb_private {

2
lldb/include/lldb/Core/Debugger.h
View File

@ -57,7 +57,7 @@ public:
const char *value,
const ConstString &instance_name,
const SettingEntry &entry,
lldb::VarSetOperationType op,
VarSetOperationType op,
Error &err,
bool pending);

45
lldb/include/lldb/Core/EmulateInstruction.h
View File

@ -10,7 +10,7 @@
#ifndef lldb_EmulateInstruction_h_
#define lldb_EmulateInstruction_h_
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/Core/PluginInterface.h"
//----------------------------------------------------------------------
@ -351,34 +351,6 @@ public:
};
union Opcode
{
uint8_t inst8;
uint16_t inst16;
uint32_t inst32;
uint64_t inst64;
union inst
{
uint8_t bytes[16];
uint8_t length;
};
};
enum OpcodeType
{
eOpcode8,
eOpcode16,
eOpcode32,
eOpcode64,
eOpcodeBytes
};
struct Instruction
{
OpcodeType opcode_type;
Opcode opcode;
};
typedef size_t (*ReadMemory) (void *baton,
const Context &context,
lldb::addr_t addr,
@ -465,12 +437,12 @@ public:
{
if (success_ptr)
*success_ptr = true;
switch (m_inst.opcode_type)
switch (m_opcode.type)
{
case eOpcode8: return m_inst.opcode.inst8;
case eOpcode16: return m_inst.opcode.inst16;
case eOpcode32: return m_inst.opcode.inst32;
case eOpcode64: return m_inst.opcode.inst64;
case eOpcode8: return m_opcode.data.inst8;
case eOpcode16: return m_opcode.data.inst16;
case eOpcode32: return m_opcode.data.inst32;
case eOpcode64: return m_opcode.data.inst64;
case eOpcodeBytes: break;
}
if (success_ptr)
@ -486,9 +458,8 @@ protected:
WriteMemory m_write_mem_callback;
ReadRegister m_read_reg_callback;
WriteRegister m_write_reg_callback;
lldb::addr_t m_inst_pc;
Instruction m_inst;
lldb::addr_t m_opcode_pc;
Opcode m_opcode;
//------------------------------------------------------------------
// For EmulateInstruction only
//------------------------------------------------------------------

2
lldb/include/lldb/Core/InputReader.h
View File

@ -10,7 +10,7 @@
#ifndef liblldb_InputReader_h_
#define liblldb_InputReader_h_
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Host/Predicate.h"

6
lldb/include/lldb/Core/Module.h
View File

@ -144,16 +144,16 @@ public:
//------------------------------------------------------------------
const Symbol *
FindFirstSymbolWithNameAndType (const ConstString &name,
lldb::SymbolType symbol_type = lldb::eSymbolTypeAny);
SymbolType symbol_type = eSymbolTypeAny);
size_t
FindSymbolsWithNameAndType (const ConstString &name,
lldb::SymbolType symbol_type,
SymbolType symbol_type,
SymbolContextList &sc_list);
size_t
FindSymbolsMatchingRegExAndType (const RegularExpression &regex,
lldb::SymbolType symbol_type,
SymbolType symbol_type,
SymbolContextList &sc_list);
//------------------------------------------------------------------

2
lldb/include/lldb/Core/ModuleList.h
View File

@ -272,7 +272,7 @@ public:
size_t
FindSymbolsWithNameAndType (const ConstString &name,
lldb::SymbolType symbol_type,
SymbolType symbol_type,
SymbolContextList &sc_list);
//------------------------------------------------------------------

8
lldb/include/lldb/Core/Section.h
View File

@ -55,7 +55,7 @@ public:
FindSectionByID (lldb::user_id_t sect_id) const;
lldb::SectionSP
FindSectionByType (lldb::SectionType sect_type, bool check_children, uint32_t start_idx = 0) const;
FindSectionByType (SectionType sect_type, bool check_children, uint32_t start_idx = 0) const;
lldb::SectionSP
GetSharedPointer (const Section *section, bool check_children) const;
@ -105,7 +105,7 @@ public:
Module* module,
lldb::user_id_t sect_id,
const ConstString &name,
lldb::SectionType sect_type,
SectionType sect_type,
lldb::addr_t file_vm_addr,
lldb::addr_t vm_size,
uint64_t file_offset,
@ -268,7 +268,7 @@ public:
lldb::addr_t
GetLinkedFileAddress () const;
lldb::SectionType
SectionType
GetType () const
{
return m_type;
@ -278,7 +278,7 @@ protected:
Section * m_parent; // Parent section or NULL if no parent.
ConstString m_name; // Name of this section
lldb::SectionType m_type; // The type of this section
SectionType m_type; // The type of this section
lldb::addr_t m_file_addr; // The absolute file virtual address range of this section if m_parent == NULL,
// offset from parent file virtual address if m_parent != NULL
lldb::addr_t m_byte_size; // Size in bytes that this section will occupy in memory at runtime

55
lldb/include/lldb/Core/UserSettingsController.h
View File

@ -31,9 +31,9 @@ namespace lldb_private {
typedef struct
{
const char *var_name;
lldb::SettableVariableType var_type;
SettableVariableType var_type;
const char *default_value;
lldb::OptionEnumValueElement *enum_values;
OptionEnumValueElement *enum_values;
bool initialized;
bool hidden;
const char *description; //help text
@ -69,7 +69,7 @@ public:
const char *index_value,
const char *value,
const SettingEntry &entry,
const lldb::VarSetOperationType op,
const VarSetOperationType op,
Error &err);
virtual bool
@ -80,14 +80,14 @@ public:
// End of pure virtual functions.
StringList
GetVariable (const char *full_dot_name,
lldb::SettableVariableType &var_type,
SettableVariableType &var_type,
const char *debugger_instance_name,
Error &err);
Error
SetVariable (const char *full_dot_name,
const char *value,
const lldb::VarSetOperationType op,
const VarSetOperationType op,
const bool override,
const char *debugger_instance_name,
const char *index_value = NULL);
@ -179,41 +179,41 @@ public:
BreakNameIntoPieces (const char *full_dot_name);
static const char *
GetTypeString (lldb::SettableVariableType var_type);
GetTypeString (SettableVariableType var_type);
static const char *
EnumToString (const lldb::OptionEnumValueElement *enum_values, int value);
EnumToString (const OptionEnumValueElement *enum_values, int value);
static void
UpdateStringVariable (lldb::VarSetOperationType op,
UpdateStringVariable (VarSetOperationType op,
std::string &string_var,
const char *new_value,
Error &err);
static void
UpdateBooleanVariable (lldb::VarSetOperationType op,
UpdateBooleanVariable (VarSetOperationType op,
bool &bool_var,
const char *new_value,
Error &err);
static void
UpdateStringArrayVariable (lldb::VarSetOperationType op,
UpdateStringArrayVariable (VarSetOperationType op,
const char *index_value,
Args &array_var,
const char *new_value,
Error &err);
static void
UpdateDictionaryVariable (lldb::VarSetOperationType op,
UpdateDictionaryVariable (VarSetOperationType op,
const char *index_value,
std::map<std::string, std::string> &dictionary,
const char *new_value,
Error &err);
static void
UpdateEnumVariable (lldb::OptionEnumValueElement *enum_values,
UpdateEnumVariable (OptionEnumValueElement *enum_values,
int *enum_var,
const char *new_value,
Error &err);
@ -301,7 +301,7 @@ protected:
void
OverrideAllInstances (const ConstString &var_name,
const char *value,
lldb::VarSetOperationType op,
VarSetOperationType op,
const char *index_value,
Error &err);
@ -313,23 +313,24 @@ protected:
// -------------------------------------------------------------------------
static void
PrintEnumValues (const lldb::OptionEnumValueElement *enum_values, Stream &str);
PrintEnumValues (const OptionEnumValueElement *enum_values,
Stream &str);
static int
BooleanMatches (const char *partial_value,
bool &word_complete,
StringList &matches);
static int
EnumMatches (const char *partial_value,
lldb::OptionEnumValueElement *enum_values,
bool &word_complete,
StringList &matches);
static int
BooleanMatches (const char *partial_value,
bool &word_complete,
StringList &matches);
static int
EnumMatches (const char *partial_value,
OptionEnumValueElement *enum_values,
bool &word_complete,
StringList &matches);
static void
VerifyOperationForType (lldb::SettableVariableType var_type,
lldb::VarSetOperationType op,
VerifyOperationForType (SettableVariableType var_type,
VarSetOperationType op,
const ConstString &var_name,
Error &err);
@ -373,7 +374,7 @@ public:
const char *value,
const ConstString &instance_name,
const SettingEntry &entry,
lldb::VarSetOperationType op,
VarSetOperationType op,
Error &err,
bool pending) = 0;

6
lldb/include/lldb/Core/Value.h
View File

@ -45,7 +45,7 @@ public:
// ====================
eContextTypeInvalid, // undefined
eContextTypeClangType, // void * (an opaque clang::QualType * that can be fed to "static QualType QualType::getFromOpaquePtr(void *)")
eContextTypeRegisterInfo, // lldb::RegisterInfo *
eContextTypeRegisterInfo, // RegisterInfo *
eContextTypeLLDBType, // lldb_private::Type *
eContextTypeVariable, // lldb_private::Variable *
eContextTypeValue // Value * (making this a proxy value. Used when putting locals on the DWARF expression parser stack)
@ -80,7 +80,7 @@ public:
ValueType
GetValueType() const;
lldb::AddressType
AddressType
GetValueAddressType () const;
ContextType
@ -95,7 +95,7 @@ public:
void
SetContext (ContextType context_type, void *p);
lldb::RegisterInfo *
RegisterInfo *
GetRegisterInfo();
Type *

4
lldb/include/lldb/Core/ValueObject.h
View File

@ -355,11 +355,11 @@ protected:
lldb::addr_t
GetPointerValue (lldb::AddressType &address_type,
GetPointerValue (AddressType &address_type,
bool scalar_is_load_address);
lldb::addr_t
GetAddressOf (lldb::AddressType &address_type,
GetAddressOf (AddressType &address_type,
bool scalar_is_load_address);
private:
//------------------------------------------------------------------

2
lldb/include/lldb/Core/ValueObjectConstResult.h
View File

@ -43,7 +43,7 @@ public:
void *clang_type,
const ConstString &name,
lldb::addr_t address,
lldb::AddressType address_type,
AddressType address_type,
uint8_t addr_byte_size);
// When an expression fails to evaluate, we return an error

4
lldb/include/lldb/Core/ValueObjectRegister.h
View File

@ -106,7 +106,7 @@ public:
protected:
lldb::RegisterContextSP m_reg_ctx;
const lldb::RegisterSet *m_reg_set;
const RegisterSet *m_reg_set;
uint32_t m_reg_set_idx;
private:
@ -151,7 +151,7 @@ public:
protected:
lldb::RegisterContextSP m_reg_ctx;
const lldb::RegisterInfo *m_reg_info;
const RegisterInfo *m_reg_info;
uint32_t m_reg_num;
ConstString m_type_name;
void *m_clang_type;

6
lldb/include/lldb/Expression/ClangExpressionDeclMap.h
View File

@ -20,7 +20,7 @@
// Other libraries and framework includes
// Project includes
#include "llvm/ADT/DenseMap.h"
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/Core/ClangForward.h"
#include "lldb/Core/Value.h"
#include "lldb/Expression/ClangExpressionVariable.h"
@ -721,7 +721,7 @@ private:
//------------------------------------------------------------------
void
AddOneRegister (NameSearchContext &context,
const lldb::RegisterInfo *reg_info);
const RegisterInfo *reg_info);
//------------------------------------------------------------------
/// Use the NameSearchContext to generate a Decl for the given
@ -878,7 +878,7 @@ private:
DoMaterializeOneRegister (bool dematerialize,
ExecutionContext &exe_ctx,
RegisterContext &reg_ctx,
const lldb::RegisterInfo &reg_info,
const RegisterInfo &reg_info,
lldb::addr_t addr,
Error &err);

2
lldb/include/lldb/Expression/ClangExpressionParser.h
View File

@ -10,7 +10,7 @@
#ifndef liblldb_ClangExpressionParser_h_
#define liblldb_ClangExpressionParser_h_
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/Core/ArchSpec.h"
#include "lldb/Core/ClangForward.h"
#include "lldb/Core/Error.h"

6
lldb/include/lldb/Expression/ClangExpressionVariable.h
View File

@ -21,7 +21,7 @@
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/Core/ClangForward.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Symbol/TaggedASTType.h"
@ -174,11 +174,11 @@ public:
const ConstString &
GetName();
lldb::RegisterInfo *
RegisterInfo *
GetRegisterInfo();
void
SetRegisterInfo (const lldb::RegisterInfo *reg_info);
SetRegisterInfo (const RegisterInfo *reg_info);
lldb::clang_type_t
GetClangType ();

10
lldb/include/lldb/Expression/ClangFunction.h
View File

@ -265,7 +265,7 @@ public:
/// @return
/// Returns one of the ExecutionResults enum indicating function call status.
//------------------------------------------------------------------
static lldb::ExecutionResults
static ExecutionResults
ExecuteFunction (ExecutionContext &exe_ctx,
lldb::addr_t function_address,
lldb::addr_t &void_arg,
@ -295,7 +295,7 @@ public:
/// @return
/// Returns one of the ExecutionResults enum indicating function call status.
//------------------------------------------------------------------
lldb::ExecutionResults
ExecutionResults
ExecuteFunction(ExecutionContext &exe_ctx,
Stream &errors,
Value &results);
@ -321,7 +321,7 @@ public:
/// @return
/// Returns one of the ExecutionResults enum indicating function call status.
//------------------------------------------------------------------
lldb::ExecutionResults
ExecutionResults
ExecuteFunction(ExecutionContext &exe_ctx,
Stream &errors, bool stop_others,
Value &results);
@ -351,7 +351,7 @@ public:
/// @return
/// Returns one of the ExecutionResults enum indicating function call status.
//------------------------------------------------------------------
lldb::ExecutionResults
ExecutionResults
ExecuteFunction(ExecutionContext &exe_ctx,
Stream &errors,
uint32_t single_thread_timeout_usec,
@ -391,7 +391,7 @@ public:
/// @return
/// Returns one of the ExecutionResults enum indicating function call status.
//------------------------------------------------------------------
lldb::ExecutionResults
ExecutionResults
ExecuteFunction(ExecutionContext &exe_ctx,
lldb::addr_t *args_addr_ptr,
Stream &errors,

4
lldb/include/lldb/Expression/ClangUserExpression.h
View File

@ -129,7 +129,7 @@ public:
/// @return
/// A Process::Execution results value.
//------------------------------------------------------------------
lldb::ExecutionResults
ExecutionResults
Execute (Stream &error_stream,
ExecutionContext &exe_ctx,
bool discard_on_error,
@ -261,7 +261,7 @@ public:
/// @result
/// A Process::ExecutionResults value. eExecutionCompleted for success.
//------------------------------------------------------------------
static lldb::ExecutionResults
static ExecutionResults
Evaluate (ExecutionContext &exe_ctx,
bool discard_on_error,
bool keep_in_memory,

2
lldb/include/lldb/Expression/IRForTarget.h
View File

@ -10,7 +10,7 @@
#ifndef liblldb_IRForTarget_h_
#define liblldb_IRForTarget_h_
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/TaggedASTType.h"

2
lldb/include/lldb/Expression/IRToDWARF.h
View File

@ -13,7 +13,7 @@
#include "llvm/Pass.h"
#include "llvm/PassManager.h"
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
class Relocator;
//----------------------------------------------------------------------

4
lldb/include/lldb/Host/Host.h
View File

@ -315,7 +315,7 @@ public:
/// \b true if \a resource_path was resolved, \a false otherwise.
//------------------------------------------------------------------
static bool
GetLLDBPath (lldb::PathType path_type,
GetLLDBPath (PathType path_type,
FileSpec &file_spec);
//------------------------------------------------------------------
@ -338,7 +338,7 @@ public:
static uint32_t
FindProcessesByName (const char *name,
lldb::NameMatchType name_match_type,
NameMatchType name_match_type,
ProcessInfoList &proc_infos);
static bool

6
lldb/include/lldb/Interpreter/Args.h
View File

@ -21,9 +21,9 @@
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-private.h"
#include "lldb/Core/Error.h"
#include "lldb/lldb-private-types.h"
#include "lldb/lldb-types.h"
#include "lldb/Core/Error.h"
namespace lldb_private {
@ -349,7 +349,7 @@ public:
StringToBoolean (const char *s, bool fail_value, bool *success_ptr);
static int32_t
StringToOptionEnum (const char *s, lldb::OptionEnumValueElement *enum_values, int32_t fail_value, bool *success_ptr);
StringToOptionEnum (const char *s, OptionEnumValueElement *enum_values, int32_t fail_value, bool *success_ptr);
static lldb::ScriptLanguage
StringToScriptLanguage (const char *s, lldb::ScriptLanguage fail_value, bool *success_ptr);

4
lldb/include/lldb/Interpreter/CommandObject.h
View File

@ -41,7 +41,7 @@ public:
struct CommandArgumentData // Used to build individual command argument lists
{
lldb::CommandArgumentType arg_type;
lldb::ArgumentRepetitionType arg_repetition;
ArgumentRepetitionType arg_repetition;
};
typedef std::vector<CommandArgumentData> CommandArgumentEntry; // Used to build individual command argument lists
@ -142,7 +142,7 @@ public:
GetFormattedCommandArguments (Stream &str);
bool
IsPairType (lldb::ArgumentRepetitionType arg_repeat_type);
IsPairType (ArgumentRepetitionType arg_repeat_type);
enum
{

2
lldb/include/lldb/Interpreter/Options.h
View File

@ -164,7 +164,7 @@ public:
// The following two pure virtual functions must be defined by every class that inherits from
// this class.
virtual const lldb::OptionDefinition*
virtual const OptionDefinition*
GetDefinitions () { return NULL; }
virtual void

10
lldb/include/lldb/Symbol/ClangASTType.h
View File

@ -10,7 +10,7 @@
#ifndef liblldb_ClangASTType_h_
#define liblldb_ClangASTType_h_
#include "lldb/lldb-include.h"
#include "lldb/lldb-private.h"
#include "lldb/Core/ClangForward.h"
namespace lldb_private {
@ -221,7 +221,7 @@ public:
bool
ReadFromMemory (ExecutionContext *exe_ctx,
lldb::addr_t addr,
lldb::AddressType address_type,
AddressType address_type,
DataExtractor &data);
static bool
@ -229,13 +229,13 @@ public:
lldb::clang_type_t opaque_clang_qual_type,
ExecutionContext *exe_ctx,
lldb::addr_t addr,
lldb::AddressType address_type,
AddressType address_type,
DataExtractor &data);
bool
WriteToMemory (ExecutionContext *exe_ctx,
lldb::addr_t addr,
lldb::AddressType address_type,
AddressType address_type,
StreamString &new_value);
static bool
@ -243,7 +243,7 @@ public:
lldb::clang_type_t opaque_clang_qual_type,
ExecutionContext *exe_ctx,
lldb::addr_t addr,
lldb::AddressType address_type,
AddressType address_type,
StreamString &new_value);
lldb::clang_type_t

2
lldb/include/lldb/Symbol/ClangNamespaceDecl.h
View File

@ -10,7 +10,7 @@
#ifndef liblldb_ClangNamespaceDecl_h_
#define liblldb_ClangNamespaceDecl_h_
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/Core/ClangForward.h"
namespace lldb_private {

2
lldb/include/lldb/Symbol/ObjectFile.h
View File

@ -156,7 +156,7 @@ public:
/// architecture (and object for archives). Returns zero if no
/// architecture or object has been selected.
//------------------------------------------------------------------
virtual lldb::AddressClass
virtual AddressClass
GetAddressClass (lldb::addr_t file_addr);
//------------------------------------------------------------------

12
lldb/include/lldb/Symbol/Symbol.h
View File

@ -31,7 +31,7 @@ public:
Symbol (lldb::user_id_t symID,
const char *name,
bool name_is_mangled,
lldb::SymbolType type,
SymbolType type,
bool external,
bool is_debug,
bool is_trampoline,
@ -44,7 +44,7 @@ public:
Symbol (lldb::user_id_t symID,
const char *name,
bool name_is_mangled,
lldb::SymbolType type,
SymbolType type,
bool external,
bool is_debug,
bool is_trampoline,
@ -58,7 +58,7 @@ public:
operator= (const Symbol& rhs);
bool
Compare (const ConstString& name, lldb::SymbolType type) const;
Compare (const ConstString& name, SymbolType type) const;
void
Dump (Stream *s, Target *target, uint32_t index) const;
@ -96,11 +96,11 @@ public:
lldb::addr_t
GetByteSize () const { return m_addr_range.GetByteSize(); }
lldb::SymbolType
SymbolType
GetType () const { return m_type; }
void
SetType (lldb::SymbolType type) { m_type = type; }
SetType (SymbolType type) { m_type = type; }
const char *
GetTypeAsString () const;
@ -186,7 +186,7 @@ public:
protected:
Mangled m_mangled; // uniqued symbol name/mangled name pair
lldb::SymbolType m_type; // symbol type
SymbolType m_type; // symbol type
uint16_t m_type_data; // data specific to m_type
uint16_t m_type_data_resolved:1, // True if the data in m_type_data has already been calculated
m_is_synthetic:1, // non-zero if this symbol is not actually in the symbol table, but synthesized from other info in the object file.

28
lldb/include/lldb/Symbol/Symtab.h
View File

@ -42,7 +42,7 @@ public:
Symbol * Resize (uint32_t count);
uint32_t AddSymbol(const Symbol& symbol);
size_t GetNumSymbols() const;
void Dump(Stream *s, Target *target, lldb::SortOrder sort_type);
void Dump(Stream *s, Target *target, SortOrder sort_type);
void Dump(Stream *s, Target *target, std::vector<uint32_t>& indexes) const;
uint32_t GetIndexForSymbol (const Symbol *symbol) const;
Mutex & GetMutex ()
@ -52,21 +52,21 @@ public:
Symbol * FindSymbolByID (lldb::user_id_t uid) const;
Symbol * SymbolAtIndex (uint32_t idx);
const Symbol * SymbolAtIndex (uint32_t idx) const;
Symbol * FindSymbolWithType (lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, uint32_t &start_idx);
// const Symbol * FindSymbolWithType (lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, uint32_t &start_idx) const;
uint32_t AppendSymbolIndexesWithType (lldb::SymbolType symbol_type, std::vector<uint32_t>& indexes, uint32_t start_idx = 0, uint32_t end_index = UINT32_MAX) const;
uint32_t AppendSymbolIndexesWithTypeAndFlagsValue (lldb::SymbolType symbol_type, uint32_t flags_value, std::vector<uint32_t>& indexes, uint32_t start_idx = 0, uint32_t end_index = UINT32_MAX) const;
uint32_t AppendSymbolIndexesWithType (lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& matches, uint32_t start_idx = 0, uint32_t end_index = UINT32_MAX) const;
Symbol * FindSymbolWithType (SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, uint32_t &start_idx);
// const Symbol * FindSymbolWithType (SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, uint32_t &start_idx) const;
uint32_t AppendSymbolIndexesWithType (SymbolType symbol_type, std::vector<uint32_t>& indexes, uint32_t start_idx = 0, uint32_t end_index = UINT32_MAX) const;
uint32_t AppendSymbolIndexesWithTypeAndFlagsValue (SymbolType symbol_type, uint32_t flags_value, std::vector<uint32_t>& indexes, uint32_t start_idx = 0, uint32_t end_index = UINT32_MAX) const;
uint32_t AppendSymbolIndexesWithType (SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& matches, uint32_t start_idx = 0, uint32_t end_index = UINT32_MAX) const;
uint32_t AppendSymbolIndexesWithName (const ConstString& symbol_name, std::vector<uint32_t>& matches);
uint32_t AppendSymbolIndexesWithName (const ConstString& symbol_name, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& matches);
uint32_t AppendSymbolIndexesWithNameAndType (const ConstString& symbol_name, lldb::SymbolType symbol_type, std::vector<uint32_t>& matches);
uint32_t AppendSymbolIndexesWithNameAndType (const ConstString& symbol_name, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& matches);
uint32_t AppendSymbolIndexesMatchingRegExAndType (const RegularExpression &regex, lldb::SymbolType symbol_type, std::vector<uint32_t>& indexes);
uint32_t AppendSymbolIndexesMatchingRegExAndType (const RegularExpression &regex, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& indexes);
size_t FindAllSymbolsWithNameAndType (const ConstString &name, lldb::SymbolType symbol_type, std::vector<uint32_t>& symbol_indexes);
size_t FindAllSymbolsWithNameAndType (const ConstString &name, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& symbol_indexes);
size_t FindAllSymbolsMatchingRexExAndType (const RegularExpression &regex, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& symbol_indexes);
Symbol * FindFirstSymbolWithNameAndType (const ConstString &name, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility);
uint32_t AppendSymbolIndexesWithNameAndType (const ConstString& symbol_name, SymbolType symbol_type, std::vector<uint32_t>& matches);
uint32_t AppendSymbolIndexesWithNameAndType (const ConstString& symbol_name, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& matches);
uint32_t AppendSymbolIndexesMatchingRegExAndType (const RegularExpression &regex, SymbolType symbol_type, std::vector<uint32_t>& indexes);
uint32_t AppendSymbolIndexesMatchingRegExAndType (const RegularExpression &regex, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& indexes);
size_t FindAllSymbolsWithNameAndType (const ConstString &name, SymbolType symbol_type, std::vector<uint32_t>& symbol_indexes);
size_t FindAllSymbolsWithNameAndType (const ConstString &name, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& symbol_indexes);
size_t FindAllSymbolsMatchingRexExAndType (const RegularExpression &regex, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& symbol_indexes);
Symbol * FindFirstSymbolWithNameAndType (const ConstString &name, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility);
Symbol * FindSymbolWithFileAddress (lldb::addr_t file_addr);
// Symbol * FindSymbolContainingAddress (const Address& value, const uint32_t* indexes, uint32_t num_indexes);
// Symbol * FindSymbolContainingAddress (const Address& value);

6
lldb/include/lldb/Symbol/Type.h
View File

@ -128,7 +128,7 @@ public:
DumpValueInMemory(ExecutionContext *exe_ctx,
Stream *s,
lldb::addr_t address,
lldb::AddressType address_type,
AddressType address_type,
bool show_types,
bool show_summary,
bool verbose);
@ -136,13 +136,13 @@ public:
bool
ReadFromMemory (ExecutionContext *exe_ctx,
lldb::addr_t address,
lldb::AddressType address_type,
AddressType address_type,
DataExtractor &data);
bool
WriteToMemory (ExecutionContext *exe_ctx,
lldb::addr_t address,
lldb::AddressType address_type,
AddressType address_type,
DataExtractor &data);
bool

2
lldb/include/lldb/Target/LanguageRuntime.h
View File

@ -14,7 +14,7 @@
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/Core/PluginInterface.h"
#include "lldb/lldb-private.h"
#include "lldb/Core/ValueObject.h"

4
lldb/include/lldb/Target/ObjCLanguageRuntime.h
View File

@ -58,10 +58,10 @@ public:
virtual ClangUtilityFunction *
CreateObjectChecker (const char *) = 0;
virtual lldb::ObjCRuntimeVersions
virtual ObjCRuntimeVersions
GetRuntimeVersion ()
{
return lldb::eObjC_VersionUnknown;
return eObjC_VersionUnknown;
}
protected:

4
lldb/include/lldb/Target/Platform.h
View File

@ -17,7 +17,7 @@
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/Core/ArchSpec.h"
#include "lldb/Core/PluginInterface.h"
#include "lldb/Host/Mutex.h"
@ -335,7 +335,7 @@ namespace lldb_private {
virtual uint32_t
FindProcessesByName (const char *name,
lldb::NameMatchType name_match_type,
NameMatchType name_match_type,
ProcessInfoList &proc_infos) = 0;
virtual bool

6
lldb/include/lldb/Target/Process.h
View File

@ -59,7 +59,7 @@ public:
const char *value,
const ConstString &instance_name,
const SettingEntry &entry,
lldb::VarSetOperationType op,
VarSetOperationType op,
Error &err,
bool pending);
@ -1431,7 +1431,7 @@ public:
lldb::StateType
GetState ();
lldb::ExecutionResults
ExecutionResults
RunThreadPlan (ExecutionContext &exe_ctx,
lldb::ThreadPlanSP &thread_plan_sp,
bool stop_others,
@ -1441,7 +1441,7 @@ public:
Stream &errors);
static const char *
ExecutionResultAsCString (lldb::ExecutionResults result);
ExecutionResultAsCString (ExecutionResults result);
protected:
friend class CommandObjectProcessLaunch;

6
lldb/include/lldb/Target/RegisterContext.h
View File

@ -43,13 +43,13 @@ public:
virtual size_t
GetRegisterCount () = 0;
virtual const lldb::RegisterInfo *
virtual const RegisterInfo *
GetRegisterInfoAtIndex (uint32_t reg) = 0;
virtual size_t
GetRegisterSetCount () = 0;
virtual const lldb::RegisterSet *
virtual const RegisterSet *
GetRegisterSet (uint32_t reg_set) = 0;
virtual bool
@ -109,7 +109,7 @@ public:
return m_thread;
}
const lldb::RegisterInfo *
const RegisterInfo *
GetRegisterInfoByName (const char *reg_name, uint32_t start_idx = 0);
uint64_t

2
lldb/include/lldb/Target/SectionLoadList.h
View File

@ -17,7 +17,7 @@
// Other libraries and framework includes
#include "llvm/ADT/DenseMap.h"
// Project includes
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/Host/Mutex.h"
namespace lldb_private {

2
lldb/include/lldb/Target/StopInfo.h
View File

@ -14,7 +14,7 @@
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
namespace lldb_private {

47
lldb/include/lldb/Target/Target.h
View File

@ -15,7 +15,7 @@
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/Breakpoint/BreakpointList.h"
#include "lldb/Breakpoint/BreakpointLocationCollection.h"
#include "lldb/Core/Broadcaster.h"
@ -55,7 +55,7 @@ public:
const char *value,
const ConstString &instance_name,
const SettingEntry &entry,
lldb::VarSetOperationType op,
VarSetOperationType op,
Error &err,
bool pending);
@ -65,42 +65,6 @@ public:
StringList &value,
Error *err);
lldb::ExecutionLevel
GetExecutionLevel () const
{
return m_execution_level;
}
void
SetExecutionLevel (lldb::ExecutionLevel execution_level)
{
m_execution_level = execution_level;
}
lldb::ExecutionMode
GetExecutionMode () const
{
return m_execution_mode;
}
void
SetExecutionMode (lldb::ExecutionMode execution_mode)
{
m_execution_mode = execution_mode;
}
lldb::ExecutionOSType
GetExecutionOSType () const
{
return m_execution_os_type;
}
void
SetExecutionOSType (lldb::ExecutionOSType execution_os_type)
{
m_execution_os_type = execution_os_type;
}
protected:
void
@ -112,9 +76,6 @@ protected:
std::string m_expr_prefix_path;
std::string m_expr_prefix_contents;
lldb::ExecutionLevel m_execution_level;
lldb::ExecutionMode m_execution_mode;
lldb::ExecutionOSType m_execution_os_type;
};
@ -492,7 +453,7 @@ public:
// we provide a way for expressions to be evaluated from the Target itself.
// If an expression is going to be run, then it should have a frame filled
// in in th execution context.
lldb::ExecutionResults
ExecutionResults
EvaluateExpression (const char *expression,
StackFrame *frame,
bool unwind_on_error,
@ -662,7 +623,7 @@ public:
const char *index_value,
const char *value,
const SettingEntry &entry,
const lldb::VarSetOperationType op,
const VarSetOperationType op,
Error&err);
bool

12
lldb/include/lldb/Target/Thread.h
View File

@ -42,7 +42,7 @@ public:
const char *value,
const ConstString &instance_name,
const SettingEntry &entry,
lldb::VarSetOperationType op,
VarSetOperationType op,
Error &err,
bool pending);
@ -270,10 +270,10 @@ public:
bool
ShouldStop (Event *event_ptr);
lldb::Vote
Vote
ShouldReportStop (Event *event_ptr);
lldb::Vote
Vote
ShouldReportRun (Event *event_ptr);
// Return whether this thread matches the specification in ThreadSpec. This is a virtual
@ -442,7 +442,7 @@ public:
//------------------------------------------------------------------
virtual ThreadPlan *
QueueThreadPlanForStepRange (bool abort_other_plans,
lldb::StepType type,
StepType type,
const AddressRange &range,
const SymbolContext &addr_context,
lldb::RunMode stop_other_threads,
@ -481,8 +481,8 @@ public:
SymbolContext *addr_context,
bool first_insn,
bool stop_other_threads,
lldb::Vote stop_vote, // = lldb::eVoteYes,
lldb::Vote run_vote, // = lldb::eVoteNoOpinion);
Vote stop_vote, // = eVoteYes,
Vote run_vote, // = eVoteNoOpinion);
uint32_t frame_idx);
//------------------------------------------------------------------

4
lldb/include/lldb/Target/ThreadList.h
View File

@ -75,10 +75,10 @@ public:
bool
ShouldStop (Event *event_ptr);
lldb::Vote
Vote
ShouldReportStop (Event *event_ptr);
lldb::Vote
Vote
ShouldReportRun (Event *event_ptr);
void

12
lldb/include/lldb/Target/ThreadPlan.h
View File

@ -210,8 +210,8 @@ public:
ThreadPlan (ThreadPlanKind kind,
const char *name,
Thread &thread,
lldb::Vote stop_vote,
lldb::Vote run_vote);
Vote stop_vote,
Vote run_vote);
virtual
~ThreadPlan();
@ -293,10 +293,10 @@ public:
// Whether a "stop class" event should be reported to the "outside world". In general
// if a thread plan is active, events should not be reported.
virtual lldb::Vote
virtual Vote
ShouldReportStop (Event *event_ptr);
virtual lldb::Vote
virtual Vote
ShouldReportRun (Event *event_ptr);
virtual void
@ -409,8 +409,8 @@ protected:
Thread &m_thread;
lldb::Vote m_stop_vote;
lldb::Vote m_run_vote;
Vote m_stop_vote;
Vote m_run_vote;
private:
//------------------------------------------------------------------

2
lldb/include/lldb/Target/ThreadPlanStepInRange.h
View File

@ -61,7 +61,7 @@ private:
friend ThreadPlan *
Thread::QueueThreadPlanForStepRange (bool abort_other_plans,
lldb::StepType type,
StepType type,
const AddressRange &range,
const SymbolContext &addr_context,
lldb::RunMode stop_others,

4
lldb/include/lldb/Target/ThreadPlanStepInstruction.h
View File

@ -38,8 +38,8 @@ protected:
ThreadPlanStepInstruction (Thread &thread,
bool step_over,
bool stop_others,
lldb::Vote stop_vote,
lldb::Vote run_vote);
Vote stop_vote,
Vote run_vote);
private:
friend ThreadPlan *

8
lldb/include/lldb/Target/ThreadPlanStepOut.h
View File

@ -39,8 +39,8 @@ public:
SymbolContext *addr_context,
bool first_insn,
bool stop_others,
lldb::Vote stop_vote,
lldb::Vote run_vote,
Vote stop_vote,
Vote run_vote,
uint32_t frame_idx);
protected:
@ -58,8 +58,8 @@ private:
SymbolContext *addr_context,
bool first_insn,
bool stop_others,
lldb::Vote stop_vote,
lldb::Vote run_vote,
Vote stop_vote,
Vote run_vote,
uint32_t frame_idx);
// Need an appropriate marker for the current stack so we can tell step out

2
lldb/include/lldb/Target/ThreadPlanStepOverRange.h
View File

@ -42,7 +42,7 @@ private:
friend ThreadPlan *
Thread::QueueThreadPlanForStepRange (bool abort_other_plans,
lldb::StepType type,
StepType type,
const AddressRange &range,
const SymbolContext &addr_context,
lldb::RunMode stop_others,

2
lldb/include/lldb/Target/ThreadPlanStepRange.h
View File

@ -31,7 +31,7 @@ public:
virtual bool ValidatePlan (Stream *error);
virtual bool PlanExplainsStop ();
virtual bool ShouldStop (Event *event_ptr) = 0;
virtual lldb::Vote ShouldReportStop (Event *event_ptr);
virtual Vote ShouldReportStop (Event *event_ptr);
virtual bool StopOthers ();
virtual lldb::StateType GetPlanRunState ();
virtual bool WillStop ();

2
lldb/include/lldb/Target/ThreadPlanTestCondition.h
View File

@ -39,7 +39,7 @@ public:
virtual bool ValidatePlan (Stream *error);
virtual bool PlanExplainsStop ();
virtual bool ShouldStop (Event *event_ptr);
virtual lldb::Vote ShouldReportStop (Event *event_ptr);
virtual Vote ShouldReportStop (Event *event_ptr);
virtual bool StopOthers ();
virtual lldb::StateType GetPlanRunState ();
virtual bool WillStop ();

2
lldb/include/lldb/Utility/CleanUp.h
View File

@ -10,7 +10,7 @@
#ifndef liblldb_CleanUp_h_
#define liblldb_CleanUp_h_
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
namespace lldb_utility {

6
lldb/include/lldb/lldb-defines.h
View File

@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_defines_h_
#define LLDB_defines_h_
#ifndef LLDB_lldb_defines_h_
#define LLDB_lldb_defines_h_
#include "lldb/lldb-types.h"
@ -107,4 +107,4 @@
#endif // #if defined(__cplusplus)
#endif // LLDB_defines_h_
#endif // LLDB_lldb_defines_h_

322
lldb/include/lldb/lldb-enumerations.h
View File

@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_enumerations_h_
#define LLDB_enumerations_h_
#ifndef LLDB_lldb_enumerations_h_
#define LLDB_lldb_enumerations_h_
namespace lldb {
@ -33,19 +33,6 @@ typedef enum StateType
///< or threads get the chance to run.
} StateType;
//----------------------------------------------------------------------
// Thread Step Types
//----------------------------------------------------------------------
typedef enum StepType
{
eStepTypeNone,
eStepTypeTrace, ///< Single step one instruction.
eStepTypeTraceOver, ///< Single step one instruction, stepping over.
eStepTypeInto, ///< Single step into a specified context.
eStepTypeOver, ///< Single step over a specified context.
eStepTypeOut ///< Single step out a specified context.
} StepType;
//----------------------------------------------------------------------
// Launch Flags
//----------------------------------------------------------------------
@ -66,32 +53,6 @@ typedef enum RunMode {
eOnlyDuringStepping
} RunMode;
//----------------------------------------------------------------------
// Address Types
//----------------------------------------------------------------------
typedef enum AddressType
{
eAddressTypeInvalid = 0,
eAddressTypeFile, ///< Address is an address as found in an object or symbol file
eAddressTypeLoad, ///< Address is an address as in the current target inferior process
eAddressTypeHost ///< Address is an address in the process that is running this code
} AddressType;
//----------------------------------------------------------------------
// Address Types
//----------------------------------------------------------------------
typedef enum AddressClass
{
eAddressClassInvalid,
eAddressClassUnknown,
eAddressClassCode,
eAddressClassCodeAlternateISA,
eAddressClassData,
eAddressClassDataConst,
eAddressClassDebug,
eAddressClassRuntime
} AddressClass;
//----------------------------------------------------------------------
// Byte ordering definitions
//----------------------------------------------------------------------
@ -206,50 +167,6 @@ typedef enum StopReason
eStopReasonPlanComplete
} StopReason;
//----------------------------------------------------------------------
// Votes - Need a tri-state, yes, no, no opinion...
//----------------------------------------------------------------------
typedef enum Vote
{
eVoteNo = -1,
eVoteNoOpinion = 0,
eVoteYes = 1
} Vote;
//----------------------------------------------------------------------
// Symbol types
//----------------------------------------------------------------------
typedef enum SymbolType
{
eSymbolTypeAny = 0,
eSymbolTypeInvalid = 0,
eSymbolTypeAbsolute,
eSymbolTypeExtern,
eSymbolTypeCode,
eSymbolTypeData,
eSymbolTypeTrampoline,
eSymbolTypeRuntime,
eSymbolTypeException,
eSymbolTypeSourceFile,
eSymbolTypeHeaderFile,
eSymbolTypeObjectFile,
eSymbolTypeCommonBlock,
eSymbolTypeBlock,
eSymbolTypeLocal,
eSymbolTypeParam,
eSymbolTypeVariable,
eSymbolTypeVariableType,
eSymbolTypeLineEntry,
eSymbolTypeLineHeader,
eSymbolTypeScopeBegin,
eSymbolTypeScopeEnd,
eSymbolTypeAdditional, // When symbols take more than one entry, the extra entries get this type
eSymbolTypeCompiler,
eSymbolTypeInstrumentation,
eSymbolTypeUndefined
} SymbolType;
//----------------------------------------------------------------------
// Command Return Status Types
//----------------------------------------------------------------------
@ -279,7 +196,6 @@ typedef enum ConnectionStatus
eConnectionStatusLostConnection // Lost connection while connected to a valid connection
} ConnectionStatus;
typedef enum ErrorType
{
eErrorTypeInvalid,
@ -343,40 +259,6 @@ typedef enum Permissions
ePermissionsExecutable = (1 << 2)
} Permissions;
typedef enum SectionType
{
eSectionTypeInvalid,
eSectionTypeCode,
eSectionTypeContainer, // The section contains child sections
eSectionTypeData,
eSectionTypeDataCString, // Inlined C string data
eSectionTypeDataCStringPointers, // Pointers to C string data
eSectionTypeDataSymbolAddress, // Address of a symbol in the symbol table
eSectionTypeData4,
eSectionTypeData8,
eSectionTypeData16,
eSectionTypeDataPointers,
eSectionTypeDebug,
eSectionTypeZeroFill,
eSectionTypeDataObjCMessageRefs, // Pointer to function pointer + selector
eSectionTypeDataObjCCFStrings, // Objective C const CFString/NSString objects
eSectionTypeDWARFDebugAbbrev,
eSectionTypeDWARFDebugAranges,
eSectionTypeDWARFDebugFrame,
eSectionTypeDWARFDebugInfo,
eSectionTypeDWARFDebugLine,
eSectionTypeDWARFDebugLoc,
eSectionTypeDWARFDebugMacInfo,
eSectionTypeDWARFDebugPubNames,
eSectionTypeDWARFDebugPubTypes,
eSectionTypeDWARFDebugRanges,
eSectionTypeDWARFDebugStr,
eSectionTypeEHFrame,
eSectionTypeOther
} SectionType;
typedef enum InputReaderAction
{
eInputReaderActivate, // reader is newly pushed onto the reader stack
@ -388,32 +270,6 @@ typedef enum InputReaderAction
eInputReaderDone // reader was just popped off the stack and is done
} InputReaderAction;
typedef enum ArchitectureType
{
eArchTypeInvalid,
eArchTypeMachO,
eArchTypeELF,
kNumArchTypes
} ArchitectureType;
typedef enum FunctionNameType
{
eFunctionNameTypeNone = 0u,
eFunctionNameTypeAuto = (1u << 1), // Automatically figure out which FunctionNameType
// bits to set based on the function name.
eFunctionNameTypeFull = (1u << 2), // The function name.
// For C this is the same as just the name of the function
// For C++ this is the demangled version of the mangled name.
// For ObjC this is the full function signature with the + or
// - and the square brackets and the class and selector
eFunctionNameTypeBase = (1u << 3), // The function name only, no namespaces or arguments and no class
// methods or selectors will be searched.
eFunctionNameTypeMethod = (1u << 4), // Find function by method name (C++) with no namespace or arguments
eFunctionNameTypeSelector = (1u << 5) // Find function by selector name (ObjC) names
} FunctionNameType;
typedef enum BreakpointEventType
{
eBreakpointEventTypeInvalidType = (1u << 0),
@ -466,39 +322,6 @@ typedef enum AccessType
eAccessPackage
} AccessType;
//----------------------------------------------------------------------
/// Settable state variable types.
///
//----------------------------------------------------------------------
typedef enum SettableVariableType
{
eSetVarTypeInt,
eSetVarTypeBoolean,
eSetVarTypeString,
eSetVarTypeArray,
eSetVarTypeDictionary,
eSetVarTypeEnum,
eSetVarTypeNone
} SettableVariableType;
typedef enum VarSetOperationType
{
eVarSetOperationReplace,
eVarSetOperationInsertBefore,
eVarSetOperationInsertAfter,
eVarSetOperationRemove,
eVarSetOperationAppend,
eVarSetOperationClear,
eVarSetOperationAssign,
eVarSetOperationInvalid
} VarSetOperationType;
//----------------------------------------------------------------------
/// Command argument types.
///
//----------------------------------------------------------------------
typedef enum CommandArgumentType
{
eArgTypeAddress = 0,
@ -564,146 +387,7 @@ typedef enum CommandArgumentType
eArgTypeLastArg // Always keep this entry as the last entry in this enumeration!!
} CommandArgumentType;
typedef enum ArgumentRepetitionType
{
eArgRepeatPlain, // Exactly one occurrence
eArgRepeatOptional, // At most one occurrence, but it's optional
eArgRepeatPlus, // One or more occurrences
eArgRepeatStar, // Zero or more occurrences
eArgRepeatRange, // Repetition of same argument, from 1 to n
eArgRepeatPairPlain, // A pair of arguments that must always go together ([arg-type arg-value]), occurs exactly once
eArgRepeatPairOptional, // A pair that occurs at most once (optional)
eArgRepeatPairPlus, // One or more occurrences of a pair
eArgRepeatPairStar, // Zero or more occurrences of a pair
eArgRepeatPairRange, // A pair that repeats from 1 to n
eArgRepeatPairRangeOptional // A pair that repeats from 1 to n, but is optional
} ArgumentRepetitionType;
typedef enum SortOrder
{
eSortOrderNone,
eSortOrderByAddress,
eSortOrderByName
} SortOrder;
//----------------------------------------------------------------------
// Used in conjunction with Host::GetLLDBResource () to find files that
// are related to
//----------------------------------------------------------------------
typedef enum PathType
{
ePathTypeLLDBShlibDir, // The directory where the lldb.so (unix) or LLDB mach-o file in LLDB.framework (MacOSX) exists
ePathTypeSupportExecutableDir, // Find LLDB support executable directory (debugserver, etc)
ePathTypeHeaderDir, // Find LLDB header file directory
ePathTypePythonDir, // Find Python modules (PYTHONPATH) directory
ePathTypeLLDBSystemPlugins, // System plug-ins directory
ePathTypeLLDBUserPlugins // User plug-ins directory
} PathType;
//----------------------------------------------------------------------
// We can execute ThreadPlans on one thread with various fall-back modes
// (try other threads after timeout, etc.) This enum gives the result of
// thread plan executions.
//----------------------------------------------------------------------
typedef enum ExecutionResults
{
eExecutionSetupError,
eExecutionCompleted,
eExecutionDiscarded,
eExecutionInterrupted,
eExecutionTimedOut
} ExecutionResults;
typedef enum ObjCRuntimeVersions {
eObjC_VersionUnknown = 0,
eAppleObjC_V1 = 1,
eAppleObjC_V2 = 2
} ObjCRuntimeVersions;
//----------------------------------------------------------------------
// LazyBool is for boolean values that need to be calculated lazily.
// Values start off set to eLazyBoolCalculate, and then they can be
// calculated once and set to eLazyBoolNo or eLazyBoolYes.
//----------------------------------------------------------------------
typedef enum LazyBool {
eLazyBoolCalculate = -1,
eLazyBoolNo = 0,
eLazyBoolYes = 1
} LazyBool;
//------------------------------------------------------------------
/// Execution Level
//------------------------------------------------------------------
typedef enum ExecutionLevel
{
eExecutionLevelAuto, // Automatically detect how to run an executable
eExecutionLevelKernel, // Execute a program as a kernel executable
eExecutionLevelUser // Execute a program as a user space executable
} ExecutionLevel;
//------------------------------------------------------------------
/// Execution mode
//------------------------------------------------------------------
typedef enum ExecutionMode
{
// Automatically detect the execution mode
eExecutionModeAuto,
// Execute with no shared libraries, everything is where the executable
// files say they are (file addresses == load addresses)
eExecutionModeStatic,
// Execute with shared libraries using a dynamic loader plug-in to
// detect when shared libraries are loaded/unloaded.
eExecutionModeDynamic
} ExecutionMode;
//------------------------------------------------------------------
/// Execution OS
//------------------------------------------------------------------
typedef enum ExecutionOSType
{
// Automatically detect the execution operating system
eExecutionOSTypeAuto,
// There is no operating system (no processes or threads).
eExecutionOSTypeNone,
// There is an OS, but when we execution stops, the entire OS is halted
// (common when debugging in eExecutionLevelKernel modes). Processes and
// threads can be queried, selected and switched between using memory
// reads/writes using a ProcessHelper plug-in (which has yet to be
// designed).
eExecutionOSTypeHalted,
// There is live OS with debug services that we can talk to for process,
// thread, and other OS queries.
eExecutionOSTypeLive
} ExecutionOSType;
//------------------------------------------------------------------
/// Name matching
//------------------------------------------------------------------
typedef enum NameMatchType
{
eNameMatchIgnore,
eNameMatchEquals,
eNameMatchContains,
eNameMatchStartsWith,
eNameMatchEndsWith,
eNameMatchRegularExpression
} NameMatchType;
} // namespace lldb
#endif // LLDB_enumerations_h_
#endif // LLDB_lldb_enumerations_h_

6
lldb/include/lldb/lldb-forward-rtti.h
View File

@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_forward_rtti_h_
#define LLDB_forward_rtti_h_
#ifndef LLDB_lldb_forward_rtti_h_
#define LLDB_lldb_forward_rtti_h_
#if defined(__cplusplus)
@ -79,4 +79,4 @@ namespace lldb {
#endif // #if defined(__cplusplus)
#endif // LLDB_forward_rtti_h_
#endif // LLDB_lldb_forward_rtti_h_

6
lldb/include/lldb/lldb-forward.h
View File

@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_forward_h_
#define LLDB_forward_h_
#ifndef LLDB_lldb_forward_h_
#define LLDB_lldb_forward_h_
#if defined(__cplusplus)
@ -169,4 +169,4 @@ struct LineEntry;
} // namespace lldb_private
#endif // #if defined(__cplusplus)
#endif // LLDB_forward_h_
#endif // LLDB_lldb_forward_h_

277
lldb/include/lldb/lldb-private-enumerations.h Normal file
View File

@ -0,0 +1,277 @@
//===-- lldb-enumerations.h -------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_lldb_private_enumerations_h_
#define LLDB_lldb_private_enumerations_h_
namespace lldb_private {
//----------------------------------------------------------------------
// Thread Step Types
//----------------------------------------------------------------------
typedef enum StepType
{
eStepTypeNone,
eStepTypeTrace, ///< Single step one instruction.
eStepTypeTraceOver, ///< Single step one instruction, stepping over.
eStepTypeInto, ///< Single step into a specified context.
eStepTypeOver, ///< Single step over a specified context.
eStepTypeOut ///< Single step out a specified context.
} StepType;
//----------------------------------------------------------------------
// Address Types
//----------------------------------------------------------------------
typedef enum AddressType
{
eAddressTypeInvalid = 0,
eAddressTypeFile, ///< Address is an address as found in an object or symbol file
eAddressTypeLoad, ///< Address is an address as in the current target inferior process
eAddressTypeHost ///< Address is an address in the process that is running this code
} AddressType;
//----------------------------------------------------------------------
// Address Class
//
// A way of classifying an address used for disassembling and setting
// breakpoints. Many object files can track exactly what parts of their
// object files are code, data and other information. This is of course
// above and beyond just looking at the section types. For example, code
// might contain PC relative data and the object file might be able to
// tell us that an address in code is data.
//----------------------------------------------------------------------
typedef enum AddressClass
{
eAddressClassInvalid,
eAddressClassUnknown,
eAddressClassCode,
eAddressClassCodeAlternateISA,
eAddressClassData,
eAddressClassDebug,
eAddressClassRuntime
} AddressClass;
//----------------------------------------------------------------------
// Votes - Need a tri-state, yes, no, no opinion...
//----------------------------------------------------------------------
typedef enum Vote
{
eVoteNo = -1,
eVoteNoOpinion = 0,
eVoteYes = 1
} Vote;
//----------------------------------------------------------------------
// Symbol types
//----------------------------------------------------------------------
typedef enum SymbolType
{
eSymbolTypeAny = 0,
eSymbolTypeInvalid = 0,
eSymbolTypeAbsolute,
eSymbolTypeExtern,
eSymbolTypeCode,
eSymbolTypeData,
eSymbolTypeTrampoline,
eSymbolTypeRuntime,
eSymbolTypeException,
eSymbolTypeSourceFile,
eSymbolTypeHeaderFile,
eSymbolTypeObjectFile,
eSymbolTypeCommonBlock,
eSymbolTypeBlock,
eSymbolTypeLocal,
eSymbolTypeParam,
eSymbolTypeVariable,
eSymbolTypeVariableType,
eSymbolTypeLineEntry,
eSymbolTypeLineHeader,
eSymbolTypeScopeBegin,
eSymbolTypeScopeEnd,
eSymbolTypeAdditional, // When symbols take more than one entry, the extra entries get this type
eSymbolTypeCompiler,
eSymbolTypeInstrumentation,
eSymbolTypeUndefined
} SymbolType;
typedef enum SectionType
{
eSectionTypeInvalid,
eSectionTypeCode,
eSectionTypeContainer, // The section contains child sections
eSectionTypeData,
eSectionTypeDataCString, // Inlined C string data
eSectionTypeDataCStringPointers, // Pointers to C string data
eSectionTypeDataSymbolAddress, // Address of a symbol in the symbol table
eSectionTypeData4,
eSectionTypeData8,
eSectionTypeData16,
eSectionTypeDataPointers,
eSectionTypeDebug,
eSectionTypeZeroFill,
eSectionTypeDataObjCMessageRefs, // Pointer to function pointer + selector
eSectionTypeDataObjCCFStrings, // Objective C const CFString/NSString objects
eSectionTypeDWARFDebugAbbrev,
eSectionTypeDWARFDebugAranges,
eSectionTypeDWARFDebugFrame,
eSectionTypeDWARFDebugInfo,
eSectionTypeDWARFDebugLine,
eSectionTypeDWARFDebugLoc,
eSectionTypeDWARFDebugMacInfo,
eSectionTypeDWARFDebugPubNames,
eSectionTypeDWARFDebugPubTypes,
eSectionTypeDWARFDebugRanges,
eSectionTypeDWARFDebugStr,
eSectionTypeEHFrame,
eSectionTypeOther
} SectionType;
typedef enum ArchitectureType
{
eArchTypeInvalid,
eArchTypeMachO,
eArchTypeELF,
kNumArchTypes
} ArchitectureType;
typedef enum FunctionNameType
{
eFunctionNameTypeNone = 0u,
eFunctionNameTypeAuto = (1u << 1), // Automatically figure out which FunctionNameType
// bits to set based on the function name.
eFunctionNameTypeFull = (1u << 2), // The function name.
// For C this is the same as just the name of the function
// For C++ this is the demangled version of the mangled name.
// For ObjC this is the full function signature with the + or
// - and the square brackets and the class and selector
eFunctionNameTypeBase = (1u << 3), // The function name only, no namespaces or arguments and no class
// methods or selectors will be searched.
eFunctionNameTypeMethod = (1u << 4), // Find function by method name (C++) with no namespace or arguments
eFunctionNameTypeSelector = (1u << 5) // Find function by selector name (ObjC) names
} FunctionNameType;
//----------------------------------------------------------------------
/// Settable state variable types.
///
//----------------------------------------------------------------------
typedef enum SettableVariableType
{
eSetVarTypeInt,
eSetVarTypeBoolean,
eSetVarTypeString,
eSetVarTypeArray,
eSetVarTypeDictionary,
eSetVarTypeEnum,
eSetVarTypeNone
} SettableVariableType;
typedef enum VarSetOperationType
{
eVarSetOperationReplace,
eVarSetOperationInsertBefore,
eVarSetOperationInsertAfter,
eVarSetOperationRemove,
eVarSetOperationAppend,
eVarSetOperationClear,
eVarSetOperationAssign,
eVarSetOperationInvalid
} VarSetOperationType;
typedef enum ArgumentRepetitionType
{
eArgRepeatPlain, // Exactly one occurrence
eArgRepeatOptional, // At most one occurrence, but it's optional
eArgRepeatPlus, // One or more occurrences
eArgRepeatStar, // Zero or more occurrences
eArgRepeatRange, // Repetition of same argument, from 1 to n
eArgRepeatPairPlain, // A pair of arguments that must always go together ([arg-type arg-value]), occurs exactly once
eArgRepeatPairOptional, // A pair that occurs at most once (optional)
eArgRepeatPairPlus, // One or more occurrences of a pair
eArgRepeatPairStar, // Zero or more occurrences of a pair
eArgRepeatPairRange, // A pair that repeats from 1 to n
eArgRepeatPairRangeOptional // A pair that repeats from 1 to n, but is optional
} ArgumentRepetitionType;
typedef enum SortOrder
{
eSortOrderNone,
eSortOrderByAddress,
eSortOrderByName
} SortOrder;
//----------------------------------------------------------------------
// Used in conjunction with Host::GetLLDBResource () to find files that
// are related to
//----------------------------------------------------------------------
typedef enum PathType
{
ePathTypeLLDBShlibDir, // The directory where the lldb.so (unix) or LLDB mach-o file in LLDB.framework (MacOSX) exists
ePathTypeSupportExecutableDir, // Find LLDB support executable directory (debugserver, etc)
ePathTypeHeaderDir, // Find LLDB header file directory
ePathTypePythonDir, // Find Python modules (PYTHONPATH) directory
ePathTypeLLDBSystemPlugins, // System plug-ins directory
ePathTypeLLDBUserPlugins // User plug-ins directory
} PathType;
//----------------------------------------------------------------------
// We can execute ThreadPlans on one thread with various fall-back modes
// (try other threads after timeout, etc.) This enum gives the result of
// thread plan executions.
//----------------------------------------------------------------------
typedef enum ExecutionResults
{
eExecutionSetupError,
eExecutionCompleted,
eExecutionDiscarded,
eExecutionInterrupted,
eExecutionTimedOut
} ExecutionResults;
typedef enum ObjCRuntimeVersions {
eObjC_VersionUnknown = 0,
eAppleObjC_V1 = 1,
eAppleObjC_V2 = 2
} ObjCRuntimeVersions;
//----------------------------------------------------------------------
// LazyBool is for boolean values that need to be calculated lazily.
// Values start off set to eLazyBoolCalculate, and then they can be
// calculated once and set to eLazyBoolNo or eLazyBoolYes.
//----------------------------------------------------------------------
typedef enum LazyBool {
eLazyBoolCalculate = -1,
eLazyBoolNo = 0,
eLazyBoolYes = 1
} LazyBool;
//------------------------------------------------------------------
/// Name matching
//------------------------------------------------------------------
typedef enum NameMatchType
{
eNameMatchIgnore,
eNameMatchEquals,
eNameMatchContains,
eNameMatchStartsWith,
eNameMatchEndsWith,
eNameMatchRegularExpression
} NameMatchType;
} // namespace lldb
#endif // LLDB_lldb_private_enumerations_h_

8
lldb/include/lldb/lldb-private-interfaces.h
View File

@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_lldb_interfaces_h_
#define liblldb_lldb_interfaces_h_
#ifndef liblldb_lldb_private_interfaces_h_
#define liblldb_lldb_private_interfaces_h_
#if defined(__cplusplus)
@ -34,8 +34,10 @@ namespace lldb_private
typedef UnwindAssemblyProfiler* (*UnwindAssemblyProfilerCreateInstance) (const ArchSpec &arch);
typedef ArchDefaultUnwindPlan* (*ArchDefaultUnwindPlanCreateInstance) (const ArchSpec &arch);
typedef ArchVolatileRegs* (*ArchVolatileRegsCreateInstance) (const ArchSpec &arch);
typedef int (*ComparisonFunction)(const void *, const void *);
} // namespace lldb_private
#endif // #if defined(__cplusplus)
#endif // liblldb_lldb_interfaces_h_
#endif // liblldb_lldb_private_interfaces_h_

6
lldb/include/lldb/lldb-private-log.h
View File

@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_lldb_log_h_
#define liblldb_lldb_log_h_
#ifndef liblldb_lldb_private_log_h_
#define liblldb_lldb_private_log_h_
// C Includes
// C++ Includes
@ -82,4 +82,4 @@ ListLogCategories (Stream *strm);
} // namespace lldb_private
#endif // liblldb_lldb_log_h_
#endif // liblldb_lldb_private_log_h_

99
lldb/include/lldb/lldb-private-types.h Normal file
View File

@ -0,0 +1,99 @@
//===-- lldb-private-types.h ------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_lldb_private_types_h_
#define liblldb_lldb_private_types_h_
#if defined(__cplusplus)
#include "lldb/lldb-private.h"
namespace lldb_private
{
//----------------------------------------------------------------------
// Every register is described in detail including its name, alternate
// name (optional), encoding, size in bytes and the default display
// format.
//----------------------------------------------------------------------
typedef struct
{
const char *name; // Name of this register, can't be NULL
const char *alt_name; // Alternate name of this register, can be NULL
uint32_t byte_size; // Size in bytes of the register
uint32_t byte_offset; // The byte offset in the register context data where this register's value is found
lldb::Encoding encoding; // Encoding of the register bits
lldb::Format format; // Default display format
uint32_t kinds[lldb::kNumRegisterKinds]; // Holds all of the various register numbers for all register kinds
} RegisterInfo;
//----------------------------------------------------------------------
// Registers are grouped into register sets
//----------------------------------------------------------------------
typedef struct
{
const char * name; // Name of this register set
const char * short_name; // A short name for this register set
size_t num_registers; // The number of registers in REGISTERS array below
const uint32_t *registers; // An array of register numbers in this set
} RegisterSet;
typedef struct
{
int value;
const char * string_value;
const char * usage;
} OptionEnumValueElement;
typedef struct
{
uint32_t usage_mask; // Used to mark options that can be used together. If (1 << n & usage_mask) != 0
// then this option belongs to option set n.
bool required; // This option is required (in the current usage level)
const char * long_option; // Full name for this option.
char short_option; // Single character for this option.
int option_has_arg; // no_argument, required_argument or optional_argument
OptionEnumValueElement *enum_values; // If non-NULL an array of enum values.
uint32_t completionType; // Cookie the option class can use to do define the argument completion.
lldb::CommandArgumentType argument_type; // Type of argument this option takes
const char * usage_text; // Full text explaining what this options does and what (if any) argument to
// pass it.
} OptionDefinition;
enum OpcodeType
{
eOpcode8,
eOpcode16,
eOpcode32,
eOpcode64,
eOpcodeBytes
};
struct Opcode
{
OpcodeType type;
union
{
uint8_t inst8;
uint16_t inst16;
uint32_t inst32;
uint64_t inst64;
struct
{
uint8_t length;
uint8_t bytes[16]; // This must be big enough to handle any opcode for any supported target.
} inst;
} data;
};
} // namespace lldb_private
#endif // #if defined(__cplusplus)
#endif // liblldb_lldb_private_types_h_

10
lldb/include/lldb/lldb-private.h
View File

@ -12,9 +12,11 @@
#if defined(__cplusplus)
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/lldb-private-enumerations.h"
#include "lldb/lldb-private-interfaces.h"
#include "lldb/lldb-private-log.h"
#include "lldb/lldb-private-types.h"
namespace lldb_private {
@ -65,13 +67,13 @@ const char *
GetVersion ();
const char *
GetVoteAsCString (lldb::Vote vote);
GetVoteAsCString (Vote vote);
const char *
GetSectionTypeAsCString (lldb::SectionType sect_type);
GetSectionTypeAsCString (SectionType sect_type);
bool
NameMatches (const char *name, lldb::NameMatchType match_type, const char *match);
NameMatches (const char *name, NameMatchType match_type, const char *match);
} // namespace lldb_private

9
lldb/include/lldb/lldb-include.h → lldb/include/lldb/lldb-public.h
View File

@ -7,10 +7,13 @@
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_include_h_
#define LLDB_include_h_
#ifndef LLDB_lldb_h_
#define LLDB_lldb_h_
#include "lldb/lldb-defines.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-forward-rtti.h"
#include "lldb/lldb-types.h"
#endif // LLDB_include_h_
#endif // LLDB_lldb_h_

80
lldb/include/lldb/lldb-types.h
View File

@ -7,19 +7,13 @@
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_types_h_
#define LLDB_types_h_
#ifndef LLDB_lldb_types_h_
#define LLDB_lldb_types_h_
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/Utility/SharingPtr.h"
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// MACOSX START
//----------------------------------------------------------------------
//----------------------------------------------------------------------
#include <assert.h>
#include <pthread.h>
#include <signal.h>
@ -88,79 +82,15 @@ const lldb::thread_t lldb_invalid_host_thread_const = { NULL, 0 } ;
#define LLDB_INVALID_HOST_TIME { 0, 0 }
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// MACOSX END
//----------------------------------------------------------------------
//----------------------------------------------------------------------
#ifdef SWIG
#define CONST_CHAR_PTR char *
#else
#define CONST_CHAR_PTR const char *
#endif
namespace lldb {
namespace lldb
{
typedef uint64_t addr_t;
typedef uint32_t user_id_t;
typedef int32_t pid_t;
typedef uint32_t tid_t;
typedef int32_t break_id_t;
typedef void * clang_type_t;
//----------------------------------------------------------------------
// Every register is described in detail including its name, alternate
// name (optional), encoding, size in bytes and the default display
// format.
//----------------------------------------------------------------------
typedef struct
{
CONST_CHAR_PTR name; // Name of this register, can't be NULL
CONST_CHAR_PTR alt_name; // Alternate name of this register, can be NULL
uint32_t byte_size; // Size in bytes of the register
uint32_t byte_offset; // The byte offset in the register context data where this register's value is found
lldb::Encoding encoding; // Encoding of the register bits
lldb::Format format; // Default display format
uint32_t kinds[kNumRegisterKinds]; // Holds all of the various register numbers for all register kinds
} RegisterInfo;
//----------------------------------------------------------------------
// Registers are grouped into register sets
//----------------------------------------------------------------------
typedef struct
{
CONST_CHAR_PTR name; // Name of this register set
CONST_CHAR_PTR short_name; // A short name for this register set
size_t num_registers; // The number of registers in REGISTERS array below
const uint32_t *registers; // An array of register numbers in this set
} RegisterSet;
typedef struct
{
int value;
CONST_CHAR_PTR string_value;
CONST_CHAR_PTR usage;
} OptionEnumValueElement;
typedef struct
{
uint32_t usage_mask; // Used to mark options that can be used together. If (1 << n & usage_mask) != 0
// then this option belongs to option set n.
bool required; // This option is required (in the current usage level)
CONST_CHAR_PTR long_option; // Full name for this option.
char short_option; // Single character for this option.
int option_has_arg; // no_argument, required_argument or optional_argument
OptionEnumValueElement *enum_values;// If non-NULL an array of enum values.
uint32_t completionType; // Cookie the option class can use to do define the argument completion.
lldb::CommandArgumentType argument_type; // Type of argument this option takes
CONST_CHAR_PTR usage_text; // Full text explaining what this options does and what (if any) argument to
// pass it.
} OptionDefinition;
typedef int (*comparison_function)(const void *, const void *);
}
#undef CONST_CHAR_PTR
#endif // LLDB_types_h_
#endif // LLDB_lldb_types_h_

12
lldb/lldb.xcodeproj/project.pbxproj
View File

@ -370,7 +370,6 @@
26B1FCBC13381071002886E2 /* libobjc.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 26F5C37410F3F61B009D5894 /* libobjc.dylib */; };
26B1FCBD13381071002886E2 /* Carbon.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4C74CB6212288704006A8171 /* Carbon.framework */; };
26B1FCC21338115F002886E2 /* Host.mm in Sources */ = {isa = PBXBuildFile; fileRef = 26BC7EE810F1B88F00F91463 /* Host.mm */; };
26B42B1F1187A92B0079C8C8 /* lldb-include.h in Headers */ = {isa = PBXBuildFile; fileRef = 26B42B1E1187A92B0079C8C8 /* lldb-include.h */; settings = {ATTRIBUTES = (Public, ); }; };
26B42C4D1187ABA50079C8C8 /* LLDB.h in Headers */ = {isa = PBXBuildFile; fileRef = 26B42C4C1187ABA50079C8C8 /* LLDB.h */; settings = {ATTRIBUTES = (Public, ); }; };
26C72C94124322890068DC16 /* SBStream.h in Headers */ = {isa = PBXBuildFile; fileRef = 26C72C93124322890068DC16 /* SBStream.h */; settings = {ATTRIBUTES = (Public, ); }; };
26C72C961243229A0068DC16 /* SBStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26C72C951243229A0068DC16 /* SBStream.cpp */; };
@ -608,6 +607,8 @@
2618EE641315B29C001D6D71 /* ThreadGDBRemote.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ThreadGDBRemote.h; sourceTree = "<group>"; };
261B5A5211C3F2AD00AABD0A /* SharingPtr.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SharingPtr.cpp; path = source/Utility/SharingPtr.cpp; sourceTree = "<group>"; };
261B5A5311C3F2AD00AABD0A /* SharingPtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SharingPtr.h; path = include/lldb/Utility/SharingPtr.h; sourceTree = "<group>"; };
26217930133BC8640083B112 /* lldb-private-types.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = "lldb-private-types.h"; path = "include/lldb/lldb-private-types.h"; sourceTree = "<group>"; };
26217932133BCB850083B112 /* lldb-private-enumerations.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = "lldb-private-enumerations.h"; path = "include/lldb/lldb-private-enumerations.h"; sourceTree = "<group>"; };
263664921140A4930075843B /* Debugger.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Debugger.cpp; path = source/Core/Debugger.cpp; sourceTree = "<group>"; };
263664941140A4C10075843B /* Debugger.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Debugger.h; path = include/lldb/Core/Debugger.h; sourceTree = "<group>"; };
26368A3B126B697600E8659F /* darwin-debug.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = "darwin-debug.cpp"; path = "tools/darwin-debug/darwin-debug.cpp"; sourceTree = "<group>"; };
@ -629,6 +630,7 @@
2660D9F611922A1300958FBD /* StringExtractor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StringExtractor.cpp; path = source/Utility/StringExtractor.cpp; sourceTree = "<group>"; };
2660D9F711922A1300958FBD /* StringExtractor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = StringExtractor.h; path = source/Utility/StringExtractor.h; sourceTree = "<group>"; };
2660D9FE11922A7F00958FBD /* ThreadPlanStepUntil.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ThreadPlanStepUntil.cpp; path = source/Target/ThreadPlanStepUntil.cpp; sourceTree = "<group>"; };
26651A14133BEC76005B64B7 /* lldb-public.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = "lldb-public.h"; path = "include/lldb/lldb-public.h"; sourceTree = "<group>"; };
26680207115FD0ED008E1FE4 /* LLDB.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = LLDB.framework; sourceTree = BUILT_PRODUCTS_DIR; };
266960591199F4230075C61A /* build-llvm.pl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.perl; path = "build-llvm.pl"; sourceTree = "<group>"; };
2669605A1199F4230075C61A /* build-swig-wrapper-classes.sh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.sh; path = "build-swig-wrapper-classes.sh"; sourceTree = "<group>"; };
@ -682,7 +684,6 @@
26A3B4AD1181454800381BC2 /* ObjectContainerBSDArchive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ObjectContainerBSDArchive.h; sourceTree = "<group>"; };
26A4EEB511682AAC007A372A /* LLDBWrapPython.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LLDBWrapPython.cpp; path = source/LLDBWrapPython.cpp; sourceTree = "<group>"; };
26B167A41123BF5500DC7B4F /* ThreadSafeValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ThreadSafeValue.h; path = include/lldb/Core/ThreadSafeValue.h; sourceTree = "<group>"; };
26B42B1E1187A92B0079C8C8 /* lldb-include.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = "lldb-include.h"; path = "include/lldb/lldb-include.h"; sourceTree = "<group>"; };
26B42C4C1187ABA50079C8C8 /* LLDB.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LLDB.h; path = include/lldb/API/LLDB.h; sourceTree = "<group>"; };
26B4E26E112F35F700AB3F64 /* TimeValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TimeValue.h; path = include/lldb/Host/TimeValue.h; sourceTree = "<group>"; };
26B8B42212EEC52A00A831B2 /* UniqueDWARFASTType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UniqueDWARFASTType.h; sourceTree = "<group>"; };
@ -1263,8 +1264,10 @@
26BC7E7410F1B85900F91463 /* lldb.cpp */,
26BC7E7510F1B85900F91463 /* lldb-log.cpp */,
26BC7C2A10F1B3BC00F91463 /* lldb-private.h */,
26217932133BCB850083B112 /* lldb-private-enumerations.h */,
26BC7C2810F1B3BC00F91463 /* lldb-private-interfaces.h */,
26BC7D5D10F1B77400F91463 /* lldb-private-log.h */,
26217930133BC8640083B112 /* lldb-private-types.h */,
262D3190111B4341004E6F88 /* API */,
26BC7CEB10F1B70800F91463 /* Breakpoint */,
26BC7D0D10F1B71D00F91463 /* Commands */,
@ -1560,9 +1563,9 @@
children = (
26BC7C2510F1B3BC00F91463 /* lldb-defines.h */,
26BC7C2610F1B3BC00F91463 /* lldb-enumerations.h */,
26DE1E6911616C2E00A093E2 /* lldb-forward-rtti.h */,
26DE1E6A11616C2E00A093E2 /* lldb-forward.h */,
26B42B1E1187A92B0079C8C8 /* lldb-include.h */,
26DE1E6911616C2E00A093E2 /* lldb-forward-rtti.h */,
26651A14133BEC76005B64B7 /* lldb-public.h */,
26BC7C2910F1B3BC00F91463 /* lldb-types.h */,
26B42C4C1187ABA50079C8C8 /* LLDB.h */,
9A9830FC1125FC5800A56CB0 /* SBDefines.h */,
@ -2452,7 +2455,6 @@
2668020F115FD12C008E1FE4 /* lldb-enumerations.h in Headers */,
26DE1E6C11616C2E00A093E2 /* lldb-forward.h in Headers */,
26DE1E6B11616C2E00A093E2 /* lldb-forward-rtti.h in Headers */,
26B42B1F1187A92B0079C8C8 /* lldb-include.h in Headers */,
26680214115FD12C008E1FE4 /* lldb-types.h in Headers */,
26B42C4D1187ABA50079C8C8 /* LLDB.h in Headers */,
26DE204311618ACA00A093E2 /* SBAddress.h in Headers */,

2
lldb/scripts/Python/build-swig-Python.sh
View File

@ -31,7 +31,7 @@ else
fi
HEADER_FILES="${SRC_ROOT}/include/lldb/lldb-include.h"\
HEADER_FILES="${SRC_ROOT}/include/lldb/lldb.h"\
" ${SRC_ROOT}/include/lldb/lldb-defines.h"\
" ${SRC_ROOT}/include/lldb/lldb-enumerations.h"\
" ${SRC_ROOT}/include/lldb/lldb-forward.h"\

2
lldb/scripts/lldb.swig
View File

@ -116,7 +116,7 @@
/* The liblldb header files to be included. */
%{
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBBlock.h"
#include "lldb/API/SBBreakpoint.h"

9
lldb/source/API/SBDebugger.cpp
View File

@ -9,7 +9,7 @@
#include "lldb/API/SBDebugger.h"
#include "lldb/lldb-include.h"
#include "lldb/lldb-private.h"
#include "lldb/API/SBListener.h"
#include "lldb/API/SBBroadcaster.h"
@ -679,7 +679,10 @@ SBDebugger::SetInternalVariable (const char *var_name, const char *value, const
{
lldb::UserSettingsControllerSP root_settings_controller = lldb_private::Debugger::GetSettingsController();
Error err = root_settings_controller->SetVariable (var_name, value, lldb::eVarSetOperationAssign, true,
Error err = root_settings_controller->SetVariable (var_name,
value,
eVarSetOperationAssign,
true,
debugger_instance_name);
SBError sb_error;
sb_error.SetError (err);
@ -691,7 +694,7 @@ lldb::SBStringList
SBDebugger::GetInternalVariableValue (const char *var_name, const char *debugger_instance_name)
{
SBStringList ret_value;
lldb::SettableVariableType var_type;
SettableVariableType var_type;
lldb_private::Error err;
lldb::UserSettingsControllerSP root_settings_controller = lldb_private::Debugger::GetSettingsController();

2
lldb/source/API/SBTarget.cpp
View File

@ -9,7 +9,7 @@
#include "lldb/API/SBTarget.h"
#include "lldb/lldb-include.h"
#include "lldb/lldb-public.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBModule.h"

4
lldb/source/Commands/CommandObjectArgs.cpp
View File

@ -71,7 +71,7 @@ CommandObjectArgs::CommandOptions::ResetOptionValues ()
Options::ResetOptionValues();
}
const lldb::OptionDefinition*
const OptionDefinition*
CommandObjectArgs::CommandOptions::GetDefinitions ()
{
return g_option_table;
@ -265,7 +265,7 @@ CommandObjectArgs::Execute
return result.Succeeded();
}
lldb::OptionDefinition
OptionDefinition
CommandObjectArgs::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "debug", 'g', no_argument, NULL, 0, eArgTypeNone, "Enable verbose debug logging of the expression parsing and evaluation."},

4
lldb/source/Commands/CommandObjectArgs.h
View File

@ -39,12 +39,12 @@ namespace lldb_private {
void
ResetOptionValues ();
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ();
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
};
CommandObjectArgs (CommandInterpreter &interpreter);

16
lldb/source/Commands/CommandObjectBreakpoint.cpp
View File

@ -70,7 +70,7 @@ CommandObjectBreakpointSet::CommandOptions::~CommandOptions ()
{
}
lldb::OptionDefinition
OptionDefinition
CommandObjectBreakpointSet::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "shlib", 's', required_argument, NULL, CommandCompletions::eModuleCompletion, eArgTypeShlibName,
@ -127,7 +127,7 @@ CommandObjectBreakpointSet::CommandOptions::g_option_table[] =
{ 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
};
const lldb::OptionDefinition*
const OptionDefinition*
CommandObjectBreakpointSet::CommandOptions::GetDefinitions ()
{
return g_option_table;
@ -649,7 +649,7 @@ CommandObjectBreakpointList::CommandOptions::~CommandOptions ()
{
}
lldb::OptionDefinition
OptionDefinition
CommandObjectBreakpointList::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "internal", 'i', no_argument, NULL, 0, eArgTypeNone,
@ -669,7 +669,7 @@ CommandObjectBreakpointList::CommandOptions::g_option_table[] =
{ 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
};
const lldb::OptionDefinition*
const OptionDefinition*
CommandObjectBreakpointList::CommandOptions::GetDefinitions ()
{
return g_option_table;
@ -1060,7 +1060,7 @@ CommandObjectBreakpointClear::CommandOptions::~CommandOptions ()
{
}
lldb::OptionDefinition
OptionDefinition
CommandObjectBreakpointClear::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "file", 'f', required_argument, NULL, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,
@ -1072,7 +1072,7 @@ CommandObjectBreakpointClear::CommandOptions::g_option_table[] =
{ 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
};
const lldb::OptionDefinition*
const OptionDefinition*
CommandObjectBreakpointClear::CommandOptions::GetDefinitions ()
{
return g_option_table;
@ -1376,7 +1376,7 @@ CommandObjectBreakpointModify::CommandOptions::~CommandOptions ()
{
}
lldb::OptionDefinition
OptionDefinition
CommandObjectBreakpointModify::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "ignore-count", 'i', required_argument, NULL, NULL, eArgTypeCount, "Set the number of times this breakpoint is skipped before stopping." },
@ -1390,7 +1390,7 @@ CommandObjectBreakpointModify::CommandOptions::g_option_table[] =
{ 0, false, NULL, 0 , 0, NULL, 0, eArgTypeNone, NULL }
};
const lldb::OptionDefinition*
const OptionDefinition*
CommandObjectBreakpointModify::CommandOptions::GetDefinitions ()
{
return g_option_table;

16
lldb/source/Commands/CommandObjectBreakpoint.h
View File

@ -87,12 +87,12 @@ public:
void
ResetOptionValues ();
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ();
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
@ -153,12 +153,12 @@ public:
void
ResetOptionValues ();
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ();
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
@ -254,12 +254,12 @@ public:
void
ResetOptionValues ();
const lldb::OptionDefinition *
const OptionDefinition *
GetDefinitions ();
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
@ -314,12 +314,12 @@ public:
void
ResetOptionValues ();
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ();
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.

6
lldb/source/Commands/CommandObjectBreakpointCommand.cpp
View File

@ -48,7 +48,7 @@ CommandObjectBreakpointCommandAdd::CommandOptions::~CommandOptions ()
// FIXME: "script-type" needs to have its contents determined dynamically, so somebody can add a new scripting
// language to lldb and have it pickable here without having to change this enumeration by hand and rebuild lldb proper.
static lldb::OptionEnumValueElement
static OptionEnumValueElement
g_script_option_enumeration[4] =
{
{ eScriptLanguageNone, "command", "Commands are in the lldb command interpreter language"},
@ -57,7 +57,7 @@ g_script_option_enumeration[4] =
{ 0, NULL, NULL }
};
lldb::OptionDefinition
OptionDefinition
CommandObjectBreakpointCommandAdd::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "one-liner", 'o', required_argument, NULL, NULL, eArgTypeOneLiner,
@ -72,7 +72,7 @@ CommandObjectBreakpointCommandAdd::CommandOptions::g_option_table[] =
{ 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
};
const lldb::OptionDefinition*
const OptionDefinition*
CommandObjectBreakpointCommandAdd::CommandOptions::GetDefinitions ()
{
return g_option_table;

4
lldb/source/Commands/CommandObjectBreakpointCommand.h
View File

@ -106,12 +106,12 @@ public:
void
ResetOptionValues ();
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ();
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.

8
lldb/source/Commands/CommandObjectCommands.cpp
View File

@ -75,7 +75,7 @@ private:
m_stop_on_continue = true;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -83,7 +83,7 @@ private:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
@ -93,7 +93,7 @@ private:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
CommandOptions m_options;
@ -165,7 +165,7 @@ public:
}
};
lldb::OptionDefinition
OptionDefinition
CommandObjectCommandsSource::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "stop-on-error", 'e', required_argument, NULL, 0, eArgTypeBoolean, "If true, stop executing commands on error."},

4
lldb/source/Commands/CommandObjectDisassemble.cpp
View File

@ -136,13 +136,13 @@ CommandObjectDisassemble::CommandOptions::ResetOptionValues ()
raw = false;
}
const lldb::OptionDefinition*
const OptionDefinition*
CommandObjectDisassemble::CommandOptions::GetDefinitions ()
{
return g_option_table;
}
lldb::OptionDefinition
OptionDefinition
CommandObjectDisassemble::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "bytes", 'b', no_argument, NULL, 0, eArgTypeNone, "Show opcode bytes when disassembling."},

4
lldb/source/Commands/CommandObjectDisassemble.h
View File

@ -41,7 +41,7 @@ public:
void
ResetOptionValues ();
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ();
bool show_mixed; // Show mixed source/assembly
@ -53,7 +53,7 @@ public:
lldb::addr_t m_start_addr;
lldb::addr_t m_end_addr;
bool m_at_pc;
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
};
CommandObjectDisassemble (CommandInterpreter &interpreter);

6
lldb/source/Commands/CommandObjectExpression.cpp
View File

@ -105,7 +105,7 @@ CommandObjectExpression::CommandOptions::ResetOptionValues ()
show_summary = true;
}
const lldb::OptionDefinition*
const OptionDefinition*
CommandObjectExpression::CommandOptions::GetDefinitions ()
{
return g_option_table;
@ -236,7 +236,7 @@ CommandObjectExpression::EvaluateExpression
{
lldb::ValueObjectSP result_valobj_sp;
lldb::ExecutionResults exe_results;
ExecutionResults exe_results;
bool keep_in_memory = true;
@ -375,7 +375,7 @@ CommandObjectExpression::ExecuteRawCommandString
return false;
}
lldb::OptionDefinition
OptionDefinition
CommandObjectExpression::CommandOptions::g_option_table[] =
{
//{ LLDB_OPT_SET_ALL, false, "language", 'l', required_argument, NULL, 0, "[c|c++|objc|objc++]", "Sets the language to use when parsing the expression."},

4
lldb/source/Commands/CommandObjectExpression.h
View File

@ -40,12 +40,12 @@ public:
void
ResetOptionValues ();
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ();
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
//Language language;
lldb::Encoding encoding;
lldb::Format format;

4
lldb/source/Commands/CommandObjectFile.cpp
View File

@ -35,14 +35,14 @@ CommandObjectFile::CommandOptions::~CommandOptions ()
{
}
lldb::OptionDefinition
OptionDefinition
CommandObjectFile::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "arch", 'a', required_argument, NULL, 0, eArgTypeArchitecture, "Specify the architecture to be used when the process is launched."},
{ 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
};
const lldb::OptionDefinition *
const OptionDefinition *
CommandObjectFile::CommandOptions::GetDefinitions ()
{
return g_option_table;

4
lldb/source/Commands/CommandObjectFile.h
View File

@ -55,12 +55,12 @@ public:
void
ResetOptionValues ();
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ();
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.

12
lldb/source/Commands/CommandObjectFrame.cpp
View File

@ -139,7 +139,7 @@ public:
relative_frame_offset = INT32_MIN;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -147,7 +147,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
int32_t relative_frame_offset;
};
@ -271,7 +271,7 @@ protected:
CommandOptions m_options;
};
lldb::OptionDefinition
OptionDefinition
CommandObjectFrameSelect::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "relative", 'r', required_argument, NULL, 0, eArgTypeOffset, "A relative frame index offset from the current frame index."},
@ -372,7 +372,7 @@ public:
globals.clear();
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -380,7 +380,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
bool use_objc:1,
use_regex:1,
show_args:1,
@ -724,7 +724,7 @@ protected:
CommandOptions m_options;
};
lldb::OptionDefinition
OptionDefinition
CommandObjectFrameVariable::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "debug", 'D', no_argument, NULL, 0, eArgTypeNone, "Enable verbose debug information."},

24
lldb/source/Commands/CommandObjectImage.cpp
View File

@ -156,7 +156,7 @@ DumpBasename (Stream &strm, const FileSpec *file_spec_ptr, uint32_t width)
static void
DumpModuleSymtab (CommandInterpreter &interpreter, Stream &strm, Module *module, lldb::SortOrder sort_order)
DumpModuleSymtab (CommandInterpreter &interpreter, Stream &strm, Module *module, SortOrder sort_order)
{
if (module)
{
@ -741,7 +741,7 @@ public:
case 's':
{
bool found_one = false;
m_sort_order = (lldb::SortOrder) Args::StringToOptionEnum (option_arg,
m_sort_order = (SortOrder) Args::StringToOptionEnum (option_arg,
g_option_table[option_idx].enum_values,
eSortOrderNone,
&found_one);
@ -767,14 +767,14 @@ public:
m_sort_order = eSortOrderNone;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
}
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
SortOrder m_sort_order;
};
@ -784,7 +784,7 @@ protected:
CommandOptions m_options;
};
static lldb::OptionEnumValueElement
static OptionEnumValueElement
g_sort_option_enumeration[4] =
{
{ eSortOrderNone, "none", "No sorting, use the original symbol table order."},
@ -794,7 +794,7 @@ g_sort_option_enumeration[4] =
};
lldb::OptionDefinition
OptionDefinition
CommandObjectImageDumpSymtab::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "sort", 's', required_argument, g_sort_option_enumeration, 0, eArgTypeSortOrder, "Supply a sort order when dumping the symbol table."},
@ -1171,7 +1171,7 @@ public:
m_format_array.clear();
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -1179,7 +1179,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
typedef std::vector< std::pair<char, uint32_t> > FormatWidthCollection;
@ -1311,7 +1311,7 @@ protected:
CommandOptions m_options;
};
lldb::OptionDefinition
OptionDefinition
CommandObjectImageList::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "arch", 'a', optional_argument, NULL, 0, eArgTypeWidth, "Display the architecture when listing images."},
@ -1441,7 +1441,7 @@ public:
m_verbose = false;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -1449,7 +1449,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
int m_type; // Should be a eLookupTypeXXX enum after parsing options
std::string m_str; // Holds name lookup
FileSpec m_file; // Files for file lookups
@ -1679,7 +1679,7 @@ protected:
CommandOptions m_options;
};
lldb::OptionDefinition
OptionDefinition
CommandObjectImageLookup::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, true, "address", 'a', required_argument, NULL, 0, eArgTypeAddress, "Lookup an address in one or more executable images."},

6
lldb/source/Commands/CommandObjectLog.cpp
View File

@ -213,7 +213,7 @@ public:
log_options = 0;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -221,7 +221,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
@ -235,7 +235,7 @@ protected:
LogStreamMap m_log_streams;
};
lldb::OptionDefinition
OptionDefinition
CommandObjectLogEnable::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "file", 'f', required_argument, NULL, 0, eArgTypeFilename, "Set the destination file to log to."},

12
lldb/source/Commands/CommandObjectMemory.cpp
View File

@ -174,7 +174,7 @@ public:
m_output_as_binary = false;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -182,7 +182,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
lldb::Format m_format;
@ -409,7 +409,7 @@ protected:
#define SET1 LLDB_OPT_SET_1
#define SET2 LLDB_OPT_SET_2
lldb::OptionDefinition
OptionDefinition
CommandObjectMemoryRead::CommandOptions::g_option_table[] =
{
{ SET1 , false, "format", 'f', required_argument, NULL, 0, eArgTypeFormat, "The format that will be used to display the memory. Defaults to bytes with ASCII (--format=Y)."},
@ -500,7 +500,7 @@ public:
m_infile_offset = 0;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -508,7 +508,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
lldb::Format m_format;
@ -864,7 +864,7 @@ protected:
#define SET1 LLDB_OPT_SET_1
#define SET2 LLDB_OPT_SET_2
lldb::OptionDefinition
OptionDefinition
CommandObjectMemoryWrite::CommandOptions::g_option_table[] =
{
{ SET1 , false, "format", 'f', required_argument, NULL, 0, eArgTypeFormat, "The format value types that will be decoded and written to memory."},

6
lldb/source/Commands/CommandObjectPlatform.cpp
View File

@ -132,7 +132,7 @@ protected:
os_version_update = UINT32_MAX;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -140,7 +140,7 @@ protected:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
@ -151,7 +151,7 @@ protected:
CommandOptions m_options;
};
lldb::OptionDefinition
OptionDefinition
CommandObjectPlatformCreate::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "sdk-version", 'v', required_argument, NULL, 0, eArgTypeNone, "Specify the initial SDK version to use prior to connecting." },

28
lldb/source/Commands/CommandObjectProcess.cpp
View File

@ -94,7 +94,7 @@ public:
no_stdio = false;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -102,7 +102,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
@ -404,7 +404,7 @@ protected:
#define SET2 LLDB_OPT_SET_2
#define SET3 LLDB_OPT_SET_3
lldb::OptionDefinition
OptionDefinition
CommandObjectProcessLaunch::CommandOptions::g_option_table[] =
{
{ SET1 | SET2 | SET3, false, "stop-at-entry", 's', no_argument, NULL, 0, eArgTypeNone, "Stop at the entry point of the program when launching a process."},
@ -489,7 +489,7 @@ public:
waitfor = false;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -512,7 +512,7 @@ public:
// We are only completing the name option for now...
const lldb::OptionDefinition *opt_defs = GetDefinitions();
const OptionDefinition *opt_defs = GetDefinitions();
if (opt_defs[opt_defs_index].short_option == 'n')
{
// Are we in the name?
@ -527,7 +527,7 @@ public:
if (platform_sp)
{
ProcessInfoList process_infos;
platform_sp->FindProcessesByName (partial_name, partial_name ? lldb::eNameMatchStartsWith : lldb::eNameMatchIgnore, process_infos);
platform_sp->FindProcessesByName (partial_name, partial_name ? eNameMatchStartsWith : eNameMatchIgnore, process_infos);
const uint32_t num_matches = process_infos.GetSize();
if (num_matches > 0)
{
@ -545,7 +545,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
@ -817,7 +817,7 @@ protected:
};
lldb::OptionDefinition
OptionDefinition
CommandObjectProcessAttach::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "plugin", 'P', required_argument, NULL, 0, eArgTypePlugin, "Name of the process plugin you want to use."},
@ -1015,7 +1015,7 @@ public:
plugin_name.clear();
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -1023,7 +1023,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
@ -1133,7 +1133,7 @@ protected:
};
lldb::OptionDefinition
OptionDefinition
CommandObjectProcessConnect::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "plugin", 'p', required_argument, NULL, 0, eArgTypePlugin, "Name of the process plugin you want to use."},
@ -1607,7 +1607,7 @@ public:
pass.clear();
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -1615,7 +1615,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
@ -1848,7 +1848,7 @@ protected:
CommandOptions m_options;
};
lldb::OptionDefinition
OptionDefinition
CommandObjectProcessHandle::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "stop", 's', required_argument, NULL, 0, eArgTypeBoolean, "Whether or not the process should be stopped if the signal is received." },

28
lldb/source/Commands/CommandObjectSettings.cpp
View File

@ -163,7 +163,7 @@ CommandObjectSettingsSet::Execute (Args& command, CommandReturnObject &result)
{
Error err = root_settings->SetVariable (var_name_string.c_str(),
var_value,
lldb::eVarSetOperationAssign,
eVarSetOperationAssign,
m_options.m_override,
m_interpreter.GetDebugger().GetInstanceName().AsCString());
if (err.Fail ())
@ -209,7 +209,7 @@ CommandObjectSettingsSet::HandleArgumentCompletion (Args &input,
&& completion_str.compare (matches.GetStringAtIndex(0)) == 0))
{
matches.Clear();
lldb::UserSettingsControllerSP root_settings = Debugger::GetSettingsController();
UserSettingsControllerSP root_settings = Debugger::GetSettingsController();
if (cursor_index == 1)
{
// The user is at the end of the variable name, which is complete and valid.
@ -248,7 +248,7 @@ CommandObjectSettingsSet::CommandOptions::~CommandOptions ()
{
}
lldb::OptionDefinition
OptionDefinition
CommandObjectSettingsSet::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "no-override", 'n', no_argument, NULL, NULL, eArgTypeNone, "Prevents already existing instances and pending settings from being assigned this new value. Using this option means that only the default or specified instance setting values will be updated." },
@ -256,7 +256,7 @@ CommandObjectSettingsSet::CommandOptions::g_option_table[] =
{ 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
};
const lldb::OptionDefinition*
const OptionDefinition*
CommandObjectSettingsSet::CommandOptions::GetDefinitions ()
{
return g_option_table;
@ -341,7 +341,7 @@ CommandObjectSettingsShow::Execute (Args& command,
if (command.GetArgumentCount())
{
// The user requested to see the value of a particular variable.
lldb::SettableVariableType var_type;
SettableVariableType var_type;
const char *variable_name = command.GetArgumentAtIndex (0);
StringList value = root_settings->GetVariable (variable_name, var_type,
m_interpreter.GetDebugger().GetInstanceName().AsCString(),
@ -365,16 +365,16 @@ CommandObjectSettingsShow::Execute (Args& command,
if (value.GetSize() == 0)
result.AppendMessageWithFormat ("%s%s = ''\n", variable_name, type_name);
else if ((var_type != lldb::eSetVarTypeArray) && (var_type != lldb::eSetVarTypeDictionary))
else if ((var_type != eSetVarTypeArray) && (var_type != eSetVarTypeDictionary))
result.AppendMessageWithFormat ("%s%s = '%s'\n", variable_name, type_name, value.GetStringAtIndex (0));
else
{
result.AppendMessageWithFormat ("%s%s:\n", variable_name, type_name);
for (unsigned i = 0, e = value.GetSize(); i != e; ++i)
{
if (var_type == lldb::eSetVarTypeArray)
if (var_type == eSetVarTypeArray)
result.AppendMessageWithFormat (" [%d]: '%s'\n", i, value.GetStringAtIndex (i));
else if (var_type == lldb::eSetVarTypeDictionary)
else if (var_type == eSetVarTypeDictionary)
result.AppendMessageWithFormat (" '%s'\n", value.GetStringAtIndex (i));
}
}
@ -615,7 +615,7 @@ CommandObjectSettingsRemove::Execute ( Args& command,
Error err = root_settings->SetVariable (var_name_string.c_str(),
NULL,
lldb::eVarSetOperationRemove,
eVarSetOperationRemove,
true,
m_interpreter.GetDebugger().GetInstanceName().AsCString(),
index_value_string.c_str());
@ -765,7 +765,7 @@ CommandObjectSettingsReplace::Execute ( Args& command,
{
Error err = root_settings->SetVariable (var_name_string.c_str(),
var_value,
lldb::eVarSetOperationReplace,
eVarSetOperationReplace,
true,
m_interpreter.GetDebugger().GetInstanceName().AsCString(),
index_value_string.c_str());
@ -911,7 +911,7 @@ CommandObjectSettingsInsertBefore::Execute ( Args&
{
Error err = root_settings->SetVariable (var_name_string.c_str(),
var_value,
lldb::eVarSetOperationInsertBefore,
eVarSetOperationInsertBefore,
true,
m_interpreter.GetDebugger().GetInstanceName().AsCString(),
index_value_string.c_str());
@ -1058,7 +1058,7 @@ CommandObjectSettingsInsertAfter::Execute ( Args& co
{
Error err = root_settings->SetVariable (var_name_string.c_str(),
var_value,
lldb::eVarSetOperationInsertAfter,
eVarSetOperationInsertAfter,
true,
m_interpreter.GetDebugger().GetInstanceName().AsCString(),
index_value_string.c_str());
@ -1183,7 +1183,7 @@ CommandObjectSettingsAppend::Execute (Args& command,
{
Error err = root_settings->SetVariable (var_name_string.c_str(),
var_value,
lldb::eVarSetOperationAppend,
eVarSetOperationAppend,
true,
m_interpreter.GetDebugger().GetInstanceName().AsCString());
if (err.Fail ())
@ -1279,7 +1279,7 @@ CommandObjectSettingsClear::Execute ( Args& command,
Error err = root_settings->SetVariable (var_name,
NULL,
lldb::eVarSetOperationClear,
eVarSetOperationClear,
false,
m_interpreter.GetDebugger().GetInstanceName().AsCString());

4
lldb/source/Commands/CommandObjectSettings.h
View File

@ -70,12 +70,12 @@ public:
void
ResetOptionValues ();
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ();
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.

12
lldb/source/Commands/CommandObjectSource.cpp
View File

@ -81,12 +81,12 @@ class CommandObjectSourceInfo : public CommandObject
start_line = 0;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
}
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
FileSpec file_spec;
@ -131,7 +131,7 @@ protected:
CommandOptions m_options;
};
lldb::OptionDefinition
OptionDefinition
CommandObjectSourceInfo::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "line", 'l', required_argument, NULL, 0, eArgTypeLineNum, "The line number at which to start the display source."},
@ -210,12 +210,12 @@ class CommandObjectSourceList : public CommandObject
m_modules.clear();
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
}
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
FileSpec file_spec;
@ -568,7 +568,7 @@ protected:
};
lldb::OptionDefinition
OptionDefinition
CommandObjectSourceList::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "count", 'c', required_argument, NULL, 0, eArgTypeCount, "The number of source lines to display."},

6
lldb/source/Commands/CommandObjectTarget.cpp
View File

@ -501,7 +501,7 @@ public:
~CommandOptions () {}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -606,7 +606,7 @@ public:
}
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
std::string m_class_name;
std::string m_function_name;
@ -824,7 +824,7 @@ private:
CommandOptions m_options;
};
lldb::OptionDefinition
OptionDefinition
CommandObjectTargetStopHookAdd::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "shlib", 's', required_argument, NULL, CommandCompletions::eModuleCompletion, eArgTypeShlibName,

22
lldb/source/Commands/CommandObjectThread.cpp
View File

@ -305,7 +305,7 @@ public:
m_start = 0;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -313,7 +313,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
uint32_t m_count;
@ -466,7 +466,7 @@ protected:
CommandOptions m_options;
};
lldb::OptionDefinition
OptionDefinition
CommandObjectThreadBacktrace::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "count", 'c', required_argument, NULL, 0, eArgTypeCount, "How many frames to display (-1 for all)"},
@ -551,7 +551,7 @@ public:
m_avoid_regexp.clear();
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -559,7 +559,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
bool m_avoid_no_debug;
@ -775,7 +775,7 @@ protected:
CommandOptions m_options;
};
static lldb::OptionEnumValueElement
static OptionEnumValueElement
g_tri_running_mode[] =
{
{ eOnlyThisThread, "this-thread", "Run only this thread"},
@ -784,7 +784,7 @@ g_tri_running_mode[] =
{ 0, NULL, NULL }
};
static lldb::OptionEnumValueElement
static OptionEnumValueElement
g_duo_running_mode[] =
{
{ eOnlyThisThread, "this-thread", "Run only this thread"},
@ -792,7 +792,7 @@ g_duo_running_mode[] =
{ 0, NULL, NULL }
};
lldb::OptionDefinition
OptionDefinition
CommandObjectThreadStepWithTypeAndScope::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "avoid-no-debug", 'a', required_argument, NULL, 0, eArgTypeBoolean, "A boolean value that sets whether step-in will step over functions with no debug information."},
@ -1050,7 +1050,7 @@ public:
m_stop_others = false;
}
const lldb::OptionDefinition*
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
@ -1061,7 +1061,7 @@ public:
// Options table: Required for subclasses of Options.
static lldb::OptionDefinition g_option_table[];
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
};
@ -1259,7 +1259,7 @@ protected:
};
lldb::OptionDefinition
OptionDefinition
CommandObjectThreadUntil::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "frame", 'f', required_argument, NULL, 0, eArgTypeFrameIndex, "Frame index for until operation - defaults to 0"},

4
lldb/source/Core/Address.cpp
View File

@ -377,7 +377,7 @@ Address::Dump (Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, Dum
case DumpStyleResolvedDescriptionNoModule:
if (IsSectionOffset())
{
lldb::AddressType addr_type = eAddressTypeLoad;
AddressType addr_type = eAddressTypeLoad;
addr_t addr = GetLoadAddress (target);
if (addr == LLDB_INVALID_ADDRESS)
{
@ -809,7 +809,7 @@ Address::ResolveLinkedAddress ()
}
}
lldb::AddressClass
AddressClass
Address::GetAddressClass () const
{
Module *module = GetModule();

4
lldb/source/Core/ArchSpec.cpp
View File

@ -285,7 +285,7 @@ ArchSpec::ArchSpec(const llvm::Triple &triple) :
SetTriple(triple);
}
ArchSpec::ArchSpec (lldb::ArchitectureType arch_type, uint32_t cpu, uint32_t subtype) :
ArchSpec::ArchSpec (ArchitectureType arch_type, uint32_t cpu, uint32_t subtype) :
m_triple (),
m_core (kCore_invalid),
m_byte_order (eByteOrderInvalid)
@ -463,7 +463,7 @@ ArchSpec::SetTriple (const char *triple_cstr)
}
bool
ArchSpec::SetArchitecture (lldb::ArchitectureType arch_type, uint32_t cpu, uint32_t sub)
ArchSpec::SetArchitecture (ArchitectureType arch_type, uint32_t cpu, uint32_t sub)
{
m_core = kCore_invalid;
bool update_triple = true;

4
lldb/source/Core/Debugger.cpp
View File

@ -762,7 +762,7 @@ Debugger::FormatPrompt
RegisterKind reg_kind = kNumRegisterKinds;
uint32_t reg_num = LLDB_INVALID_REGNUM;
FileSpec format_file_spec;
const lldb::RegisterInfo *reg_info = NULL;
const RegisterInfo *reg_info = NULL;
RegisterContext *reg_ctx = NULL;
// Each variable must set success to true below...
@ -1440,7 +1440,7 @@ DebuggerInstanceSettings::UpdateInstanceSettingsVariable (const ConstString &var
const char *value,
const ConstString &instance_name,
const SettingEntry &entry,
lldb::VarSetOperationType op,
VarSetOperationType op,
Error &err,
bool pending)
{

4
lldb/source/Core/EmulateInstruction.cpp
View File

@ -59,9 +59,9 @@ EmulateInstruction::EmulateInstruction
m_write_mem_callback (write_mem_callback),
m_read_reg_callback (read_reg_callback),
m_write_reg_callback (write_reg_callback),
m_inst_pc (LLDB_INVALID_ADDRESS)
m_opcode_pc (LLDB_INVALID_ADDRESS)
{
::memset (&m_inst, 0, sizeof (m_inst));
::memset (&m_opcode, 0, sizeof (m_opcode));
}
uint64_t

2
lldb/source/Core/Section.cpp
View File

@ -567,7 +567,7 @@ SectionList::FindSectionByID (user_id_t sect_id) const
SectionSP
SectionList::FindSectionByType (lldb::SectionType sect_type, bool check_children, uint32_t start_idx) const
SectionList::FindSectionByType (SectionType sect_type, bool check_children, uint32_t start_idx) const
{
SectionSP sect_sp;
uint32_t num_sections = m_sections.size();

8
lldb/source/Core/Value.cpp
View File

@ -208,7 +208,7 @@ Value::GetValueType() const
return m_value_type;
}
lldb::AddressType
AddressType
Value::GetValueAddressType () const
{
if (m_context_type == eContextTypeValue)
@ -515,7 +515,7 @@ Value::GetValueAsData (ExecutionContext *exe_ctx, clang::ASTContext *ast_context
Error error;
lldb::addr_t address = LLDB_INVALID_ADDRESS;
lldb::AddressType address_type = eAddressTypeFile;
AddressType address_type = eAddressTypeFile;
switch (m_value_type)
{
default:
@ -663,7 +663,7 @@ Value::GetValueAsData (ExecutionContext *exe_ctx, clang::ASTContext *ast_context
}
else
{
error.SetErrorStringWithFormat ("unsupported lldb::AddressType value (%i)", address_type);
error.SetErrorStringWithFormat ("unsupported AddressType value (%i)", address_type);
}
}
else
@ -714,7 +714,7 @@ Value::ResolveValue(ExecutionContext *exe_ctx, clang::ASTContext *ast_context)
case eValueTypeLoadAddress: // load address value
case eValueTypeHostAddress: // host address value (for memory in the process that is using liblldb)
{
lldb::AddressType address_type = m_value_type == eValueTypeLoadAddress ? eAddressTypeLoad : eAddressTypeHost;
AddressType address_type = m_value_type == eValueTypeLoadAddress ? eAddressTypeLoad : eAddressTypeHost;
lldb::addr_t addr = m_value.ULongLong(LLDB_INVALID_ADDRESS);
DataExtractor data;
if (ClangASTType::ReadFromMemory (ast_context, opaque_clang_qual_type, exe_ctx, addr, address_type, data))

12
lldb/source/Core/ValueObject.cpp
View File

@ -439,7 +439,7 @@ ValueObject::GetSummaryAsCString (ExecutionContextScope *exe_scope)
if (process != NULL)
{
lldb::addr_t cstr_address = LLDB_INVALID_ADDRESS;
lldb::AddressType cstr_address_type = eAddressTypeInvalid;
AddressType cstr_address_type = eAddressTypeInvalid;
size_t cstr_len = 0;
if (type_flags.Test (ClangASTContext::eTypeIsArray))
@ -521,7 +521,7 @@ ValueObject::GetSummaryAsCString (ExecutionContextScope *exe_scope)
}
else if (ClangASTContext::IsFunctionPointerType (clang_type))
{
lldb::AddressType func_ptr_address_type = eAddressTypeInvalid;
AddressType func_ptr_address_type = eAddressTypeInvalid;
lldb::addr_t func_ptr_address = GetPointerValue (func_ptr_address_type, true);
if (func_ptr_address != 0 && func_ptr_address != LLDB_INVALID_ADDRESS)
@ -684,7 +684,7 @@ ValueObject::GetValueAsCString (ExecutionContextScope *exe_scope)
}
addr_t
ValueObject::GetAddressOf (lldb::AddressType &address_type, bool scalar_is_load_address)
ValueObject::GetAddressOf (AddressType &address_type, bool scalar_is_load_address)
{
switch (m_value.GetValueType())
{
@ -710,7 +710,7 @@ ValueObject::GetAddressOf (lldb::AddressType &address_type, bool scalar_is_load_
}
addr_t
ValueObject::GetPointerValue (lldb::AddressType &address_type, bool scalar_is_load_address)
ValueObject::GetPointerValue (AddressType &address_type, bool scalar_is_load_address)
{
lldb::addr_t address = LLDB_INVALID_ADDRESS;
address_type = eAddressTypeInvalid;
@ -1145,7 +1145,7 @@ ValueObject::DumpValueObject
{
// We have a pointer or reference whose value is an address.
// Make sure that address is not NULL
lldb::AddressType ptr_address_type;
AddressType ptr_address_type;
if (valobj->GetPointerValue (ptr_address_type, true) == 0)
print_children = false;
@ -1339,7 +1339,7 @@ ValueObject::Dereference (Error &error)
ValueObject::AddressOf (Error &error)
{
lldb::ValueObjectSP valobj_sp;
lldb::AddressType address_type = eAddressTypeInvalid;
AddressType address_type = eAddressTypeInvalid;
const bool scalar_is_load_address = false;
lldb::addr_t addr = GetAddressOf (address_type, scalar_is_load_address);
error.Clear();

2
lldb/source/Core/ValueObjectConstResult.cpp
View File

@ -97,7 +97,7 @@ ValueObjectConstResult::ValueObjectConstResult
void *clang_type,
const ConstString &name,
lldb::addr_t address,
lldb::AddressType address_type,
AddressType address_type,
uint8_t addr_byte_size
) :
ValueObject (NULL),

20
lldb/source/Expression/ClangExpressionDeclMap.cpp
View File

@ -470,7 +470,7 @@ ClangExpressionDeclMap::GetSymbolAddress
SymbolContextList sc_list;
m_parser_vars->m_exe_ctx->target->GetImages().FindSymbolsWithNameAndType(name, lldb::eSymbolTypeAny, sc_list);
m_parser_vars->m_exe_ctx->target->GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
if (!sc_list.GetSize())
return false;
@ -598,7 +598,7 @@ ClangExpressionDeclMap::GetObjectPointer
return false;
}
lldb::RegisterInfo *register_info = location_value->GetRegisterInfo();
RegisterInfo *register_info = location_value->GetRegisterInfo();
if (!register_info)
{
@ -990,7 +990,7 @@ ClangExpressionDeclMap::DoMaterializeOnePersistentVariable
var_sp->GetTypeFromUser().GetOpaqueQualType(),
var_sp->GetName(),
mem,
lldb::eAddressTypeLoad,
eAddressTypeLoad,
pvar_byte_size));
}
@ -1000,7 +1000,7 @@ ClangExpressionDeclMap::DoMaterializeOnePersistentVariable
return false;
}
if (var_sp->m_live_sp->GetValue().GetValueAddressType() != lldb::eAddressTypeLoad)
if (var_sp->m_live_sp->GetValue().GetValueAddressType() != eAddressTypeLoad)
{
err.SetErrorStringWithFormat("The address of the memory area for %s is in an incorrect format", var_sp->GetName().GetCString());
return false;
@ -1084,7 +1084,7 @@ ClangExpressionDeclMap::DoMaterializeOnePersistentVariable
var_sp->GetTypeFromUser().GetOpaqueQualType(),
var_sp->GetName(),
mem,
lldb::eAddressTypeLoad,
eAddressTypeLoad,
pvar_byte_size));
// Clear the flag if the variable will never be deallocated.
@ -1221,7 +1221,7 @@ ClangExpressionDeclMap::DoMaterializeOneVariable
lldb::addr_t mem; // The address of a spare memory area aused to hold the variable.
lldb::RegisterInfo *register_info = location_value->GetRegisterInfo();
RegisterInfo *register_info = location_value->GetRegisterInfo();
if (!register_info)
{
@ -1250,7 +1250,7 @@ ClangExpressionDeclMap::DoMaterializeOneVariable
return false;
}
if (expr_var->m_live_sp->GetValue().GetValueAddressType() != lldb::eAddressTypeLoad)
if (expr_var->m_live_sp->GetValue().GetValueAddressType() != eAddressTypeLoad)
{
err.SetErrorStringWithFormat("The address of the memory area for %s is in an incorrect format", name.GetCString());
return false;
@ -1348,7 +1348,7 @@ ClangExpressionDeclMap::DoMaterializeOneVariable
type.GetOpaqueQualType(),
name,
mem,
lldb::eAddressTypeLoad,
eAddressTypeLoad,
value_byte_size));
// Now write the location of the area into the struct.
@ -1432,7 +1432,7 @@ ClangExpressionDeclMap::DoMaterializeOneRegister
bool dematerialize,
ExecutionContext &exe_ctx,
RegisterContext &reg_ctx,
const lldb::RegisterInfo &reg_info,
const RegisterInfo &reg_info,
lldb::addr_t addr,
Error &err
)
@ -1762,7 +1762,7 @@ ClangExpressionDeclMap::GetDecls (NameSearchContext &context, const ConstString
if (m_parser_vars->m_exe_ctx->GetRegisterContext())
{
const lldb::RegisterInfo *reg_info(m_parser_vars->m_exe_ctx->GetRegisterContext()->GetRegisterInfoByName(reg_name));
const RegisterInfo *reg_info(m_parser_vars->m_exe_ctx->GetRegisterContext()->GetRegisterInfoByName(reg_name));
if (reg_info)
AddOneRegister(context, reg_info);

2
lldb/source/Expression/ClangExpressionParser.cpp
View File

@ -214,7 +214,7 @@ ClangExpressionParser::ClangExpressionParser (ExecutionContextScope *exe_scope,
{
if (process->GetObjCLanguageRuntime())
{
if (process->GetObjCLanguageRuntime()->GetRuntimeVersion() == lldb::eAppleObjC_V2)
if (process->GetObjCLanguageRuntime()->GetRuntimeVersion() == eAppleObjC_V2)
{
m_compiler->getLangOpts().ObjCNonFragileABI = true; // NOT i386
m_compiler->getLangOpts().ObjCNonFragileABI2 = true; // NOT i386

6
lldb/source/Expression/ClangExpressionVariable.cpp
View File

@ -62,16 +62,16 @@ ClangExpressionVariable::GetValueObject()
return m_frozen_sp;
}
lldb::RegisterInfo *
RegisterInfo *
ClangExpressionVariable::GetRegisterInfo()
{
return m_frozen_sp->GetValue().GetRegisterInfo();
}
void
ClangExpressionVariable::SetRegisterInfo (const lldb::RegisterInfo *reg_info)
ClangExpressionVariable::SetRegisterInfo (const RegisterInfo *reg_info)
{
return m_frozen_sp->GetValue().SetContext (Value::eContextTypeRegisterInfo, const_cast<lldb::RegisterInfo *>(reg_info));
return m_frozen_sp->GetValue().SetContext (Value::eContextTypeRegisterInfo, const_cast<RegisterInfo *>(reg_info));
}
lldb::clang_type_t

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