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

[LLDB] Migrate llvm::make_unique to std::make_unique 

Now that we've moved to C++14, we no longer need the llvm::make_unique
implementation from STLExtras.h. This patch is a mechanical replacement
of (hopefully) all the llvm::make_unique instances across the monorepo.

Differential revision: https://reviews.llvm.org/D66259

llvm-svn: 368933
This commit is contained in:
Jonas Devlieghere 2019-08-14 22:19:23 +00:00
parent 1737f71322
commit a8f3ae7c9c
63 changed files with 110 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -203,7 +203,7 @@ public:
/// Create and register a new provider. /// Create and register a new provider.
template <typename T> T *Create() { template <typename T> T *Create() {
std::unique_ptr<ProviderBase> provider = llvm::make_unique<T>(m_root); std::unique_ptr<ProviderBase> provider = std::make_unique<T>(m_root);
return static_cast<T *>(Register(std::move(provider))); return static_cast<T *>(Register(std::move(provider)));
} }

4
lldb/include/lldb/Utility/ReproducerInstrumentation.h
View File

@ -442,7 +442,7 @@ public:
void Register(Signature *f, llvm::StringRef result = {}, void Register(Signature *f, llvm::StringRef result = {},
llvm::StringRef scope = {}, llvm::StringRef name = {}, llvm::StringRef scope = {}, llvm::StringRef name = {},
llvm::StringRef args = {}) { llvm::StringRef args = {}) {
DoRegister(uintptr_t(f), llvm::make_unique<DefaultReplayer<Signature>>(f), DoRegister(uintptr_t(f), std::make_unique<DefaultReplayer<Signature>>(f),
SignatureStr(result, scope, name, args)); SignatureStr(result, scope, name, args));
} }
@ -452,7 +452,7 @@ public:
void Register(Signature *f, Signature *g, llvm::StringRef result = {}, void Register(Signature *f, Signature *g, llvm::StringRef result = {},
llvm::StringRef scope = {}, llvm::StringRef name = {}, llvm::StringRef scope = {}, llvm::StringRef name = {},
llvm::StringRef args = {}) { llvm::StringRef args = {}) {
DoRegister(uintptr_t(f), llvm::make_unique<DefaultReplayer<Signature>>(g), DoRegister(uintptr_t(f), std::make_unique<DefaultReplayer<Signature>>(g),
SignatureStr(result, scope, name, args)); SignatureStr(result, scope, name, args));
} }

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

@ -28,7 +28,7 @@ SBAddress::SBAddress() : m_opaque_up(new Address()) {
SBAddress::SBAddress(const Address *lldb_object_ptr) SBAddress::SBAddress(const Address *lldb_object_ptr)
: m_opaque_up(new Address()) { : m_opaque_up(new Address()) {
if (lldb_object_ptr) if (lldb_object_ptr)
m_opaque_up = llvm::make_unique<Address>(*lldb_object_ptr); m_opaque_up = std::make_unique<Address>(*lldb_object_ptr);
} }
SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) { SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) {

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

@ -41,7 +41,7 @@ using namespace lldb_private;
SBBreakpointCallbackBaton::SBBreakpointCallbackBaton(SBBreakpointHitCallback SBBreakpointCallbackBaton::SBBreakpointCallbackBaton(SBBreakpointHitCallback
callback, callback,
void *baton) void *baton)
: TypedBaton(llvm::make_unique<CallbackData>()) { : TypedBaton(std::make_unique<CallbackData>()) {
getItem()->callback = callback; getItem()->callback = callback;
getItem()->callback_baton = baton; getItem()->callback_baton = baton;
} }

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

@ -88,7 +88,7 @@ public:
file = absolute_path.GetPath(); file = absolute_path.GetPath();
} }
return llvm::make_unique<CommandLoader>(std::move(files)); return std::make_unique<CommandLoader>(std::move(files));
} }
FILE *GetNextFile() { FILE *GetNextFile() {
@ -204,7 +204,7 @@ lldb::SBError SBDebugger::InitializeWithErrorHandling() {
SBError error; SBError error;
if (auto e = g_debugger_lifetime->Initialize( if (auto e = g_debugger_lifetime->Initialize(
llvm::make_unique<SystemInitializerFull>(), LoadPlugin)) { std::make_unique<SystemInitializerFull>(), LoadPlugin)) {
error.SetError(Status(std::move(e))); error.SetError(Status(std::move(e)));
} }
return LLDB_RECORD_RESULT(error); return LLDB_RECORD_RESULT(error);
@ -599,18 +599,18 @@ const char *SBDebugger::StateAsCString(StateType state) {
static void AddBoolConfigEntry(StructuredData::Dictionary &dict, static void AddBoolConfigEntry(StructuredData::Dictionary &dict,
llvm::StringRef name, bool value, llvm::StringRef name, bool value,
llvm::StringRef description) { llvm::StringRef description) {
auto entry_up = llvm::make_unique<StructuredData::Dictionary>(); auto entry_up = std::make_unique<StructuredData::Dictionary>();
entry_up->AddBooleanItem("value", value); entry_up->AddBooleanItem("value", value);
entry_up->AddStringItem("description", description); entry_up->AddStringItem("description", description);
dict.AddItem(name, std::move(entry_up)); dict.AddItem(name, std::move(entry_up));
} }
static void AddLLVMTargets(StructuredData::Dictionary &dict) { static void AddLLVMTargets(StructuredData::Dictionary &dict) {
auto array_up = llvm::make_unique<StructuredData::Array>(); auto array_up = std::make_unique<StructuredData::Array>();
#define LLVM_TARGET(target) \ #define LLVM_TARGET(target) \
array_up->AddItem(llvm::make_unique<StructuredData::String>(#target)); array_up->AddItem(std::make_unique<StructuredData::String>(#target));
#include "llvm/Config/Targets.def" #include "llvm/Config/Targets.def"
auto entry_up = llvm::make_unique<StructuredData::Dictionary>(); auto entry_up = std::make_unique<StructuredData::Dictionary>();
entry_up->AddItem("value", std::move(array_up)); entry_up->AddItem("value", std::move(array_up));
entry_up->AddStringItem("description", "A list of configured LLVM targets."); entry_up->AddStringItem("description", "A list of configured LLVM targets.");
dict.AddItem("targets", std::move(entry_up)); dict.AddItem("targets", std::move(entry_up));
@ -620,7 +620,7 @@ SBStructuredData SBDebugger::GetBuildConfiguration() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger, LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger,
GetBuildConfiguration); GetBuildConfiguration);
auto config_up = llvm::make_unique<StructuredData::Dictionary>(); auto config_up = std::make_unique<StructuredData::Dictionary>();
AddBoolConfigEntry( AddBoolConfigEntry(
*config_up, "xml", XMLDocument::XMLEnabled(), *config_up, "xml", XMLDocument::XMLEnabled(),
"A boolean value that indicates if XML support is enabled in LLDB"); "A boolean value that indicates if XML support is enabled in LLDB");
@ -1012,7 +1012,7 @@ SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
GetAvailablePlatformInfoAtIndex, (uint32_t), idx); GetAvailablePlatformInfoAtIndex, (uint32_t), idx);
SBStructuredData data; SBStructuredData data;
auto platform_dict = llvm::make_unique<StructuredData::Dictionary>(); auto platform_dict = std::make_unique<StructuredData::Dictionary>();
llvm::StringRef name_str("name"), desc_str("description"); llvm::StringRef name_str("name"), desc_str("description");
if (idx == 0) { if (idx == 0) {

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

@ -32,7 +32,7 @@ SBDeclaration::SBDeclaration(const SBDeclaration &rhs) : m_opaque_up() {
SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr) SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr)
: m_opaque_up() { : m_opaque_up() {
if (lldb_object_ptr) if (lldb_object_ptr)
m_opaque_up = llvm::make_unique<Declaration>(*lldb_object_ptr); m_opaque_up = std::make_unique<Declaration>(*lldb_object_ptr);
} }
const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) { const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) {

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

@ -1107,7 +1107,7 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
if (target->GetDisplayExpressionsInCrashlogs()) { if (target->GetDisplayExpressionsInCrashlogs()) {
StreamString frame_description; StreamString frame_description;
frame->DumpUsingSettingsFormat(&frame_description); frame->DumpUsingSettingsFormat(&frame_description);
stack_trace = llvm::make_unique<llvm::PrettyStackTraceFormat>( stack_trace = std::make_unique<llvm::PrettyStackTraceFormat>(
"SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value " "SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value "
"= %u) %s", "= %u) %s",
expr, options.GetFetchDynamicValue(), expr, options.GetFetchDynamicValue(),

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

@ -32,7 +32,7 @@ SBLineEntry::SBLineEntry(const SBLineEntry &rhs) : m_opaque_up() {
SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr) SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr)
: m_opaque_up() { : m_opaque_up() {
if (lldb_object_ptr) if (lldb_object_ptr)
m_opaque_up = llvm::make_unique<LineEntry>(*lldb_object_ptr); m_opaque_up = std::make_unique<LineEntry>(*lldb_object_ptr);
} }
const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) { const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) {
@ -45,7 +45,7 @@ const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) {
} }
void SBLineEntry::SetLineEntry(const lldb_private::LineEntry &lldb_object_ref) { void SBLineEntry::SetLineEntry(const lldb_private::LineEntry &lldb_object_ref) {
m_opaque_up = llvm::make_unique<LineEntry>(lldb_object_ref); m_opaque_up = std::make_unique<LineEntry>(lldb_object_ref);
} }
SBLineEntry::~SBLineEntry() {} SBLineEntry::~SBLineEntry() {}

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

@ -21,7 +21,7 @@ SBStringList::SBStringList() : m_opaque_up() {
SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr) SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr)
: m_opaque_up() { : m_opaque_up() {
if (lldb_strings_ptr) if (lldb_strings_ptr)
m_opaque_up = llvm::make_unique<StringList>(*lldb_strings_ptr); m_opaque_up = std::make_unique<StringList>(*lldb_strings_ptr);
} }
SBStringList::SBStringList(const SBStringList &rhs) : m_opaque_up() { SBStringList::SBStringList(const SBStringList &rhs) : m_opaque_up() {

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

@ -27,7 +27,7 @@ SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_up() {
(const lldb_private::SymbolContext *), sc_ptr); (const lldb_private::SymbolContext *), sc_ptr);
if (sc_ptr) if (sc_ptr)
m_opaque_up = llvm::make_unique<SymbolContext>(*sc_ptr); m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr);
} }
SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() { SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() {
@ -51,7 +51,7 @@ const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) { void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) {
if (sc_ptr) if (sc_ptr)
m_opaque_up = llvm::make_unique<SymbolContext>(*sc_ptr); m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr);
else else
m_opaque_up->Clear(true); m_opaque_up->Clear(true);
} }

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

@ -218,7 +218,7 @@ SBStructuredData SBTarget::GetStatistics() {
if (!target_sp) if (!target_sp)
return LLDB_RECORD_RESULT(data); return LLDB_RECORD_RESULT(data);
auto stats_up = llvm::make_unique<StructuredData::Dictionary>(); auto stats_up = std::make_unique<StructuredData::Dictionary>();
int i = 0; int i = 0;
for (auto &Entry : target_sp->GetStatistics()) { for (auto &Entry : target_sp->GetStatistics()) {
std::string Desc = lldb_private::GetStatDescription( std::string Desc = lldb_private::GetStatDescription(

2
lldb/source/API/Utils.h
View File

@ -16,7 +16,7 @@ namespace lldb_private {
template <typename T> std::unique_ptr<T> clone(const std::unique_ptr<T> &src) { template <typename T> std::unique_ptr<T> clone(const std::unique_ptr<T> &src) {
if (src) if (src)
return llvm::make_unique<T>(*src); return std::make_unique<T>(*src);
return nullptr; return nullptr;
} }

2
lldb/source/Breakpoint/BreakpointOptions.cpp
View File

@ -309,7 +309,7 @@ std::unique_ptr<BreakpointOptions> BreakpointOptions::CreateFromStructuredData(
} }
} }
auto bp_options = llvm::make_unique<BreakpointOptions>( auto bp_options = std::make_unique<BreakpointOptions>(
condition_ref.str().c_str(), enabled, condition_ref.str().c_str(), enabled,
ignore_count, one_shot, auto_continue); ignore_count, one_shot, auto_continue);
if (cmd_data_up) { if (cmd_data_up) {

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

@ -159,7 +159,7 @@ public:
{ {
if (!m_commands.empty()) if (!m_commands.empty())
{ {
auto cmd_data = llvm::make_unique<BreakpointOptions::CommandData>(); auto cmd_data = std::make_unique<BreakpointOptions::CommandData>();
for (std::string &str : m_commands) for (std::string &str : m_commands)
cmd_data->user_source.AppendString(str); cmd_data->user_source.AppendString(str);

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

@ -238,7 +238,7 @@ are no syntax errors may indicate that a function was declared but never called.
if (!bp_options) if (!bp_options)
continue; continue;
auto cmd_data = llvm::make_unique<BreakpointOptions::CommandData>(); auto cmd_data = std::make_unique<BreakpointOptions::CommandData>();
cmd_data->user_source.SplitIntoLines(line.c_str(), line.size()); cmd_data->user_source.SplitIntoLines(line.c_str(), line.size());
bp_options->SetCommandDataCallback(cmd_data); bp_options->SetCommandDataCallback(cmd_data);
} }
@ -260,7 +260,7 @@ are no syntax errors may indicate that a function was declared but never called.
SetBreakpointCommandCallback(std::vector<BreakpointOptions *> &bp_options_vec, SetBreakpointCommandCallback(std::vector<BreakpointOptions *> &bp_options_vec,
const char *oneliner) { const char *oneliner) {
for (auto bp_options : bp_options_vec) { for (auto bp_options : bp_options_vec) {
auto cmd_data = llvm::make_unique<BreakpointOptions::CommandData>(); auto cmd_data = std::make_unique<BreakpointOptions::CommandData>();
cmd_data->user_source.AppendString(oneliner); cmd_data->user_source.AppendString(oneliner);
cmd_data->stop_on_error = m_options.m_stop_on_error; cmd_data->stop_on_error = m_options.m_stop_on_error;

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

@ -997,7 +997,7 @@ protected:
Status error; Status error;
auto name = command[0].ref; auto name = command[0].ref;
m_regex_cmd_up = llvm::make_unique<CommandObjectRegexCommand>( m_regex_cmd_up = std::make_unique<CommandObjectRegexCommand>(
m_interpreter, name, m_options.GetHelp(), m_options.GetSyntax(), 10, 0, m_interpreter, name, m_options.GetHelp(), m_options.GetSyntax(), 10, 0,
true); true);

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

@ -275,7 +275,7 @@ Status Debugger::SetPropertyValue(const ExecutionContext *exe_ctx,
if (str.length()) if (str.length())
new_prompt = str; new_prompt = str;
GetCommandInterpreter().UpdatePrompt(new_prompt); GetCommandInterpreter().UpdatePrompt(new_prompt);
auto bytes = llvm::make_unique<EventDataBytes>(new_prompt); auto bytes = std::make_unique<EventDataBytes>(new_prompt);
auto prompt_change_event_sp = std::make_shared<Event>( auto prompt_change_event_sp = std::make_shared<Event>(
CommandInterpreter::eBroadcastBitResetPrompt, bytes.release()); CommandInterpreter::eBroadcastBitResetPrompt, bytes.release());
GetCommandInterpreter().BroadcastEvent(prompt_change_event_sp); GetCommandInterpreter().BroadcastEvent(prompt_change_event_sp);
@ -704,7 +704,7 @@ Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton)
m_listener_sp(Listener::MakeListener("lldb.Debugger")), m_listener_sp(Listener::MakeListener("lldb.Debugger")),
m_source_manager_up(), m_source_file_cache(), m_source_manager_up(), m_source_file_cache(),
m_command_interpreter_up( m_command_interpreter_up(
llvm::make_unique<CommandInterpreter>(*this, false)), std::make_unique<CommandInterpreter>(*this, false)),
m_script_interpreter_sp(), m_input_reader_stack(), m_instance_name(), m_script_interpreter_sp(), m_input_reader_stack(), m_instance_name(),
m_loaded_plugins(), m_event_handler_thread(), m_io_handler_thread(), m_loaded_plugins(), m_event_handler_thread(), m_io_handler_thread(),
m_sync_broadcaster(nullptr, "lldb.debugger.sync"), m_sync_broadcaster(nullptr, "lldb.debugger.sync"),
@ -1239,7 +1239,7 @@ ScriptInterpreter *Debugger::GetScriptInterpreter(bool can_create) {
SourceManager &Debugger::GetSourceManager() { SourceManager &Debugger::GetSourceManager() {
if (!m_source_manager_up) if (!m_source_manager_up)
m_source_manager_up = llvm::make_unique<SourceManager>(shared_from_this()); m_source_manager_up = std::make_unique<SourceManager>(shared_from_this());
return *m_source_manager_up; return *m_source_manager_up;
} }

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

@ -292,7 +292,7 @@ ObjectFile *Module::GetMemoryObjectFile(const lldb::ProcessSP &process_sp,
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (process_sp) { if (process_sp) {
m_did_load_objfile = true; m_did_load_objfile = true;
auto data_up = llvm::make_unique<DataBufferHeap>(size_to_read, 0); auto data_up = std::make_unique<DataBufferHeap>(size_to_read, 0);
Status readmem_error; Status readmem_error;
const size_t bytes_read = const size_t bytes_read =
process_sp->ReadMemory(header_addr, data_up->GetBytes(), process_sp->ReadMemory(header_addr, data_up->GetBytes(),
@ -1297,7 +1297,7 @@ UnwindTable &Module::GetUnwindTable() {
SectionList *Module::GetUnifiedSectionList() { SectionList *Module::GetUnifiedSectionList() {
if (!m_sections_up) if (!m_sections_up)
m_sections_up = llvm::make_unique<SectionList>(); m_sections_up = std::make_unique<SectionList>();
return m_sections_up.get(); return m_sections_up.get();
} }

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

@ -140,7 +140,7 @@ void ValueObjectSynthetic::CreateSynthFilter() {
} }
m_synth_filter_up = (m_synth_sp->GetFrontEnd(*valobj_for_frontend)); m_synth_filter_up = (m_synth_sp->GetFrontEnd(*valobj_for_frontend));
if (!m_synth_filter_up) if (!m_synth_filter_up)
m_synth_filter_up = llvm::make_unique<DummySyntheticFrontEnd>(*m_parent); m_synth_filter_up = std::make_unique<DummySyntheticFrontEnd>(*m_parent);
} }
bool ValueObjectSynthetic::UpdateValue() { bool ValueObjectSynthetic::UpdateValue() {

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

@ -316,7 +316,7 @@ void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr,
}; };
if (process_sp->GetTarget().GetEnableSaveObjects()) { if (process_sp->GetTarget().GetEnableSaveObjects()) {
m_object_cache_up = llvm::make_unique<ObjectDumper>(); m_object_cache_up = std::make_unique<ObjectDumper>();
m_execution_engine_up->setObjectCache(m_object_cache_up.get()); m_execution_engine_up->setObjectCache(m_object_cache_up.get());
} }

8
lldb/source/Host/common/Socket.cpp
View File

@ -114,16 +114,16 @@ std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol,
switch (protocol) { switch (protocol) {
case ProtocolTcp: case ProtocolTcp:
socket_up = socket_up =
llvm::make_unique<TCPSocket>(true, child_processes_inherit); std::make_unique<TCPSocket>(true, child_processes_inherit);
break; break;
case ProtocolUdp: case ProtocolUdp:
socket_up = socket_up =
llvm::make_unique<UDPSocket>(true, child_processes_inherit); std::make_unique<UDPSocket>(true, child_processes_inherit);
break; break;
case ProtocolUnixDomain: case ProtocolUnixDomain:
#ifndef LLDB_DISABLE_POSIX #ifndef LLDB_DISABLE_POSIX
socket_up = socket_up =
llvm::make_unique<DomainSocket>(true, child_processes_inherit); std::make_unique<DomainSocket>(true, child_processes_inherit);
#else #else
error.SetErrorString( error.SetErrorString(
"Unix domain sockets are not supported on this platform."); "Unix domain sockets are not supported on this platform.");
@ -132,7 +132,7 @@ std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol,
case ProtocolUnixAbstract: case ProtocolUnixAbstract:
#ifdef __linux__ #ifdef __linux__
socket_up = socket_up =
llvm::make_unique<AbstractSocket>(child_processes_inherit); std::make_unique<AbstractSocket>(child_processes_inherit);
#else #else
error.SetErrorString( error.SetErrorString(
"Abstract domain sockets are not supported on this platform."); "Abstract domain sockets are not supported on this platform.");

4
lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
View File

@ -87,7 +87,7 @@ void DynamicLoaderPOSIXDYLD::DidAttach() {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
LLDB_LOGF(log, "DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64, __FUNCTION__, LLDB_LOGF(log, "DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64, __FUNCTION__,
m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID); m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID);
m_auxv = llvm::make_unique<AuxVector>(m_process->GetAuxvData()); m_auxv = std::make_unique<AuxVector>(m_process->GetAuxvData());
LLDB_LOGF( LLDB_LOGF(
log, "DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " reloaded auxv data", log, "DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " reloaded auxv data",
@ -179,7 +179,7 @@ void DynamicLoaderPOSIXDYLD::DidLaunch() {
ModuleSP executable; ModuleSP executable;
addr_t load_offset; addr_t load_offset;
m_auxv = llvm::make_unique<AuxVector>(m_process->GetAuxvData()); m_auxv = std::make_unique<AuxVector>(m_process->GetAuxvData());
executable = GetTargetExecutable(); executable = GetTargetExecutable();
load_offset = ComputeLoadOffset(); load_offset = ComputeLoadOffset();

2
lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp
View File

@ -135,7 +135,7 @@ void ClangASTSource::InstallASTContext(clang::ASTContext &ast_context,
; ;
m_merger_up = m_merger_up =
llvm::make_unique<clang::ExternalASTMerger>(target, sources); std::make_unique<clang::ExternalASTMerger>(target, sources);
} else { } else {
m_ast_importer_sp->InstallMapCompleter(&ast_context, *this); m_ast_importer_sp->InstallMapCompleter(&ast_context, *this);
} }

2
lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h
View File

@ -356,7 +356,7 @@ private:
/// Activate parser-specific variables /// Activate parser-specific variables
void EnableParserVars() { void EnableParserVars() {
if (!m_parser_vars.get()) if (!m_parser_vars.get())
m_parser_vars = llvm::make_unique<ParserVars>(); m_parser_vars = std::make_unique<ParserVars>();
} }
/// Deallocate parser-specific variables /// Deallocate parser-specific variables

4
lldb/source/Plugins/Language/ObjC/NSDictionary.h
View File

@ -68,10 +68,10 @@ public:
}; };
typedef Matcher::UP MatcherUP; typedef Matcher::UP MatcherUP;
MatcherUP GetFullMatch(ConstString n) { return llvm::make_unique<Full>(n); } MatcherUP GetFullMatch(ConstString n) { return std::make_unique<Full>(n); }
MatcherUP GetPrefixMatch(ConstString p) { MatcherUP GetPrefixMatch(ConstString p) {
return llvm::make_unique<Prefix>(p); return std::make_unique<Prefix>(p);
} }
}; };

2
lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp
View File

@ -127,7 +127,7 @@ Symtab *ObjectFileBreakpad::GetSymtab() {
void ObjectFileBreakpad::CreateSections(SectionList &unified_section_list) { void ObjectFileBreakpad::CreateSections(SectionList &unified_section_list) {
if (m_sections_up) if (m_sections_up)
return; return;
m_sections_up = llvm::make_unique<SectionList>(); m_sections_up = std::make_unique<SectionList>();
llvm::Optional<Record::Kind> current_section; llvm::Optional<Record::Kind> current_section;
offset_t section_start; offset_t section_start;

2
lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
View File

@ -1762,7 +1762,7 @@ void ObjectFileELF::CreateSections(SectionList &unified_section_list) {
if (m_sections_up) if (m_sections_up)
return; return;
m_sections_up = llvm::make_unique<SectionList>(); m_sections_up = std::make_unique<SectionList>();
VMAddressProvider regular_provider(GetType(), "PT_LOAD"); VMAddressProvider regular_provider(GetType(), "PT_LOAD");
VMAddressProvider tls_provider(GetType(), "PT_TLS"); VMAddressProvider tls_provider(GetType(), "PT_TLS");

2
lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
View File

@ -874,7 +874,7 @@ ObjectFile *ObjectFileMachO::CreateInstance(const lldb::ModuleSP &module_sp,
return nullptr; return nullptr;
data_offset = 0; data_offset = 0;
} }
auto objfile_up = llvm::make_unique<ObjectFileMachO>( auto objfile_up = std::make_unique<ObjectFileMachO>(
module_sp, data_sp, data_offset, file, file_offset, length); module_sp, data_sp, data_offset, file, file_offset, length);
if (!objfile_up || !objfile_up->ParseHeader()) if (!objfile_up || !objfile_up->ParseHeader())
return nullptr; return nullptr;

6
lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp
View File

@ -133,7 +133,7 @@ ObjectFile *ObjectFilePECOFF::CreateInstance(const lldb::ModuleSP &module_sp,
return nullptr; return nullptr;
} }
auto objfile_up = llvm::make_unique<ObjectFilePECOFF>( auto objfile_up = std::make_unique<ObjectFilePECOFF>(
module_sp, data_sp, data_offset, file, file_offset, length); module_sp, data_sp, data_offset, file, file_offset, length);
if (!objfile_up || !objfile_up->ParseHeader()) if (!objfile_up || !objfile_up->ParseHeader())
return nullptr; return nullptr;
@ -150,7 +150,7 @@ ObjectFile *ObjectFilePECOFF::CreateMemoryInstance(
const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) { const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
if (!data_sp || !ObjectFilePECOFF::MagicBytesMatch(data_sp)) if (!data_sp || !ObjectFilePECOFF::MagicBytesMatch(data_sp))
return nullptr; return nullptr;
auto objfile_up = llvm::make_unique<ObjectFilePECOFF>( auto objfile_up = std::make_unique<ObjectFilePECOFF>(
module_sp, data_sp, process_sp, header_addr); module_sp, data_sp, process_sp, header_addr);
if (objfile_up.get() && objfile_up->ParseHeader()) { if (objfile_up.get() && objfile_up->ParseHeader()) {
return objfile_up.release(); return objfile_up.release();
@ -524,7 +524,7 @@ DataExtractor ObjectFilePECOFF::ReadImageData(uint32_t offset, size_t size) {
ProcessSP process_sp(m_process_wp.lock()); ProcessSP process_sp(m_process_wp.lock());
DataExtractor data; DataExtractor data;
if (process_sp) { if (process_sp) {
auto data_up = llvm::make_unique<DataBufferHeap>(size, 0); auto data_up = std::make_unique<DataBufferHeap>(size, 0);
Status readmem_error; Status readmem_error;
size_t bytes_read = size_t bytes_read =
process_sp->ReadMemory(m_image_base + offset, data_up->GetBytes(), process_sp->ReadMemory(m_image_base + offset, data_up->GetBytes(),

2
lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp
View File

@ -1591,7 +1591,7 @@ NativeThreadLinux &NativeProcessLinux::AddThread(lldb::tid_t thread_id) {
if (m_threads.empty()) if (m_threads.empty())
SetCurrentThreadID(thread_id); SetCurrentThreadID(thread_id);
m_threads.push_back(llvm::make_unique<NativeThreadLinux>(*this, thread_id)); m_threads.push_back(std::make_unique<NativeThreadLinux>(*this, thread_id));
if (m_pt_proces_trace_id != LLDB_INVALID_UID) { if (m_pt_proces_trace_id != LLDB_INVALID_UID) {
auto traceMonitor = ProcessorTraceMonitor::Create( auto traceMonitor = ProcessorTraceMonitor::Create(

2
lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp
View File

@ -97,7 +97,7 @@ static const RegisterSet g_reg_sets_arm[k_num_register_sets] = {
std::unique_ptr<NativeRegisterContextLinux> std::unique_ptr<NativeRegisterContextLinux>
NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux( NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
const ArchSpec &target_arch, NativeThreadProtocol &native_thread) { const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
return llvm::make_unique<NativeRegisterContextLinux_arm>(target_arch, return std::make_unique<NativeRegisterContextLinux_arm>(target_arch,
native_thread); native_thread);
} }

4
lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp
View File

@ -112,10 +112,10 @@ NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
const ArchSpec &target_arch, NativeThreadProtocol &native_thread) { const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
switch (target_arch.GetMachine()) { switch (target_arch.GetMachine()) {
case llvm::Triple::arm: case llvm::Triple::arm:
return llvm::make_unique<NativeRegisterContextLinux_arm>(target_arch, return std::make_unique<NativeRegisterContextLinux_arm>(target_arch,
native_thread); native_thread);
case llvm::Triple::aarch64: case llvm::Triple::aarch64:
return llvm::make_unique<NativeRegisterContextLinux_arm64>(target_arch, return std::make_unique<NativeRegisterContextLinux_arm64>(target_arch,
native_thread); native_thread);
default: default:
llvm_unreachable("have no register context for architecture"); llvm_unreachable("have no register context for architecture");

2
lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp
View File

@ -79,7 +79,7 @@ using namespace lldb_private::process_linux;
std::unique_ptr<NativeRegisterContextLinux> std::unique_ptr<NativeRegisterContextLinux>
NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux( NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
const ArchSpec &target_arch, NativeThreadProtocol &native_thread) { const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
return llvm::make_unique<NativeRegisterContextLinux_mips64>(target_arch, return std::make_unique<NativeRegisterContextLinux_mips64>(target_arch,
native_thread); native_thread);
} }

2
lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.cpp
View File

@ -118,7 +118,7 @@ NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
const ArchSpec &target_arch, NativeThreadProtocol &native_thread) { const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
switch (target_arch.GetMachine()) { switch (target_arch.GetMachine()) {
case llvm::Triple::ppc64le: case llvm::Triple::ppc64le:
return llvm::make_unique<NativeRegisterContextLinux_ppc64le>(target_arch, return std::make_unique<NativeRegisterContextLinux_ppc64le>(target_arch,
native_thread); native_thread);
default: default:
llvm_unreachable("have no register context for architecture"); llvm_unreachable("have no register context for architecture");

2
lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp
View File

@ -95,7 +95,7 @@ static const RegisterSet g_reg_sets_s390x[k_num_register_sets] = {
std::unique_ptr<NativeRegisterContextLinux> std::unique_ptr<NativeRegisterContextLinux>
NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux( NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
const ArchSpec &target_arch, NativeThreadProtocol &native_thread) { const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
return llvm::make_unique<NativeRegisterContextLinux_s390x>(target_arch, return std::make_unique<NativeRegisterContextLinux_s390x>(target_arch,
native_thread); native_thread);
} }

2
lldb/source/Plugins/Process/Linux/SingleStepCheck.cpp
View File

@ -172,7 +172,7 @@ std::unique_ptr<SingleStepWorkaround> SingleStepWorkaround::Get(::pid_t tid) {
} }
LLDB_LOG(log, "workaround for thread {0} prepared", tid); LLDB_LOG(log, "workaround for thread {0} prepared", tid);
return llvm::make_unique<SingleStepWorkaround>(tid, original_set); return std::make_unique<SingleStepWorkaround>(tid, original_set);
} }
SingleStepWorkaround::~SingleStepWorkaround() { SingleStepWorkaround::~SingleStepWorkaround() {

2
lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp
View File

@ -659,7 +659,7 @@ NativeThreadNetBSD &NativeProcessNetBSD::AddThread(lldb::tid_t thread_id) {
if (m_threads.empty()) if (m_threads.empty())
SetCurrentThreadID(thread_id); SetCurrentThreadID(thread_id);
m_threads.push_back(llvm::make_unique<NativeThreadNetBSD>(*this, thread_id)); m_threads.push_back(std::make_unique<NativeThreadNetBSD>(*this, thread_id));
return static_cast<NativeThreadNetBSD &>(*m_threads.back()); return static_cast<NativeThreadNetBSD &>(*m_threads.back());
} }

2
lldb/source/Plugins/Process/POSIX/NativeProcessELF.cpp
View File

@ -21,7 +21,7 @@ NativeProcessELF::GetAuxValue(enum AuxVector::EntryType type) {
DataExtractor auxv_data(buffer_or_error.get()->getBufferStart(), DataExtractor auxv_data(buffer_or_error.get()->getBufferStart(),
buffer_or_error.get()->getBufferSize(), buffer_or_error.get()->getBufferSize(),
GetByteOrder(), GetAddressByteSize()); GetByteOrder(), GetAddressByteSize());
m_aux_vector = llvm::make_unique<AuxVector>(auxv_data); m_aux_vector = std::make_unique<AuxVector>(auxv_data);
} }
return m_aux_vector->GetAuxValue(type); return m_aux_vector->GetAuxValue(type);

4
lldb/source/Plugins/Process/Windows/Common/NativeProcessWindows.cpp
View File

@ -410,7 +410,7 @@ void NativeProcessWindows::OnDebuggerConnected(lldb::addr_t image_base) {
// The very first one shall always be the main thread. // The very first one shall always be the main thread.
assert(m_threads.empty()); assert(m_threads.empty());
m_threads.push_back(llvm::make_unique<NativeThreadWindows>( m_threads.push_back(std::make_unique<NativeThreadWindows>(
*this, m_session_data->m_debugger->GetMainThread())); *this, m_session_data->m_debugger->GetMainThread()));
} }
@ -514,7 +514,7 @@ NativeProcessWindows::OnDebugException(bool first_chance,
void NativeProcessWindows::OnCreateThread(const HostThread &new_thread) { void NativeProcessWindows::OnCreateThread(const HostThread &new_thread) {
llvm::sys::ScopedLock lock(m_mutex); llvm::sys::ScopedLock lock(m_mutex);
m_threads.push_back( m_threads.push_back(
llvm::make_unique<NativeThreadWindows>(*this, new_thread)); std::make_unique<NativeThreadWindows>(*this, new_thread));
} }
void NativeProcessWindows::OnExitThread(lldb::tid_t thread_id, void NativeProcessWindows::OnExitThread(lldb::tid_t thread_id,

2
lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_i386.cpp
View File

@ -86,7 +86,7 @@ static Status SetThreadContextHelper(lldb::thread_t thread_handle,
std::unique_ptr<NativeRegisterContextWindows> std::unique_ptr<NativeRegisterContextWindows>
NativeRegisterContextWindows::CreateHostNativeRegisterContextWindows( NativeRegisterContextWindows::CreateHostNativeRegisterContextWindows(
const ArchSpec &target_arch, NativeThreadProtocol &native_thread) { const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
return llvm::make_unique<NativeRegisterContextWindows_i386>(target_arch, return std::make_unique<NativeRegisterContextWindows_i386>(target_arch,
native_thread); native_thread);
} }

4
lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_x86_64.cpp
View File

@ -100,11 +100,11 @@ NativeRegisterContextWindows::CreateHostNativeRegisterContextWindows(
const ArchSpec &target_arch, NativeThreadProtocol &native_thread) { const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
// Register context for a WoW64 application. // Register context for a WoW64 application.
if (target_arch.GetAddressByteSize() == 4) if (target_arch.GetAddressByteSize() == 4)
return llvm::make_unique<NativeRegisterContextWindows_WoW64>(target_arch, return std::make_unique<NativeRegisterContextWindows_WoW64>(target_arch,
native_thread); native_thread);
// Register context for a native 64-bit application. // Register context for a native 64-bit application.
return llvm::make_unique<NativeRegisterContextWindows_x86_64>(target_arch, return std::make_unique<NativeRegisterContextWindows_x86_64>(target_arch,
native_thread); native_thread);
} }

2
lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
View File

@ -179,7 +179,7 @@ public:
FileSpec history_file = GetRoot().CopyByAppendingPathComponent(Info::file); FileSpec history_file = GetRoot().CopyByAppendingPathComponent(Info::file);
std::error_code EC; std::error_code EC;
m_stream_up = llvm::make_unique<raw_fd_ostream>( m_stream_up = std::make_unique<raw_fd_ostream>(
history_file.GetPath(), EC, sys::fs::OpenFlags::OF_Text); history_file.GetPath(), EC, sys::fs::OpenFlags::OF_Text);
return m_stream_up.get(); return m_stream_up.get();
} }

6
lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp
View File

@ -55,7 +55,7 @@ public:
/*length*/ 0, /*data_sp*/ nullptr, /*data_offset*/ 0), /*length*/ 0, /*data_sp*/ nullptr, /*data_offset*/ 0),
m_arch(module_spec.GetArchitecture()), m_uuid(module_spec.GetUUID()), m_arch(module_spec.GetArchitecture()), m_uuid(module_spec.GetUUID()),
m_base(base), m_size(size) { m_base(base), m_size(size) {
m_symtab_up = llvm::make_unique<Symtab>(this); m_symtab_up = std::make_unique<Symtab>(this);
} }
ConstString GetPluginName() override { return ConstString("placeholder"); } ConstString GetPluginName() override { return ConstString("placeholder"); }
@ -80,7 +80,7 @@ public:
} }
void CreateSections(SectionList &unified_section_list) override { void CreateSections(SectionList &unified_section_list) override {
m_sections_up = llvm::make_unique<SectionList>(); m_sections_up = std::make_unique<SectionList>();
auto section_sp = std::make_shared<Section>( auto section_sp = std::make_shared<Section>(
GetModule(), this, /*sect_id*/ 0, ConstString(".module_image"), GetModule(), this, /*sect_id*/ 0, ConstString(".module_image"),
eSectionTypeOther, m_base, m_size, /*file_offset*/ 0, /*file_size*/ 0, eSectionTypeOther, m_base, m_size, /*file_offset*/ 0, /*file_size*/ 0,
@ -444,7 +444,7 @@ bool ProcessMinidump::GetProcessInfo(ProcessInstanceInfo &info) {
// debug information than needed. // debug information than needed.
JITLoaderList &ProcessMinidump::GetJITLoaders() { JITLoaderList &ProcessMinidump::GetJITLoaders() {
if (!m_jit_loaders_up) { if (!m_jit_loaders_up) {
m_jit_loaders_up = llvm::make_unique<JITLoaderList>(); m_jit_loaders_up = std::make_unique<JITLoaderList>();
} }
return *m_jit_loaders_up; return *m_jit_loaders_up;
} }

8
lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
View File

@ -558,7 +558,7 @@ void ScriptInterpreterPythonImpl::IOHandlerInputComplete(IOHandler &io_handler,
if (!bp_options) if (!bp_options)
continue; continue;
auto data_up = llvm::make_unique<CommandDataPython>(); auto data_up = std::make_unique<CommandDataPython>();
if (!data_up) if (!data_up)
break; break;
data_up->user_source.SplitIntoLines(data); data_up->user_source.SplitIntoLines(data);
@ -583,7 +583,7 @@ void ScriptInterpreterPythonImpl::IOHandlerInputComplete(IOHandler &io_handler,
case eIOHandlerWatchpoint: { case eIOHandlerWatchpoint: {
WatchpointOptions *wp_options = WatchpointOptions *wp_options =
(WatchpointOptions *)io_handler.GetUserData(); (WatchpointOptions *)io_handler.GetUserData();
auto data_up = llvm::make_unique<WatchpointOptions::CommandData>(); auto data_up = std::make_unique<WatchpointOptions::CommandData>();
data_up->user_source.SplitIntoLines(data); data_up->user_source.SplitIntoLines(data);
if (GenerateWatchpointCommandCallbackData(data_up->user_source, if (GenerateWatchpointCommandCallbackData(data_up->user_source,
@ -1290,7 +1290,7 @@ Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
// Set a Python one-liner as the callback for the breakpoint. // Set a Python one-liner as the callback for the breakpoint.
Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback( Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
BreakpointOptions *bp_options, const char *command_body_text) { BreakpointOptions *bp_options, const char *command_body_text) {
auto data_up = llvm::make_unique<CommandDataPython>(); auto data_up = std::make_unique<CommandDataPython>();
// Split the command_body_text into lines, and pass that to // Split the command_body_text into lines, and pass that to
// GenerateBreakpointCommandCallbackData. That will wrap the body in an // GenerateBreakpointCommandCallbackData. That will wrap the body in an
@ -1313,7 +1313,7 @@ Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
// Set a Python one-liner as the callback for the watchpoint. // Set a Python one-liner as the callback for the watchpoint.
void ScriptInterpreterPythonImpl::SetWatchpointCommandCallback( void ScriptInterpreterPythonImpl::SetWatchpointCommandCallback(
WatchpointOptions *wp_options, const char *oneliner) { WatchpointOptions *wp_options, const char *oneliner) {
auto data_up = llvm::make_unique<WatchpointOptions::CommandData>(); auto data_up = std::make_unique<WatchpointOptions::CommandData>();
// It's necessary to set both user_source and script_source to the oneliner. // 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 // The former is used to generate callback description (as in watchpoint

2
lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp
View File

@ -590,7 +590,7 @@ void SymbolFileBreakpad::ParseLineTableAndSupportFiles(CompileUnit &cu,
"How did we create compile units without a base address?"); "How did we create compile units without a base address?");
SupportFileMap map; SupportFileMap map;
data.line_table_up = llvm::make_unique<LineTable>(&cu); data.line_table_up = std::make_unique<LineTable>(&cu);
std::unique_ptr<LineSequence> line_seq_up( std::unique_ptr<LineSequence> line_seq_up(
data.line_table_up->CreateLineSequenceContainer()); data.line_table_up->CreateLineSequenceContainer());
llvm::Optional<addr_t> next_addr; llvm::Optional<addr_t> next_addr;

10
lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp
View File

@ -21,30 +21,30 @@ std::unique_ptr<AppleDWARFIndex> AppleDWARFIndex::Create(
Module &module, DWARFDataExtractor apple_names, Module &module, DWARFDataExtractor apple_names,
DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types, DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types,
DWARFDataExtractor apple_objc, DWARFDataExtractor debug_str) { DWARFDataExtractor apple_objc, DWARFDataExtractor debug_str) {
auto apple_names_table_up = llvm::make_unique<DWARFMappedHash::MemoryTable>( auto apple_names_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
apple_names, debug_str, ".apple_names"); apple_names, debug_str, ".apple_names");
if (!apple_names_table_up->IsValid()) if (!apple_names_table_up->IsValid())
apple_names_table_up.reset(); apple_names_table_up.reset();
auto apple_namespaces_table_up = auto apple_namespaces_table_up =
llvm::make_unique<DWARFMappedHash::MemoryTable>( std::make_unique<DWARFMappedHash::MemoryTable>(
apple_namespaces, debug_str, ".apple_namespaces"); apple_namespaces, debug_str, ".apple_namespaces");
if (!apple_namespaces_table_up->IsValid()) if (!apple_namespaces_table_up->IsValid())
apple_namespaces_table_up.reset(); apple_namespaces_table_up.reset();
auto apple_types_table_up = llvm::make_unique<DWARFMappedHash::MemoryTable>( auto apple_types_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
apple_types, debug_str, ".apple_types"); apple_types, debug_str, ".apple_types");
if (!apple_types_table_up->IsValid()) if (!apple_types_table_up->IsValid())
apple_types_table_up.reset(); apple_types_table_up.reset();
auto apple_objc_table_up = llvm::make_unique<DWARFMappedHash::MemoryTable>( auto apple_objc_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
apple_objc, debug_str, ".apple_objc"); apple_objc, debug_str, ".apple_objc");
if (!apple_objc_table_up->IsValid()) if (!apple_objc_table_up->IsValid())
apple_objc_table_up.reset(); apple_objc_table_up.reset();
if (apple_names_table_up || apple_names_table_up || apple_types_table_up || if (apple_names_table_up || apple_names_table_up || apple_types_table_up ||
apple_objc_table_up) apple_objc_table_up)
return llvm::make_unique<AppleDWARFIndex>( return std::make_unique<AppleDWARFIndex>(
module, std::move(apple_names_table_up), module, std::move(apple_names_table_up),
std::move(apple_namespaces_table_up), std::move(apple_types_table_up), std::move(apple_namespaces_table_up), std::move(apple_types_table_up),
std::move(apple_objc_table_up)); std::move(apple_objc_table_up));

2
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp
View File

@ -38,7 +38,7 @@ llvm::Expected<DWARFDebugAranges &> DWARFDebugInfo::GetCompileUnitAranges() {
if (m_cu_aranges_up) if (m_cu_aranges_up)
return *m_cu_aranges_up; return *m_cu_aranges_up;
m_cu_aranges_up = llvm::make_unique<DWARFDebugAranges>(); m_cu_aranges_up = std::make_unique<DWARFDebugAranges>();
const DWARFDataExtractor &debug_aranges_data = const DWARFDataExtractor &debug_aranges_data =
m_context.getOrLoadArangesData(); m_context.getOrLoadArangesData();
if (llvm::Error error = m_cu_aranges_up->extract(debug_aranges_data)) if (llvm::Error error = m_cu_aranges_up->extract(debug_aranges_data))

2
lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp
View File

@ -24,7 +24,7 @@ DebugNamesDWARFIndex::Create(Module &module, DWARFDataExtractor debug_names,
return llvm::make_error<llvm::StringError>("debug info null", return llvm::make_error<llvm::StringError>("debug info null",
llvm::inconvertibleErrorCode()); llvm::inconvertibleErrorCode());
} }
auto index_up = llvm::make_unique<DebugNames>(debug_names.GetAsLLVM(), auto index_up = std::make_unique<DebugNames>(debug_names.GetAsLLVM(),
debug_str.GetAsLLVM()); debug_str.GetAsLLVM());
if (llvm::Error E = index_up->extract()) if (llvm::Error E = index_up->extract())
return std::move(E); return std::move(E);

10
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
View File

@ -474,7 +474,7 @@ void SymbolFileDWARF::InitializeObject() {
} }
} }
m_index = llvm::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(), m_index = std::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(),
DebugInfo()); DebugInfo());
} }
@ -612,7 +612,7 @@ DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() {
if (debug_abbrev_data.GetByteSize() == 0) if (debug_abbrev_data.GetByteSize() == 0)
return nullptr; return nullptr;
auto abbr = llvm::make_unique<DWARFDebugAbbrev>(); auto abbr = std::make_unique<DWARFDebugAbbrev>();
llvm::Error error = abbr->parse(debug_abbrev_data); llvm::Error error = abbr->parse(debug_abbrev_data);
if (error) { if (error) {
Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO); Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
@ -635,7 +635,7 @@ DWARFDebugInfo *SymbolFileDWARF::DebugInfo() {
Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION, Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION,
static_cast<void *>(this)); static_cast<void *>(this));
if (m_context.getOrLoadDebugInfoData().GetByteSize() > 0) if (m_context.getOrLoadDebugInfoData().GetByteSize() > 0)
m_info = llvm::make_unique<DWARFDebugInfo>(*this, m_context); m_info = std::make_unique<DWARFDebugInfo>(*this, m_context);
} }
return m_info.get(); return m_info.get();
} }
@ -989,7 +989,7 @@ bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
// into LLDB, we should explore using a callback to populate the line table // into LLDB, we should explore using a callback to populate the line table
// while we parse to reduce memory usage. // while we parse to reduce memory usage.
std::unique_ptr<LineTable> line_table_up = std::unique_ptr<LineTable> line_table_up =
llvm::make_unique<LineTable>(&comp_unit); std::make_unique<LineTable>(&comp_unit);
LineSequence *sequence = line_table_up->CreateLineSequenceContainer(); LineSequence *sequence = line_table_up->CreateLineSequenceContainer();
for (auto &row : line_table->Rows) { for (auto &row : line_table->Rows) {
line_table_up->AppendLineEntryToSequence( line_table_up->AppendLineEntryToSequence(
@ -1585,7 +1585,7 @@ SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(
if (dwo_obj_file == nullptr) if (dwo_obj_file == nullptr)
return nullptr; return nullptr;
return llvm::make_unique<SymbolFileDWARFDwo>(dwo_obj_file, *dwarf_cu); return std::make_unique<SymbolFileDWARFDwo>(dwo_obj_file, *dwarf_cu);
} }
void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() { void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {

4
lldb/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.cpp
View File

@ -130,7 +130,7 @@ CompilandIndexItem &CompileUnitIndex::GetOrCreateCompiland(uint16_t modi) {
if (!stream_data) { if (!stream_data) {
llvm::pdb::ModuleDebugStreamRef debug_stream(descriptor, nullptr); llvm::pdb::ModuleDebugStreamRef debug_stream(descriptor, nullptr);
cci = llvm::make_unique<CompilandIndexItem>(PdbCompilandId{ modi }, debug_stream, std::move(descriptor)); cci = std::make_unique<CompilandIndexItem>(PdbCompilandId{ modi }, debug_stream, std::move(descriptor));
return *cci; return *cci;
} }
@ -139,7 +139,7 @@ CompilandIndexItem &CompileUnitIndex::GetOrCreateCompiland(uint16_t modi) {
cantFail(debug_stream.reload()); cantFail(debug_stream.reload());
cci = llvm::make_unique<CompilandIndexItem>( cci = std::make_unique<CompilandIndexItem>(
PdbCompilandId{modi}, std::move(debug_stream), std::move(descriptor)); PdbCompilandId{modi}, std::move(debug_stream), std::move(descriptor));
ParseExtendedInfo(m_index, *cci); ParseExtendedInfo(m_index, *cci);

8
lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp
View File

@ -91,10 +91,10 @@ static std::unique_ptr<PDBFile> loadPDBFile(std::string PdbPath,
std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(*ErrorOrBuffer); std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(*ErrorOrBuffer);
llvm::StringRef Path = Buffer->getBufferIdentifier(); llvm::StringRef Path = Buffer->getBufferIdentifier();
auto Stream = llvm::make_unique<llvm::MemoryBufferByteStream>( auto Stream = std::make_unique<llvm::MemoryBufferByteStream>(
std::move(Buffer), llvm::support::little); std::move(Buffer), llvm::support::little);
auto File = llvm::make_unique<PDBFile>(Path, std::move(Stream), Allocator); auto File = std::make_unique<PDBFile>(Path, std::move(Stream), Allocator);
if (auto EC = File->parseFileHeaders()) { if (auto EC = File->parseFileHeaders()) {
llvm::consumeError(std::move(EC)); llvm::consumeError(std::move(EC));
return nullptr; return nullptr;
@ -333,7 +333,7 @@ void SymbolFileNativePDB::InitializeObject() {
ts_or_err->SetSymbolFile(this); ts_or_err->SetSymbolFile(this);
auto *clang = llvm::cast_or_null<ClangASTContext>(&ts_or_err.get()); auto *clang = llvm::cast_or_null<ClangASTContext>(&ts_or_err.get());
lldbassert(clang); lldbassert(clang);
m_ast = llvm::make_unique<PdbAstBuilder>(*m_objfile_sp, *m_index, *clang); m_ast = std::make_unique<PdbAstBuilder>(*m_objfile_sp, *m_index, *clang);
} }
} }
@ -1068,7 +1068,7 @@ bool SymbolFileNativePDB::ParseLineTable(CompileUnit &comp_unit) {
CompilandIndexItem *cci = CompilandIndexItem *cci =
m_index->compilands().GetCompiland(cu_id.asCompiland().modi); m_index->compilands().GetCompiland(cu_id.asCompiland().modi);
lldbassert(cci); lldbassert(cci);
auto line_table = llvm::make_unique<LineTable>(&comp_unit); auto line_table = std::make_unique<LineTable>(&comp_unit);
// This is basically a copy of the .debug$S subsections from all original COFF // This is basically a copy of the .debug$S subsections from all original COFF
// object files merged together with address relocations applied. We are // object files merged together with address relocations applied. We are

2
lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
View File

@ -1800,7 +1800,7 @@ bool SymbolFilePDB::ParseCompileUnitLineTable(CompileUnit &comp_unit,
// to do a mapping so that we can hand out indices. // to do a mapping so that we can hand out indices.
llvm::DenseMap<uint32_t, uint32_t> index_map; llvm::DenseMap<uint32_t, uint32_t> index_map;
BuildSupportFileIdToSupportFileIndexMap(*compiland_up, index_map); BuildSupportFileIdToSupportFileIndexMap(*compiland_up, index_map);
auto line_table = llvm::make_unique<LineTable>(&comp_unit); auto line_table = std::make_unique<LineTable>(&comp_unit);
// Find contributions to `compiland` from all source and header files. // Find contributions to `compiland` from all source and header files.
std::string path = comp_unit.GetPath(); std::string path = comp_unit.GetPath();

2
lldb/source/Symbol/ClangASTContext.cpp
View File

@ -8444,7 +8444,7 @@ ClangASTContext::CreateBaseClassSpecifier(lldb::opaque_compiler_type_t type,
if (!type) if (!type)
return nullptr; return nullptr;
return llvm::make_unique<clang::CXXBaseSpecifier>( return std::make_unique<clang::CXXBaseSpecifier>(
clang::SourceRange(), is_virtual, base_of_class, clang::SourceRange(), is_virtual, base_of_class,
ClangASTContext::ConvertAccessTypeToAccessSpecifier(access), ClangASTContext::ConvertAccessTypeToAccessSpecifier(access),
getASTContext()->getTrivialTypeSourceInfo(GetQualType(type)), getASTContext()->getTrivialTypeSourceInfo(GetQualType(type)),

2
lldb/source/Target/Platform.cpp
View File

@ -384,7 +384,7 @@ Platform::Platform(bool is_host)
m_rsync_opts(), m_rsync_prefix(), m_supports_ssh(false), m_ssh_opts(), m_rsync_opts(), m_rsync_prefix(), m_supports_ssh(false), m_ssh_opts(),
m_ignores_remote_hostname(false), m_trap_handlers(), m_ignores_remote_hostname(false), m_trap_handlers(),
m_calculated_trap_handlers(false), m_calculated_trap_handlers(false),
m_module_cache(llvm::make_unique<ModuleCache>()) { m_module_cache(std::make_unique<ModuleCache>()) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
LLDB_LOGF(log, "%p Platform::Platform()", static_cast<void *>(this)); LLDB_LOGF(log, "%p Platform::Platform()", static_cast<void *>(this));
} }

4
lldb/source/Utility/Reproducer.cpp
View File

@ -175,7 +175,7 @@ void Generator::AddProvidersToIndex() {
index.AppendPathComponent("index.yaml"); index.AppendPathComponent("index.yaml");
std::error_code EC; std::error_code EC;
auto strm = llvm::make_unique<raw_fd_ostream>(index.GetPath(), EC, auto strm = std::make_unique<raw_fd_ostream>(index.GetPath(), EC,
sys::fs::OpenFlags::OF_None); sys::fs::OpenFlags::OF_None);
yaml::Output yout(*strm); yaml::Output yout(*strm);
@ -223,7 +223,7 @@ bool Loader::HasFile(StringRef file) {
llvm::Expected<std::unique_ptr<DataRecorder>> llvm::Expected<std::unique_ptr<DataRecorder>>
DataRecorder::Create(const FileSpec &filename) { DataRecorder::Create(const FileSpec &filename) {
std::error_code ec; std::error_code ec;
auto recorder = llvm::make_unique<DataRecorder>(std::move(filename), ec); auto recorder = std::make_unique<DataRecorder>(std::move(filename), ec);
if (ec) if (ec)
return llvm::errorCodeToError(ec); return llvm::errorCodeToError(ec);
return std::move(recorder); return std::move(recorder);

4
lldb/source/Utility/StructuredData.cpp
View File

@ -47,7 +47,7 @@ StructuredData::ParseJSONFromFile(const FileSpec &input_spec, Status &error) {
static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser) { static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser) {
// The "JSONParser::Token::ObjectStart" token should have already been // The "JSONParser::Token::ObjectStart" token should have already been
// consumed by the time this function is called // consumed by the time this function is called
auto dict_up = llvm::make_unique<StructuredData::Dictionary>(); auto dict_up = std::make_unique<StructuredData::Dictionary>();
std::string value; std::string value;
std::string key; std::string key;
@ -78,7 +78,7 @@ static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser) {
static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser) { static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser) {
// The "JSONParser::Token::ObjectStart" token should have already been // The "JSONParser::Token::ObjectStart" token should have already been
// consumed by the time this function is called // consumed by the time this function is called
auto array_up = llvm::make_unique<StructuredData::Array>(); auto array_up = std::make_unique<StructuredData::Array>();
std::string value; std::string value;
std::string key; std::string key;

6
lldb/tools/lldb-instr/Instrument.cpp
View File

@ -335,7 +335,7 @@ public:
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI, std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef File) override { StringRef File) override {
MyRewriter.setSourceMgr(CI.getSourceManager(), CI.getLangOpts()); MyRewriter.setSourceMgr(CI.getSourceManager(), CI.getLangOpts());
return llvm::make_unique<SBConsumer>(MyRewriter, CI.getASTContext()); return std::make_unique<SBConsumer>(MyRewriter, CI.getASTContext());
} }
private: private:
@ -348,8 +348,8 @@ int main(int argc, const char **argv) {
"instrumentation framework."); "instrumentation framework.");
auto PCHOpts = std::make_shared<PCHContainerOperations>(); auto PCHOpts = std::make_shared<PCHContainerOperations>();
PCHOpts->registerWriter(llvm::make_unique<ObjectFilePCHContainerWriter>()); PCHOpts->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
PCHOpts->registerReader(llvm::make_unique<ObjectFilePCHContainerReader>()); PCHOpts->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
ClangTool T(OP.getCompilations(), OP.getSourcePathList(), PCHOpts); ClangTool T(OP.getCompilations(), OP.getSourcePathList(), PCHOpts);
return T.run(newFrontendActionFactory<SBAction>().get()); return T.run(newFrontendActionFactory<SBAction>().get());

2
lldb/tools/lldb-server/lldb-server.cpp
View File

@ -39,7 +39,7 @@ int main_platform(int argc, char *argv[]);
namespace llgs { namespace llgs {
static void initialize() { static void initialize() {
if (auto e = g_debugger_lifetime->Initialize( if (auto e = g_debugger_lifetime->Initialize(
llvm::make_unique<SystemInitializerLLGS>(), nullptr)) std::make_unique<SystemInitializerLLGS>(), nullptr))
llvm::consumeError(std::move(e)); llvm::consumeError(std::move(e));
} }

2
lldb/tools/lldb-test/lldb-test.cpp
View File

@ -969,7 +969,7 @@ int main(int argc, const char *argv[]) {
SystemLifetimeManager DebuggerLifetime; SystemLifetimeManager DebuggerLifetime;
if (auto e = DebuggerLifetime.Initialize( if (auto e = DebuggerLifetime.Initialize(
llvm::make_unique<SystemInitializerTest>(), nullptr)) { std::make_unique<SystemInitializerTest>(), nullptr)) {
WithColor::error() << "initialization failed: " << toString(std::move(e)) WithColor::error() << "initialization failed: " << toString(std::move(e))
<< '\n'; << '\n';
return 1; return 1;

2
lldb/unittests/Host/MainLoopTest.cpp
View File

@ -110,7 +110,7 @@ TEST_F(MainLoopTest, DetectsEOF) {
PseudoTerminal term; PseudoTerminal term;
ASSERT_TRUE(term.OpenFirstAvailableMaster(O_RDWR, nullptr, 0)); ASSERT_TRUE(term.OpenFirstAvailableMaster(O_RDWR, nullptr, 0));
ASSERT_TRUE(term.OpenSlave(O_RDWR | O_NOCTTY, nullptr, 0)); ASSERT_TRUE(term.OpenSlave(O_RDWR | O_NOCTTY, nullptr, 0));
auto conn = llvm::make_unique<ConnectionFileDescriptor>( auto conn = std::make_unique<ConnectionFileDescriptor>(
term.ReleaseMasterFileDescriptor(), true); term.ReleaseMasterFileDescriptor(), true);
Status error; Status error;

4
lldb/unittests/Process/minidump/RegisterContextMinidumpTest.cpp
View File

@ -51,7 +51,7 @@ TEST(RegisterContextMinidump, ConvertMinidumpContext_x86_32) {
sizeof(Context)); sizeof(Context));
ArchSpec arch("i386-pc-linux"); ArchSpec arch("i386-pc-linux");
auto RegInterface = llvm::make_unique<RegisterContextLinux_i386>(arch); auto RegInterface = std::make_unique<RegisterContextLinux_i386>(arch);
lldb::DataBufferSP Buf = lldb::DataBufferSP Buf =
ConvertMinidumpContext_x86_32(ContextRef, RegInterface.get()); ConvertMinidumpContext_x86_32(ContextRef, RegInterface.get());
ASSERT_EQ(RegInterface->GetGPRSize(), Buf->GetByteSize()); ASSERT_EQ(RegInterface->GetGPRSize(), Buf->GetByteSize());
@ -112,7 +112,7 @@ TEST(RegisterContextMinidump, ConvertMinidumpContext_x86_64) {
sizeof(Context)); sizeof(Context));
ArchSpec arch("x86_64-pc-linux"); ArchSpec arch("x86_64-pc-linux");
auto RegInterface = llvm::make_unique<RegisterContextLinux_x86_64>(arch); auto RegInterface = std::make_unique<RegisterContextLinux_x86_64>(arch);
lldb::DataBufferSP Buf = lldb::DataBufferSP Buf =
ConvertMinidumpContext_x86_64(ContextRef, RegInterface.get()); ConvertMinidumpContext_x86_64(ContextRef, RegInterface.get());
ASSERT_EQ(RegInterface->GetGPRSize(), Buf->GetByteSize()); ASSERT_EQ(RegInterface->GetGPRSize(), Buf->GetByteSize());

4
lldb/unittests/tools/lldb-server/tests/MessageObjects.cpp
View File

@ -319,7 +319,7 @@ StopReplyStop::create(StringRef Response, support::endianness Endian,
if (!RegistersOr) if (!RegistersOr)
return RegistersOr.takeError(); return RegistersOr.takeError();
return llvm::make_unique<StopReplyStop>(Signal, Thread, Name, return std::make_unique<StopReplyStop>(Signal, Thread, Name,
std::move(ThreadPcs), std::move(ThreadPcs),
std::move(*RegistersOr), Reason); std::move(*RegistersOr), Reason);
} }
@ -329,7 +329,7 @@ StopReplyExit::create(StringRef Response) {
uint8_t Status; uint8_t Status;
if (!to_integer(Response, Status, 16)) if (!to_integer(Response, Status, 16))
return make_parsing_error("StopReply: exit status"); return make_parsing_error("StopReply: exit status");
return llvm::make_unique<StopReplyExit>(Status); return std::make_unique<StopReplyExit>(Status);
} }
//====== Globals =============================================================== //====== Globals ===============================================================

2
lldb/unittests/tools/lldb-server/tests/TestClient.cpp
View File

@ -111,7 +111,7 @@ Expected<std::unique_ptr<TestClient>> TestClient::launchCustom(StringRef Log, Ar
Socket *accept_socket; Socket *accept_socket;
listen_socket.Accept(accept_socket); listen_socket.Accept(accept_socket);
auto Conn = llvm::make_unique<ConnectionFileDescriptor>(accept_socket); auto Conn = std::make_unique<ConnectionFileDescriptor>(accept_socket);
auto Client = std::unique_ptr<TestClient>(new TestClient(std::move(Conn))); auto Client = std::unique_ptr<TestClient>(new TestClient(std::move(Conn)));
if (Error E = Client->initializeConnection()) if (Error E = Client->initializeConnection())