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.
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)));
}

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

@ -442,7 +442,7 @@ public:
void Register(Signature *f, llvm::StringRef result = {},
llvm::StringRef scope = {}, llvm::StringRef name = {},
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));
}
@ -452,7 +452,7 @@ public:
void Register(Signature *f, Signature *g, llvm::StringRef result = {},
llvm::StringRef scope = {}, llvm::StringRef name = {},
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));
}

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)
: m_opaque_up(new Address()) {
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()) {

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

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

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

@ -88,7 +88,7 @@ public:
file = absolute_path.GetPath();
}
return llvm::make_unique<CommandLoader>(std::move(files));
return std::make_unique<CommandLoader>(std::move(files));
}
FILE *GetNextFile() {
@ -204,7 +204,7 @@ lldb::SBError SBDebugger::InitializeWithErrorHandling() {
SBError error;
if (auto e = g_debugger_lifetime->Initialize(
llvm::make_unique<SystemInitializerFull>(), LoadPlugin)) {
std::make_unique<SystemInitializerFull>(), LoadPlugin)) {
error.SetError(Status(std::move(e)));
}
return LLDB_RECORD_RESULT(error);
@ -599,18 +599,18 @@ const char *SBDebugger::StateAsCString(StateType state) {
static void AddBoolConfigEntry(StructuredData::Dictionary &dict,
llvm::StringRef name, bool value,
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->AddStringItem("description", description);
dict.AddItem(name, std::move(entry_up));
}
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) \
array_up->AddItem(llvm::make_unique<StructuredData::String>(#target));
array_up->AddItem(std::make_unique<StructuredData::String>(#target));
#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->AddStringItem("description", "A list of configured LLVM targets.");
dict.AddItem("targets", std::move(entry_up));
@ -620,7 +620,7 @@ SBStructuredData SBDebugger::GetBuildConfiguration() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger,
GetBuildConfiguration);
auto config_up = llvm::make_unique<StructuredData::Dictionary>();
auto config_up = std::make_unique<StructuredData::Dictionary>();
AddBoolConfigEntry(
*config_up, "xml", XMLDocument::XMLEnabled(),
"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);
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");
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)
: m_opaque_up() {
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) {

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

@ -1107,7 +1107,7 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
if (target->GetDisplayExpressionsInCrashlogs()) {
StreamString 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 "
"= %u) %s",
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)
: m_opaque_up() {
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) {
@ -45,7 +45,7 @@ const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) {
}
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() {}

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)
: m_opaque_up() {
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() {

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

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

@ -218,7 +218,7 @@ SBStructuredData SBTarget::GetStatistics() {
if (!target_sp)
return LLDB_RECORD_RESULT(data);
auto stats_up = llvm::make_unique<StructuredData::Dictionary>();
auto stats_up = std::make_unique<StructuredData::Dictionary>();
int i = 0;
for (auto &Entry : target_sp->GetStatistics()) {
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) {
if (src)
return llvm::make_unique<T>(*src);
return std::make_unique<T>(*src);
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,
ignore_count, one_shot, auto_continue);
if (cmd_data_up) {

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

@ -159,7 +159,7 @@ public:
{
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)
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)
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());
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,
const char *oneliner) {
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->stop_on_error = m_options.m_stop_on_error;

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

@ -997,7 +997,7 @@ protected:
Status error;
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,
true);

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

@ -275,7 +275,7 @@ Status Debugger::SetPropertyValue(const ExecutionContext *exe_ctx,
if (str.length())
new_prompt = str;
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>(
CommandInterpreter::eBroadcastBitResetPrompt, bytes.release());
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_source_manager_up(), m_source_file_cache(),
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_loaded_plugins(), m_event_handler_thread(), m_io_handler_thread(),
m_sync_broadcaster(nullptr, "lldb.debugger.sync"),
@ -1239,7 +1239,7 @@ ScriptInterpreter *Debugger::GetScriptInterpreter(bool can_create) {
SourceManager &Debugger::GetSourceManager() {
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;
}

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);
if (process_sp) {
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;
const size_t bytes_read =
process_sp->ReadMemory(header_addr, data_up->GetBytes(),
@ -1297,7 +1297,7 @@ UnwindTable &Module::GetUnwindTable() {
SectionList *Module::GetUnifiedSectionList() {
if (!m_sections_up)
m_sections_up = llvm::make_unique<SectionList>();
m_sections_up = std::make_unique<SectionList>();
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));
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() {

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()) {
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());
}

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

@ -114,16 +114,16 @@ std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol,
switch (protocol) {
case ProtocolTcp:
socket_up =
llvm::make_unique<TCPSocket>(true, child_processes_inherit);
std::make_unique<TCPSocket>(true, child_processes_inherit);
break;
case ProtocolUdp:
socket_up =
llvm::make_unique<UDPSocket>(true, child_processes_inherit);
std::make_unique<UDPSocket>(true, child_processes_inherit);
break;
case ProtocolUnixDomain:
#ifndef LLDB_DISABLE_POSIX
socket_up =
llvm::make_unique<DomainSocket>(true, child_processes_inherit);
std::make_unique<DomainSocket>(true, child_processes_inherit);
#else
error.SetErrorString(
"Unix domain sockets are not supported on this platform.");
@ -132,7 +132,7 @@ std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol,
case ProtocolUnixAbstract:
#ifdef __linux__
socket_up =
llvm::make_unique<AbstractSocket>(child_processes_inherit);
std::make_unique<AbstractSocket>(child_processes_inherit);
#else
error.SetErrorString(
"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));
LLDB_LOGF(log, "DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64, __FUNCTION__,
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(
log, "DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " reloaded auxv data",
@ -179,7 +179,7 @@ void DynamicLoaderPOSIXDYLD::DidLaunch() {
ModuleSP executable;
addr_t load_offset;
m_auxv = llvm::make_unique<AuxVector>(m_process->GetAuxvData());
m_auxv = std::make_unique<AuxVector>(m_process->GetAuxvData());
executable = GetTargetExecutable();
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 =
llvm::make_unique<clang::ExternalASTMerger>(target, sources);
std::make_unique<clang::ExternalASTMerger>(target, sources);
} else {
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
void EnableParserVars() {
if (!m_parser_vars.get())
m_parser_vars = llvm::make_unique<ParserVars>();
m_parser_vars = std::make_unique<ParserVars>();
}
/// Deallocate parser-specific variables

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

@ -68,10 +68,10 @@ public:
};
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) {
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) {
if (m_sections_up)
return;
m_sections_up = llvm::make_unique<SectionList>();
m_sections_up = std::make_unique<SectionList>();
llvm::Optional<Record::Kind> current_section;
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)
return;
m_sections_up = llvm::make_unique<SectionList>();
m_sections_up = std::make_unique<SectionList>();
VMAddressProvider regular_provider(GetType(), "PT_LOAD");
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;
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);
if (!objfile_up || !objfile_up->ParseHeader())
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;
}
auto objfile_up = llvm::make_unique<ObjectFilePECOFF>(
auto objfile_up = std::make_unique<ObjectFilePECOFF>(
module_sp, data_sp, data_offset, file, file_offset, length);
if (!objfile_up || !objfile_up->ParseHeader())
return nullptr;
@ -150,7 +150,7 @@ ObjectFile *ObjectFilePECOFF::CreateMemoryInstance(
const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
if (!data_sp || !ObjectFilePECOFF::MagicBytesMatch(data_sp))
return nullptr;
auto objfile_up = llvm::make_unique<ObjectFilePECOFF>(
auto objfile_up = std::make_unique<ObjectFilePECOFF>(
module_sp, data_sp, process_sp, header_addr);
if (objfile_up.get() && objfile_up->ParseHeader()) {
return objfile_up.release();
@ -524,7 +524,7 @@ DataExtractor ObjectFilePECOFF::ReadImageData(uint32_t offset, size_t size) {
ProcessSP process_sp(m_process_wp.lock());
DataExtractor data;
if (process_sp) {
auto data_up = llvm::make_unique<DataBufferHeap>(size, 0);
auto data_up = std::make_unique<DataBufferHeap>(size, 0);
Status readmem_error;
size_t bytes_read =
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())
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) {
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>
NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
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);
}

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

@ -112,10 +112,10 @@ NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
switch (target_arch.GetMachine()) {
case llvm::Triple::arm:
return llvm::make_unique<NativeRegisterContextLinux_arm>(target_arch,
return std::make_unique<NativeRegisterContextLinux_arm>(target_arch,
native_thread);
case llvm::Triple::aarch64:
return llvm::make_unique<NativeRegisterContextLinux_arm64>(target_arch,
return std::make_unique<NativeRegisterContextLinux_arm64>(target_arch,
native_thread);
default:
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>
NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
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);
}

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

@ -118,7 +118,7 @@ NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
switch (target_arch.GetMachine()) {
case llvm::Triple::ppc64le:
return llvm::make_unique<NativeRegisterContextLinux_ppc64le>(target_arch,
return std::make_unique<NativeRegisterContextLinux_ppc64le>(target_arch,
native_thread);
default:
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>
NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
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);
}

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);
return llvm::make_unique<SingleStepWorkaround>(tid, original_set);
return std::make_unique<SingleStepWorkaround>(tid, original_set);
}
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())
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());
}

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(),
buffer_or_error.get()->getBufferSize(),
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);

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.
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()));
}
@ -514,7 +514,7 @@ NativeProcessWindows::OnDebugException(bool first_chance,
void NativeProcessWindows::OnCreateThread(const HostThread &new_thread) {
llvm::sys::ScopedLock lock(m_mutex);
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,

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>
NativeRegisterContextWindows::CreateHostNativeRegisterContextWindows(
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);
}

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) {
// Register context for a WoW64 application.
if (target_arch.GetAddressByteSize() == 4)
return llvm::make_unique<NativeRegisterContextWindows_WoW64>(target_arch,
return std::make_unique<NativeRegisterContextWindows_WoW64>(target_arch,
native_thread);
// 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);
}

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

@ -179,7 +179,7 @@ public:
FileSpec history_file = GetRoot().CopyByAppendingPathComponent(Info::file);
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);
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),
m_arch(module_spec.GetArchitecture()), m_uuid(module_spec.GetUUID()),
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"); }
@ -80,7 +80,7 @@ public:
}
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>(
GetModule(), this, /*sect_id*/ 0, ConstString(".module_image"),
eSectionTypeOther, m_base, m_size, /*file_offset*/ 0, /*file_size*/ 0,
@ -444,7 +444,7 @@ bool ProcessMinidump::GetProcessInfo(ProcessInstanceInfo &info) {
// debug information than needed.
JITLoaderList &ProcessMinidump::GetJITLoaders() {
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;
}

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

@ -558,7 +558,7 @@ void ScriptInterpreterPythonImpl::IOHandlerInputComplete(IOHandler &io_handler,
if (!bp_options)
continue;
auto data_up = llvm::make_unique<CommandDataPython>();
auto data_up = std::make_unique<CommandDataPython>();
if (!data_up)
break;
data_up->user_source.SplitIntoLines(data);
@ -583,7 +583,7 @@ void ScriptInterpreterPythonImpl::IOHandlerInputComplete(IOHandler &io_handler,
case eIOHandlerWatchpoint: {
WatchpointOptions *wp_options =
(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);
if (GenerateWatchpointCommandCallbackData(data_up->user_source,
@ -1290,7 +1290,7 @@ Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
// Set a Python one-liner as the callback for the breakpoint.
Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
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
// 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.
void ScriptInterpreterPythonImpl::SetWatchpointCommandCallback(
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.
// 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?");
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(
data.line_table_up->CreateLineSequenceContainer());
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,
DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types,
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");
if (!apple_names_table_up->IsValid())
apple_names_table_up.reset();
auto apple_namespaces_table_up =
llvm::make_unique<DWARFMappedHash::MemoryTable>(
std::make_unique<DWARFMappedHash::MemoryTable>(
apple_namespaces, debug_str, ".apple_namespaces");
if (!apple_namespaces_table_up->IsValid())
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");
if (!apple_types_table_up->IsValid())
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");
if (!apple_objc_table_up->IsValid())
apple_objc_table_up.reset();
if (apple_names_table_up || apple_names_table_up || apple_types_table_up ||
apple_objc_table_up)
return llvm::make_unique<AppleDWARFIndex>(
return std::make_unique<AppleDWARFIndex>(
module, std::move(apple_names_table_up),
std::move(apple_namespaces_table_up), std::move(apple_types_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)
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 =
m_context.getOrLoadArangesData();
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",
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());
if (llvm::Error E = index_up->extract())
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());
}
@ -612,7 +612,7 @@ DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() {
if (debug_abbrev_data.GetByteSize() == 0)
return nullptr;
auto abbr = llvm::make_unique<DWARFDebugAbbrev>();
auto abbr = std::make_unique<DWARFDebugAbbrev>();
llvm::Error error = abbr->parse(debug_abbrev_data);
if (error) {
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,
static_cast<void *>(this));
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();
}
@ -989,7 +989,7 @@ bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
// into LLDB, we should explore using a callback to populate the line table
// while we parse to reduce memory usage.
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();
for (auto &row : line_table->Rows) {
line_table_up->AppendLineEntryToSequence(
@ -1585,7 +1585,7 @@ SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(
if (dwo_obj_file == 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() {

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

@ -130,7 +130,7 @@ CompilandIndexItem &CompileUnitIndex::GetOrCreateCompiland(uint16_t modi) {
if (!stream_data) {
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;
}
@ -139,7 +139,7 @@ CompilandIndexItem &CompileUnitIndex::GetOrCreateCompiland(uint16_t modi) {
cantFail(debug_stream.reload());
cci = llvm::make_unique<CompilandIndexItem>(
cci = std::make_unique<CompilandIndexItem>(
PdbCompilandId{modi}, std::move(debug_stream), std::move(descriptor));
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);
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);
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()) {
llvm::consumeError(std::move(EC));
return nullptr;
@ -333,7 +333,7 @@ void SymbolFileNativePDB::InitializeObject() {
ts_or_err->SetSymbolFile(this);
auto *clang = llvm::cast_or_null<ClangASTContext>(&ts_or_err.get());
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 =
m_index->compilands().GetCompiland(cu_id.asCompiland().modi);
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
// 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.
llvm::DenseMap<uint32_t, uint32_t> 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.
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)
return nullptr;
return llvm::make_unique<clang::CXXBaseSpecifier>(
return std::make_unique<clang::CXXBaseSpecifier>(
clang::SourceRange(), is_virtual, base_of_class,
ClangASTContext::ConvertAccessTypeToAccessSpecifier(access),
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_ignores_remote_hostname(false), m_trap_handlers(),
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));
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");
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);
yaml::Output yout(*strm);
@ -223,7 +223,7 @@ bool Loader::HasFile(StringRef file) {
llvm::Expected<std::unique_ptr<DataRecorder>>
DataRecorder::Create(const FileSpec &filename) {
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)
return llvm::errorCodeToError(ec);
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) {
// The "JSONParser::Token::ObjectStart" token should have already been
// 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 key;
@ -78,7 +78,7 @@ static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser) {
static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser) {
// The "JSONParser::Token::ObjectStart" token should have already been
// 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 key;

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

@ -335,7 +335,7 @@ public:
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef File) override {
MyRewriter.setSourceMgr(CI.getSourceManager(), CI.getLangOpts());
return llvm::make_unique<SBConsumer>(MyRewriter, CI.getASTContext());
return std::make_unique<SBConsumer>(MyRewriter, CI.getASTContext());
}
private:
@ -348,8 +348,8 @@ int main(int argc, const char **argv) {
"instrumentation framework.");
auto PCHOpts = std::make_shared<PCHContainerOperations>();
PCHOpts->registerWriter(llvm::make_unique<ObjectFilePCHContainerWriter>());
PCHOpts->registerReader(llvm::make_unique<ObjectFilePCHContainerReader>());
PCHOpts->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
PCHOpts->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
ClangTool T(OP.getCompilations(), OP.getSourcePathList(), PCHOpts);
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 {
static void initialize() {
if (auto e = g_debugger_lifetime->Initialize(
llvm::make_unique<SystemInitializerLLGS>(), nullptr))
std::make_unique<SystemInitializerLLGS>(), nullptr))
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;
if (auto e = DebuggerLifetime.Initialize(
llvm::make_unique<SystemInitializerTest>(), nullptr)) {
std::make_unique<SystemInitializerTest>(), nullptr)) {
WithColor::error() << "initialization failed: " << toString(std::move(e))
<< '\n';
return 1;

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

@ -110,7 +110,7 @@ TEST_F(MainLoopTest, DetectsEOF) {
PseudoTerminal term;
ASSERT_TRUE(term.OpenFirstAvailableMaster(O_RDWR, 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);
Status error;

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

@ -51,7 +51,7 @@ TEST(RegisterContextMinidump, ConvertMinidumpContext_x86_32) {
sizeof(Context));
ArchSpec arch("i386-pc-linux");
auto RegInterface = llvm::make_unique<RegisterContextLinux_i386>(arch);
auto RegInterface = std::make_unique<RegisterContextLinux_i386>(arch);
lldb::DataBufferSP Buf =
ConvertMinidumpContext_x86_32(ContextRef, RegInterface.get());
ASSERT_EQ(RegInterface->GetGPRSize(), Buf->GetByteSize());
@ -112,7 +112,7 @@ TEST(RegisterContextMinidump, ConvertMinidumpContext_x86_64) {
sizeof(Context));
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 =
ConvertMinidumpContext_x86_64(ContextRef, RegInterface.get());
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)
return RegistersOr.takeError();
return llvm::make_unique<StopReplyStop>(Signal, Thread, Name,
return std::make_unique<StopReplyStop>(Signal, Thread, Name,
std::move(ThreadPcs),
std::move(*RegistersOr), Reason);
}
@ -329,7 +329,7 @@ StopReplyExit::create(StringRef Response) {
uint8_t Status;
if (!to_integer(Response, Status, 16))
return make_parsing_error("StopReply: exit status");
return llvm::make_unique<StopReplyExit>(Status);
return std::make_unique<StopReplyExit>(Status);
}
//====== 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;
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)));
if (Error E = Client->initializeConnection())