shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity

After discussing with Chris Lattner, we require C++11, so lets get rid of the macros and just use C++11.

Browse Source 
llvm-svn: 179805
This commit is contained in:
Greg Clayton 2013-04-18 22:45:39 +00:00
parent 9f7a221fdc
commit 7b0992d9cd
162 changed files with 432 additions and 465 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lldb/include/lldb/API/SBAddress.h
View File

@ -141,7 +141,7 @@ protected:
private:
STD_UNIQUE_PTR(lldb_private::Address) m_opaque_ap;
std::unique_ptr<lldb_private::Address> m_opaque_ap;
};

2
lldb/include/lldb/API/SBCommandReturnObject.h
View File

@ -118,7 +118,7 @@ protected:
SetLLDBObjectPtr (lldb_private::CommandReturnObject *ptr);
private:
STD_UNIQUE_PTR(lldb_private::CommandReturnObject) m_opaque_ap;
std::unique_ptr<lldb_private::CommandReturnObject> m_opaque_ap;
};
} // namespace lldb

2
lldb/include/lldb/API/SBDeclaration.h
View File

@ -80,7 +80,7 @@ namespace lldb {
void
SetDeclaration (const lldb_private::Declaration &lldb_object_ref);
STD_UNIQUE_PTR(lldb_private::Declaration) m_opaque_ap;
std::unique_ptr<lldb_private::Declaration> m_opaque_ap;
};

2
lldb/include/lldb/API/SBError.h
View File

@ -93,7 +93,7 @@ protected:
SetError (const lldb_private::Error &lldb_error);
private:
STD_UNIQUE_PTR(lldb_private::Error) m_opaque_ap;
std::unique_ptr<lldb_private::Error> m_opaque_ap;
void
CreateIfNeeded ();

2
lldb/include/lldb/API/SBExpressionOptions.h
View File

@ -81,7 +81,7 @@ protected:
private:
// This auto_pointer is made in the constructor and is always valid.
mutable STD_UNIQUE_PTR(lldb_private::EvaluateExpressionOptions) m_opaque_ap;
mutable std::unique_ptr<lldb_private::EvaluateExpressionOptions> m_opaque_ap;
};
} // namespace lldb

2
lldb/include/lldb/API/SBFileSpec.h
View File

@ -84,7 +84,7 @@ private:
const lldb_private::FileSpec &
ref() const;
STD_UNIQUE_PTR(lldb_private::FileSpec) m_opaque_ap;
std::unique_ptr<lldb_private::FileSpec> m_opaque_ap;
};

2
lldb/include/lldb/API/SBFileSpecList.h
View File

@ -63,7 +63,7 @@ friend class SBTarget;
const lldb_private::FileSpecList &
ref() const;
STD_UNIQUE_PTR(lldb_private::FileSpecList) m_opaque_ap;
std::unique_ptr<lldb_private::FileSpecList> m_opaque_ap;
};

2
lldb/include/lldb/API/SBLineEntry.h
View File

@ -90,7 +90,7 @@ private:
void
SetLineEntry (const lldb_private::LineEntry &lldb_object_ref);
STD_UNIQUE_PTR(lldb_private::LineEntry) m_opaque_ap;
std::unique_ptr<lldb_private::LineEntry> m_opaque_ap;
};

2
lldb/include/lldb/API/SBSourceManager.h
View File

@ -45,7 +45,7 @@ protected:
private:
STD_UNIQUE_PTR(lldb_private::SourceManagerImpl) m_opaque_ap;
std::unique_ptr<lldb_private::SourceManagerImpl> m_opaque_ap;
};
} // namespace lldb

2
lldb/include/lldb/API/SBStream.h
View File

@ -100,7 +100,7 @@ protected:
private:
DISALLOW_COPY_AND_ASSIGN (SBStream);
STD_UNIQUE_PTR(lldb_private::Stream) m_opaque_ap;
std::unique_ptr<lldb_private::Stream> m_opaque_ap;
bool m_is_file;
};

2
lldb/include/lldb/API/SBStringList.h
View File

@ -62,7 +62,7 @@ protected:
private:
STD_UNIQUE_PTR(lldb_private::StringList) m_opaque_ap;
std::unique_ptr<lldb_private::StringList> m_opaque_ap;
};

2
lldb/include/lldb/API/SBSymbolContext.h
View File

@ -85,7 +85,7 @@ protected:
SetSymbolContext (const lldb_private::SymbolContext *sc_ptr);
private:
STD_UNIQUE_PTR(lldb_private::SymbolContext) m_opaque_ap;
std::unique_ptr<lldb_private::SymbolContext> m_opaque_ap;
};

2
lldb/include/lldb/API/SBSymbolContextList.h
View File

@ -60,7 +60,7 @@ protected:
operator*() const;
private:
STD_UNIQUE_PTR(lldb_private::SymbolContextList) m_opaque_ap;
std::unique_ptr<lldb_private::SymbolContextList> m_opaque_ap;
};

4
lldb/include/lldb/API/SBType.h
View File

@ -65,7 +65,7 @@ protected:
const lldb_private::TypeMemberImpl &
ref () const;
STD_UNIQUE_PTR(lldb_private::TypeMemberImpl) m_opaque_ap;
std::unique_ptr<lldb_private::TypeMemberImpl> m_opaque_ap;
};
class SBType
@ -234,7 +234,7 @@ public:
private:
STD_UNIQUE_PTR(lldb_private::TypeListImpl) m_opaque_ap;
std::unique_ptr<lldb_private::TypeListImpl> m_opaque_ap;
};

2
lldb/include/lldb/API/SBValue.h
View File

@ -440,7 +440,7 @@ protected:
SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic);
private:
typedef STD_SHARED_PTR(ValueImpl) ValueImplSP;
typedef std::shared_ptr<ValueImpl> ValueImplSP;
ValueImplSP m_opaque_sp;
void

2
lldb/include/lldb/API/SBValueList.h
View File

@ -86,7 +86,7 @@ private:
ValueListImpl &
ref ();
STD_UNIQUE_PTR(ValueListImpl) m_opaque_ap;
std::unique_ptr<ValueListImpl> m_opaque_ap;
};

2
lldb/include/lldb/Breakpoint/Breakpoint.h
View File

@ -74,7 +74,7 @@ namespace lldb_private {
/// not by the breakpoint.
//----------------------------------------------------------------------
class Breakpoint:
public STD_ENABLE_SHARED_FROM_THIS(Breakpoint),
public std::enable_shared_from_this<Breakpoint>,
public Stoppoint
{
public:

4
lldb/include/lldb/Breakpoint/BreakpointLocation.h
View File

@ -46,7 +46,7 @@ namespace lldb_private {
//----------------------------------------------------------------------
class BreakpointLocation :
public STD_ENABLE_SHARED_FROM_THIS(BreakpointLocation),
public std::enable_shared_from_this<BreakpointLocation>,
public StoppointLocation
{
public:
@ -379,7 +379,7 @@ private:
bool m_being_created;
Address m_address; ///< The address defining this location.
Breakpoint &m_owner; ///< The breakpoint that produced this object.
STD_UNIQUE_PTR(BreakpointOptions) m_options_ap; ///< Breakpoint options pointer, NULL if we're using our breakpoint's options.
std::unique_ptr<BreakpointOptions> m_options_ap; ///< Breakpoint options pointer, NULL if we're using our breakpoint's options.
lldb::BreakpointSiteSP m_bp_site_sp; ///< Our breakpoint site (it may be shared by more than one location.)
void

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

@ -348,8 +348,8 @@ private:
bool m_enabled;
bool m_one_shot;
uint32_t m_ignore_count; // Number of times to ignore this breakpoint
STD_UNIQUE_PTR(ThreadSpec) m_thread_spec_ap; // Thread for which this breakpoint will take
STD_UNIQUE_PTR(ClangUserExpression) m_condition_ap; // The condition to test.
std::unique_ptr<ThreadSpec> m_thread_spec_ap; // Thread for which this breakpoint will take
std::unique_ptr<ClangUserExpression> m_condition_ap; // The condition to test.
};

2
lldb/include/lldb/Breakpoint/BreakpointSite.h
View File

@ -39,7 +39,7 @@ namespace lldb_private {
//----------------------------------------------------------------------
class BreakpointSite :
public STD_ENABLE_SHARED_FROM_THIS(BreakpointSite),
public std::enable_shared_from_this<BreakpointSite>,
public StoppointLocation
{
public:

4
lldb/include/lldb/Breakpoint/Watchpoint.h
View File

@ -28,7 +28,7 @@
namespace lldb_private {
class Watchpoint :
public STD_ENABLE_SHARED_FROM_THIS(Watchpoint),
public std::enable_shared_from_this<Watchpoint>,
public StoppointLocation
{
public:
@ -234,7 +234,7 @@ private:
// the callback machinery.
bool m_being_created;
STD_UNIQUE_PTR(ClangUserExpression) m_condition_ap; // The condition to test.
std::unique_ptr<ClangUserExpression> m_condition_ap; // The condition to test.
void SetID(lldb::watch_id_t id) { m_loc_id = id; }

2
lldb/include/lldb/Breakpoint/WatchpointOptions.h
View File

@ -247,7 +247,7 @@ private:
WatchpointHitCallback m_callback; // This is the callback function pointer
lldb::BatonSP m_callback_baton_sp; // This is the client data for the callback
bool m_callback_is_synchronous;
STD_UNIQUE_PTR(ThreadSpec) m_thread_spec_ap; // Thread for which this watchpoint will take
std::unique_ptr<ThreadSpec> m_thread_spec_ap; // Thread for which this watchpoint will take
};
} // namespace lldb_private

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

@ -47,7 +47,7 @@ namespace lldb_private {
class Debugger :
public STD_ENABLE_SHARED_FROM_THIS(Debugger),
public std::enable_shared_from_this<Debugger>,
public UserID,
public Properties,
public BroadcasterManager
@ -359,10 +359,10 @@ protected:
TargetList m_target_list;
PlatformList m_platform_list;
Listener m_listener;
STD_UNIQUE_PTR(SourceManager) m_source_manager_ap; // This is a scratch source manager that we return if we have no targets.
std::unique_ptr<SourceManager> m_source_manager_ap; // This is a scratch source manager that we return if we have no targets.
SourceManager::SourceFileCache m_source_file_cache; // All the source managers for targets created in this debugger used this shared
// source file cache.
STD_UNIQUE_PTR(CommandInterpreter) m_command_interpreter_ap;
std::unique_ptr<CommandInterpreter> m_command_interpreter_ap;
InputReaderStack m_input_reader_stack;
std::string m_input_reader_data;

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

@ -234,7 +234,7 @@ protected:
};
class Disassembler :
public STD_ENABLE_SHARED_FROM_THIS(Disassembler),
public std::enable_shared_from_this<Disassembler>,
public PluginInterface
{
public:

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

@ -205,7 +205,7 @@ private:
Broadcaster * m_broadcaster; // The broadcaster that sent this event
uint32_t m_type; // The bit describing this event
STD_UNIQUE_PTR(EventData) m_data_ap; // User specific data for this event
std::unique_ptr<EventData> m_data_ap; // User specific data for this event
DISALLOW_COPY_AND_ASSIGN (Event);

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

@ -224,7 +224,7 @@ public:
ListCategories (Stream *strm) = 0;
protected:
STD_UNIQUE_PTR(Log) m_log_ap;
std::unique_ptr<Log> m_log_ap;
private:
DISALLOW_COPY_AND_ASSIGN (LogChannel);

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

@ -41,7 +41,7 @@ namespace lldb_private {
/// made.
//----------------------------------------------------------------------
class Module :
public STD_ENABLE_SHARED_FROM_THIS(Module),
public std::enable_shared_from_this<Module>,
public SymbolContextScope
{
public:
@ -941,7 +941,7 @@ protected:
ConstString m_object_name; ///< The name an object within this module that is selected, or empty of the module is represented by \a m_file.
uint64_t m_object_offset;
lldb::ObjectFileSP m_objfile_sp; ///< A shared pointer to the object file parser for this module as it may or may not be shared with the SymbolFile
STD_UNIQUE_PTR(SymbolVendor) m_symfile_ap; ///< A pointer to the symbol vendor for this module.
std::unique_ptr<SymbolVendor> m_symfile_ap; ///< A pointer to the symbol vendor for this module.
ClangASTContext m_ast; ///< The AST context for this module.
PathMappingList m_source_mappings; ///< Module specific source remappings for when you have debug info for a module that doesn't match where the sources currently are

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

@ -100,7 +100,7 @@ protected:
class Section :
public STD_ENABLE_SHARED_FROM_THIS(Section),
public std::enable_shared_from_this<Section>,
public ModuleChild,
public UserID,
public Flags

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

@ -86,7 +86,7 @@ public:
#endif // SWIG
typedef STD_SHARED_PTR(File) FileSP;
typedef std::shared_ptr<File> FileSP;
#ifndef SWIG

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

@ -151,7 +151,7 @@ protected:
// we need to hold on to the SyntheticChildren because someone might delete the type binding while we are alive
lldb::SyntheticChildrenSP m_synth_sp;
STD_UNIQUE_PTR(SyntheticChildrenFrontEnd) m_synth_filter_ap;
std::unique_ptr<SyntheticChildrenFrontEnd> m_synth_filter_ap;
typedef std::map<uint32_t, ValueObject*> ByIndexMap;
typedef std::map<const char*, uint32_t> NameToIndexMap;

4
lldb/include/lldb/DataFormatters/FormatNavigator.h
View File

@ -256,11 +256,7 @@ public:
typedef typename MapType::key_type MapKeyType;
typedef typename MapType::mapped_type MapValueType;
typedef typename BackEndType::CallbackType CallbackType;
#ifdef _LIBCPP_VERSION
typedef typename std::shared_ptr<FormatNavigator<KeyType, ValueType> > SharedPointer;
#else
typedef typename std::tr1::shared_ptr<FormatNavigator<KeyType, ValueType> > SharedPointer;
#endif
friend class TypeCategoryImpl;

2
lldb/include/lldb/DataFormatters/TypeCategory.h
View File

@ -180,7 +180,7 @@ namespace lldb_private {
const char** matching_category = NULL,
FormatCategoryItems* matching_type = NULL);
typedef STD_SHARED_PTR(TypeCategoryImpl) SharedPointer;
typedef std::shared_ptr<TypeCategoryImpl> SharedPointer;
private:
SummaryNavigator::SharedPointer m_summary_nav;

2
lldb/include/lldb/DataFormatters/TypeFormat.h
View File

@ -133,7 +133,7 @@ namespace lldb_private {
TypeFormatImpl (lldb::Format f = lldb::eFormatInvalid,
const Flags& flags = Flags());
typedef STD_SHARED_PTR(TypeFormatImpl) SharedPointer;
typedef std::shared_ptr<TypeFormatImpl> SharedPointer;
typedef bool(*ValueCallback)(void*, ConstString, const lldb::TypeFormatImplSP&);
~TypeFormatImpl ()

6
lldb/include/lldb/DataFormatters/TypeSummary.h
View File

@ -331,7 +331,7 @@ namespace lldb_private {
return m_my_revision;
}
typedef STD_SHARED_PTR(TypeSummaryImpl) SharedPointer;
typedef std::shared_ptr<TypeSummaryImpl> SharedPointer;
typedef bool(*SummaryCallback)(void*, ConstString, const lldb::TypeSummaryImplSP&);
typedef bool(*RegexSummaryCallback)(void*, lldb::RegularExpressionSP, const lldb::TypeSummaryImplSP&);
@ -461,7 +461,7 @@ namespace lldb_private {
return TypeSummaryImpl::eTypeCallback;
}
typedef STD_SHARED_PTR(CXXFunctionSummaryFormat) SharedPointer;
typedef std::shared_ptr<CXXFunctionSummaryFormat> SharedPointer;
private:
DISALLOW_COPY_AND_ASSIGN(CXXFunctionSummaryFormat);
@ -535,7 +535,7 @@ namespace lldb_private {
return TypeSummaryImpl::eTypeScript;
}
typedef STD_SHARED_PTR(ScriptSummaryFormat) SharedPointer;
typedef std::shared_ptr<ScriptSummaryFormat> SharedPointer;
private:

10
lldb/include/lldb/DataFormatters/TypeSynthetic.h
View File

@ -68,8 +68,8 @@ namespace lldb_private {
virtual bool
MightHaveChildren () = 0;
typedef STD_SHARED_PTR(SyntheticChildrenFrontEnd) SharedPointer;
typedef STD_UNIQUE_PTR(SyntheticChildrenFrontEnd) AutoPointer;
typedef std::shared_ptr<SyntheticChildrenFrontEnd> SharedPointer;
typedef std::unique_ptr<SyntheticChildrenFrontEnd> AutoPointer;
private:
DISALLOW_COPY_AND_ASSIGN(SyntheticChildrenFrontEnd);
@ -247,7 +247,7 @@ namespace lldb_private {
virtual SyntheticChildrenFrontEnd::AutoPointer
GetFrontEnd (ValueObject &backend) = 0;
typedef STD_SHARED_PTR(SyntheticChildren) SharedPointer;
typedef std::shared_ptr<SyntheticChildren> SharedPointer;
typedef bool(*SyntheticChildrenCallback)(void*, ConstString, const SyntheticChildren::SharedPointer&);
uint32_t&
@ -415,7 +415,7 @@ namespace lldb_private {
return UINT32_MAX;
}
typedef STD_SHARED_PTR(SyntheticChildrenFrontEnd) SharedPointer;
typedef std::shared_ptr<SyntheticChildrenFrontEnd> SharedPointer;
private:
DISALLOW_COPY_AND_ASSIGN(FrontEnd);
@ -573,7 +573,7 @@ namespace lldb_private {
return m_interpreter->GetIndexOfChildWithName(m_wrapper_sp, name.GetCString());
}
typedef STD_SHARED_PTR(SyntheticChildrenFrontEnd) SharedPointer;
typedef std::shared_ptr<SyntheticChildrenFrontEnd> SharedPointer;
private:
DISALLOW_COPY_AND_ASSIGN(FrontEnd);

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

@ -714,7 +714,7 @@ private:
DISALLOW_COPY_AND_ASSIGN (ParserVars);
};
STD_UNIQUE_PTR(ParserVars) m_parser_vars;
std::unique_ptr<ParserVars> m_parser_vars;
//----------------------------------------------------------------------
/// Activate parser-specific variables
@ -756,7 +756,7 @@ private:
TypeFromUser m_object_pointer_type; ///< The type of the "this" variable, if one exists
};
STD_UNIQUE_PTR(StructVars) m_struct_vars;
std::unique_ptr<StructVars> m_struct_vars;
//----------------------------------------------------------------------
/// Activate struct variables
@ -795,7 +795,7 @@ private:
lldb::addr_t m_materialized_location; ///< The address at which the struct is placed. Falls inside the allocated area.
};
STD_UNIQUE_PTR(MaterialVars) m_material_vars;
std::unique_ptr<MaterialVars> m_material_vars;
//----------------------------------------------------------------------
/// Activate materialization-specific variables

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

@ -112,7 +112,7 @@ public:
Error
PrepareForExecution (lldb::addr_t &func_addr,
lldb::addr_t &func_end,
STD_UNIQUE_PTR(IRExecutionUnit) &execution_unit_ap,
std::unique_ptr<IRExecutionUnit> &execution_unit_ap,
ExecutionContext &exe_ctx,
bool &can_interpret,
lldb_private::ExecutionPolicy execution_policy);
@ -136,14 +136,14 @@ public:
private:
ClangExpression & m_expr; ///< The expression to be parsed
STD_UNIQUE_PTR(llvm::LLVMContext) m_llvm_context; ///< The LLVM context to generate IR into
STD_UNIQUE_PTR(clang::FileManager) m_file_manager; ///< The Clang file manager object used by the compiler
STD_UNIQUE_PTR(clang::CompilerInstance) m_compiler; ///< The Clang compiler used to parse expressions into IR
STD_UNIQUE_PTR(clang::Builtin::Context) m_builtin_context; ///< Context for Clang built-ins
STD_UNIQUE_PTR(clang::SelectorTable) m_selector_table; ///< Selector table for Objective-C methods
STD_UNIQUE_PTR(clang::ASTContext) m_ast_context; ///< The AST context used to hold types and names for the parser
STD_UNIQUE_PTR(clang::CodeGenerator) m_code_generator; ///< The Clang object that generates IR
STD_UNIQUE_PTR(IRExecutionUnit) m_execution_unit; ///< The container for the finished Module
std::unique_ptr<llvm::LLVMContext> m_llvm_context; ///< The LLVM context to generate IR into
std::unique_ptr<clang::FileManager> m_file_manager; ///< The Clang file manager object used by the compiler
std::unique_ptr<clang::CompilerInstance> m_compiler; ///< The Clang compiler used to parse expressions into IR
std::unique_ptr<clang::Builtin::Context> m_builtin_context; ///< Context for Clang built-ins
std::unique_ptr<clang::SelectorTable> m_selector_table; ///< Selector table for Objective-C methods
std::unique_ptr<clang::ASTContext> m_ast_context; ///< The AST context used to hold types and names for the parser
std::unique_ptr<clang::CodeGenerator> m_code_generator; ///< The Clang object that generates IR
std::unique_ptr<IRExecutionUnit> m_execution_unit; ///< The container for the finished Module
};
}

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

@ -248,7 +248,7 @@ public:
void
TransferAddress (bool force = false);
typedef STD_SHARED_PTR(ValueObjectConstResult) ValueObjectConstResultSP;
typedef std::shared_ptr<ValueObjectConstResult> ValueObjectConstResultSP;
//----------------------------------------------------------------------
/// Members

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

@ -619,8 +619,8 @@ private:
// For ClangFunction only
//------------------------------------------------------------------
STD_UNIQUE_PTR(ClangExpressionParser) m_parser; ///< The parser responsible for compiling the function.
STD_UNIQUE_PTR(IRExecutionUnit) m_execution_unit_ap;
std::unique_ptr<ClangExpressionParser> m_parser; ///< The parser responsible for compiling the function.
std::unique_ptr<IRExecutionUnit> m_execution_unit_ap;
Function *m_function_ptr; ///< The function we're going to call. May be NULL if we don't have debug info for the function.
Address m_function_addr; ///< If we don't have the FunctionSP, we at least need the address & return type.

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

@ -46,7 +46,7 @@ namespace lldb_private
class ClangUserExpression : public ClangExpression
{
public:
typedef STD_SHARED_PTR(ClangUserExpression) ClangUserExpressionSP;
typedef std::shared_ptr<ClangUserExpression> ClangUserExpressionSP;
enum { kDefaultTimeout = 500000u };
//------------------------------------------------------------------
@ -420,10 +420,10 @@ private:
std::string m_transformed_text; ///< The text of the expression, as send to the parser
ResultType m_desired_type; ///< The type to coerce the expression's result to. If eResultTypeAny, inferred from the expression.
STD_UNIQUE_PTR(ClangExpressionDeclMap) m_expr_decl_map; ///< The map to use when parsing the expression.
STD_UNIQUE_PTR(IRExecutionUnit) m_execution_unit_ap; ///< The execution unit the expression is stored in.
STD_UNIQUE_PTR(Materializer) m_materializer_ap; ///< The materializer to use when running the expression.
STD_UNIQUE_PTR(ASTResultSynthesizer) m_result_synthesizer; ///< The result synthesizer, if one is needed.
std::unique_ptr<ClangExpressionDeclMap> m_expr_decl_map; ///< The map to use when parsing the expression.
std::unique_ptr<IRExecutionUnit> m_execution_unit_ap; ///< The execution unit the expression is stored in.
std::unique_ptr<Materializer> m_materializer_ap; ///< The materializer to use when running the expression.
std::unique_ptr<ASTResultSynthesizer> m_result_synthesizer; ///< The result synthesizer, if one is needed.
bool m_enforce_valid_object; ///< True if the expression parser should enforce the presence of a valid class pointer in order to generate the expression as a method.
bool m_cplusplus; ///< True if the expression is compiled as a C++ member function (true if it was parsed when exe_ctx was in a C++ method).

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

@ -167,8 +167,8 @@ public:
}
private:
STD_UNIQUE_PTR(ClangExpressionDeclMap) m_expr_decl_map; ///< The map to use when parsing and materializing the expression.
STD_UNIQUE_PTR(IRExecutionUnit) m_execution_unit_ap;
std::unique_ptr<ClangExpressionDeclMap> m_expr_decl_map; ///< The map to use when parsing and materializing the expression.
std::unique_ptr<IRExecutionUnit> m_execution_unit_ap;
std::string m_function_text; ///< The text of the function. Must be a well-formed translation unit.
std::string m_function_name; ///< The name of the function.

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

@ -77,8 +77,8 @@ public:
bool DoCheckersExplainStop (lldb::addr_t addr, Stream &message);
STD_UNIQUE_PTR(ClangUtilityFunction) m_valid_pointer_check;
STD_UNIQUE_PTR(ClangUtilityFunction) m_objc_object_check;
std::unique_ptr<ClangUtilityFunction> m_valid_pointer_check;
std::unique_ptr<ClangUtilityFunction> m_objc_object_check;
};
//----------------------------------------------------------------------

12
lldb/include/lldb/Expression/IRExecutionUnit.h
View File

@ -66,8 +66,8 @@ public:
//------------------------------------------------------------------
/// Constructor
//------------------------------------------------------------------
IRExecutionUnit (STD_UNIQUE_PTR(llvm::LLVMContext) &context_ap,
STD_UNIQUE_PTR(llvm::Module) &module_ap,
IRExecutionUnit (std::unique_ptr<llvm::LLVMContext> &context_ap,
std::unique_ptr<llvm::Module> &module_ap,
ConstString &name,
const lldb::TargetSP &target_sp,
std::vector<std::string> &cpu_features);
@ -422,7 +422,7 @@ private:
return m_default_mm_ap->getPointerToNamedFunction(Name, AbortOnFailure);
}
private:
STD_UNIQUE_PTR(JITMemoryManager) m_default_mm_ap; ///< The memory allocator to use in actually creating space. All calls are passed through to it.
std::unique_ptr<JITMemoryManager> m_default_mm_ap; ///< The memory allocator to use in actually creating space. All calls are passed through to it.
IRExecutionUnit &m_parent; ///< The execution unit this is a proxy for.
};
@ -502,9 +502,9 @@ private:
typedef std::vector<AllocationRecord> RecordVector;
RecordVector m_records;
STD_UNIQUE_PTR(llvm::LLVMContext) m_context_ap;
STD_UNIQUE_PTR(llvm::ExecutionEngine) m_execution_engine_ap;
STD_UNIQUE_PTR(llvm::Module) m_module_ap; ///< Holder for the module until it's been handed off
std::unique_ptr<llvm::LLVMContext> m_context_ap;
std::unique_ptr<llvm::ExecutionEngine> m_execution_engine_ap;
std::unique_ptr<llvm::Module> m_module_ap; ///< Holder for the module until it's been handed off
llvm::Module *m_module; ///< Owned by the execution engine
std::vector<std::string> m_cpu_features;
llvm::SmallVector<JittedFunction, 1> m_jitted_functions; ///< A vector of all functions that have been JITted into machine code

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

@ -654,7 +654,7 @@ private:
lldb_private::ConstString m_result_name; ///< The name of the result variable ($0, $1, ...)
lldb_private::TypeFromParser m_result_type; ///< The type of the result variable.
llvm::Module *m_module; ///< The module being processed, or NULL if that has not been determined yet.
STD_UNIQUE_PTR(llvm::DataLayout) m_target_data; ///< The target data for the module being processed, or NULL if there is no module.
std::unique_ptr<llvm::DataLayout> m_target_data; ///< The target data for the module being processed, or NULL if there is no module.
lldb_private::ClangExpressionDeclMap *m_decl_map; ///< The DeclMap containing the Decls
StaticDataAllocator m_data_allocator; ///< The allocator to use for constant strings
lldb_private::IRMemoryMap &m_memory_map; ///< The memory map to pass to the IR interpreter

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

@ -83,7 +83,7 @@ private:
size_t m_size; ///< The size of the requested allocation
uint32_t m_permissions; ///< The access permissions on the memory in the process. In the host, the memory is always read/write.
uint8_t m_alignment; ///< The alignment of the requested allocation
STD_UNIQUE_PTR(DataBufferHeap) m_data_ap;
std::unique_ptr<DataBufferHeap> m_data_ap;
AllocationPolicy m_policy;
Allocation () :

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

@ -73,8 +73,8 @@ public:
lldb::addr_t m_process_address;
};
typedef STD_SHARED_PTR(Dematerializer) DematerializerSP;
typedef STD_WEAK_PTR(Dematerializer) DematerializerWP;
typedef std::shared_ptr<Dematerializer> DematerializerSP;
typedef std::weak_ptr<Dematerializer> DematerializerWP;
DematerializerSP Materialize (lldb::StackFrameSP &frame_sp, IRMemoryMap &map, lldb::addr_t process_address, Error &err);
@ -152,7 +152,7 @@ public:
private:
uint32_t AddStructMember (Entity &entity);
typedef STD_UNIQUE_PTR(Entity) EntityUP;
typedef std::unique_ptr<Entity> EntityUP;
typedef std::vector<EntityUP> EntityVector;
unsigned m_result_index;

2
lldb/include/lldb/Host/Terminal.h
View File

@ -173,7 +173,7 @@ protected:
//------------------------------------------------------------------
Terminal m_tty; ///< A terminal
int m_tflags; ///< Cached tflags information.
STD_UNIQUE_PTR(struct termios) m_termios_ap; ///< Cached terminal state information.
std::unique_ptr<struct termios> m_termios_ap; ///< Cached terminal state information.
lldb::pid_t m_process_group;///< Cached process group information.
};

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

@ -30,7 +30,7 @@ namespace lldb_private {
typedef std::pair<int, std::string> OptionArgValue;
typedef std::pair<std::string, OptionArgValue> OptionArgPair;
typedef std::vector<OptionArgPair> OptionArgVector;
typedef STD_SHARED_PTR(OptionArgVector) OptionArgVectorSP;
typedef std::shared_ptr<OptionArgVector> OptionArgVectorSP;
struct OptionArgElement
{

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

@ -463,7 +463,7 @@ private:
OptionArgMap m_alias_options; // Stores any options (with or without arguments) that go with any alias.
std::vector<std::string> m_command_history;
std::string m_repeat_command; // Stores the command that will be executed for an empty command string.
STD_UNIQUE_PTR(ScriptInterpreter) m_script_interpreter_ap;
std::unique_ptr<ScriptInterpreter> m_script_interpreter_ap;
char m_comment_char;
char m_repeat_char;
bool m_batch_command_mode;

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

@ -21,7 +21,9 @@
namespace lldb_private {
class OptionValueProperties : public OptionValue, public STD_ENABLE_SHARED_FROM_THIS(OptionValueProperties)
class OptionValueProperties :
public OptionValue,
public std::enable_shared_from_this<OptionValueProperties>
{
public:

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

@ -425,7 +425,7 @@ public:
return lldb::ScriptInterpreterObjectSP(new ScriptInterpreterObject(object));
}
virtual STD_UNIQUE_PTR(ScriptInterpreterLocker)
virtual std::unique_ptr<ScriptInterpreterLocker>
AcquireInterpreterLock ();
const char *

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

@ -181,7 +181,7 @@ public:
virtual lldb::ScriptInterpreterObjectSP
MakeScriptObject (void* object);
virtual STD_UNIQUE_PTR(ScriptInterpreterLocker)
virtual std::unique_ptr<ScriptInterpreterLocker>
AcquireInterpreterLock ();
void

22
lldb/include/lldb/Symbol/ClangASTContext.h
View File

@ -1014,18 +1014,18 @@ protected:
// Classes that inherit from ClangASTContext can see and modify these
//------------------------------------------------------------------
std::string m_target_triple;
STD_UNIQUE_PTR(clang::ASTContext) m_ast_ap;
STD_UNIQUE_PTR(clang::LangOptions) m_language_options_ap;
STD_UNIQUE_PTR(clang::FileManager) m_file_manager_ap;
STD_UNIQUE_PTR(clang::FileSystemOptions) m_file_system_options_ap;
STD_UNIQUE_PTR(clang::SourceManager) m_source_manager_ap;
STD_UNIQUE_PTR(clang::DiagnosticsEngine) m_diagnostics_engine_ap;
STD_UNIQUE_PTR(clang::DiagnosticConsumer) m_diagnostic_consumer_ap;
std::unique_ptr<clang::ASTContext> m_ast_ap;
std::unique_ptr<clang::LangOptions> m_language_options_ap;
std::unique_ptr<clang::FileManager> m_file_manager_ap;
std::unique_ptr<clang::FileSystemOptions> m_file_system_options_ap;
std::unique_ptr<clang::SourceManager> m_source_manager_ap;
std::unique_ptr<clang::DiagnosticsEngine> m_diagnostics_engine_ap;
std::unique_ptr<clang::DiagnosticConsumer> m_diagnostic_consumer_ap;
llvm::IntrusiveRefCntPtr<clang::TargetOptions> m_target_options_rp;
STD_UNIQUE_PTR(clang::TargetInfo) m_target_info_ap;
STD_UNIQUE_PTR(clang::IdentifierTable) m_identifier_table_ap;
STD_UNIQUE_PTR(clang::SelectorTable) m_selector_table_ap;
STD_UNIQUE_PTR(clang::Builtin::Context) m_builtins_ap;
std::unique_ptr<clang::TargetInfo> m_target_info_ap;
std::unique_ptr<clang::IdentifierTable> m_identifier_table_ap;
std::unique_ptr<clang::SelectorTable> m_selector_table_ap;
std::unique_ptr<clang::Builtin::Context> m_builtins_ap;
CompleteTagDeclCallback m_callback_tag_decl;
CompleteObjCInterfaceDeclCallback m_callback_objc_decl;
void * m_callback_baton;

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

@ -157,7 +157,7 @@ public:
//
typedef std::vector < std::pair<lldb::ModuleSP, ClangNamespaceDecl> > NamespaceMap;
typedef STD_SHARED_PTR(NamespaceMap) NamespaceMapSP;
typedef std::shared_ptr<NamespaceMap> NamespaceMapSP;
void RegisterNamespaceMap (const clang::NamespaceDecl *decl,
NamespaceMapSP &namespace_map);
@ -285,7 +285,7 @@ private:
clang::ASTContext *m_source_ctx;
};
typedef STD_SHARED_PTR(Minion) MinionSP;
typedef std::shared_ptr<Minion> MinionSP;
typedef std::map<clang::ASTContext *, MinionSP> MinionMap;
typedef std::map<const clang::NamespaceDecl *, NamespaceMapSP> NamespaceMetaMap;
@ -308,7 +308,7 @@ private:
MapCompleter *m_map_completer;
};
typedef STD_SHARED_PTR(ASTContextMetadata) ASTContextMetadataSP;
typedef std::shared_ptr<ASTContextMetadata> ASTContextMetadataSP;
typedef std::map<const clang::ASTContext *, ASTContextMetadataSP> ContextMetadataMap;
ContextMetadataMap m_metadata_map;

4
lldb/include/lldb/Symbol/CompileUnit.h
View File

@ -32,7 +32,7 @@ namespace lldb_private {
/// files), and a line table.
//----------------------------------------------------------------------
class CompileUnit :
public STD_ENABLE_SHARED_FROM_THIS(CompileUnit),
public std::enable_shared_from_this<CompileUnit>,
public ModuleChild,
public FileSpec,
public UserID,
@ -401,7 +401,7 @@ protected:
std::vector<lldb::FunctionSP> m_functions; ///< The sparsely populated list of shared pointers to functions
///< that gets populated as functions get partially parsed.
FileSpecList m_support_files; ///< Files associated with this compile unit's line table and declarations.
STD_UNIQUE_PTR(LineTable) m_line_table_ap; ///< Line table that will get parsed on demand.
std::unique_ptr<LineTable> m_line_table_ap; ///< Line table that will get parsed on demand.
lldb::VariableListSP m_variables; ///< Global and static variable list that will get parsed on demand.
private:

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

@ -98,7 +98,7 @@ private:
inst_length (0), ptr_encoding (0), initial_row() {}
};
typedef STD_SHARED_PTR(CIE) CIESP;
typedef std::shared_ptr<CIE> CIESP;
typedef std::map<off_t, CIESP> cie_map_t;

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

@ -50,7 +50,7 @@ namespace lldb_private {
/// this abstract class.
//----------------------------------------------------------------------
class ObjectFile:
public STD_ENABLE_SHARED_FROM_THIS(ObjectFile),
public std::enable_shared_from_this<ObjectFile>,
public PluginInterface,
public ModuleChild
{
@ -621,8 +621,8 @@ protected:
lldb_private::UnwindTable m_unwind_table; /// < Table of FuncUnwinders objects created for this ObjectFile's functions
lldb::ProcessWP m_process_wp;
const lldb::addr_t m_memory_addr;
STD_UNIQUE_PTR(lldb_private::SectionList) m_sections_ap;
STD_UNIQUE_PTR(lldb_private::Symtab) m_symtab_ap;
std::unique_ptr<lldb_private::SectionList> m_sections_ap;
std::unique_ptr<lldb_private::Symtab> m_symtab_ap;
//------------------------------------------------------------------
/// Sets the architecture for a module. At present the architecture

4
lldb/include/lldb/Symbol/SymbolContext.h
View File

@ -367,12 +367,12 @@ private:
lldb::TargetSP m_target_sp;
std::string m_module_spec;
lldb::ModuleSP m_module_sp;
STD_UNIQUE_PTR(FileSpec) m_file_spec_ap;
std::unique_ptr<FileSpec> m_file_spec_ap;
size_t m_start_line;
size_t m_end_line;
std::string m_function_spec;
std::string m_class_name;
STD_UNIQUE_PTR(AddressRange) m_address_range_ap;
std::unique_ptr<AddressRange> m_address_range_ap;
uint32_t m_type; // Or'ed bits from SpecificationType
};

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

@ -191,7 +191,7 @@ protected:
TypeList m_type_list; // Uniqued types for all parsers owned by this module
CompileUnits m_compile_units; // The current compile units
lldb::ObjectFileSP m_objfile_sp; // Keep a reference to the object file in case it isn't the same as the module object file (debug symbols in a separate file)
STD_UNIQUE_PTR(SymbolFile) m_sym_file_ap; // A single symbol file. Suclasses can add more of these if needed.
std::unique_ptr<SymbolFile> m_sym_file_ap; // A single symbol file. Suclasses can add more of these if needed.
private:
//------------------------------------------------------------------

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

@ -21,7 +21,7 @@
namespace lldb_private {
class SymbolFileType :
public STD_ENABLE_SHARED_FROM_THIS(SymbolFileType),
public std::enable_shared_from_this<SymbolFileType>,
public UserID
{
public:
@ -50,7 +50,7 @@ class SymbolFileType :
};
class Type :
public STD_ENABLE_SHARED_FROM_THIS(Type),
public std::enable_shared_from_this<Type>,
public UserID
{
public:

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

@ -342,7 +342,7 @@ public:
public:
typedef STD_SHARED_PTR(Row) RowSP;
typedef std::shared_ptr<Row> RowSP;
UnwindPlan (lldb::RegisterKind reg_kind) :
m_row_list (),

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

@ -170,7 +170,7 @@ namespace lldb_private {
DeallocateMemory (lldb::addr_t ptr);
protected:
typedef STD_SHARED_PTR(AllocatedBlock) AllocatedBlockSP;
typedef std::shared_ptr<AllocatedBlock> AllocatedBlockSP;
AllocatedBlockSP
AllocatePage (uint32_t byte_size,

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

@ -138,7 +138,7 @@ public:
typedef lldb::addr_t ObjCISA;
class ClassDescriptor;
typedef STD_SHARED_PTR(ClassDescriptor) ClassDescriptorSP;
typedef std::shared_ptr<ClassDescriptor> ClassDescriptorSP;
// the information that we want to support retrieving from an ObjC class
// this needs to be pure virtual since there are at least 2 different implementations

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

@ -93,7 +93,7 @@ public:
SetStopOnSharedLibraryEvents (bool stop);
};
typedef STD_SHARED_PTR(ProcessProperties) ProcessPropertiesSP;
typedef std::shared_ptr<ProcessProperties> ProcessPropertiesSP;
//----------------------------------------------------------------------
// ProcessInfo
@ -1343,7 +1343,7 @@ protected:
/// @brief A plug-in interface definition class for debugging a process.
//----------------------------------------------------------------------
class Process :
public STD_ENABLE_SHARED_FROM_THIS(Process),
public std::enable_shared_from_this<Process>,
public ProcessProperties,
public UserID,
public Broadcaster,
@ -3588,9 +3588,9 @@ protected:
std::vector<lldb::addr_t> m_image_tokens;
Listener &m_listener;
BreakpointSiteList m_breakpoint_site_list; ///< This is the list of breakpoint locations we intend to insert in the target.
STD_UNIQUE_PTR(DynamicLoader) m_dyld_ap;
STD_UNIQUE_PTR(DynamicCheckerFunctions) m_dynamic_checkers_ap; ///< The functions used by the expression parser to validate data that expressions use.
STD_UNIQUE_PTR(OperatingSystem) m_os_ap;
std::unique_ptr<DynamicLoader> m_dyld_ap;
std::unique_ptr<DynamicCheckerFunctions> m_dynamic_checkers_ap; ///< The functions used by the expression parser to validate data that expressions use.
std::unique_ptr<OperatingSystem> m_os_ap;
UnixSignals m_unix_signals; /// This is the current signal set for this process.
lldb::ABISP m_abi_sp;
lldb::InputReaderSP m_process_input_reader;
@ -3604,7 +3604,7 @@ protected:
AllocatedMemoryCache m_allocated_memory_cache;
bool m_should_detach; /// Should we detach if the process object goes away with an explicit call to Kill or Detach?
LanguageRuntimeCollection m_language_runtimes;
STD_UNIQUE_PTR(NextEventAction) m_next_event_action_ap;
std::unique_ptr<NextEventAction> m_next_event_action_ap;
std::vector<PreResumeCallbackAndBaton> m_pre_resume_actions;
ReadWriteLock m_public_run_lock;
#if defined(__APPLE__)

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

@ -20,7 +20,7 @@
namespace lldb_private {
class RegisterContext :
public STD_ENABLE_SHARED_FROM_THIS(RegisterContext),
public std::enable_shared_from_this<RegisterContext>,
public ExecutionContextScope
{
public:

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

@ -27,7 +27,7 @@
namespace lldb_private {
class StackFrame :
public STD_ENABLE_SHARED_FROM_THIS(StackFrame),
public std::enable_shared_from_this<StackFrame>,
public ExecutionContextScope
{
public:

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

@ -98,7 +98,7 @@ protected:
SetFrameAtIndex (uint32_t idx, lldb::StackFrameSP &frame_sp);
static void
Merge (STD_UNIQUE_PTR(StackFrameList)& curr_ap,
Merge (std::unique_ptr<StackFrameList>& curr_ap,
lldb::StackFrameListSP& prev_sp);
void

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

@ -149,7 +149,7 @@ public:
};
typedef STD_SHARED_PTR(TargetProperties) TargetPropertiesSP;
typedef std::shared_ptr<TargetProperties> TargetPropertiesSP;
class EvaluateExpressionOptions
{
@ -285,7 +285,7 @@ private:
// Target
//----------------------------------------------------------------------
class Target :
public STD_ENABLE_SHARED_FROM_THIS(Target),
public std::enable_shared_from_this<Target>,
public TargetProperties,
public Broadcaster,
public ExecutionContextScope,
@ -1023,7 +1023,7 @@ public:
lldb::TargetSP m_target_sp;
StringList m_commands;
lldb::SymbolContextSpecifierSP m_specifier_sp;
STD_UNIQUE_PTR(ThreadSpec) m_thread_spec_ap;
std::unique_ptr<ThreadSpec> m_thread_spec_ap;
bool m_active;
// Use AddStopHook to make a new empty stop hook. The GetCommandPointer and fill it with commands,
@ -1031,7 +1031,7 @@ public:
StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid);
friend class Target;
};
typedef STD_SHARED_PTR(StopHook) StopHookSP;
typedef std::shared_ptr<StopHook> StopHookSP;
// Add an empty stop hook to the Target's stop hook list, and returns a shared pointer to it in new_hook.
// Returns the id of the new hook.
@ -1159,12 +1159,12 @@ protected:
bool m_valid;
lldb::SearchFilterSP m_search_filter_sp;
PathMappingList m_image_search_paths;
STD_UNIQUE_PTR(ClangASTContext) m_scratch_ast_context_ap;
STD_UNIQUE_PTR(ClangASTSource) m_scratch_ast_source_ap;
STD_UNIQUE_PTR(ClangASTImporter) m_ast_importer_ap;
std::unique_ptr<ClangASTContext> m_scratch_ast_context_ap;
std::unique_ptr<ClangASTSource> m_scratch_ast_source_ap;
std::unique_ptr<ClangASTImporter> m_ast_importer_ap;
ClangPersistentVariables m_persistent_variables; ///< These are the persistent variables associated with this process for the expression parser.
STD_UNIQUE_PTR(SourceManager) m_source_manager_ap;
std::unique_ptr<SourceManager> m_source_manager_ap;
typedef std::map<lldb::user_id_t, StopHookSP> StopHookCollection;
StopHookCollection m_stop_hooks;

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

@ -47,10 +47,10 @@ public:
GetTraceEnabledState() const;
};
typedef STD_SHARED_PTR(ThreadProperties) ThreadPropertiesSP;
typedef std::shared_ptr<ThreadProperties> ThreadPropertiesSP;
class Thread :
public STD_ENABLE_SHARED_FROM_THIS(Thread),
public std::enable_shared_from_this<Thread>,
public ThreadProperties,
public UserID,
public ExecutionContextScope,
@ -966,7 +966,7 @@ protected:
lldb::StateType m_resume_state; ///< This state is used to force a thread to be suspended from outside the ThreadPlan logic.
lldb::StateType m_temporary_resume_state; ///< This state records what the thread was told to do by the thread plan logic for the current resume.
/// It gets set in Thread::WillResume.
STD_UNIQUE_PTR(lldb_private::Unwind) m_unwinder_ap;
std::unique_ptr<lldb_private::Unwind> m_unwinder_ap;
bool m_destroy_called; // This is used internally to make sure derived Thread classes call DestroyThread.
uint32_t m_thread_stop_reason_stop_id; // This is the stop id for which the StopInfo is valid. Can use this so you know that
// the thread's m_actual_stop_info_sp is current and you don't have to fetch it again

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

@ -93,7 +93,7 @@ private:
// from step in.
static uint32_t s_default_flag_values;
STD_UNIQUE_PTR(RegularExpression) m_avoid_regexp_ap;
std::unique_ptr<RegularExpression> m_avoid_regexp_ap;
bool m_step_past_prologue; // FIXME: For now hard-coded to true, we could put a switch in for this if there's
// demand for that.
bool m_virtual_step; // true if we've just done a "virtual step", i.e. just moved the inline stack depth.

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

@ -30,7 +30,7 @@ public:
typedef T& reference_type;
typedef T* pointer_type;
typedef typename STD_SHARED_PTR(T) T_SP;
typedef typename std::shared_ptr<T> T_SP;
PriorityPointerPair() :
m_high(),

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

@ -198,7 +198,7 @@ template<class Y>
SharingPtr<T>::SharingPtr(Y* p)
: ptr_(p), cntrl_(0)
{
std::auto_ptr<Y> hold(p);
std::unique_ptr<Y> hold(p);
typedef imp::shared_ptr_pointer<Y*> _CntrlBlk;
cntrl_ = new _CntrlBlk(p);
hold.release();

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

@ -12,24 +12,6 @@
#if defined(__cplusplus)
#include <ciso646> // detect C++ lib
#ifdef _LIBCPP_VERSION
#include <memory>
#define STD_SHARED_PTR(T) std::shared_ptr<T>
#define STD_WEAK_PTR(T) std::weak_ptr<T>
#define STD_UNIQUE_PTR(T) std::unique_ptr<T>
#define STD_ENABLE_SHARED_FROM_THIS(T) std::enable_shared_from_this<T>
#define STD_STATIC_POINTER_CAST(T,V) std::static_pointer_cast<T>(V)
#else
#include <tr1/memory>
#define STD_SHARED_PTR(T) std::tr1::shared_ptr<T>
#define STD_WEAK_PTR(T) std::tr1::weak_ptr<T>
#define STD_UNIQUE_PTR(T) std::auto_ptr<T>
#define STD_ENABLE_SHARED_FROM_THIS(T) std::tr1::enable_shared_from_this<T>
#define STD_STATIC_POINTER_CAST(T,V) std::tr1::static_pointer_cast<T>(V)
#endif
#include "lldb/Utility/SharingPtr.h"
//----------------------------------------------------------------------
@ -277,116 +259,116 @@ struct LineEntry;
//----------------------------------------------------------------------
namespace lldb {
typedef STD_SHARED_PTR(lldb_private::ABI) ABISP;
typedef STD_SHARED_PTR(lldb_private::Baton) BatonSP;
typedef STD_SHARED_PTR(lldb_private::Block) BlockSP;
typedef STD_SHARED_PTR(lldb_private::Breakpoint) BreakpointSP;
typedef STD_WEAK_PTR( lldb_private::Breakpoint) BreakpointWP;
typedef STD_SHARED_PTR(lldb_private::BreakpointSite) BreakpointSiteSP;
typedef STD_WEAK_PTR( lldb_private::BreakpointSite) BreakpointSiteWP;
typedef STD_SHARED_PTR(lldb_private::BreakpointLocation) BreakpointLocationSP;
typedef STD_WEAK_PTR( lldb_private::BreakpointLocation) BreakpointLocationWP;
typedef STD_SHARED_PTR(lldb_private::BreakpointResolver) BreakpointResolverSP;
typedef STD_SHARED_PTR(lldb_private::Broadcaster) BroadcasterSP;
typedef STD_SHARED_PTR(lldb_private::ClangExpressionVariable) ClangExpressionVariableSP;
typedef STD_SHARED_PTR(lldb_private::CommandObject) CommandObjectSP;
typedef STD_SHARED_PTR(lldb_private::Communication) CommunicationSP;
typedef STD_SHARED_PTR(lldb_private::Connection) ConnectionSP;
typedef STD_SHARED_PTR(lldb_private::CompileUnit) CompUnitSP;
typedef STD_SHARED_PTR(lldb_private::DataBuffer) DataBufferSP;
typedef STD_SHARED_PTR(lldb_private::DataExtractor) DataExtractorSP;
typedef STD_SHARED_PTR(lldb_private::Debugger) DebuggerSP;
typedef STD_WEAK_PTR( lldb_private::Debugger) DebuggerWP;
typedef STD_SHARED_PTR(lldb_private::Disassembler) DisassemblerSP;
typedef STD_SHARED_PTR(lldb_private::DynamicLibrary) DynamicLibrarySP;
typedef STD_SHARED_PTR(lldb_private::DynamicLoader) DynamicLoaderSP;
typedef STD_SHARED_PTR(lldb_private::Event) EventSP;
typedef STD_SHARED_PTR(lldb_private::ExecutionContextRef) ExecutionContextRefSP;
typedef STD_SHARED_PTR(lldb_private::Function) FunctionSP;
typedef STD_SHARED_PTR(lldb_private::FuncUnwinders) FuncUnwindersSP;
typedef STD_SHARED_PTR(lldb_private::InlineFunctionInfo) InlineFunctionInfoSP;
typedef STD_SHARED_PTR(lldb_private::InputReader) InputReaderSP;
typedef STD_SHARED_PTR(lldb_private::Instruction) InstructionSP;
typedef STD_SHARED_PTR(lldb_private::LanguageRuntime) LanguageRuntimeSP;
typedef STD_SHARED_PTR(lldb_private::LineTable) LineTableSP;
typedef STD_SHARED_PTR(lldb_private::Listener) ListenerSP;
typedef STD_SHARED_PTR(lldb_private::LogChannel) LogChannelSP;
typedef STD_SHARED_PTR(lldb_private::Module) ModuleSP;
typedef STD_WEAK_PTR( lldb_private::Module) ModuleWP;
typedef STD_SHARED_PTR(lldb_private::ObjectFile) ObjectFileSP;
typedef STD_WEAK_PTR( lldb_private::ObjectFile) ObjectFileWP;
typedef STD_SHARED_PTR(lldb_private::OptionValue) OptionValueSP;
typedef STD_WEAK_PTR( lldb_private::OptionValue) OptionValueWP;
typedef STD_SHARED_PTR(lldb_private::OptionValueArch) OptionValueArchSP;
typedef STD_SHARED_PTR(lldb_private::OptionValueArgs) OptionValueArgsSP;
typedef STD_SHARED_PTR(lldb_private::OptionValueArray) OptionValueArraySP;
typedef STD_SHARED_PTR(lldb_private::OptionValueBoolean) OptionValueBooleanSP;
typedef STD_SHARED_PTR(lldb_private::OptionValueDictionary) OptionValueDictionarySP;
typedef STD_SHARED_PTR(lldb_private::OptionValueFileSpec) OptionValueFileSpecSP;
typedef STD_SHARED_PTR(lldb_private::OptionValueFileSpecList) OptionValueFileSpecListSP;
typedef STD_SHARED_PTR(lldb_private::OptionValueFormat) OptionValueFormatSP;
typedef STD_SHARED_PTR(lldb_private::OptionValuePathMappings) OptionValuePathMappingsSP;
typedef STD_SHARED_PTR(lldb_private::OptionValueProperties) OptionValuePropertiesSP;
typedef STD_SHARED_PTR(lldb_private::OptionValueRegex) OptionValueRegexSP;
typedef STD_SHARED_PTR(lldb_private::OptionValueSInt64) OptionValueSInt64SP;
typedef STD_SHARED_PTR(lldb_private::OptionValueString) OptionValueStringSP;
typedef STD_SHARED_PTR(lldb_private::OptionValueUInt64) OptionValueUInt64SP;
typedef STD_SHARED_PTR(lldb_private::OptionValueUUID) OptionValueUUIDSP;
typedef STD_SHARED_PTR(lldb_private::Platform) PlatformSP;
typedef STD_SHARED_PTR(lldb_private::Process) ProcessSP;
typedef STD_SHARED_PTR(lldb_private::ProcessAttachInfo) ProcessAttachInfoSP;
typedef STD_SHARED_PTR(lldb_private::ProcessLaunchInfo) ProcessLaunchInfoSP;
typedef STD_WEAK_PTR( lldb_private::Process) ProcessWP;
typedef STD_SHARED_PTR(lldb_private::Property) PropertySP;
typedef STD_SHARED_PTR(lldb_private::RegisterContext) RegisterContextSP;
typedef STD_SHARED_PTR(lldb_private::RegularExpression) RegularExpressionSP;
typedef STD_SHARED_PTR(lldb_private::ScriptInterpreterObject) ScriptInterpreterObjectSP;
typedef std::shared_ptr<lldb_private::ABI> ABISP;
typedef std::shared_ptr<lldb_private::Baton> BatonSP;
typedef std::shared_ptr<lldb_private::Block> BlockSP;
typedef std::shared_ptr<lldb_private::Breakpoint> BreakpointSP;
typedef std::weak_ptr<lldb_private::Breakpoint> BreakpointWP;
typedef std::shared_ptr<lldb_private::BreakpointSite> BreakpointSiteSP;
typedef std::weak_ptr<lldb_private::BreakpointSite> BreakpointSiteWP;
typedef std::shared_ptr<lldb_private::BreakpointLocation> BreakpointLocationSP;
typedef std::weak_ptr<lldb_private::BreakpointLocation> BreakpointLocationWP;
typedef std::shared_ptr<lldb_private::BreakpointResolver> BreakpointResolverSP;
typedef std::shared_ptr<lldb_private::Broadcaster> BroadcasterSP;
typedef std::shared_ptr<lldb_private::ClangExpressionVariable> ClangExpressionVariableSP;
typedef std::shared_ptr<lldb_private::CommandObject> CommandObjectSP;
typedef std::shared_ptr<lldb_private::Communication> CommunicationSP;
typedef std::shared_ptr<lldb_private::Connection> ConnectionSP;
typedef std::shared_ptr<lldb_private::CompileUnit> CompUnitSP;
typedef std::shared_ptr<lldb_private::DataBuffer> DataBufferSP;
typedef std::shared_ptr<lldb_private::DataExtractor> DataExtractorSP;
typedef std::shared_ptr<lldb_private::Debugger> DebuggerSP;
typedef std::weak_ptr<lldb_private::Debugger> DebuggerWP;
typedef std::shared_ptr<lldb_private::Disassembler> DisassemblerSP;
typedef std::shared_ptr<lldb_private::DynamicLibrary> DynamicLibrarySP;
typedef std::shared_ptr<lldb_private::DynamicLoader> DynamicLoaderSP;
typedef std::shared_ptr<lldb_private::Event> EventSP;
typedef std::shared_ptr<lldb_private::ExecutionContextRef> ExecutionContextRefSP;
typedef std::shared_ptr<lldb_private::Function> FunctionSP;
typedef std::shared_ptr<lldb_private::FuncUnwinders> FuncUnwindersSP;
typedef std::shared_ptr<lldb_private::InlineFunctionInfo> InlineFunctionInfoSP;
typedef std::shared_ptr<lldb_private::InputReader> InputReaderSP;
typedef std::shared_ptr<lldb_private::Instruction> InstructionSP;
typedef std::shared_ptr<lldb_private::LanguageRuntime> LanguageRuntimeSP;
typedef std::shared_ptr<lldb_private::LineTable> LineTableSP;
typedef std::shared_ptr<lldb_private::Listener> ListenerSP;
typedef std::shared_ptr<lldb_private::LogChannel> LogChannelSP;
typedef std::shared_ptr<lldb_private::Module> ModuleSP;
typedef std::weak_ptr<lldb_private::Module> ModuleWP;
typedef std::shared_ptr<lldb_private::ObjectFile> ObjectFileSP;
typedef std::weak_ptr<lldb_private::ObjectFile> ObjectFileWP;
typedef std::shared_ptr<lldb_private::OptionValue> OptionValueSP;
typedef std::weak_ptr<lldb_private::OptionValue> OptionValueWP;
typedef std::shared_ptr<lldb_private::OptionValueArch> OptionValueArchSP;
typedef std::shared_ptr<lldb_private::OptionValueArgs> OptionValueArgsSP;
typedef std::shared_ptr<lldb_private::OptionValueArray> OptionValueArraySP;
typedef std::shared_ptr<lldb_private::OptionValueBoolean> OptionValueBooleanSP;
typedef std::shared_ptr<lldb_private::OptionValueDictionary> OptionValueDictionarySP;
typedef std::shared_ptr<lldb_private::OptionValueFileSpec> OptionValueFileSpecSP;
typedef std::shared_ptr<lldb_private::OptionValueFileSpecList> OptionValueFileSpecListSP;
typedef std::shared_ptr<lldb_private::OptionValueFormat> OptionValueFormatSP;
typedef std::shared_ptr<lldb_private::OptionValuePathMappings> OptionValuePathMappingsSP;
typedef std::shared_ptr<lldb_private::OptionValueProperties> OptionValuePropertiesSP;
typedef std::shared_ptr<lldb_private::OptionValueRegex> OptionValueRegexSP;
typedef std::shared_ptr<lldb_private::OptionValueSInt64> OptionValueSInt64SP;
typedef std::shared_ptr<lldb_private::OptionValueString> OptionValueStringSP;
typedef std::shared_ptr<lldb_private::OptionValueUInt64> OptionValueUInt64SP;
typedef std::shared_ptr<lldb_private::OptionValueUUID> OptionValueUUIDSP;
typedef std::shared_ptr<lldb_private::Platform> PlatformSP;
typedef std::shared_ptr<lldb_private::Process> ProcessSP;
typedef std::shared_ptr<lldb_private::ProcessAttachInfo> ProcessAttachInfoSP;
typedef std::shared_ptr<lldb_private::ProcessLaunchInfo> ProcessLaunchInfoSP;
typedef std::weak_ptr<lldb_private::Process> ProcessWP;
typedef std::shared_ptr<lldb_private::Property> PropertySP;
typedef std::shared_ptr<lldb_private::RegisterContext> RegisterContextSP;
typedef std::shared_ptr<lldb_private::RegularExpression> RegularExpressionSP;
typedef std::shared_ptr<lldb_private::ScriptInterpreterObject> ScriptInterpreterObjectSP;
#ifndef LLDB_DISABLE_PYTHON
typedef STD_SHARED_PTR(lldb_private::ScriptSummaryFormat) ScriptSummaryFormatSP;
typedef std::shared_ptr<lldb_private::ScriptSummaryFormat> ScriptSummaryFormatSP;
#endif // #ifndef LLDB_DISABLE_PYTHON
typedef STD_SHARED_PTR(lldb_private::Section) SectionSP;
typedef STD_WEAK_PTR( lldb_private::Section) SectionWP;
typedef STD_SHARED_PTR(lldb_private::SearchFilter) SearchFilterSP;
typedef STD_SHARED_PTR(lldb_private::Settings) SettingsSP;
typedef STD_SHARED_PTR(lldb_private::StackFrame) StackFrameSP;
typedef STD_WEAK_PTR( lldb_private::StackFrame) StackFrameWP;
typedef STD_SHARED_PTR(lldb_private::StackFrameList) StackFrameListSP;
typedef STD_SHARED_PTR(lldb_private::StopInfo) StopInfoSP;
typedef STD_SHARED_PTR(lldb_private::StoppointLocation) StoppointLocationSP;
typedef STD_SHARED_PTR(lldb_private::Stream) StreamSP;
typedef STD_WEAK_PTR (lldb_private::Stream) StreamWP;
typedef STD_SHARED_PTR(lldb_private::StringSummaryFormat) StringTypeSummaryImplSP;
typedef STD_SHARED_PTR(lldb_private::SymbolFile) SymbolFileSP;
typedef STD_SHARED_PTR(lldb_private::SymbolFileType) SymbolFileTypeSP;
typedef STD_WEAK_PTR( lldb_private::SymbolFileType) SymbolFileTypeWP;
typedef STD_SHARED_PTR(lldb_private::SymbolContextSpecifier) SymbolContextSpecifierSP;
typedef STD_SHARED_PTR(lldb_private::SyntheticChildren) SyntheticChildrenSP;
typedef STD_SHARED_PTR(lldb_private::SyntheticChildrenFrontEnd) SyntheticChildrenFrontEndSP;
typedef STD_SHARED_PTR(lldb_private::Target) TargetSP;
typedef STD_WEAK_PTR( lldb_private::Target) TargetWP;
typedef STD_SHARED_PTR(lldb_private::Thread) ThreadSP;
typedef STD_WEAK_PTR( lldb_private::Thread) ThreadWP;
typedef STD_SHARED_PTR(lldb_private::ThreadPlan) ThreadPlanSP;
typedef STD_SHARED_PTR(lldb_private::ThreadPlanTracer) ThreadPlanTracerSP;
typedef STD_SHARED_PTR(lldb_private::Type) TypeSP;
typedef STD_WEAK_PTR( lldb_private::Type) TypeWP;
typedef STD_SHARED_PTR(lldb_private::TypeCategoryImpl) TypeCategoryImplSP;
typedef STD_SHARED_PTR(lldb_private::TypeImpl) TypeImplSP;
typedef STD_SHARED_PTR(lldb_private::TypeFilterImpl) TypeFilterImplSP;
typedef STD_SHARED_PTR(lldb_private::TypeFormatImpl) TypeFormatImplSP;
typedef STD_SHARED_PTR(lldb_private::TypeNameSpecifierImpl) TypeNameSpecifierImplSP;
typedef STD_SHARED_PTR(lldb_private::TypeSummaryImpl) TypeSummaryImplSP;
typedef std::shared_ptr<lldb_private::Section> SectionSP;
typedef std::weak_ptr<lldb_private::Section> SectionWP;
typedef std::shared_ptr<lldb_private::SearchFilter> SearchFilterSP;
typedef std::shared_ptr<lldb_private::Settings> SettingsSP;
typedef std::shared_ptr<lldb_private::StackFrame> StackFrameSP;
typedef std::weak_ptr<lldb_private::StackFrame> StackFrameWP;
typedef std::shared_ptr<lldb_private::StackFrameList> StackFrameListSP;
typedef std::shared_ptr<lldb_private::StopInfo> StopInfoSP;
typedef std::shared_ptr<lldb_private::StoppointLocation> StoppointLocationSP;
typedef std::shared_ptr<lldb_private::Stream> StreamSP;
typedef std::weak_ptr<lldb_private::Stream> StreamWP;
typedef std::shared_ptr<lldb_private::StringSummaryFormat> StringTypeSummaryImplSP;
typedef std::shared_ptr<lldb_private::SymbolFile> SymbolFileSP;
typedef std::shared_ptr<lldb_private::SymbolFileType> SymbolFileTypeSP;
typedef std::weak_ptr<lldb_private::SymbolFileType> SymbolFileTypeWP;
typedef std::shared_ptr<lldb_private::SymbolContextSpecifier> SymbolContextSpecifierSP;
typedef std::shared_ptr<lldb_private::SyntheticChildren> SyntheticChildrenSP;
typedef std::shared_ptr<lldb_private::SyntheticChildrenFrontEnd> SyntheticChildrenFrontEndSP;
typedef std::shared_ptr<lldb_private::Target> TargetSP;
typedef std::weak_ptr<lldb_private::Target> TargetWP;
typedef std::shared_ptr<lldb_private::Thread> ThreadSP;
typedef std::weak_ptr<lldb_private::Thread> ThreadWP;
typedef std::shared_ptr<lldb_private::ThreadPlan> ThreadPlanSP;
typedef std::shared_ptr<lldb_private::ThreadPlanTracer> ThreadPlanTracerSP;
typedef std::shared_ptr<lldb_private::Type> TypeSP;
typedef std::weak_ptr<lldb_private::Type> TypeWP;
typedef std::shared_ptr<lldb_private::TypeCategoryImpl> TypeCategoryImplSP;
typedef std::shared_ptr<lldb_private::TypeImpl> TypeImplSP;
typedef std::shared_ptr<lldb_private::TypeFilterImpl> TypeFilterImplSP;
typedef std::shared_ptr<lldb_private::TypeFormatImpl> TypeFormatImplSP;
typedef std::shared_ptr<lldb_private::TypeNameSpecifierImpl> TypeNameSpecifierImplSP;
typedef std::shared_ptr<lldb_private::TypeSummaryImpl> TypeSummaryImplSP;
#ifndef LLDB_DISABLE_PYTHON
typedef STD_SHARED_PTR(lldb_private::ScriptedSyntheticChildren) ScriptedSyntheticChildrenSP;
typedef std::shared_ptr<lldb_private::ScriptedSyntheticChildren> ScriptedSyntheticChildrenSP;
#endif
typedef STD_SHARED_PTR(lldb_private::UnwindPlan) UnwindPlanSP;
typedef std::shared_ptr<lldb_private::UnwindPlan> UnwindPlanSP;
typedef lldb_private::SharingPtr<lldb_private::ValueObject> ValueObjectSP;
typedef STD_SHARED_PTR(lldb_private::Value) ValueSP;
typedef STD_SHARED_PTR(lldb_private::ValueList) ValueListSP;
typedef STD_SHARED_PTR(lldb_private::Variable) VariableSP;
typedef STD_SHARED_PTR(lldb_private::VariableList) VariableListSP;
typedef STD_SHARED_PTR(lldb_private::ValueObjectList) ValueObjectListSP;
typedef STD_SHARED_PTR(lldb_private::Watchpoint) WatchpointSP;
typedef std::shared_ptr<lldb_private::Value> ValueSP;
typedef std::shared_ptr<lldb_private::ValueList> ValueListSP;
typedef std::shared_ptr<lldb_private::Variable> VariableSP;
typedef std::shared_ptr<lldb_private::VariableList> VariableListSP;
typedef std::shared_ptr<lldb_private::ValueObjectList> ValueObjectListSP;
typedef std::shared_ptr<lldb_private::Watchpoint> WatchpointSP;
} // namespace lldb

2
lldb/scripts/Python/interface/SBExpressionOptions.i
View File

@ -83,7 +83,7 @@ protected:
private:
// This auto_pointer is made in the constructor and is always valid.
mutable STD_UNIQUE_PTR(lldb_private::EvaluateExpressionOptions) m_opaque_ap;
mutable std::unique_ptr<lldb_private::EvaluateExpressionOptions> m_opaque_ap;
};
} // namespace lldb

2
lldb/scripts/Python/interface/SBSection.i
View File

@ -122,7 +122,7 @@ public:
private:
STD_UNIQUE_PTR(lldb_private::SectionImpl) m_opaque_ap;
std::unique_ptr<lldb_private::SectionImpl> m_opaque_ap;
};
} // namespace lldb

2
lldb/scripts/Python/interface/SBType.i
View File

@ -65,7 +65,7 @@ public:
%}
protected:
STD_UNIQUE_PTR(lldb_private::TypeMemberImpl) m_opaque_ap;
std::unique_ptr<lldb_private::TypeMemberImpl> m_opaque_ap;
};
%feature("docstring",

8
lldb/source/API/SBTypeCategory.cpp
View File

@ -169,7 +169,7 @@ SBTypeCategory::GetFilterForType (SBTypeNameSpecifier spec)
if (!children_sp)
return lldb::SBTypeFilter();
TypeFilterImplSP filter_sp = STD_STATIC_POINTER_CAST(TypeFilterImpl,children_sp);
TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(children_sp);
return lldb::SBTypeFilter(filter_sp);
@ -233,7 +233,7 @@ SBTypeCategory::GetSyntheticForType (SBTypeNameSpecifier spec)
if (!children_sp)
return lldb::SBTypeSynthetic();
ScriptedSyntheticChildrenSP synth_sp = STD_STATIC_POINTER_CAST(ScriptedSyntheticChildren,children_sp);
ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
return lldb::SBTypeSynthetic(synth_sp);
}
@ -250,7 +250,7 @@ SBTypeCategory::GetFilterAtIndex (uint32_t index)
if (!children_sp.get())
return lldb::SBTypeFilter();
TypeFilterImplSP filter_sp = STD_STATIC_POINTER_CAST(TypeFilterImpl,children_sp);
TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(children_sp);
return lldb::SBTypeFilter(filter_sp);
}
@ -285,7 +285,7 @@ SBTypeCategory::GetSyntheticAtIndex (uint32_t index)
if (!children_sp.get())
return lldb::SBTypeSynthetic();
ScriptedSyntheticChildrenSP synth_sp = STD_STATIC_POINTER_CAST(ScriptedSyntheticChildren,children_sp);
ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
return lldb::SBTypeSynthetic(synth_sp);
}

4
lldb/source/API/SBValue.cpp
View File

@ -708,7 +708,7 @@ SBValue::GetTypeFilter ()
if (synthetic_sp && !synthetic_sp->IsScripted())
{
TypeFilterImplSP filter_sp = STD_STATIC_POINTER_CAST(TypeFilterImpl,synthetic_sp);
TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(synthetic_sp);
filter.SetSP(filter_sp);
}
}
@ -746,7 +746,7 @@ SBValue::GetTypeSynthetic ()
if (children_sp && children_sp->IsScripted())
{
ScriptedSyntheticChildrenSP synth_sp = STD_STATIC_POINTER_CAST(ScriptedSyntheticChildren,children_sp);
ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
synthetic.SetSP(synth_sp);
}
}

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

@ -206,7 +206,7 @@ one command per line.\n" );
CommandReturnObject &result)
{
InputReaderSP reader_sp (new InputReader(m_interpreter.GetDebugger()));
STD_UNIQUE_PTR(BreakpointOptions::CommandData) data_ap(new BreakpointOptions::CommandData());
std::unique_ptr<BreakpointOptions::CommandData> data_ap(new BreakpointOptions::CommandData());
if (reader_sp && data_ap.get())
{
BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release()));
@ -242,7 +242,7 @@ one command per line.\n" );
SetBreakpointCommandCallback (BreakpointOptions *bp_options,
const char *oneliner)
{
STD_UNIQUE_PTR(BreakpointOptions::CommandData) data_ap(new BreakpointOptions::CommandData());
std::unique_ptr<BreakpointOptions::CommandData> data_ap(new BreakpointOptions::CommandData());
// It's necessary to set both user_source and script_source to the oneliner.
// The former is used to generate callback description (as in breakpoint command list)

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

@ -1066,7 +1066,7 @@ protected:
}
private:
STD_UNIQUE_PTR(CommandObjectRegexCommand) m_regex_cmd_ap;
std::unique_ptr<CommandObjectRegexCommand> m_regex_cmd_ap;
class CommandOptions : public Options
{

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

@ -4882,7 +4882,7 @@ protected:
target->AddStopHook (new_hook_sp);
// First step, make the specifier.
STD_UNIQUE_PTR(SymbolContextSpecifier) specifier_ap;
std::unique_ptr<SymbolContextSpecifier> specifier_ap;
if (m_options.m_sym_ctx_specified)
{
specifier_ap.reset(new SymbolContextSpecifier(m_interpreter.GetDebugger().GetSelectedTarget()));

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

@ -61,7 +61,7 @@ public:
{
}
typedef STD_SHARED_PTR(ScriptAddOptions) SharedPointer;
typedef std::shared_ptr<ScriptAddOptions> SharedPointer;
};
@ -94,7 +94,7 @@ public:
{
}
typedef STD_SHARED_PTR(SynthAddOptions) SharedPointer;
typedef std::shared_ptr<SynthAddOptions> SharedPointer;
};

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

@ -190,7 +190,7 @@ but do NOT enter more than one command per line. \n" );
CommandReturnObject &result)
{
InputReaderSP reader_sp (new InputReader(m_interpreter.GetDebugger()));
STD_UNIQUE_PTR(WatchpointOptions::CommandData) data_ap(new WatchpointOptions::CommandData());
std::unique_ptr<WatchpointOptions::CommandData> data_ap(new WatchpointOptions::CommandData());
if (reader_sp && data_ap.get())
{
BatonSP baton_sp (new WatchpointOptions::CommandBaton (data_ap.release()));
@ -226,7 +226,7 @@ but do NOT enter more than one command per line. \n" );
SetWatchpointCommandCallback (WatchpointOptions *wp_options,
const char *oneliner)
{
STD_UNIQUE_PTR(WatchpointOptions::CommandData) data_ap(new WatchpointOptions::CommandData());
std::unique_ptr<WatchpointOptions::CommandData> data_ap(new WatchpointOptions::CommandData());
// It's necessary to set both user_source and script_source to the oneliner.
// The former is used to generate callback description (as in watchpoint command list)

6
lldb/source/Core/Disassembler.cpp
View File

@ -638,7 +638,7 @@ Instruction::Dump (lldb_private::Stream *s,
bool
Instruction::DumpEmulation (const ArchSpec &arch)
{
STD_UNIQUE_PTR(EmulateInstruction) insn_emulator_ap (EmulateInstruction::FindPlugin (arch, eInstructionTypeAny, NULL));
std::unique_ptr<EmulateInstruction> insn_emulator_ap (EmulateInstruction::FindPlugin (arch, eInstructionTypeAny, NULL));
if (insn_emulator_ap.get())
{
insn_emulator_ap->SetInstruction (GetOpcode(), GetAddress(), NULL);
@ -904,7 +904,7 @@ Instruction::TestEmulation (Stream *out_stream, const char *file_name)
arch.SetTriple (llvm::Triple (value_sp->GetStringValue()));
bool success = false;
STD_UNIQUE_PTR(EmulateInstruction) insn_emulator_ap (EmulateInstruction::FindPlugin (arch, eInstructionTypeAny, NULL));
std::unique_ptr<EmulateInstruction> insn_emulator_ap (EmulateInstruction::FindPlugin (arch, eInstructionTypeAny, NULL));
if (insn_emulator_ap.get())
success = insn_emulator_ap->TestEmulation (out_stream, arch, data_dictionary);
@ -925,7 +925,7 @@ Instruction::Emulate (const ArchSpec &arch,
EmulateInstruction::ReadRegisterCallback read_reg_callback,
EmulateInstruction::WriteRegisterCallback write_reg_callback)
{
STD_UNIQUE_PTR(EmulateInstruction) insn_emulator_ap (EmulateInstruction::FindPlugin (arch, eInstructionTypeAny, NULL));
std::unique_ptr<EmulateInstruction> insn_emulator_ap (EmulateInstruction::FindPlugin (arch, eInstructionTypeAny, NULL));
if (insn_emulator_ap.get())
{
insn_emulator_ap->SetBaton (baton);

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

@ -24,7 +24,7 @@ DynamicLoader::FindPlugin (Process *process, const char *plugin_name)
create_callback = PluginManager::GetDynamicLoaderCreateCallbackForPluginName (plugin_name);
if (create_callback)
{
STD_UNIQUE_PTR(DynamicLoader) instance_ap(create_callback(process, true));
std::unique_ptr<DynamicLoader> instance_ap(create_callback(process, true));
if (instance_ap.get())
return instance_ap.release();
}
@ -33,7 +33,7 @@ DynamicLoader::FindPlugin (Process *process, const char *plugin_name)
{
for (uint32_t idx = 0; (create_callback = PluginManager::GetDynamicLoaderCreateCallbackAtIndex(idx)) != NULL; ++idx)
{
STD_UNIQUE_PTR(DynamicLoader) instance_ap(create_callback(process, false));
std::unique_ptr<DynamicLoader> instance_ap(create_callback(process, false));
if (instance_ap.get())
return instance_ap.release();
}

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

@ -254,7 +254,7 @@ Module::GetMemoryObjectFile (const lldb::ProcessSP &process_sp, lldb::addr_t hea
if (process_sp)
{
m_did_load_objfile = true;
STD_UNIQUE_PTR(DataBufferHeap) data_ap (new DataBufferHeap (512, 0));
std::unique_ptr<DataBufferHeap> data_ap (new DataBufferHeap (512, 0));
Error readmem_error;
const size_t bytes_read = process_sp->ReadMemory (header_addr,
data_ap->GetBytes(),

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

@ -35,7 +35,7 @@ StreamAsynchronousIO::Flush ()
{
if (m_accumulated_data.GetSize() > 0)
{
STD_UNIQUE_PTR(EventDataBytes) data_bytes_ap (new EventDataBytes);
std::unique_ptr<EventDataBytes> data_bytes_ap (new EventDataBytes);
// Let's swap the bytes to avoid LARGE string copies.
data_bytes_ap->SwapBytes (m_accumulated_data.GetString());
EventSP new_event_sp (new Event (m_broadcast_event_type, data_bytes_ap.release()));

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

@ -1164,7 +1164,7 @@ ClangExpressionDeclMap::LookupDecl (clang::NamedDecl *decl, ClangExpressionVaria
if (parser_vars->m_lldb_var)
{
STD_UNIQUE_PTR(Value) value(GetVariableValue(parser_vars->m_lldb_var, NULL));
std::unique_ptr<Value> value(GetVariableValue(parser_vars->m_lldb_var, NULL));
if (is_reference && value.get() && value->GetValueType() == Value::eValueTypeLoadAddress)
{
@ -1299,7 +1299,7 @@ ClangExpressionDeclMap::GetSpecialValue (const ConstString &name)
!var->LocationIsValidForFrame (frame))
return Value();
STD_UNIQUE_PTR(Value) value(GetVariableValue(var, NULL));
std::unique_ptr<Value> value(GetVariableValue(var, NULL));
if (value.get() && value->GetValueType() == Value::eValueTypeLoadAddress)
{
@ -1394,7 +1394,7 @@ ClangExpressionDeclMap::GetObjectPointer
return false;
}
STD_UNIQUE_PTR(lldb_private::Value) location_value(GetVariableValue(object_ptr_var,
std::unique_ptr<lldb_private::Value> location_value(GetVariableValue(object_ptr_var,
NULL));
if (!location_value.get())
@ -2583,7 +2583,7 @@ ClangExpressionDeclMap::GetVariableValue
DWARFExpression &var_location_expr = var->LocationExpression();
STD_UNIQUE_PTR(Value) var_location(new Value);
std::unique_ptr<Value> var_location(new Value);
lldb::addr_t loclist_base_load_addr = LLDB_INVALID_ADDRESS;
@ -2805,7 +2805,7 @@ ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
m_parser_vars->m_target_info.address_byte_size));
assert (entity.get());
STD_UNIQUE_PTR(Value) symbol_location(new Value);
std::unique_ptr<Value> symbol_location(new Value);
const Address &symbol_address = symbol.GetAddress();
lldb::addr_t symbol_load_addr = symbol_address.GetLoadAddress(target);
@ -2949,7 +2949,7 @@ ClangExpressionDeclMap::AddOneFunction (NameSearchContext &context,
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
NamedDecl *fun_decl = NULL;
STD_UNIQUE_PTR(Value) fun_location(new Value);
std::unique_ptr<Value> fun_location(new Value);
const Address *fun_address = NULL;
// only valid for Functions, not for Symbols

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

@ -352,7 +352,7 @@ ClangExpressionParser::ClangExpressionParser (ExecutionContextScope *exe_scope,
m_selector_table.reset(new SelectorTable());
m_builtin_context.reset(new Builtin::Context());
STD_UNIQUE_PTR(clang::ASTContext) ast_context(new ASTContext(m_compiler->getLangOpts(),
std::unique_ptr<clang::ASTContext> ast_context(new ASTContext(m_compiler->getLangOpts(),
m_compiler->getSourceManager(),
&m_compiler->getTarget(),
m_compiler->getPreprocessor().getIdentifierTable(),
@ -463,7 +463,7 @@ static bool FindFunctionInModule (ConstString &mangled_name,
Error
ClangExpressionParser::PrepareForExecution (lldb::addr_t &func_addr,
lldb::addr_t &func_end,
STD_UNIQUE_PTR(IRExecutionUnit) &execution_unit_ap,
std::unique_ptr<IRExecutionUnit> &execution_unit_ap,
ExecutionContext &exe_ctx,
bool &can_interpret,
ExecutionPolicy execution_policy)
@ -472,11 +472,11 @@ ClangExpressionParser::PrepareForExecution (lldb::addr_t &func_addr,
func_end = LLDB_INVALID_ADDRESS;
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
STD_UNIQUE_PTR(llvm::ExecutionEngine) execution_engine_ap;
std::unique_ptr<llvm::ExecutionEngine> execution_engine_ap;
Error err;
STD_UNIQUE_PTR(llvm::Module) module_ap (m_code_generator->ReleaseModule());
std::unique_ptr<llvm::Module> module_ap (m_code_generator->ReleaseModule());
if (!module_ap.get())
{

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

@ -396,7 +396,7 @@ ClangUserExpression::Parse (Stream &error_stream,
ApplyObjcCastHack(m_expr_text);
//ApplyUnicharHack(m_expr_text);
STD_UNIQUE_PTR(ExpressionSourceCode) source_code (ExpressionSourceCode::CreateWrapped(m_expr_prefix.c_str(), m_expr_text.c_str()));
std::unique_ptr<ExpressionSourceCode> source_code (ExpressionSourceCode::CreateWrapped(m_expr_prefix.c_str(), m_expr_text.c_str()));
lldb::LanguageType lang_type;

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

@ -1062,7 +1062,7 @@ DWARFExpression::Update_DW_OP_addr (lldb::addr_t file_addr)
// we then replace the data for this expression
// So first we copy the data into a heap buffer
STD_UNIQUE_PTR(DataBufferHeap) head_data_ap (new DataBufferHeap (m_data.GetDataStart(),
std::unique_ptr<DataBufferHeap> head_data_ap (new DataBufferHeap (m_data.GetDataStart(),
m_data.GetByteSize()));
// Make en encoder so we can write the address into the buffer using

4
lldb/source/Expression/IRExecutionUnit.cpp
View File

@ -25,8 +25,8 @@
using namespace lldb_private;
IRExecutionUnit::IRExecutionUnit (STD_UNIQUE_PTR(llvm::LLVMContext) &context_ap,
STD_UNIQUE_PTR(llvm::Module) &module_ap,
IRExecutionUnit::IRExecutionUnit (std::unique_ptr<llvm::LLVMContext> &context_ap,
std::unique_ptr<llvm::Module> &module_ap,
ConstString &name,
const lldb::TargetSP &target_sp,
std::vector<std::string> &cpu_features) :

2
lldb/source/Host/common/File.cpp
View File

@ -556,7 +556,7 @@ File::Read (size_t &num_bytes, off_t &offset, bool null_terminate, DataBufferSP
if (num_bytes > bytes_left)
num_bytes = bytes_left;
STD_UNIQUE_PTR(DataBufferHeap) data_heap_ap;
std::unique_ptr<DataBufferHeap> data_heap_ap;
data_heap_ap.reset(new DataBufferHeap(num_bytes + (null_terminate ? 1 : 0), '\0'));
if (data_heap_ap.get())

2
lldb/source/Host/common/FileSpec.cpp
View File

@ -744,7 +744,7 @@ DataBufferSP
FileSpec::MemoryMapFileContents(off_t file_offset, size_t file_size) const
{
DataBufferSP data_sp;
STD_UNIQUE_PTR(DataBufferMemoryMap) mmap_data(new DataBufferMemoryMap());
std::unique_ptr<DataBufferMemoryMap> mmap_data(new DataBufferMemoryMap());
if (mmap_data.get())
{
if (mmap_data->MemoryMapFromFileSpec (this, file_offset, file_size) >= file_size)

2
lldb/source/Host/common/Host.cpp
View File

@ -1313,7 +1313,7 @@ Host::RunShellCommand (const char *command,
}
// The process monitor callback will delete the 'shell_info_ptr' below...
STD_UNIQUE_PTR(ShellInfo) shell_info_ap (new ShellInfo());
std::unique_ptr<ShellInfo> shell_info_ap (new ShellInfo());
const bool monitor_signals = false;
launch_info.SetMonitorProcessCallback(MonitorShellCommand, shell_info_ap.get(), monitor_signals);

2
lldb/source/Host/freebsd/Host.cpp
View File

@ -294,7 +294,7 @@ Host::GetAuxvData(lldb_private::Process *process)
struct ps_strings ps_strings;
struct ptrace_io_desc pid;
DataBufferSP buf_sp;
STD_UNIQUE_PTR(DataBufferHeap) buf_ap(new DataBufferHeap(1024, 0));
std::unique_ptr<DataBufferHeap> buf_ap(new DataBufferHeap(1024, 0));
if (::sysctl(mib, 2, &ps_strings_addr, &ps_strings_size, NULL, 0) == 0) {
pid.piod_op = PIOD_READ_D;

2
lldb/source/Host/linux/Host.cpp
View File

@ -72,7 +72,7 @@ Host::GetAuxvData(lldb_private::Process *process)
return buf_sp;
size_t bytes_read = 0;
STD_UNIQUE_PTR(DataBufferHeap) buf_ap(new DataBufferHeap(1024, 0));
std::unique_ptr<DataBufferHeap> buf_ap(new DataBufferHeap(1024, 0));
for (;;)
{
size_t avail = buf_ap->GetByteSize() - bytes_read;

24
lldb/source/Interpreter/CommandInterpreter.cpp
View File

@ -391,7 +391,7 @@ CommandInterpreter::LoadCommandDictionary ()
size_t num_regexes = sizeof break_regexes/sizeof(char *[2]);
STD_UNIQUE_PTR(CommandObjectRegexCommand)
std::unique_ptr<CommandObjectRegexCommand>
break_regex_cmd_ap(new CommandObjectRegexCommand (*this,
"_regexp-break",
"Set a breakpoint using a regular expression to specify the location, where <linenum> is in decimal and <address> is in hex.",
@ -418,7 +418,7 @@ CommandInterpreter::LoadCommandDictionary ()
}
}
STD_UNIQUE_PTR(CommandObjectRegexCommand)
std::unique_ptr<CommandObjectRegexCommand>
tbreak_regex_cmd_ap(new CommandObjectRegexCommand (*this,
"_regexp-tbreak",
"Set a one shot breakpoint using a regular expression to specify the location, where <linenum> is in decimal and <address> is in hex.",
@ -449,7 +449,7 @@ CommandInterpreter::LoadCommandDictionary ()
}
}
STD_UNIQUE_PTR(CommandObjectRegexCommand)
std::unique_ptr<CommandObjectRegexCommand>
attach_regex_cmd_ap(new CommandObjectRegexCommand (*this,
"_regexp-attach",
"Attach to a process id if in decimal, otherwise treat the argument as a process name to attach to.",
@ -467,7 +467,7 @@ CommandInterpreter::LoadCommandDictionary ()
}
}
STD_UNIQUE_PTR(CommandObjectRegexCommand)
std::unique_ptr<CommandObjectRegexCommand>
down_regex_cmd_ap(new CommandObjectRegexCommand (*this,
"_regexp-down",
"Go down \"n\" frames in the stack (1 frame by default).",
@ -482,7 +482,7 @@ CommandInterpreter::LoadCommandDictionary ()
}
}
STD_UNIQUE_PTR(CommandObjectRegexCommand)
std::unique_ptr<CommandObjectRegexCommand>
up_regex_cmd_ap(new CommandObjectRegexCommand (*this,
"_regexp-up",
"Go up \"n\" frames in the stack (1 frame by default).",
@ -497,7 +497,7 @@ CommandInterpreter::LoadCommandDictionary ()
}
}
STD_UNIQUE_PTR(CommandObjectRegexCommand)
std::unique_ptr<CommandObjectRegexCommand>
display_regex_cmd_ap(new CommandObjectRegexCommand (*this,
"_regexp-display",
"Add an expression evaluation stop-hook.",
@ -511,7 +511,7 @@ CommandInterpreter::LoadCommandDictionary ()
}
}
STD_UNIQUE_PTR(CommandObjectRegexCommand)
std::unique_ptr<CommandObjectRegexCommand>
undisplay_regex_cmd_ap(new CommandObjectRegexCommand (*this,
"_regexp-undisplay",
"Remove an expression evaluation stop-hook.",
@ -525,7 +525,7 @@ CommandInterpreter::LoadCommandDictionary ()
}
}
STD_UNIQUE_PTR(CommandObjectRegexCommand)
std::unique_ptr<CommandObjectRegexCommand>
connect_gdb_remote_cmd_ap(new CommandObjectRegexCommand (*this,
"gdb-remote",
"Connect to a remote GDB server. If no hostname is provided, localhost is assumed.",
@ -540,7 +540,7 @@ CommandInterpreter::LoadCommandDictionary ()
}
}
STD_UNIQUE_PTR(CommandObjectRegexCommand)
std::unique_ptr<CommandObjectRegexCommand>
connect_kdp_remote_cmd_ap(new CommandObjectRegexCommand (*this,
"kdp-remote",
"Connect to a remote KDP server. udp port 41139 is the default port number.",
@ -555,7 +555,7 @@ CommandInterpreter::LoadCommandDictionary ()
}
}
STD_UNIQUE_PTR(CommandObjectRegexCommand)
std::unique_ptr<CommandObjectRegexCommand>
bt_regex_cmd_ap(new CommandObjectRegexCommand (*this,
"_regexp-bt",
"Show a backtrace. An optional argument is accepted; if that argument is a number, it specifies the number of frames to display. If that argument is 'all', full backtraces of all threads are displayed.",
@ -575,7 +575,7 @@ CommandInterpreter::LoadCommandDictionary ()
}
}
STD_UNIQUE_PTR(CommandObjectRegexCommand)
std::unique_ptr<CommandObjectRegexCommand>
list_regex_cmd_ap(new CommandObjectRegexCommand (*this,
"_regexp-list",
"Implements the GDB 'list' command in all of its forms except FILE:FUNCTION and maps them to the appropriate 'source list' commands.",
@ -597,7 +597,7 @@ CommandInterpreter::LoadCommandDictionary ()
}
}
STD_UNIQUE_PTR(CommandObjectRegexCommand)
std::unique_ptr<CommandObjectRegexCommand>
env_regex_cmd_ap(new CommandObjectRegexCommand (*this,
"_regexp-env",
"Implements a shortcut to viewing and setting environment variables.",

2
lldb/source/Interpreter/Options.cpp
View File

@ -901,7 +901,7 @@ Options::HandleOptionArgumentCompletion
)
{
const OptionDefinition *opt_defs = GetDefinitions();
STD_UNIQUE_PTR(SearchFilter) filter_ap;
std::unique_ptr<SearchFilter> filter_ap;
int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;

4
lldb/source/Interpreter/ScriptInterpreter.cpp
View File

@ -81,10 +81,10 @@ ScriptInterpreter::LanguageToString (lldb::ScriptLanguage language)
return return_value;
}
STD_UNIQUE_PTR(ScriptInterpreterLocker)
std::unique_ptr<ScriptInterpreterLocker>
ScriptInterpreter::AcquireInterpreterLock ()
{
return STD_UNIQUE_PTR(ScriptInterpreterLocker)(new ScriptInterpreterLocker());
return std::unique_ptr<ScriptInterpreterLocker>(new ScriptInterpreterLocker());
}
void

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