diff options
Diffstat (limited to 'source')
140 files changed, 1798 insertions, 1794 deletions
diff --git a/source/API/SBAddress.cpp b/source/API/SBAddress.cpp index 0cad2b7fd..2765a7f14 100644 --- a/source/API/SBAddress.cpp +++ b/source/API/SBAddress.cpp @@ -20,25 +20,25 @@ using namespace lldb; using namespace lldb_private; -SBAddress::SBAddress() : m_opaque_ap(new Address()) {} +SBAddress::SBAddress() : m_opaque_up(new Address()) {} SBAddress::SBAddress(const Address *lldb_object_ptr) - : m_opaque_ap(new Address()) { + : m_opaque_up(new Address()) { if (lldb_object_ptr) ref() = *lldb_object_ptr; } -SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_ap(new Address()) { +SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) { if (rhs.IsValid()) ref() = rhs.ref(); } SBAddress::SBAddress(lldb::SBSection section, lldb::addr_t offset) - : m_opaque_ap(new Address(section.GetSP(), offset)) {} + : m_opaque_up(new Address(section.GetSP(), offset)) {} // Create an address by resolving a load address using the supplied target SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target) - : m_opaque_ap(new Address()) { + : m_opaque_up(new Address()) { SetLoadAddress(load_addr, target); } @@ -49,7 +49,7 @@ const SBAddress &SBAddress::operator=(const SBAddress &rhs) { if (rhs.IsValid()) ref() = rhs.ref(); else - m_opaque_ap.reset(new Address()); + m_opaque_up.reset(new Address()); } return *this; } @@ -61,10 +61,10 @@ bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) { } bool SBAddress::IsValid() const { - return m_opaque_ap != NULL && m_opaque_ap->IsValid(); + return m_opaque_up != NULL && m_opaque_up->IsValid(); } -void SBAddress::Clear() { m_opaque_ap.reset(new Address()); } +void SBAddress::Clear() { m_opaque_up.reset(new Address()); } void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) { Address &addr = ref(); @@ -76,12 +76,12 @@ void SBAddress::SetAddress(const Address *lldb_object_ptr) { if (lldb_object_ptr) ref() = *lldb_object_ptr; else - m_opaque_ap.reset(new Address()); + m_opaque_up.reset(new Address()); } lldb::addr_t SBAddress::GetFileAddress() const { - if (m_opaque_ap->IsValid()) - return m_opaque_ap->GetFileAddress(); + if (m_opaque_up->IsValid()) + return m_opaque_up->GetFileAddress(); else return LLDB_INVALID_ADDRESS; } @@ -92,9 +92,9 @@ lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const { lldb::addr_t addr = LLDB_INVALID_ADDRESS; TargetSP target_sp(target.GetSP()); if (target_sp) { - if (m_opaque_ap->IsValid()) { + if (m_opaque_up->IsValid()) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - addr = m_opaque_ap->GetLoadAddress(target_sp.get()); + addr = m_opaque_up->GetLoadAddress(target_sp.get()); } } @@ -117,20 +117,20 @@ void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) { if (target.IsValid()) *this = target.ResolveLoadAddress(load_addr); else - m_opaque_ap->Clear(); + m_opaque_up->Clear(); // Check if we weren't were able to resolve a section offset address. If we // weren't it is ok, the load address might be a location on the stack or // heap, so we should just have an address with no section and a valid offset - if (!m_opaque_ap->IsValid()) - m_opaque_ap->SetOffset(load_addr); + if (!m_opaque_up->IsValid()) + m_opaque_up->SetOffset(load_addr); } bool SBAddress::OffsetAddress(addr_t offset) { - if (m_opaque_ap->IsValid()) { - addr_t addr_offset = m_opaque_ap->GetOffset(); + if (m_opaque_up->IsValid()) { + addr_t addr_offset = m_opaque_up->GetOffset(); if (addr_offset != LLDB_INVALID_ADDRESS) { - m_opaque_ap->SetOffset(addr_offset + offset); + m_opaque_up->SetOffset(addr_offset + offset); return true; } } @@ -139,45 +139,45 @@ bool SBAddress::OffsetAddress(addr_t offset) { lldb::SBSection SBAddress::GetSection() { lldb::SBSection sb_section; - if (m_opaque_ap->IsValid()) - sb_section.SetSP(m_opaque_ap->GetSection()); + if (m_opaque_up->IsValid()) + sb_section.SetSP(m_opaque_up->GetSection()); return sb_section; } lldb::addr_t SBAddress::GetOffset() { - if (m_opaque_ap->IsValid()) - return m_opaque_ap->GetOffset(); + if (m_opaque_up->IsValid()) + return m_opaque_up->GetOffset(); return 0; } -Address *SBAddress::operator->() { return m_opaque_ap.get(); } +Address *SBAddress::operator->() { return m_opaque_up.get(); } -const Address *SBAddress::operator->() const { return m_opaque_ap.get(); } +const Address *SBAddress::operator->() const { return m_opaque_up.get(); } Address &SBAddress::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new Address()); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new Address()); + return *m_opaque_up; } const Address &SBAddress::ref() const { // This object should already have checked with "IsValid()" prior to calling // this function. In case you didn't we will assert and die to let you know. - assert(m_opaque_ap.get()); - return *m_opaque_ap; + assert(m_opaque_up.get()); + return *m_opaque_up; } -Address *SBAddress::get() { return m_opaque_ap.get(); } +Address *SBAddress::get() { return m_opaque_up.get(); } bool SBAddress::GetDescription(SBStream &description) { // Call "ref()" on the stream to make sure it creates a backing stream in // case there isn't one already... Stream &strm = description.ref(); - if (m_opaque_ap->IsValid()) { - m_opaque_ap->Dump(&strm, NULL, Address::DumpStyleResolvedDescription, + if (m_opaque_up->IsValid()) { + m_opaque_up->Dump(&strm, NULL, Address::DumpStyleResolvedDescription, Address::DumpStyleModuleWithFileAddress, 4); StreamString sstrm; - // m_opaque_ap->Dump (&sstrm, NULL, + // m_opaque_up->Dump (&sstrm, NULL, // Address::DumpStyleResolvedDescription, Address::DumpStyleInvalid, // 4); // if (sstrm.GetData()) @@ -190,52 +190,52 @@ bool SBAddress::GetDescription(SBStream &description) { SBModule SBAddress::GetModule() { SBModule sb_module; - if (m_opaque_ap->IsValid()) - sb_module.SetSP(m_opaque_ap->GetModule()); + if (m_opaque_up->IsValid()) + sb_module.SetSP(m_opaque_up->GetModule()); return sb_module; } SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) { SBSymbolContext sb_sc; SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope); - if (m_opaque_ap->IsValid()) - m_opaque_ap->CalculateSymbolContext(&sb_sc.ref(), scope); + if (m_opaque_up->IsValid()) + m_opaque_up->CalculateSymbolContext(&sb_sc.ref(), scope); return sb_sc; } SBCompileUnit SBAddress::GetCompileUnit() { SBCompileUnit sb_comp_unit; - if (m_opaque_ap->IsValid()) - sb_comp_unit.reset(m_opaque_ap->CalculateSymbolContextCompileUnit()); + if (m_opaque_up->IsValid()) + sb_comp_unit.reset(m_opaque_up->CalculateSymbolContextCompileUnit()); return sb_comp_unit; } SBFunction SBAddress::GetFunction() { SBFunction sb_function; - if (m_opaque_ap->IsValid()) - sb_function.reset(m_opaque_ap->CalculateSymbolContextFunction()); + if (m_opaque_up->IsValid()) + sb_function.reset(m_opaque_up->CalculateSymbolContextFunction()); return sb_function; } SBBlock SBAddress::GetBlock() { SBBlock sb_block; - if (m_opaque_ap->IsValid()) - sb_block.SetPtr(m_opaque_ap->CalculateSymbolContextBlock()); + if (m_opaque_up->IsValid()) + sb_block.SetPtr(m_opaque_up->CalculateSymbolContextBlock()); return sb_block; } SBSymbol SBAddress::GetSymbol() { SBSymbol sb_symbol; - if (m_opaque_ap->IsValid()) - sb_symbol.reset(m_opaque_ap->CalculateSymbolContextSymbol()); + if (m_opaque_up->IsValid()) + sb_symbol.reset(m_opaque_up->CalculateSymbolContextSymbol()); return sb_symbol; } SBLineEntry SBAddress::GetLineEntry() { SBLineEntry sb_line_entry; - if (m_opaque_ap->IsValid()) { + if (m_opaque_up->IsValid()) { LineEntry line_entry; - if (m_opaque_ap->CalculateSymbolContextLineEntry(line_entry)) + if (m_opaque_up->CalculateSymbolContextLineEntry(line_entry)) sb_line_entry.SetLineEntry(line_entry); } return sb_line_entry; diff --git a/source/API/SBCommandReturnObject.cpp b/source/API/SBCommandReturnObject.cpp index 6d7fae12e..4c28dc3d0 100644 --- a/source/API/SBCommandReturnObject.cpp +++ b/source/API/SBCommandReturnObject.cpp @@ -19,53 +19,53 @@ using namespace lldb; using namespace lldb_private; SBCommandReturnObject::SBCommandReturnObject() - : m_opaque_ap(new CommandReturnObject()) {} + : m_opaque_up(new CommandReturnObject()) {} SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs) - : m_opaque_ap() { - if (rhs.m_opaque_ap) - m_opaque_ap.reset(new CommandReturnObject(*rhs.m_opaque_ap)); + : m_opaque_up() { + if (rhs.m_opaque_up) + m_opaque_up.reset(new CommandReturnObject(*rhs.m_opaque_up)); } SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject *ptr) - : m_opaque_ap(ptr) {} + : m_opaque_up(ptr) {} SBCommandReturnObject::~SBCommandReturnObject() = default; CommandReturnObject *SBCommandReturnObject::Release() { - return m_opaque_ap.release(); + return m_opaque_up.release(); } const SBCommandReturnObject &SBCommandReturnObject:: operator=(const SBCommandReturnObject &rhs) { if (this != &rhs) { - if (rhs.m_opaque_ap) - m_opaque_ap.reset(new CommandReturnObject(*rhs.m_opaque_ap)); + if (rhs.m_opaque_up) + m_opaque_up.reset(new CommandReturnObject(*rhs.m_opaque_up)); else - m_opaque_ap.reset(); + m_opaque_up.reset(); } return *this; } -bool SBCommandReturnObject::IsValid() const { return m_opaque_ap != nullptr; } +bool SBCommandReturnObject::IsValid() const { return m_opaque_up != nullptr; } const char *SBCommandReturnObject::GetOutput() { Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (m_opaque_ap) { - llvm::StringRef output = m_opaque_ap->GetOutputData(); + if (m_opaque_up) { + llvm::StringRef output = m_opaque_up->GetOutputData(); ConstString result(output.empty() ? llvm::StringRef("") : output); if (log) log->Printf("SBCommandReturnObject(%p)::GetOutput () => \"%s\"", - static_cast<void *>(m_opaque_ap.get()), result.AsCString()); + static_cast<void *>(m_opaque_up.get()), result.AsCString()); return result.AsCString(); } if (log) log->Printf("SBCommandReturnObject(%p)::GetOutput () => nullptr", - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(m_opaque_up.get())); return nullptr; } @@ -73,29 +73,29 @@ const char *SBCommandReturnObject::GetOutput() { const char *SBCommandReturnObject::GetError() { Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (m_opaque_ap) { - llvm::StringRef output = m_opaque_ap->GetErrorData(); + if (m_opaque_up) { + llvm::StringRef output = m_opaque_up->GetErrorData(); ConstString result(output.empty() ? llvm::StringRef("") : output); if (log) log->Printf("SBCommandReturnObject(%p)::GetError () => \"%s\"", - static_cast<void *>(m_opaque_ap.get()), result.AsCString()); + static_cast<void *>(m_opaque_up.get()), result.AsCString()); return result.AsCString(); } if (log) log->Printf("SBCommandReturnObject(%p)::GetError () => nullptr", - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(m_opaque_up.get())); return nullptr; } size_t SBCommandReturnObject::GetOutputSize() { - return (m_opaque_ap ? m_opaque_ap->GetOutputData().size() : 0); + return (m_opaque_up ? m_opaque_up->GetOutputData().size() : 0); } size_t SBCommandReturnObject::GetErrorSize() { - return (m_opaque_ap ? m_opaque_ap->GetErrorData().size() : 0); + return (m_opaque_up ? m_opaque_up->GetErrorData().size() : 0); } size_t SBCommandReturnObject::PutOutput(FILE *fh) { @@ -117,71 +117,71 @@ size_t SBCommandReturnObject::PutError(FILE *fh) { } void SBCommandReturnObject::Clear() { - if (m_opaque_ap) - m_opaque_ap->Clear(); + if (m_opaque_up) + m_opaque_up->Clear(); } lldb::ReturnStatus SBCommandReturnObject::GetStatus() { - return (m_opaque_ap ? m_opaque_ap->GetStatus() : lldb::eReturnStatusInvalid); + return (m_opaque_up ? m_opaque_up->GetStatus() : lldb::eReturnStatusInvalid); } void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) { - if (m_opaque_ap) - m_opaque_ap->SetStatus(status); + if (m_opaque_up) + m_opaque_up->SetStatus(status); } bool SBCommandReturnObject::Succeeded() { - return (m_opaque_ap ? m_opaque_ap->Succeeded() : false); + return (m_opaque_up ? m_opaque_up->Succeeded() : false); } bool SBCommandReturnObject::HasResult() { - return (m_opaque_ap ? m_opaque_ap->HasResult() : false); + return (m_opaque_up ? m_opaque_up->HasResult() : false); } void SBCommandReturnObject::AppendMessage(const char *message) { - if (m_opaque_ap) - m_opaque_ap->AppendMessage(message); + if (m_opaque_up) + m_opaque_up->AppendMessage(message); } void SBCommandReturnObject::AppendWarning(const char *message) { - if (m_opaque_ap) - m_opaque_ap->AppendWarning(message); + if (m_opaque_up) + m_opaque_up->AppendWarning(message); } CommandReturnObject *SBCommandReturnObject::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } CommandReturnObject *SBCommandReturnObject::get() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } CommandReturnObject &SBCommandReturnObject::operator*() const { - assert(m_opaque_ap.get()); - return *(m_opaque_ap.get()); + assert(m_opaque_up.get()); + return *(m_opaque_up.get()); } CommandReturnObject &SBCommandReturnObject::ref() const { - assert(m_opaque_ap.get()); - return *(m_opaque_ap.get()); + assert(m_opaque_up.get()); + return *(m_opaque_up.get()); } void SBCommandReturnObject::SetLLDBObjectPtr(CommandReturnObject *ptr) { - if (m_opaque_ap) - m_opaque_ap.reset(ptr); + if (m_opaque_up) + m_opaque_up.reset(ptr); } bool SBCommandReturnObject::GetDescription(SBStream &description) { Stream &strm = description.ref(); - if (m_opaque_ap) { + if (m_opaque_up) { description.Printf("Error: "); - lldb::ReturnStatus status = m_opaque_ap->GetStatus(); + lldb::ReturnStatus status = m_opaque_up->GetStatus(); if (status == lldb::eReturnStatusStarted) strm.PutCString("Started"); else if (status == lldb::eReturnStatusInvalid) strm.PutCString("Invalid"); - else if (m_opaque_ap->Succeeded()) + else if (m_opaque_up->Succeeded()) strm.PutCString("Success"); else strm.PutCString("Fail"); @@ -207,51 +207,51 @@ void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) { void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh, bool transfer_ownership) { - if (m_opaque_ap) - m_opaque_ap->SetImmediateOutputFile(fh, transfer_ownership); + if (m_opaque_up) + m_opaque_up->SetImmediateOutputFile(fh, transfer_ownership); } void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh, bool transfer_ownership) { - if (m_opaque_ap) - m_opaque_ap->SetImmediateErrorFile(fh, transfer_ownership); + if (m_opaque_up) + m_opaque_up->SetImmediateErrorFile(fh, transfer_ownership); } void SBCommandReturnObject::PutCString(const char *string, int len) { - if (m_opaque_ap) { + if (m_opaque_up) { if (len == 0 || string == nullptr || *string == 0) { return; } else if (len > 0) { std::string buffer(string, len); - m_opaque_ap->AppendMessage(buffer.c_str()); + m_opaque_up->AppendMessage(buffer.c_str()); } else - m_opaque_ap->AppendMessage(string); + m_opaque_up->AppendMessage(string); } } const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) { - if (!m_opaque_ap) + if (!m_opaque_up) return nullptr; if (!only_if_no_immediate || - m_opaque_ap->GetImmediateOutputStream().get() == nullptr) + m_opaque_up->GetImmediateOutputStream().get() == nullptr) return GetOutput(); return nullptr; } const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) { - if (!m_opaque_ap) + if (!m_opaque_up) return nullptr; if (!only_if_no_immediate || - m_opaque_ap->GetImmediateErrorStream().get() == nullptr) + m_opaque_up->GetImmediateErrorStream().get() == nullptr) return GetError(); return nullptr; } size_t SBCommandReturnObject::Printf(const char *format, ...) { - if (m_opaque_ap) { + if (m_opaque_up) { va_list args; va_start(args, format); - size_t result = m_opaque_ap->GetOutputStream().PrintfVarArg(format, args); + size_t result = m_opaque_up->GetOutputStream().PrintfVarArg(format, args); va_end(args); return result; } @@ -260,15 +260,15 @@ size_t SBCommandReturnObject::Printf(const char *format, ...) { void SBCommandReturnObject::SetError(lldb::SBError &error, const char *fallback_error_cstr) { - if (m_opaque_ap) { + if (m_opaque_up) { if (error.IsValid()) - m_opaque_ap->SetError(error.ref(), fallback_error_cstr); + m_opaque_up->SetError(error.ref(), fallback_error_cstr); else if (fallback_error_cstr) - m_opaque_ap->SetError(Status(), fallback_error_cstr); + m_opaque_up->SetError(Status(), fallback_error_cstr); } } void SBCommandReturnObject::SetError(const char *error_cstr) { - if (m_opaque_ap && error_cstr) - m_opaque_ap->SetError(error_cstr); + if (m_opaque_up && error_cstr) + m_opaque_up->SetError(error_cstr); } diff --git a/source/API/SBCompileUnit.cpp b/source/API/SBCompileUnit.cpp index 17623af09..ef7d4c1d3 100644 --- a/source/API/SBCompileUnit.cpp +++ b/source/API/SBCompileUnit.cpp @@ -148,7 +148,7 @@ lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) { TypeClass type_class = static_cast<TypeClass>(type_mask); TypeList type_list; vendor->GetTypes(m_opaque_ptr, type_class, type_list); - sb_type_list.m_opaque_ap->Append(type_list); + sb_type_list.m_opaque_up->Append(type_list); return sb_type_list; } diff --git a/source/API/SBDeclaration.cpp b/source/API/SBDeclaration.cpp index a943c2cd8..db1ec5e55 100644 --- a/source/API/SBDeclaration.cpp +++ b/source/API/SBDeclaration.cpp @@ -18,15 +18,15 @@ using namespace lldb; using namespace lldb_private; -SBDeclaration::SBDeclaration() : m_opaque_ap() {} +SBDeclaration::SBDeclaration() : m_opaque_up() {} -SBDeclaration::SBDeclaration(const SBDeclaration &rhs) : m_opaque_ap() { +SBDeclaration::SBDeclaration(const SBDeclaration &rhs) : m_opaque_up() { if (rhs.IsValid()) ref() = rhs.ref(); } SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr) - : m_opaque_ap() { + : m_opaque_up() { if (lldb_object_ptr) ref() = *lldb_object_ptr; } @@ -36,7 +36,7 @@ const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) { if (rhs.IsValid()) ref() = rhs.ref(); else - m_opaque_ap.reset(); + m_opaque_up.reset(); } return *this; } @@ -49,21 +49,21 @@ void SBDeclaration::SetDeclaration( SBDeclaration::~SBDeclaration() {} bool SBDeclaration::IsValid() const { - return m_opaque_ap.get() && m_opaque_ap->IsValid(); + return m_opaque_up.get() && m_opaque_up->IsValid(); } SBFileSpec SBDeclaration::GetFileSpec() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFileSpec sb_file_spec; - if (m_opaque_ap.get() && m_opaque_ap->GetFile()) - sb_file_spec.SetFileSpec(m_opaque_ap->GetFile()); + if (m_opaque_up.get() && m_opaque_up->GetFile()) + sb_file_spec.SetFileSpec(m_opaque_up->GetFile()); if (log) { SBStream sstr; sb_file_spec.GetDescription(sstr); log->Printf("SBLineEntry(%p)::GetFileSpec () => SBFileSpec(%p): %s", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<const void *>(sb_file_spec.get()), sstr.GetData()); } @@ -74,19 +74,19 @@ uint32_t SBDeclaration::GetLine() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t line = 0; - if (m_opaque_ap) - line = m_opaque_ap->GetLine(); + if (m_opaque_up) + line = m_opaque_up->GetLine(); if (log) log->Printf("SBLineEntry(%p)::GetLine () => %u", - static_cast<void *>(m_opaque_ap.get()), line); + static_cast<void *>(m_opaque_up.get()), line); return line; } uint32_t SBDeclaration::GetColumn() const { - if (m_opaque_ap) - return m_opaque_ap->GetColumn(); + if (m_opaque_up) + return m_opaque_up->GetColumn(); return 0; } @@ -101,8 +101,8 @@ void SBDeclaration::SetLine(uint32_t line) { ref().SetLine(line); } void SBDeclaration::SetColumn(uint32_t column) { ref().SetColumn(column); } bool SBDeclaration::operator==(const SBDeclaration &rhs) const { - lldb_private::Declaration *lhs_ptr = m_opaque_ap.get(); - lldb_private::Declaration *rhs_ptr = rhs.m_opaque_ap.get(); + lldb_private::Declaration *lhs_ptr = m_opaque_up.get(); + lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get(); if (lhs_ptr && rhs_ptr) return lldb_private::Declaration::Compare(*lhs_ptr, *rhs_ptr) == 0; @@ -111,8 +111,8 @@ bool SBDeclaration::operator==(const SBDeclaration &rhs) const { } bool SBDeclaration::operator!=(const SBDeclaration &rhs) const { - lldb_private::Declaration *lhs_ptr = m_opaque_ap.get(); - lldb_private::Declaration *rhs_ptr = rhs.m_opaque_ap.get(); + lldb_private::Declaration *lhs_ptr = m_opaque_up.get(); + lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get(); if (lhs_ptr && rhs_ptr) return lldb_private::Declaration::Compare(*lhs_ptr, *rhs_ptr) != 0; @@ -121,25 +121,25 @@ bool SBDeclaration::operator!=(const SBDeclaration &rhs) const { } const lldb_private::Declaration *SBDeclaration::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } lldb_private::Declaration &SBDeclaration::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new lldb_private::Declaration()); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new lldb_private::Declaration()); + return *m_opaque_up; } const lldb_private::Declaration &SBDeclaration::ref() const { - return *m_opaque_ap; + return *m_opaque_up; } bool SBDeclaration::GetDescription(SBStream &description) { Stream &strm = description.ref(); - if (m_opaque_ap) { + if (m_opaque_up) { char file_path[PATH_MAX * 2]; - m_opaque_ap->GetFile().GetPath(file_path, sizeof(file_path)); + m_opaque_up->GetFile().GetPath(file_path, sizeof(file_path)); strm.Printf("%s:%u", file_path, GetLine()); if (GetColumn() > 0) strm.Printf(":%u", GetColumn()); @@ -149,4 +149,4 @@ bool SBDeclaration::GetDescription(SBStream &description) { return true; } -lldb_private::Declaration *SBDeclaration::get() { return m_opaque_ap.get(); } +lldb_private::Declaration *SBDeclaration::get() { return m_opaque_up.get(); } diff --git a/source/API/SBError.cpp b/source/API/SBError.cpp index 5220ac4d3..2eca54639 100644 --- a/source/API/SBError.cpp +++ b/source/API/SBError.cpp @@ -16,48 +16,48 @@ using namespace lldb; using namespace lldb_private; -SBError::SBError() : m_opaque_ap() {} +SBError::SBError() : m_opaque_up() {} -SBError::SBError(const SBError &rhs) : m_opaque_ap() { +SBError::SBError(const SBError &rhs) : m_opaque_up() { if (rhs.IsValid()) - m_opaque_ap.reset(new Status(*rhs)); + m_opaque_up.reset(new Status(*rhs)); } SBError::~SBError() {} const SBError &SBError::operator=(const SBError &rhs) { if (rhs.IsValid()) { - if (m_opaque_ap) - *m_opaque_ap = *rhs; + if (m_opaque_up) + *m_opaque_up = *rhs; else - m_opaque_ap.reset(new Status(*rhs)); + m_opaque_up.reset(new Status(*rhs)); } else - m_opaque_ap.reset(); + m_opaque_up.reset(); return *this; } const char *SBError::GetCString() const { - if (m_opaque_ap) - return m_opaque_ap->AsCString(); + if (m_opaque_up) + return m_opaque_up->AsCString(); return NULL; } void SBError::Clear() { - if (m_opaque_ap) - m_opaque_ap->Clear(); + if (m_opaque_up) + m_opaque_up->Clear(); } bool SBError::Fail() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool ret_value = false; - if (m_opaque_ap) - ret_value = m_opaque_ap->Fail(); + if (m_opaque_up) + ret_value = m_opaque_up->Fail(); if (log) log->Printf("SBError(%p)::Fail () => %i", - static_cast<void *>(m_opaque_ap.get()), ret_value); + static_cast<void *>(m_opaque_up.get()), ret_value); return ret_value; } @@ -65,12 +65,12 @@ bool SBError::Fail() const { bool SBError::Success() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool ret_value = true; - if (m_opaque_ap) - ret_value = m_opaque_ap->Success(); + if (m_opaque_up) + ret_value = m_opaque_up->Success(); if (log) log->Printf("SBError(%p)::Success () => %i", - static_cast<void *>(m_opaque_ap.get()), ret_value); + static_cast<void *>(m_opaque_up.get()), ret_value); return ret_value; } @@ -79,12 +79,12 @@ uint32_t SBError::GetError() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t err = 0; - if (m_opaque_ap) - err = m_opaque_ap->GetError(); + if (m_opaque_up) + err = m_opaque_up->GetError(); if (log) log->Printf("SBError(%p)::GetError () => 0x%8.8x", - static_cast<void *>(m_opaque_ap.get()), err); + static_cast<void *>(m_opaque_up.get()), err); return err; } @@ -92,74 +92,74 @@ uint32_t SBError::GetError() const { ErrorType SBError::GetType() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ErrorType err_type = eErrorTypeInvalid; - if (m_opaque_ap) - err_type = m_opaque_ap->GetType(); + if (m_opaque_up) + err_type = m_opaque_up->GetType(); if (log) log->Printf("SBError(%p)::GetType () => %i", - static_cast<void *>(m_opaque_ap.get()), err_type); + static_cast<void *>(m_opaque_up.get()), err_type); return err_type; } void SBError::SetError(uint32_t err, ErrorType type) { CreateIfNeeded(); - m_opaque_ap->SetError(err, type); + m_opaque_up->SetError(err, type); } void SBError::SetError(const Status &lldb_error) { CreateIfNeeded(); - *m_opaque_ap = lldb_error; + *m_opaque_up = lldb_error; } void SBError::SetErrorToErrno() { CreateIfNeeded(); - m_opaque_ap->SetErrorToErrno(); + m_opaque_up->SetErrorToErrno(); } void SBError::SetErrorToGenericError() { CreateIfNeeded(); - m_opaque_ap->SetErrorToErrno(); + m_opaque_up->SetErrorToErrno(); } void SBError::SetErrorString(const char *err_str) { CreateIfNeeded(); - m_opaque_ap->SetErrorString(err_str); + m_opaque_up->SetErrorString(err_str); } int SBError::SetErrorStringWithFormat(const char *format, ...) { CreateIfNeeded(); va_list args; va_start(args, format); - int num_chars = m_opaque_ap->SetErrorStringWithVarArg(format, args); + int num_chars = m_opaque_up->SetErrorStringWithVarArg(format, args); va_end(args); return num_chars; } -bool SBError::IsValid() const { return m_opaque_ap != NULL; } +bool SBError::IsValid() const { return m_opaque_up != NULL; } void SBError::CreateIfNeeded() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new Status()); + if (m_opaque_up == NULL) + m_opaque_up.reset(new Status()); } -lldb_private::Status *SBError::operator->() { return m_opaque_ap.get(); } +lldb_private::Status *SBError::operator->() { return m_opaque_up.get(); } -lldb_private::Status *SBError::get() { return m_opaque_ap.get(); } +lldb_private::Status *SBError::get() { return m_opaque_up.get(); } lldb_private::Status &SBError::ref() { CreateIfNeeded(); - return *m_opaque_ap; + return *m_opaque_up; } const lldb_private::Status &SBError::operator*() const { // Be sure to call "IsValid()" before calling this function or it will crash - return *m_opaque_ap; + return *m_opaque_up; } bool SBError::GetDescription(SBStream &description) { - if (m_opaque_ap) { - if (m_opaque_ap->Success()) + if (m_opaque_up) { + if (m_opaque_up->Success()) description.Printf("success"); else { const char *err_string = GetCString(); diff --git a/source/API/SBExpressionOptions.cpp b/source/API/SBExpressionOptions.cpp index eabf23bb4..1b83713af 100644 --- a/source/API/SBExpressionOptions.cpp +++ b/source/API/SBExpressionOptions.cpp @@ -16,11 +16,11 @@ using namespace lldb; using namespace lldb_private; SBExpressionOptions::SBExpressionOptions() - : m_opaque_ap(new EvaluateExpressionOptions()) {} + : m_opaque_up(new EvaluateExpressionOptions()) {} SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs) { - m_opaque_ap.reset(new EvaluateExpressionOptions()); - *(m_opaque_ap.get()) = rhs.ref(); + m_opaque_up.reset(new EvaluateExpressionOptions()); + *(m_opaque_up.get()) = rhs.ref(); } const SBExpressionOptions &SBExpressionOptions:: @@ -34,143 +34,145 @@ operator=(const SBExpressionOptions &rhs) { SBExpressionOptions::~SBExpressionOptions() {} bool SBExpressionOptions::GetCoerceResultToId() const { - return m_opaque_ap->DoesCoerceToId(); + return m_opaque_up->DoesCoerceToId(); } void SBExpressionOptions::SetCoerceResultToId(bool coerce) { - m_opaque_ap->SetCoerceToId(coerce); + m_opaque_up->SetCoerceToId(coerce); } bool SBExpressionOptions::GetUnwindOnError() const { - return m_opaque_ap->DoesUnwindOnError(); + return m_opaque_up->DoesUnwindOnError(); } void SBExpressionOptions::SetUnwindOnError(bool unwind) { - m_opaque_ap->SetUnwindOnError(unwind); + m_opaque_up->SetUnwindOnError(unwind); } bool SBExpressionOptions::GetIgnoreBreakpoints() const { - return m_opaque_ap->DoesIgnoreBreakpoints(); + return m_opaque_up->DoesIgnoreBreakpoints(); } void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) { - m_opaque_ap->SetIgnoreBreakpoints(ignore); + m_opaque_up->SetIgnoreBreakpoints(ignore); } lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const { - return m_opaque_ap->GetUseDynamic(); + return m_opaque_up->GetUseDynamic(); } void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) { - m_opaque_ap->SetUseDynamic(dynamic); + m_opaque_up->SetUseDynamic(dynamic); } uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const { - return m_opaque_ap->GetTimeout() ? m_opaque_ap->GetTimeout()->count() : 0; + return m_opaque_up->GetTimeout() ? m_opaque_up->GetTimeout()->count() : 0; } void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) { - m_opaque_ap->SetTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None) + m_opaque_up->SetTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None) : std::chrono::microseconds(timeout)); } uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const { - return m_opaque_ap->GetOneThreadTimeout() ? m_opaque_ap->GetOneThreadTimeout()->count() : 0; + return m_opaque_up->GetOneThreadTimeout() + ? m_opaque_up->GetOneThreadTimeout()->count() + : 0; } void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) { - m_opaque_ap->SetOneThreadTimeout(timeout == 0 + m_opaque_up->SetOneThreadTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None) : std::chrono::microseconds(timeout)); } bool SBExpressionOptions::GetTryAllThreads() const { - return m_opaque_ap->GetTryAllThreads(); + return m_opaque_up->GetTryAllThreads(); } void SBExpressionOptions::SetTryAllThreads(bool run_others) { - m_opaque_ap->SetTryAllThreads(run_others); + m_opaque_up->SetTryAllThreads(run_others); } bool SBExpressionOptions::GetStopOthers() const { - return m_opaque_ap->GetStopOthers(); + return m_opaque_up->GetStopOthers(); } void SBExpressionOptions::SetStopOthers(bool run_others) { - m_opaque_ap->SetStopOthers(run_others); + m_opaque_up->SetStopOthers(run_others); } bool SBExpressionOptions::GetTrapExceptions() const { - return m_opaque_ap->GetTrapExceptions(); + return m_opaque_up->GetTrapExceptions(); } void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) { - m_opaque_ap->SetTrapExceptions(trap_exceptions); + m_opaque_up->SetTrapExceptions(trap_exceptions); } void SBExpressionOptions::SetLanguage(lldb::LanguageType language) { - m_opaque_ap->SetLanguage(language); + m_opaque_up->SetLanguage(language); } void SBExpressionOptions::SetCancelCallback( lldb::ExpressionCancelCallback callback, void *baton) { - m_opaque_ap->SetCancelCallback(callback, baton); + m_opaque_up->SetCancelCallback(callback, baton); } bool SBExpressionOptions::GetGenerateDebugInfo() { - return m_opaque_ap->GetGenerateDebugInfo(); + return m_opaque_up->GetGenerateDebugInfo(); } void SBExpressionOptions::SetGenerateDebugInfo(bool b) { - return m_opaque_ap->SetGenerateDebugInfo(b); + return m_opaque_up->SetGenerateDebugInfo(b); } bool SBExpressionOptions::GetSuppressPersistentResult() { - return m_opaque_ap->GetResultIsInternal(); + return m_opaque_up->GetResultIsInternal(); } void SBExpressionOptions::SetSuppressPersistentResult(bool b) { - return m_opaque_ap->SetResultIsInternal(b); + return m_opaque_up->SetResultIsInternal(b); } const char *SBExpressionOptions::GetPrefix() const { - return m_opaque_ap->GetPrefix(); + return m_opaque_up->GetPrefix(); } void SBExpressionOptions::SetPrefix(const char *prefix) { - return m_opaque_ap->SetPrefix(prefix); + return m_opaque_up->SetPrefix(prefix); } bool SBExpressionOptions::GetAutoApplyFixIts() { - return m_opaque_ap->GetAutoApplyFixIts(); + return m_opaque_up->GetAutoApplyFixIts(); } void SBExpressionOptions::SetAutoApplyFixIts(bool b) { - return m_opaque_ap->SetAutoApplyFixIts(b); + return m_opaque_up->SetAutoApplyFixIts(b); } bool SBExpressionOptions::GetTopLevel() { - return m_opaque_ap->GetExecutionPolicy() == eExecutionPolicyTopLevel; + return m_opaque_up->GetExecutionPolicy() == eExecutionPolicyTopLevel; } void SBExpressionOptions::SetTopLevel(bool b) { - m_opaque_ap->SetExecutionPolicy(b ? eExecutionPolicyTopLevel - : m_opaque_ap->default_execution_policy); + m_opaque_up->SetExecutionPolicy(b ? eExecutionPolicyTopLevel + : m_opaque_up->default_execution_policy); } bool SBExpressionOptions::GetAllowJIT() { - return m_opaque_ap->GetExecutionPolicy() != eExecutionPolicyNever; + return m_opaque_up->GetExecutionPolicy() != eExecutionPolicyNever; } void SBExpressionOptions::SetAllowJIT(bool allow) { - m_opaque_ap->SetExecutionPolicy(allow ? m_opaque_ap->default_execution_policy - : eExecutionPolicyNever); + m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy + : eExecutionPolicyNever); } EvaluateExpressionOptions *SBExpressionOptions::get() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } EvaluateExpressionOptions &SBExpressionOptions::ref() const { - return *(m_opaque_ap.get()); + return *(m_opaque_up.get()); } diff --git a/source/API/SBFileSpec.cpp b/source/API/SBFileSpec.cpp index 6ce105d42..e606d6f7b 100644 --- a/source/API/SBFileSpec.cpp +++ b/source/API/SBFileSpec.cpp @@ -22,50 +22,50 @@ using namespace lldb; using namespace lldb_private; -SBFileSpec::SBFileSpec() : m_opaque_ap(new lldb_private::FileSpec()) {} +SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) {} SBFileSpec::SBFileSpec(const SBFileSpec &rhs) - : m_opaque_ap(new lldb_private::FileSpec(*rhs.m_opaque_ap)) {} + : m_opaque_up(new lldb_private::FileSpec(*rhs.m_opaque_up)) {} SBFileSpec::SBFileSpec(const lldb_private::FileSpec &fspec) - : m_opaque_ap(new lldb_private::FileSpec(fspec)) {} + : m_opaque_up(new lldb_private::FileSpec(fspec)) {} // Deprecated!!! -SBFileSpec::SBFileSpec(const char *path) : m_opaque_ap(new FileSpec(path)) { - FileSystem::Instance().Resolve(*m_opaque_ap); +SBFileSpec::SBFileSpec(const char *path) : m_opaque_up(new FileSpec(path)) { + FileSystem::Instance().Resolve(*m_opaque_up); } SBFileSpec::SBFileSpec(const char *path, bool resolve) - : m_opaque_ap(new FileSpec(path)) { + : m_opaque_up(new FileSpec(path)) { if (resolve) - FileSystem::Instance().Resolve(*m_opaque_ap); + FileSystem::Instance().Resolve(*m_opaque_up); } SBFileSpec::~SBFileSpec() {} const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) { if (this != &rhs) - *m_opaque_ap = *rhs.m_opaque_ap; + *m_opaque_up = *rhs.m_opaque_up; return *this; } -bool SBFileSpec::IsValid() const { return m_opaque_ap->operator bool(); } +bool SBFileSpec::IsValid() const { return m_opaque_up->operator bool(); } bool SBFileSpec::Exists() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - bool result = FileSystem::Instance().Exists(*m_opaque_ap); + bool result = FileSystem::Instance().Exists(*m_opaque_up); if (log) log->Printf("SBFileSpec(%p)::Exists () => %s", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), (result ? "true" : "false")); return result; } bool SBFileSpec::ResolveExecutableLocation() { - return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_ap); + return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_up); } int SBFileSpec::ResolvePath(const char *src_path, char *dst_path, @@ -77,60 +77,60 @@ int SBFileSpec::ResolvePath(const char *src_path, char *dst_path, } const char *SBFileSpec::GetFilename() const { - const char *s = m_opaque_ap->GetFilename().AsCString(); + const char *s = m_opaque_up->GetFilename().AsCString(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { if (s) log->Printf("SBFileSpec(%p)::GetFilename () => \"%s\"", - static_cast<void *>(m_opaque_ap.get()), s); + static_cast<void *>(m_opaque_up.get()), s); else log->Printf("SBFileSpec(%p)::GetFilename () => NULL", - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(m_opaque_up.get())); } return s; } const char *SBFileSpec::GetDirectory() const { - FileSpec directory{*m_opaque_ap}; + FileSpec directory{*m_opaque_up}; directory.GetFilename().Clear(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { if (directory) log->Printf("SBFileSpec(%p)::GetDirectory () => \"%s\"", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), directory.GetCString()); else log->Printf("SBFileSpec(%p)::GetDirectory () => NULL", - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(m_opaque_up.get())); } return directory.GetCString(); } void SBFileSpec::SetFilename(const char *filename) { if (filename && filename[0]) - m_opaque_ap->GetFilename().SetCString(filename); + m_opaque_up->GetFilename().SetCString(filename); else - m_opaque_ap->GetFilename().Clear(); + m_opaque_up->GetFilename().Clear(); } void SBFileSpec::SetDirectory(const char *directory) { if (directory && directory[0]) - m_opaque_ap->GetDirectory().SetCString(directory); + m_opaque_up->GetDirectory().SetCString(directory); else - m_opaque_ap->GetDirectory().Clear(); + m_opaque_up->GetDirectory().Clear(); } uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - uint32_t result = m_opaque_ap->GetPath(dst_path, dst_len); + uint32_t result = m_opaque_up->GetPath(dst_path, dst_len); if (log) log->Printf("SBFileSpec(%p)::GetPath (dst_path=\"%.*s\", dst_len=%" PRIu64 ") => %u", - static_cast<void *>(m_opaque_ap.get()), result, dst_path, + static_cast<void *>(m_opaque_up.get()), result, dst_path, static_cast<uint64_t>(dst_len), result); if (result == 0 && dst_path && dst_len > 0) @@ -139,31 +139,31 @@ uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const { } const lldb_private::FileSpec *SBFileSpec::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::FileSpec *SBFileSpec::get() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::FileSpec &SBFileSpec::operator*() const { - return *m_opaque_ap; + return *m_opaque_up; } -const lldb_private::FileSpec &SBFileSpec::ref() const { return *m_opaque_ap; } +const lldb_private::FileSpec &SBFileSpec::ref() const { return *m_opaque_up; } void SBFileSpec::SetFileSpec(const lldb_private::FileSpec &fs) { - *m_opaque_ap = fs; + *m_opaque_up = fs; } bool SBFileSpec::GetDescription(SBStream &description) const { Stream &strm = description.ref(); char path[PATH_MAX]; - if (m_opaque_ap->GetPath(path, sizeof(path))) + if (m_opaque_up->GetPath(path, sizeof(path))) strm.PutCString(path); return true; } void SBFileSpec::AppendPathComponent(const char *fn) { - m_opaque_ap->AppendPathComponent(fn); + m_opaque_up->AppendPathComponent(fn); } diff --git a/source/API/SBFileSpecList.cpp b/source/API/SBFileSpecList.cpp index 4717f8883..35304fe17 100644 --- a/source/API/SBFileSpecList.cpp +++ b/source/API/SBFileSpecList.cpp @@ -20,19 +20,19 @@ using namespace lldb; using namespace lldb_private; -SBFileSpecList::SBFileSpecList() : m_opaque_ap(new FileSpecList()) {} +SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) {} -SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_ap() { +SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_up() { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (rhs.m_opaque_ap) - m_opaque_ap.reset(new FileSpecList(*(rhs.get()))); + if (rhs.m_opaque_up) + m_opaque_up.reset(new FileSpecList(*(rhs.get()))); if (log) { log->Printf("SBFileSpecList::SBFileSpecList (const SBFileSpecList " "rhs.ap=%p) => SBFileSpecList(%p)", - static_cast<void *>(rhs.m_opaque_ap.get()), - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(rhs.m_opaque_up.get()), + static_cast<void *>(m_opaque_up.get())); } } @@ -40,59 +40,59 @@ SBFileSpecList::~SBFileSpecList() {} const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) { if (this != &rhs) { - m_opaque_ap.reset(new lldb_private::FileSpecList(*(rhs.get()))); + m_opaque_up.reset(new lldb_private::FileSpecList(*(rhs.get()))); } return *this; } -uint32_t SBFileSpecList::GetSize() const { return m_opaque_ap->GetSize(); } +uint32_t SBFileSpecList::GetSize() const { return m_opaque_up->GetSize(); } void SBFileSpecList::Append(const SBFileSpec &sb_file) { - m_opaque_ap->Append(sb_file.ref()); + m_opaque_up->Append(sb_file.ref()); } bool SBFileSpecList::AppendIfUnique(const SBFileSpec &sb_file) { - return m_opaque_ap->AppendIfUnique(sb_file.ref()); + return m_opaque_up->AppendIfUnique(sb_file.ref()); } -void SBFileSpecList::Clear() { m_opaque_ap->Clear(); } +void SBFileSpecList::Clear() { m_opaque_up->Clear(); } uint32_t SBFileSpecList::FindFileIndex(uint32_t idx, const SBFileSpec &sb_file, bool full) { - return m_opaque_ap->FindFileIndex(idx, sb_file.ref(), full); + return m_opaque_up->FindFileIndex(idx, sb_file.ref(), full); } const SBFileSpec SBFileSpecList::GetFileSpecAtIndex(uint32_t idx) const { SBFileSpec new_spec; - new_spec.SetFileSpec(m_opaque_ap->GetFileSpecAtIndex(idx)); + new_spec.SetFileSpec(m_opaque_up->GetFileSpecAtIndex(idx)); return new_spec; } const lldb_private::FileSpecList *SBFileSpecList::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::FileSpecList *SBFileSpecList::get() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::FileSpecList &SBFileSpecList::operator*() const { - return *m_opaque_ap; + return *m_opaque_up; } const lldb_private::FileSpecList &SBFileSpecList::ref() const { - return *m_opaque_ap; + return *m_opaque_up; } bool SBFileSpecList::GetDescription(SBStream &description) const { Stream &strm = description.ref(); - if (m_opaque_ap) { - uint32_t num_files = m_opaque_ap->GetSize(); + if (m_opaque_up) { + uint32_t num_files = m_opaque_up->GetSize(); strm.Printf("%d files: ", num_files); for (uint32_t i = 0; i < num_files; i++) { char path[PATH_MAX]; - if (m_opaque_ap->GetFileSpecAtIndex(i).GetPath(path, sizeof(path))) + if (m_opaque_up->GetFileSpecAtIndex(i).GetPath(path, sizeof(path))) strm.Printf("\n %s", path); } } else diff --git a/source/API/SBLineEntry.cpp b/source/API/SBLineEntry.cpp index 66cc9cc6e..17cdf2316 100644 --- a/source/API/SBLineEntry.cpp +++ b/source/API/SBLineEntry.cpp @@ -18,15 +18,15 @@ using namespace lldb; using namespace lldb_private; -SBLineEntry::SBLineEntry() : m_opaque_ap() {} +SBLineEntry::SBLineEntry() : m_opaque_up() {} -SBLineEntry::SBLineEntry(const SBLineEntry &rhs) : m_opaque_ap() { +SBLineEntry::SBLineEntry(const SBLineEntry &rhs) : m_opaque_up() { if (rhs.IsValid()) ref() = rhs.ref(); } SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr) - : m_opaque_ap() { + : m_opaque_up() { if (lldb_object_ptr) ref() = *lldb_object_ptr; } @@ -36,7 +36,7 @@ const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) { if (rhs.IsValid()) ref() = rhs.ref(); else - m_opaque_ap.reset(); + m_opaque_up.reset(); } return *this; } @@ -49,8 +49,8 @@ SBLineEntry::~SBLineEntry() {} SBAddress SBLineEntry::GetStartAddress() const { SBAddress sb_address; - if (m_opaque_ap) - sb_address.SetAddress(&m_opaque_ap->range.GetBaseAddress()); + if (m_opaque_up) + sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress()); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { @@ -60,7 +60,7 @@ SBAddress SBLineEntry::GetStartAddress() const { addr->Dump(&sstr, NULL, Address::DumpStyleModuleWithFileAddress, Address::DumpStyleInvalid, 4); log->Printf("SBLineEntry(%p)::GetStartAddress () => SBAddress (%p): %s", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<void *>(sb_address.get()), sstr.GetData()); } @@ -69,9 +69,9 @@ SBAddress SBLineEntry::GetStartAddress() const { SBAddress SBLineEntry::GetEndAddress() const { SBAddress sb_address; - if (m_opaque_ap) { - sb_address.SetAddress(&m_opaque_ap->range.GetBaseAddress()); - sb_address.OffsetAddress(m_opaque_ap->range.GetByteSize()); + if (m_opaque_up) { + sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress()); + sb_address.OffsetAddress(m_opaque_up->range.GetByteSize()); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { @@ -81,28 +81,28 @@ SBAddress SBLineEntry::GetEndAddress() const { addr->Dump(&sstr, NULL, Address::DumpStyleModuleWithFileAddress, Address::DumpStyleInvalid, 4); log->Printf("SBLineEntry(%p)::GetEndAddress () => SBAddress (%p): %s", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<void *>(sb_address.get()), sstr.GetData()); } return sb_address; } bool SBLineEntry::IsValid() const { - return m_opaque_ap.get() && m_opaque_ap->IsValid(); + return m_opaque_up.get() && m_opaque_up->IsValid(); } SBFileSpec SBLineEntry::GetFileSpec() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFileSpec sb_file_spec; - if (m_opaque_ap.get() && m_opaque_ap->file) - sb_file_spec.SetFileSpec(m_opaque_ap->file); + if (m_opaque_up.get() && m_opaque_up->file) + sb_file_spec.SetFileSpec(m_opaque_up->file); if (log) { SBStream sstr; sb_file_spec.GetDescription(sstr); log->Printf("SBLineEntry(%p)::GetFileSpec () => SBFileSpec(%p): %s", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<const void *>(sb_file_spec.get()), sstr.GetData()); } @@ -113,19 +113,19 @@ uint32_t SBLineEntry::GetLine() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t line = 0; - if (m_opaque_ap) - line = m_opaque_ap->line; + if (m_opaque_up) + line = m_opaque_up->line; if (log) log->Printf("SBLineEntry(%p)::GetLine () => %u", - static_cast<void *>(m_opaque_ap.get()), line); + static_cast<void *>(m_opaque_up.get()), line); return line; } uint32_t SBLineEntry::GetColumn() const { - if (m_opaque_ap) - return m_opaque_ap->column; + if (m_opaque_up) + return m_opaque_up->column; return 0; } @@ -140,8 +140,8 @@ void SBLineEntry::SetLine(uint32_t line) { ref().line = line; } void SBLineEntry::SetColumn(uint32_t column) { ref().line = column; } bool SBLineEntry::operator==(const SBLineEntry &rhs) const { - lldb_private::LineEntry *lhs_ptr = m_opaque_ap.get(); - lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_ap.get(); + lldb_private::LineEntry *lhs_ptr = m_opaque_up.get(); + lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get(); if (lhs_ptr && rhs_ptr) return lldb_private::LineEntry::Compare(*lhs_ptr, *rhs_ptr) == 0; @@ -150,8 +150,8 @@ bool SBLineEntry::operator==(const SBLineEntry &rhs) const { } bool SBLineEntry::operator!=(const SBLineEntry &rhs) const { - lldb_private::LineEntry *lhs_ptr = m_opaque_ap.get(); - lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_ap.get(); + lldb_private::LineEntry *lhs_ptr = m_opaque_up.get(); + lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get(); if (lhs_ptr && rhs_ptr) return lldb_private::LineEntry::Compare(*lhs_ptr, *rhs_ptr) != 0; @@ -160,23 +160,23 @@ bool SBLineEntry::operator!=(const SBLineEntry &rhs) const { } const lldb_private::LineEntry *SBLineEntry::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } lldb_private::LineEntry &SBLineEntry::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new lldb_private::LineEntry()); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new lldb_private::LineEntry()); + return *m_opaque_up; } -const lldb_private::LineEntry &SBLineEntry::ref() const { return *m_opaque_ap; } +const lldb_private::LineEntry &SBLineEntry::ref() const { return *m_opaque_up; } bool SBLineEntry::GetDescription(SBStream &description) { Stream &strm = description.ref(); - if (m_opaque_ap) { + if (m_opaque_up) { char file_path[PATH_MAX * 2]; - m_opaque_ap->file.GetPath(file_path, sizeof(file_path)); + m_opaque_up->file.GetPath(file_path, sizeof(file_path)); strm.Printf("%s:%u", file_path, GetLine()); if (GetColumn() > 0) strm.Printf(":%u", GetColumn()); @@ -186,4 +186,4 @@ bool SBLineEntry::GetDescription(SBStream &description) { return true; } -lldb_private::LineEntry *SBLineEntry::get() { return m_opaque_ap.get(); } +lldb_private::LineEntry *SBLineEntry::get() { return m_opaque_up.get(); } diff --git a/source/API/SBMemoryRegionInfo.cpp b/source/API/SBMemoryRegionInfo.cpp index 26778d973..2a3f7c7c4 100644 --- a/source/API/SBMemoryRegionInfo.cpp +++ b/source/API/SBMemoryRegionInfo.cpp @@ -17,16 +17,16 @@ using namespace lldb; using namespace lldb_private; SBMemoryRegionInfo::SBMemoryRegionInfo() - : m_opaque_ap(new MemoryRegionInfo()) {} + : m_opaque_up(new MemoryRegionInfo()) {} SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr) - : m_opaque_ap(new MemoryRegionInfo()) { + : m_opaque_up(new MemoryRegionInfo()) { if (lldb_object_ptr) ref() = *lldb_object_ptr; } SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs) - : m_opaque_ap(new MemoryRegionInfo()) { + : m_opaque_up(new MemoryRegionInfo()) { ref() = rhs.ref(); } @@ -40,7 +40,7 @@ operator=(const SBMemoryRegionInfo &rhs) { SBMemoryRegionInfo::~SBMemoryRegionInfo() {} -void SBMemoryRegionInfo::Clear() { m_opaque_ap->Clear(); } +void SBMemoryRegionInfo::Clear() { m_opaque_up->Clear(); } bool SBMemoryRegionInfo::operator==(const SBMemoryRegionInfo &rhs) const { return ref() == rhs.ref(); @@ -50,47 +50,47 @@ bool SBMemoryRegionInfo::operator!=(const SBMemoryRegionInfo &rhs) const { return ref() != rhs.ref(); } -MemoryRegionInfo &SBMemoryRegionInfo::ref() { return *m_opaque_ap; } +MemoryRegionInfo &SBMemoryRegionInfo::ref() { return *m_opaque_up; } -const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_ap; } +const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; } lldb::addr_t SBMemoryRegionInfo::GetRegionBase() { - return m_opaque_ap->GetRange().GetRangeBase(); + return m_opaque_up->GetRange().GetRangeBase(); } lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() { - return m_opaque_ap->GetRange().GetRangeEnd(); + return m_opaque_up->GetRange().GetRangeEnd(); } bool SBMemoryRegionInfo::IsReadable() { - return m_opaque_ap->GetReadable() == MemoryRegionInfo::eYes; + return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsWritable() { - return m_opaque_ap->GetWritable() == MemoryRegionInfo::eYes; + return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsExecutable() { - return m_opaque_ap->GetExecutable() == MemoryRegionInfo::eYes; + return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsMapped() { - return m_opaque_ap->GetMapped() == MemoryRegionInfo::eYes; + return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes; } const char *SBMemoryRegionInfo::GetName() { - return m_opaque_ap->GetName().AsCString(); + return m_opaque_up->GetName().AsCString(); } bool SBMemoryRegionInfo::GetDescription(SBStream &description) { Stream &strm = description.ref(); - const addr_t load_addr = m_opaque_ap->GetRange().base; + const addr_t load_addr = m_opaque_up->GetRange().base; strm.Printf("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 " ", load_addr, - load_addr + m_opaque_ap->GetRange().size); - strm.Printf(m_opaque_ap->GetReadable() ? "R" : "-"); - strm.Printf(m_opaque_ap->GetWritable() ? "W" : "-"); - strm.Printf(m_opaque_ap->GetExecutable() ? "X" : "-"); + load_addr + m_opaque_up->GetRange().size); + strm.Printf(m_opaque_up->GetReadable() ? "R" : "-"); + strm.Printf(m_opaque_up->GetWritable() ? "W" : "-"); + strm.Printf(m_opaque_up->GetExecutable() ? "X" : "-"); strm.Printf("]"); return true; diff --git a/source/API/SBMemoryRegionInfoList.cpp b/source/API/SBMemoryRegionInfoList.cpp index 290804a9c..a0104b98e 100644 --- a/source/API/SBMemoryRegionInfoList.cpp +++ b/source/API/SBMemoryRegionInfoList.cpp @@ -64,69 +64,67 @@ private: MemoryRegionInfos m_regions; }; -MemoryRegionInfos &SBMemoryRegionInfoList::ref() { - return m_opaque_ap->Ref(); -} +MemoryRegionInfos &SBMemoryRegionInfoList::ref() { return m_opaque_up->Ref(); } const MemoryRegionInfos &SBMemoryRegionInfoList::ref() const { - return m_opaque_ap->Ref(); + return m_opaque_up->Ref(); } SBMemoryRegionInfoList::SBMemoryRegionInfoList() - : m_opaque_ap(new MemoryRegionInfoListImpl()) {} + : m_opaque_up(new MemoryRegionInfoListImpl()) {} SBMemoryRegionInfoList::SBMemoryRegionInfoList( const SBMemoryRegionInfoList &rhs) - : m_opaque_ap(new MemoryRegionInfoListImpl(*rhs.m_opaque_ap)) {} + : m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) {} SBMemoryRegionInfoList::~SBMemoryRegionInfoList() {} const SBMemoryRegionInfoList &SBMemoryRegionInfoList:: operator=(const SBMemoryRegionInfoList &rhs) { if (this != &rhs) { - *m_opaque_ap = *rhs.m_opaque_ap; + *m_opaque_up = *rhs.m_opaque_up; } return *this; } uint32_t SBMemoryRegionInfoList::GetSize() const { - return m_opaque_ap->GetSize(); + return m_opaque_up->GetSize(); } bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex( uint32_t idx, SBMemoryRegionInfo ®ion_info) { Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - bool result = m_opaque_ap->GetMemoryRegionInfoAtIndex(idx, region_info.ref()); + bool result = m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref()); if (log) { SBStream sstr; region_info.GetDescription(sstr); log->Printf("SBMemoryRegionInfoList::GetMemoryRegionAtIndex (this.ap=%p, " "idx=%d) => SBMemoryRegionInfo (this.ap=%p, '%s')", - static_cast<void *>(m_opaque_ap.get()), idx, - static_cast<void *>(region_info.m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), idx, + static_cast<void *>(region_info.m_opaque_up.get()), sstr.GetData()); } return result; } -void SBMemoryRegionInfoList::Clear() { m_opaque_ap->Clear(); } +void SBMemoryRegionInfoList::Clear() { m_opaque_up->Clear(); } void SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region) { - m_opaque_ap->Append(sb_region.ref()); + m_opaque_up->Append(sb_region.ref()); } void SBMemoryRegionInfoList::Append(SBMemoryRegionInfoList &sb_region_list) { - m_opaque_ap->Append(*sb_region_list); + m_opaque_up->Append(*sb_region_list); } const MemoryRegionInfoListImpl *SBMemoryRegionInfoList::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const MemoryRegionInfoListImpl &SBMemoryRegionInfoList::operator*() const { - assert(m_opaque_ap.get()); - return *m_opaque_ap; + assert(m_opaque_up.get()); + return *m_opaque_up; } diff --git a/source/API/SBModule.cpp b/source/API/SBModule.cpp index b7385d6f6..a7886b034 100644 --- a/source/API/SBModule.cpp +++ b/source/API/SBModule.cpp @@ -36,7 +36,7 @@ SBModule::SBModule(const lldb::ModuleSP &module_sp) : m_opaque_sp(module_sp) {} SBModule::SBModule(const SBModuleSpec &module_spec) : m_opaque_sp() { ModuleSP module_sp; - Status error = ModuleList::GetSharedModule(*module_spec.m_opaque_ap, + Status error = ModuleList::GetSharedModule(*module_spec.m_opaque_up, module_sp, NULL, NULL, NULL); if (module_sp) SetSP(module_sp); @@ -492,7 +492,7 @@ lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) { TypeClass type_class = static_cast<TypeClass>(type_mask); TypeList type_list; vendor->GetTypes(NULL, type_class, type_list); - sb_type_list.m_opaque_ap->Append(type_list); + sb_type_list.m_opaque_up->Append(type_list); return sb_type_list; } diff --git a/source/API/SBModuleSpec.cpp b/source/API/SBModuleSpec.cpp index 882b312e4..a4d62665c 100644 --- a/source/API/SBModuleSpec.cpp +++ b/source/API/SBModuleSpec.cpp @@ -17,58 +17,58 @@ using namespace lldb; using namespace lldb_private; -SBModuleSpec::SBModuleSpec() : m_opaque_ap(new lldb_private::ModuleSpec()) {} +SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) {} SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) - : m_opaque_ap(new lldb_private::ModuleSpec(*rhs.m_opaque_ap)) {} + : m_opaque_up(new lldb_private::ModuleSpec(*rhs.m_opaque_up)) {} const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) { if (this != &rhs) - *m_opaque_ap = *(rhs.m_opaque_ap); + *m_opaque_up = *(rhs.m_opaque_up); return *this; } SBModuleSpec::~SBModuleSpec() {} -bool SBModuleSpec::IsValid() const { return m_opaque_ap->operator bool(); } +bool SBModuleSpec::IsValid() const { return m_opaque_up->operator bool(); } -void SBModuleSpec::Clear() { m_opaque_ap->Clear(); } +void SBModuleSpec::Clear() { m_opaque_up->Clear(); } SBFileSpec SBModuleSpec::GetFileSpec() { - SBFileSpec sb_spec(m_opaque_ap->GetFileSpec()); + SBFileSpec sb_spec(m_opaque_up->GetFileSpec()); return sb_spec; } void SBModuleSpec::SetFileSpec(const lldb::SBFileSpec &sb_spec) { - m_opaque_ap->GetFileSpec() = *sb_spec; + m_opaque_up->GetFileSpec() = *sb_spec; } lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() { - return SBFileSpec(m_opaque_ap->GetPlatformFileSpec()); + return SBFileSpec(m_opaque_up->GetPlatformFileSpec()); } void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) { - m_opaque_ap->GetPlatformFileSpec() = *sb_spec; + m_opaque_up->GetPlatformFileSpec() = *sb_spec; } lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() { - return SBFileSpec(m_opaque_ap->GetSymbolFileSpec()); + return SBFileSpec(m_opaque_up->GetSymbolFileSpec()); } void SBModuleSpec::SetSymbolFileSpec(const lldb::SBFileSpec &sb_spec) { - m_opaque_ap->GetSymbolFileSpec() = *sb_spec; + m_opaque_up->GetSymbolFileSpec() = *sb_spec; } const char *SBModuleSpec::GetObjectName() { - return m_opaque_ap->GetObjectName().GetCString(); + return m_opaque_up->GetObjectName().GetCString(); } void SBModuleSpec::SetObjectName(const char *name) { - m_opaque_ap->GetObjectName().SetCString(name); + m_opaque_up->GetObjectName().SetCString(name); } const char *SBModuleSpec::GetTriple() { - std::string triple(m_opaque_ap->GetArchitecture().GetTriple().str()); + std::string triple(m_opaque_up->GetArchitecture().GetTriple().str()); // Unique the string so we don't run into ownership issues since the const // strings put the string into the string pool once and the strings never // comes out @@ -77,35 +77,35 @@ const char *SBModuleSpec::GetTriple() { } void SBModuleSpec::SetTriple(const char *triple) { - m_opaque_ap->GetArchitecture().SetTriple(triple); + m_opaque_up->GetArchitecture().SetTriple(triple); } const uint8_t *SBModuleSpec::GetUUIDBytes() { - return m_opaque_ap->GetUUID().GetBytes().data(); + return m_opaque_up->GetUUID().GetBytes().data(); } size_t SBModuleSpec::GetUUIDLength() { - return m_opaque_ap->GetUUID().GetBytes().size(); + return m_opaque_up->GetUUID().GetBytes().size(); } bool SBModuleSpec::SetUUIDBytes(const uint8_t *uuid, size_t uuid_len) { - m_opaque_ap->GetUUID() = UUID::fromOptionalData(uuid, uuid_len); - return m_opaque_ap->GetUUID().IsValid(); + m_opaque_up->GetUUID() = UUID::fromOptionalData(uuid, uuid_len); + return m_opaque_up->GetUUID().IsValid(); } bool SBModuleSpec::GetDescription(lldb::SBStream &description) { - m_opaque_ap->Dump(description.ref()); + m_opaque_up->Dump(description.ref()); return true; } -SBModuleSpecList::SBModuleSpecList() : m_opaque_ap(new ModuleSpecList()) {} +SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) {} SBModuleSpecList::SBModuleSpecList(const SBModuleSpecList &rhs) - : m_opaque_ap(new ModuleSpecList(*rhs.m_opaque_ap)) {} + : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) {} SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) { if (this != &rhs) - *m_opaque_ap = *rhs.m_opaque_ap; + *m_opaque_up = *rhs.m_opaque_up; return *this; } @@ -116,43 +116,43 @@ SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) { FileSpec file_spec(path); FileSystem::Instance().Resolve(file_spec); Host::ResolveExecutableInBundle(file_spec); - ObjectFile::GetModuleSpecifications(file_spec, 0, 0, *specs.m_opaque_ap); + ObjectFile::GetModuleSpecifications(file_spec, 0, 0, *specs.m_opaque_up); return specs; } void SBModuleSpecList::Append(const SBModuleSpec &spec) { - m_opaque_ap->Append(*spec.m_opaque_ap); + m_opaque_up->Append(*spec.m_opaque_up); } void SBModuleSpecList::Append(const SBModuleSpecList &spec_list) { - m_opaque_ap->Append(*spec_list.m_opaque_ap); + m_opaque_up->Append(*spec_list.m_opaque_up); } -size_t SBModuleSpecList::GetSize() { return m_opaque_ap->GetSize(); } +size_t SBModuleSpecList::GetSize() { return m_opaque_up->GetSize(); } SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) { SBModuleSpec sb_module_spec; - m_opaque_ap->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_ap); + m_opaque_up->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_up); return sb_module_spec; } SBModuleSpec SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) { SBModuleSpec sb_module_spec; - m_opaque_ap->FindMatchingModuleSpec(*match_spec.m_opaque_ap, - *sb_module_spec.m_opaque_ap); + m_opaque_up->FindMatchingModuleSpec(*match_spec.m_opaque_up, + *sb_module_spec.m_opaque_up); return sb_module_spec; } SBModuleSpecList SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) { SBModuleSpecList specs; - m_opaque_ap->FindMatchingModuleSpecs(*match_spec.m_opaque_ap, - *specs.m_opaque_ap); + m_opaque_up->FindMatchingModuleSpecs(*match_spec.m_opaque_up, + *specs.m_opaque_up); return specs; } bool SBModuleSpecList::GetDescription(lldb::SBStream &description) { - m_opaque_ap->Dump(description.ref()); + m_opaque_up->Dump(description.ref()); return true; } diff --git a/source/API/SBProcessInfo.cpp b/source/API/SBProcessInfo.cpp index a786a5e0d..80eaebe41 100644 --- a/source/API/SBProcessInfo.cpp +++ b/source/API/SBProcessInfo.cpp @@ -14,11 +14,11 @@ using namespace lldb; using namespace lldb_private; -SBProcessInfo::SBProcessInfo() : m_opaque_ap() {} +SBProcessInfo::SBProcessInfo() : m_opaque_up() {} -SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_ap() { +SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_up() { if (rhs.IsValid()) { - ref() = *rhs.m_opaque_ap; + ref() = *rhs.m_opaque_up; } } @@ -27,118 +27,118 @@ SBProcessInfo::~SBProcessInfo() {} SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) { if (this != &rhs) { if (rhs.IsValid()) - ref() = *rhs.m_opaque_ap; + ref() = *rhs.m_opaque_up; else - m_opaque_ap.reset(); + m_opaque_up.reset(); } return *this; } ProcessInstanceInfo &SBProcessInfo::ref() { - if (m_opaque_ap == nullptr) { - m_opaque_ap.reset(new ProcessInstanceInfo()); + if (m_opaque_up == nullptr) { + m_opaque_up.reset(new ProcessInstanceInfo()); } - return *m_opaque_ap; + return *m_opaque_up; } void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) { ref() = proc_info_ref; } -bool SBProcessInfo::IsValid() const { return m_opaque_ap != nullptr; } +bool SBProcessInfo::IsValid() const { return m_opaque_up != nullptr; } const char *SBProcessInfo::GetName() { const char *name = nullptr; - if (m_opaque_ap) { - name = m_opaque_ap->GetName(); + if (m_opaque_up) { + name = m_opaque_up->GetName(); } return name; } SBFileSpec SBProcessInfo::GetExecutableFile() { SBFileSpec file_spec; - if (m_opaque_ap) { - file_spec.SetFileSpec(m_opaque_ap->GetExecutableFile()); + if (m_opaque_up) { + file_spec.SetFileSpec(m_opaque_up->GetExecutableFile()); } return file_spec; } lldb::pid_t SBProcessInfo::GetProcessID() { lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID; - if (m_opaque_ap) { - proc_id = m_opaque_ap->GetProcessID(); + if (m_opaque_up) { + proc_id = m_opaque_up->GetProcessID(); } return proc_id; } uint32_t SBProcessInfo::GetUserID() { uint32_t user_id = UINT32_MAX; - if (m_opaque_ap) { - user_id = m_opaque_ap->GetUserID(); + if (m_opaque_up) { + user_id = m_opaque_up->GetUserID(); } return user_id; } uint32_t SBProcessInfo::GetGroupID() { uint32_t group_id = UINT32_MAX; - if (m_opaque_ap) { - group_id = m_opaque_ap->GetGroupID(); + if (m_opaque_up) { + group_id = m_opaque_up->GetGroupID(); } return group_id; } bool SBProcessInfo::UserIDIsValid() { bool is_valid = false; - if (m_opaque_ap) { - is_valid = m_opaque_ap->UserIDIsValid(); + if (m_opaque_up) { + is_valid = m_opaque_up->UserIDIsValid(); } return is_valid; } bool SBProcessInfo::GroupIDIsValid() { bool is_valid = false; - if (m_opaque_ap) { - is_valid = m_opaque_ap->GroupIDIsValid(); + if (m_opaque_up) { + is_valid = m_opaque_up->GroupIDIsValid(); } return is_valid; } uint32_t SBProcessInfo::GetEffectiveUserID() { uint32_t user_id = UINT32_MAX; - if (m_opaque_ap) { - user_id = m_opaque_ap->GetEffectiveUserID(); + if (m_opaque_up) { + user_id = m_opaque_up->GetEffectiveUserID(); } return user_id; } uint32_t SBProcessInfo::GetEffectiveGroupID() { uint32_t group_id = UINT32_MAX; - if (m_opaque_ap) { - group_id = m_opaque_ap->GetEffectiveGroupID(); + if (m_opaque_up) { + group_id = m_opaque_up->GetEffectiveGroupID(); } return group_id; } bool SBProcessInfo::EffectiveUserIDIsValid() { bool is_valid = false; - if (m_opaque_ap) { - is_valid = m_opaque_ap->EffectiveUserIDIsValid(); + if (m_opaque_up) { + is_valid = m_opaque_up->EffectiveUserIDIsValid(); } return is_valid; } bool SBProcessInfo::EffectiveGroupIDIsValid() { bool is_valid = false; - if (m_opaque_ap) { - is_valid = m_opaque_ap->EffectiveGroupIDIsValid(); + if (m_opaque_up) { + is_valid = m_opaque_up->EffectiveGroupIDIsValid(); } return is_valid; } lldb::pid_t SBProcessInfo::GetParentProcessID() { lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID; - if (m_opaque_ap) { - proc_id = m_opaque_ap->GetParentProcessID(); + if (m_opaque_up) { + proc_id = m_opaque_up->GetParentProcessID(); } return proc_id; } diff --git a/source/API/SBSourceManager.cpp b/source/API/SBSourceManager.cpp index 9a469b1e4..85eba4f88 100644 --- a/source/API/SBSourceManager.cpp +++ b/source/API/SBSourceManager.cpp @@ -71,23 +71,23 @@ using namespace lldb; using namespace lldb_private; SBSourceManager::SBSourceManager(const SBDebugger &debugger) { - m_opaque_ap.reset(new SourceManagerImpl(debugger.get_sp())); + m_opaque_up.reset(new SourceManagerImpl(debugger.get_sp())); } SBSourceManager::SBSourceManager(const SBTarget &target) { - m_opaque_ap.reset(new SourceManagerImpl(target.GetSP())); + m_opaque_up.reset(new SourceManagerImpl(target.GetSP())); } SBSourceManager::SBSourceManager(const SBSourceManager &rhs) { if (&rhs == this) return; - m_opaque_ap.reset(new SourceManagerImpl(*(rhs.m_opaque_ap.get()))); + m_opaque_up.reset(new SourceManagerImpl(*(rhs.m_opaque_up.get()))); } const lldb::SBSourceManager &SBSourceManager:: operator=(const lldb::SBSourceManager &rhs) { - m_opaque_ap.reset(new SourceManagerImpl(*(rhs.m_opaque_ap.get()))); + m_opaque_up.reset(new SourceManagerImpl(*(rhs.m_opaque_up.get()))); return *this; } @@ -106,10 +106,10 @@ size_t SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn( const SBFileSpec &file, uint32_t line, uint32_t column, uint32_t context_before, uint32_t context_after, const char *current_line_cstr, SBStream &s) { - if (m_opaque_ap == NULL) + if (m_opaque_up == NULL) return 0; - return m_opaque_ap->DisplaySourceLinesWithLineNumbers( + return m_opaque_up->DisplaySourceLinesWithLineNumbers( file.ref(), line, column, context_before, context_after, current_line_cstr, s.get()); } diff --git a/source/API/SBStream.cpp b/source/API/SBStream.cpp index 2e7098511..11479d521 100644 --- a/source/API/SBStream.cpp +++ b/source/API/SBStream.cpp @@ -17,31 +17,31 @@ using namespace lldb; using namespace lldb_private; -SBStream::SBStream() : m_opaque_ap(new StreamString()), m_is_file(false) {} +SBStream::SBStream() : m_opaque_up(new StreamString()), m_is_file(false) {} SBStream::SBStream(SBStream &&rhs) - : m_opaque_ap(std::move(rhs.m_opaque_ap)), m_is_file(rhs.m_is_file) {} + : m_opaque_up(std::move(rhs.m_opaque_up)), m_is_file(rhs.m_is_file) {} SBStream::~SBStream() {} -bool SBStream::IsValid() const { return (m_opaque_ap != NULL); } +bool SBStream::IsValid() const { return (m_opaque_up != NULL); } // If this stream is not redirected to a file, it will maintain a local cache // for the stream data which can be accessed using this accessor. const char *SBStream::GetData() { - if (m_is_file || m_opaque_ap == NULL) + if (m_is_file || m_opaque_up == NULL) return NULL; - return static_cast<StreamString *>(m_opaque_ap.get())->GetData(); + return static_cast<StreamString *>(m_opaque_up.get())->GetData(); } // If this stream is not redirected to a file, it will maintain a local cache // for the stream output whose length can be accessed using this accessor. size_t SBStream::GetSize() { - if (m_is_file || m_opaque_ap == NULL) + if (m_is_file || m_opaque_up == NULL) return 0; - return static_cast<StreamString *>(m_opaque_ap.get())->GetSize(); + return static_cast<StreamString *>(m_opaque_up.get())->GetSize(); } void SBStream::Printf(const char *format, ...) { @@ -58,11 +58,11 @@ void SBStream::RedirectToFile(const char *path, bool append) { return; std::string local_data; - if (m_opaque_ap) { + if (m_opaque_up) { // See if we have any locally backed data. If so, copy it so we can then // redirect it to the file so we don't lose the data if (!m_is_file) - local_data = static_cast<StreamString *>(m_opaque_ap.get())->GetString(); + local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString(); } StreamFile *stream_file = new StreamFile; uint32_t open_options = File::eOpenOptionWrite | File::eOpenOptionCanCreate; @@ -73,15 +73,15 @@ void SBStream::RedirectToFile(const char *path, bool append) { FileSystem::Instance().Open(stream_file->GetFile(), FileSpec(path), open_options); - m_opaque_ap.reset(stream_file); + m_opaque_up.reset(stream_file); - if (m_opaque_ap) { + if (m_opaque_up) { m_is_file = true; // If we had any data locally in our StreamString, then pass that along to // the to new file we are redirecting to. if (!local_data.empty()) - m_opaque_ap->Write(&local_data[0], local_data.size()); + m_opaque_up->Write(&local_data[0], local_data.size()); } else m_is_file = false; } @@ -91,63 +91,63 @@ void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) { return; std::string local_data; - if (m_opaque_ap) { + if (m_opaque_up) { // See if we have any locally backed data. If so, copy it so we can then // redirect it to the file so we don't lose the data if (!m_is_file) - local_data = static_cast<StreamString *>(m_opaque_ap.get())->GetString(); + local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString(); } - m_opaque_ap.reset(new StreamFile(fh, transfer_fh_ownership)); + m_opaque_up.reset(new StreamFile(fh, transfer_fh_ownership)); - if (m_opaque_ap) { + if (m_opaque_up) { m_is_file = true; // If we had any data locally in our StreamString, then pass that along to // the to new file we are redirecting to. if (!local_data.empty()) - m_opaque_ap->Write(&local_data[0], local_data.size()); + m_opaque_up->Write(&local_data[0], local_data.size()); } else m_is_file = false; } void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) { std::string local_data; - if (m_opaque_ap) { + if (m_opaque_up) { // See if we have any locally backed data. If so, copy it so we can then // redirect it to the file so we don't lose the data if (!m_is_file) - local_data = static_cast<StreamString *>(m_opaque_ap.get())->GetString(); + local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString(); } - m_opaque_ap.reset(new StreamFile(::fdopen(fd, "w"), transfer_fh_ownership)); - if (m_opaque_ap) { + m_opaque_up.reset(new StreamFile(::fdopen(fd, "w"), transfer_fh_ownership)); + if (m_opaque_up) { m_is_file = true; // If we had any data locally in our StreamString, then pass that along to // the to new file we are redirecting to. if (!local_data.empty()) - m_opaque_ap->Write(&local_data[0], local_data.size()); + m_opaque_up->Write(&local_data[0], local_data.size()); } else m_is_file = false; } -lldb_private::Stream *SBStream::operator->() { return m_opaque_ap.get(); } +lldb_private::Stream *SBStream::operator->() { return m_opaque_up.get(); } -lldb_private::Stream *SBStream::get() { return m_opaque_ap.get(); } +lldb_private::Stream *SBStream::get() { return m_opaque_up.get(); } lldb_private::Stream &SBStream::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new StreamString()); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new StreamString()); + return *m_opaque_up; } void SBStream::Clear() { - if (m_opaque_ap) { + if (m_opaque_up) { // See if we have any locally backed data. If so, copy it so we can then // redirect it to the file so we don't lose the data if (m_is_file) - m_opaque_ap.reset(); + m_opaque_up.reset(); else - static_cast<StreamString *>(m_opaque_ap.get())->Clear(); + static_cast<StreamString *>(m_opaque_up.get())->Clear(); } } diff --git a/source/API/SBStringList.cpp b/source/API/SBStringList.cpp index 8a4cc0419..312a9dab9 100644 --- a/source/API/SBStringList.cpp +++ b/source/API/SBStringList.cpp @@ -13,25 +13,25 @@ using namespace lldb; using namespace lldb_private; -SBStringList::SBStringList() : m_opaque_ap() {} +SBStringList::SBStringList() : m_opaque_up() {} SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr) - : m_opaque_ap() { + : m_opaque_up() { if (lldb_strings_ptr) - m_opaque_ap.reset(new lldb_private::StringList(*lldb_strings_ptr)); + m_opaque_up.reset(new lldb_private::StringList(*lldb_strings_ptr)); } -SBStringList::SBStringList(const SBStringList &rhs) : m_opaque_ap() { +SBStringList::SBStringList(const SBStringList &rhs) : m_opaque_up() { if (rhs.IsValid()) - m_opaque_ap.reset(new lldb_private::StringList(*rhs)); + m_opaque_up.reset(new lldb_private::StringList(*rhs)); } const SBStringList &SBStringList::operator=(const SBStringList &rhs) { if (this != &rhs) { if (rhs.IsValid()) - m_opaque_ap.reset(new lldb_private::StringList(*rhs)); + m_opaque_up.reset(new lldb_private::StringList(*rhs)); else - m_opaque_ap.reset(); + m_opaque_up.reset(); } return *this; } @@ -39,70 +39,70 @@ const SBStringList &SBStringList::operator=(const SBStringList &rhs) { SBStringList::~SBStringList() {} const lldb_private::StringList *SBStringList::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::StringList &SBStringList::operator*() const { - return *m_opaque_ap; + return *m_opaque_up; } -bool SBStringList::IsValid() const { return (m_opaque_ap != NULL); } +bool SBStringList::IsValid() const { return (m_opaque_up != NULL); } void SBStringList::AppendString(const char *str) { if (str != NULL) { if (IsValid()) - m_opaque_ap->AppendString(str); + m_opaque_up->AppendString(str); else - m_opaque_ap.reset(new lldb_private::StringList(str)); + m_opaque_up.reset(new lldb_private::StringList(str)); } } void SBStringList::AppendList(const char **strv, int strc) { if ((strv != NULL) && (strc > 0)) { if (IsValid()) - m_opaque_ap->AppendList(strv, strc); + m_opaque_up->AppendList(strv, strc); else - m_opaque_ap.reset(new lldb_private::StringList(strv, strc)); + m_opaque_up.reset(new lldb_private::StringList(strv, strc)); } } void SBStringList::AppendList(const SBStringList &strings) { if (strings.IsValid()) { if (!IsValid()) - m_opaque_ap.reset(new lldb_private::StringList()); - m_opaque_ap->AppendList(*(strings.m_opaque_ap)); + m_opaque_up.reset(new lldb_private::StringList()); + m_opaque_up->AppendList(*(strings.m_opaque_up)); } } void SBStringList::AppendList(const StringList &strings) { if (!IsValid()) - m_opaque_ap.reset(new lldb_private::StringList()); - m_opaque_ap->AppendList(strings); + m_opaque_up.reset(new lldb_private::StringList()); + m_opaque_up->AppendList(strings); } uint32_t SBStringList::GetSize() const { if (IsValid()) { - return m_opaque_ap->GetSize(); + return m_opaque_up->GetSize(); } return 0; } const char *SBStringList::GetStringAtIndex(size_t idx) { if (IsValid()) { - return m_opaque_ap->GetStringAtIndex(idx); + return m_opaque_up->GetStringAtIndex(idx); } return NULL; } const char *SBStringList::GetStringAtIndex(size_t idx) const { if (IsValid()) { - return m_opaque_ap->GetStringAtIndex(idx); + return m_opaque_up->GetStringAtIndex(idx); } return NULL; } void SBStringList::Clear() { if (IsValid()) { - m_opaque_ap->Clear(); + m_opaque_up->Clear(); } } diff --git a/source/API/SBSymbolContext.cpp b/source/API/SBSymbolContext.cpp index e64c0610a..0260d1dc0 100644 --- a/source/API/SBSymbolContext.cpp +++ b/source/API/SBSymbolContext.cpp @@ -17,19 +17,19 @@ using namespace lldb; using namespace lldb_private; -SBSymbolContext::SBSymbolContext() : m_opaque_ap() {} +SBSymbolContext::SBSymbolContext() : m_opaque_up() {} -SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_ap() { +SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_up() { if (sc_ptr) - m_opaque_ap.reset(new SymbolContext(*sc_ptr)); + m_opaque_up.reset(new SymbolContext(*sc_ptr)); } -SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_ap() { +SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() { if (rhs.IsValid()) { - if (m_opaque_ap) - *m_opaque_ap = *rhs.m_opaque_ap; + if (m_opaque_up) + *m_opaque_up = *rhs.m_opaque_up; else - ref() = *rhs.m_opaque_ap; + ref() = *rhs.m_opaque_up; } } @@ -38,32 +38,32 @@ SBSymbolContext::~SBSymbolContext() {} const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) { if (this != &rhs) { if (rhs.IsValid()) - m_opaque_ap.reset(new lldb_private::SymbolContext(*rhs.m_opaque_ap)); + m_opaque_up.reset(new lldb_private::SymbolContext(*rhs.m_opaque_up)); } return *this; } void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) { if (sc_ptr) { - if (m_opaque_ap) - *m_opaque_ap = *sc_ptr; + if (m_opaque_up) + *m_opaque_up = *sc_ptr; else - m_opaque_ap.reset(new SymbolContext(*sc_ptr)); + m_opaque_up.reset(new SymbolContext(*sc_ptr)); } else { - if (m_opaque_ap) - m_opaque_ap->Clear(true); + if (m_opaque_up) + m_opaque_up->Clear(true); } } -bool SBSymbolContext::IsValid() const { return m_opaque_ap != NULL; } +bool SBSymbolContext::IsValid() const { return m_opaque_up != NULL; } SBModule SBSymbolContext::GetModule() { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBModule sb_module; ModuleSP module_sp; - if (m_opaque_ap) { - module_sp = m_opaque_ap->module_sp; + if (m_opaque_up) { + module_sp = m_opaque_up->module_sp; sb_module.SetSP(module_sp); } @@ -71,7 +71,7 @@ SBModule SBSymbolContext::GetModule() { SBStream sstr; sb_module.GetDescription(sstr); log->Printf("SBSymbolContext(%p)::GetModule () => SBModule(%p): %s", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<void *>(module_sp.get()), sstr.GetData()); } @@ -79,7 +79,7 @@ SBModule SBSymbolContext::GetModule() { } SBCompileUnit SBSymbolContext::GetCompileUnit() { - return SBCompileUnit(m_opaque_ap ? m_opaque_ap->comp_unit : NULL); + return SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : NULL); } SBFunction SBSymbolContext::GetFunction() { @@ -87,33 +87,33 @@ SBFunction SBSymbolContext::GetFunction() { Function *function = NULL; - if (m_opaque_ap) - function = m_opaque_ap->function; + if (m_opaque_up) + function = m_opaque_up->function; SBFunction sb_function(function); if (log) log->Printf("SBSymbolContext(%p)::GetFunction () => SBFunction(%p)", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<void *>(function)); return sb_function; } SBBlock SBSymbolContext::GetBlock() { - return SBBlock(m_opaque_ap ? m_opaque_ap->block : NULL); + return SBBlock(m_opaque_up ? m_opaque_up->block : NULL); } SBLineEntry SBSymbolContext::GetLineEntry() { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBLineEntry sb_line_entry; - if (m_opaque_ap) - sb_line_entry.SetLineEntry(m_opaque_ap->line_entry); + if (m_opaque_up) + sb_line_entry.SetLineEntry(m_opaque_up->line_entry); if (log) { log->Printf("SBSymbolContext(%p)::GetLineEntry () => SBLineEntry(%p)", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<void *>(sb_line_entry.get())); } @@ -125,14 +125,14 @@ SBSymbol SBSymbolContext::GetSymbol() { Symbol *symbol = NULL; - if (m_opaque_ap) - symbol = m_opaque_ap->symbol; + if (m_opaque_up) + symbol = m_opaque_up->symbol; SBSymbol sb_symbol(symbol); if (log) log->Printf("SBSymbolContext(%p)::GetSymbol () => SBSymbol(%p)", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<void *>(symbol)); return sb_symbol; @@ -166,35 +166,35 @@ void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) { } lldb_private::SymbolContext *SBSymbolContext::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::SymbolContext &SBSymbolContext::operator*() const { - assert(m_opaque_ap.get()); - return *m_opaque_ap; + assert(m_opaque_up.get()); + return *m_opaque_up; } lldb_private::SymbolContext &SBSymbolContext::operator*() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new SymbolContext); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new SymbolContext); + return *m_opaque_up; } lldb_private::SymbolContext &SBSymbolContext::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new SymbolContext); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new SymbolContext); + return *m_opaque_up; } lldb_private::SymbolContext *SBSymbolContext::get() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } bool SBSymbolContext::GetDescription(SBStream &description) { Stream &strm = description.ref(); - if (m_opaque_ap) { - m_opaque_ap->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL); + if (m_opaque_up) { + m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL); } else strm.PutCString("No value"); @@ -205,8 +205,8 @@ SBSymbolContext SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc, SBAddress &parent_frame_addr) const { SBSymbolContext sb_sc; - if (m_opaque_ap.get() && curr_frame_pc.IsValid()) { - if (m_opaque_ap->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(), + if (m_opaque_up.get() && curr_frame_pc.IsValid()) { + if (m_opaque_up->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(), parent_frame_addr.ref())) return sb_sc; } diff --git a/source/API/SBSymbolContextList.cpp b/source/API/SBSymbolContextList.cpp index b078aab10..da344c4d5 100644 --- a/source/API/SBSymbolContextList.cpp +++ b/source/API/SBSymbolContextList.cpp @@ -14,32 +14,32 @@ using namespace lldb; using namespace lldb_private; SBSymbolContextList::SBSymbolContextList() - : m_opaque_ap(new SymbolContextList()) {} + : m_opaque_up(new SymbolContextList()) {} SBSymbolContextList::SBSymbolContextList(const SBSymbolContextList &rhs) - : m_opaque_ap(new SymbolContextList(*rhs.m_opaque_ap)) {} + : m_opaque_up(new SymbolContextList(*rhs.m_opaque_up)) {} SBSymbolContextList::~SBSymbolContextList() {} const SBSymbolContextList &SBSymbolContextList:: operator=(const SBSymbolContextList &rhs) { if (this != &rhs) { - *m_opaque_ap = *rhs.m_opaque_ap; + *m_opaque_up = *rhs.m_opaque_up; } return *this; } uint32_t SBSymbolContextList::GetSize() const { - if (m_opaque_ap) - return m_opaque_ap->GetSize(); + if (m_opaque_up) + return m_opaque_up->GetSize(); return 0; } SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) { SBSymbolContext sb_sc; - if (m_opaque_ap) { + if (m_opaque_up) { SymbolContext sc; - if (m_opaque_ap->GetContextAtIndex(idx, sc)) { + if (m_opaque_up->GetContextAtIndex(idx, sc)) { sb_sc.SetSymbolContext(&sc); } } @@ -47,34 +47,34 @@ SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) { } void SBSymbolContextList::Clear() { - if (m_opaque_ap) - m_opaque_ap->Clear(); + if (m_opaque_up) + m_opaque_up->Clear(); } void SBSymbolContextList::Append(SBSymbolContext &sc) { - if (sc.IsValid() && m_opaque_ap.get()) - m_opaque_ap->Append(*sc); + if (sc.IsValid() && m_opaque_up.get()) + m_opaque_up->Append(*sc); } void SBSymbolContextList::Append(SBSymbolContextList &sc_list) { - if (sc_list.IsValid() && m_opaque_ap.get()) - m_opaque_ap->Append(*sc_list); + if (sc_list.IsValid() && m_opaque_up.get()) + m_opaque_up->Append(*sc_list); } -bool SBSymbolContextList::IsValid() const { return m_opaque_ap != NULL; } +bool SBSymbolContextList::IsValid() const { return m_opaque_up != NULL; } lldb_private::SymbolContextList *SBSymbolContextList::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } lldb_private::SymbolContextList &SBSymbolContextList::operator*() const { - assert(m_opaque_ap.get()); - return *m_opaque_ap; + assert(m_opaque_up.get()); + return *m_opaque_up; } bool SBSymbolContextList::GetDescription(lldb::SBStream &description) { Stream &strm = description.ref(); - if (m_opaque_ap) - m_opaque_ap->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL); + if (m_opaque_up) + m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL); return true; } diff --git a/source/API/SBTarget.cpp b/source/API/SBTarget.cpp index c7dee6343..b863b3d3b 100644 --- a/source/API/SBTarget.cpp +++ b/source/API/SBTarget.cpp @@ -1570,7 +1570,7 @@ lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) { lldb::SBModule sb_module; TargetSP target_sp(GetSP()); if (target_sp) - sb_module.SetSP(target_sp->GetSharedModule(*module_spec.m_opaque_ap)); + sb_module.SetSP(target_sp->GetSharedModule(*module_spec.m_opaque_up)); return sb_module; } diff --git a/source/API/SBType.cpp b/source/API/SBType.cpp index b67f9bc84..25a56dea7 100644 --- a/source/API/SBType.cpp +++ b/source/API/SBType.cpp @@ -44,7 +44,7 @@ SBType::SBType(const SBType &rhs) : m_opaque_sp() { } // SBType::SBType (TypeImpl* impl) : -// m_opaque_ap(impl) +// m_opaque_up(impl) //{} // bool SBType::operator==(SBType &rhs) { @@ -444,20 +444,20 @@ lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) { return eTemplateArgumentKindNull; } -SBTypeList::SBTypeList() : m_opaque_ap(new TypeListImpl()) {} +SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {} SBTypeList::SBTypeList(const SBTypeList &rhs) - : m_opaque_ap(new TypeListImpl()) { + : m_opaque_up(new TypeListImpl()) { for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize(); i < rhs_size; i++) Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i)); } -bool SBTypeList::IsValid() { return (m_opaque_ap != NULL); } +bool SBTypeList::IsValid() { return (m_opaque_up != NULL); } SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { if (this != &rhs) { - m_opaque_ap.reset(new TypeListImpl()); + m_opaque_up.reset(new TypeListImpl()); for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize(); i < rhs_size; i++) Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i)); @@ -467,75 +467,75 @@ SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { void SBTypeList::Append(SBType type) { if (type.IsValid()) - m_opaque_ap->Append(type.m_opaque_sp); + m_opaque_up->Append(type.m_opaque_sp); } SBType SBTypeList::GetTypeAtIndex(uint32_t index) { - if (m_opaque_ap) - return SBType(m_opaque_ap->GetTypeAtIndex(index)); + if (m_opaque_up) + return SBType(m_opaque_up->GetTypeAtIndex(index)); return SBType(); } -uint32_t SBTypeList::GetSize() { return m_opaque_ap->GetSize(); } +uint32_t SBTypeList::GetSize() { return m_opaque_up->GetSize(); } SBTypeList::~SBTypeList() {} -SBTypeMember::SBTypeMember() : m_opaque_ap() {} +SBTypeMember::SBTypeMember() : m_opaque_up() {} SBTypeMember::~SBTypeMember() {} -SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_ap() { +SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_up() { if (this != &rhs) { if (rhs.IsValid()) - m_opaque_ap.reset(new TypeMemberImpl(rhs.ref())); + m_opaque_up.reset(new TypeMemberImpl(rhs.ref())); } } lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) { if (this != &rhs) { if (rhs.IsValid()) - m_opaque_ap.reset(new TypeMemberImpl(rhs.ref())); + m_opaque_up.reset(new TypeMemberImpl(rhs.ref())); } return *this; } -bool SBTypeMember::IsValid() const { return m_opaque_ap.get(); } +bool SBTypeMember::IsValid() const { return m_opaque_up.get(); } const char *SBTypeMember::GetName() { - if (m_opaque_ap) - return m_opaque_ap->GetName().GetCString(); + if (m_opaque_up) + return m_opaque_up->GetName().GetCString(); return NULL; } SBType SBTypeMember::GetType() { SBType sb_type; - if (m_opaque_ap) { - sb_type.SetSP(m_opaque_ap->GetTypeImpl()); + if (m_opaque_up) { + sb_type.SetSP(m_opaque_up->GetTypeImpl()); } return sb_type; } uint64_t SBTypeMember::GetOffsetInBytes() { - if (m_opaque_ap) - return m_opaque_ap->GetBitOffset() / 8u; + if (m_opaque_up) + return m_opaque_up->GetBitOffset() / 8u; return 0; } uint64_t SBTypeMember::GetOffsetInBits() { - if (m_opaque_ap) - return m_opaque_ap->GetBitOffset(); + if (m_opaque_up) + return m_opaque_up->GetBitOffset(); return 0; } bool SBTypeMember::IsBitfield() { - if (m_opaque_ap) - return m_opaque_ap->GetIsBitfield(); + if (m_opaque_up) + return m_opaque_up->GetIsBitfield(); return false; } uint32_t SBTypeMember::GetBitfieldSizeInBits() { - if (m_opaque_ap) - return m_opaque_ap->GetBitfieldBitSize(); + if (m_opaque_up) + return m_opaque_up->GetBitfieldBitSize(); return 0; } @@ -543,23 +543,23 @@ bool SBTypeMember::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { Stream &strm = description.ref(); - if (m_opaque_ap) { - const uint32_t bit_offset = m_opaque_ap->GetBitOffset(); + if (m_opaque_up) { + const uint32_t bit_offset = m_opaque_up->GetBitOffset(); const uint32_t byte_offset = bit_offset / 8u; const uint32_t byte_bit_offset = bit_offset % 8u; - const char *name = m_opaque_ap->GetName().GetCString(); + const char *name = m_opaque_up->GetName().GetCString(); if (byte_bit_offset) strm.Printf("+%u + %u bits: (", byte_offset, byte_bit_offset); else strm.Printf("+%u: (", byte_offset); - TypeImplSP type_impl_sp(m_opaque_ap->GetTypeImpl()); + TypeImplSP type_impl_sp(m_opaque_up->GetTypeImpl()); if (type_impl_sp) type_impl_sp->GetDescription(strm, description_level); strm.Printf(") %s", name); - if (m_opaque_ap->GetIsBitfield()) { - const uint32_t bitfield_bit_size = m_opaque_ap->GetBitfieldBitSize(); + if (m_opaque_up->GetIsBitfield()) { + const uint32_t bitfield_bit_size = m_opaque_up->GetBitfieldBitSize(); strm.Printf(" : %u", bitfield_bit_size); } } else { @@ -569,16 +569,16 @@ bool SBTypeMember::GetDescription(lldb::SBStream &description, } void SBTypeMember::reset(TypeMemberImpl *type_member_impl) { - m_opaque_ap.reset(type_member_impl); + m_opaque_up.reset(type_member_impl); } TypeMemberImpl &SBTypeMember::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new TypeMemberImpl()); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new TypeMemberImpl()); + return *m_opaque_up; } -const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_ap; } +const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; } SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() {} diff --git a/source/API/SBTypeEnumMember.cpp b/source/API/SBTypeEnumMember.cpp index d8b70a431..5ea28e40e 100644 --- a/source/API/SBTypeEnumMember.cpp +++ b/source/API/SBTypeEnumMember.cpp @@ -85,22 +85,22 @@ const TypeEnumMemberImpl &SBTypeEnumMember::ref() const { } SBTypeEnumMemberList::SBTypeEnumMemberList() - : m_opaque_ap(new TypeEnumMemberListImpl()) {} + : m_opaque_up(new TypeEnumMemberListImpl()) {} SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs) - : m_opaque_ap(new TypeEnumMemberListImpl()) { + : m_opaque_up(new TypeEnumMemberListImpl()) { for (uint32_t i = 0, rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize(); i < rhs_size; i++) Append(const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i)); } -bool SBTypeEnumMemberList::IsValid() { return (m_opaque_ap != NULL); } +bool SBTypeEnumMemberList::IsValid() { return (m_opaque_up != NULL); } SBTypeEnumMemberList &SBTypeEnumMemberList:: operator=(const SBTypeEnumMemberList &rhs) { if (this != &rhs) { - m_opaque_ap.reset(new TypeEnumMemberListImpl()); + m_opaque_up.reset(new TypeEnumMemberListImpl()); for (uint32_t i = 0, rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize(); i < rhs_size; i++) @@ -112,17 +112,17 @@ operator=(const SBTypeEnumMemberList &rhs) { void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) { if (enum_member.IsValid()) - m_opaque_ap->Append(enum_member.m_opaque_sp); + m_opaque_up->Append(enum_member.m_opaque_sp); } SBTypeEnumMember SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) { - if (m_opaque_ap) - return SBTypeEnumMember(m_opaque_ap->GetTypeEnumMemberAtIndex(index)); + if (m_opaque_up) + return SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index)); return SBTypeEnumMember(); } -uint32_t SBTypeEnumMemberList::GetSize() { return m_opaque_ap->GetSize(); } +uint32_t SBTypeEnumMemberList::GetSize() { return m_opaque_up->GetSize(); } SBTypeEnumMemberList::~SBTypeEnumMemberList() {} diff --git a/source/API/SBTypeSummary.cpp b/source/API/SBTypeSummary.cpp index 23c2781b7..5c0152209 100644 --- a/source/API/SBTypeSummary.cpp +++ b/source/API/SBTypeSummary.cpp @@ -18,62 +18,62 @@ using namespace lldb; using namespace lldb_private; SBTypeSummaryOptions::SBTypeSummaryOptions() { - m_opaque_ap.reset(new TypeSummaryOptions()); + m_opaque_up.reset(new TypeSummaryOptions()); } SBTypeSummaryOptions::SBTypeSummaryOptions( const lldb::SBTypeSummaryOptions &rhs) { - if (rhs.m_opaque_ap) - m_opaque_ap.reset(new TypeSummaryOptions(*rhs.m_opaque_ap)); + if (rhs.m_opaque_up) + m_opaque_up.reset(new TypeSummaryOptions(*rhs.m_opaque_up)); else - m_opaque_ap.reset(new TypeSummaryOptions()); + m_opaque_up.reset(new TypeSummaryOptions()); } SBTypeSummaryOptions::~SBTypeSummaryOptions() {} -bool SBTypeSummaryOptions::IsValid() { return m_opaque_ap.get(); } +bool SBTypeSummaryOptions::IsValid() { return m_opaque_up.get(); } lldb::LanguageType SBTypeSummaryOptions::GetLanguage() { if (IsValid()) - return m_opaque_ap->GetLanguage(); + return m_opaque_up->GetLanguage(); return lldb::eLanguageTypeUnknown; } lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() { if (IsValid()) - return m_opaque_ap->GetCapping(); + return m_opaque_up->GetCapping(); return eTypeSummaryCapped; } void SBTypeSummaryOptions::SetLanguage(lldb::LanguageType l) { if (IsValid()) - m_opaque_ap->SetLanguage(l); + m_opaque_up->SetLanguage(l); } void SBTypeSummaryOptions::SetCapping(lldb::TypeSummaryCapping c) { if (IsValid()) - m_opaque_ap->SetCapping(c); + m_opaque_up->SetCapping(c); } lldb_private::TypeSummaryOptions *SBTypeSummaryOptions::operator->() { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::TypeSummaryOptions *SBTypeSummaryOptions:: operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } lldb_private::TypeSummaryOptions *SBTypeSummaryOptions::get() { - return m_opaque_ap.get(); + return m_opaque_up.get(); } lldb_private::TypeSummaryOptions &SBTypeSummaryOptions::ref() { - return *m_opaque_ap; + return *m_opaque_up; } const lldb_private::TypeSummaryOptions &SBTypeSummaryOptions::ref() const { - return *m_opaque_ap; + return *m_opaque_up; } SBTypeSummaryOptions::SBTypeSummaryOptions( @@ -84,9 +84,9 @@ SBTypeSummaryOptions::SBTypeSummaryOptions( void SBTypeSummaryOptions::SetOptions( const lldb_private::TypeSummaryOptions *lldb_object_ptr) { if (lldb_object_ptr) - m_opaque_ap.reset(new TypeSummaryOptions(*lldb_object_ptr)); + m_opaque_up.reset(new TypeSummaryOptions(*lldb_object_ptr)); else - m_opaque_ap.reset(new TypeSummaryOptions()); + m_opaque_up.reset(new TypeSummaryOptions()); } SBTypeSummary::SBTypeSummary() : m_opaque_sp() {} diff --git a/source/API/SBValueList.cpp b/source/API/SBValueList.cpp index b03b86e41..69af083b1 100644 --- a/source/API/SBValueList.cpp +++ b/source/API/SBValueList.cpp @@ -67,77 +67,77 @@ private: std::vector<lldb::SBValue> m_values; }; -SBValueList::SBValueList() : m_opaque_ap() {} +SBValueList::SBValueList() : m_opaque_up() {} -SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_ap() { +SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_up() { Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (rhs.IsValid()) - m_opaque_ap.reset(new ValueListImpl(*rhs)); + m_opaque_up.reset(new ValueListImpl(*rhs)); if (log) { log->Printf( "SBValueList::SBValueList (rhs.ap=%p) => this.ap = %p", - static_cast<void *>(rhs.IsValid() ? rhs.m_opaque_ap.get() : NULL), - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(rhs.IsValid() ? rhs.m_opaque_up.get() : NULL), + static_cast<void *>(m_opaque_up.get())); } } -SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_ap() { +SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() { Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (lldb_object_ptr) - m_opaque_ap.reset(new ValueListImpl(*lldb_object_ptr)); + m_opaque_up.reset(new ValueListImpl(*lldb_object_ptr)); if (log) { log->Printf("SBValueList::SBValueList (lldb_object_ptr=%p) => this.ap = %p", static_cast<const void *>(lldb_object_ptr), - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(m_opaque_up.get())); } } SBValueList::~SBValueList() {} -bool SBValueList::IsValid() const { return (m_opaque_ap != NULL); } +bool SBValueList::IsValid() const { return (m_opaque_up != NULL); } -void SBValueList::Clear() { m_opaque_ap.reset(); } +void SBValueList::Clear() { m_opaque_up.reset(); } const SBValueList &SBValueList::operator=(const SBValueList &rhs) { if (this != &rhs) { if (rhs.IsValid()) - m_opaque_ap.reset(new ValueListImpl(*rhs)); + m_opaque_up.reset(new ValueListImpl(*rhs)); else - m_opaque_ap.reset(); + m_opaque_up.reset(); } return *this; } -ValueListImpl *SBValueList::operator->() { return m_opaque_ap.get(); } +ValueListImpl *SBValueList::operator->() { return m_opaque_up.get(); } -ValueListImpl &SBValueList::operator*() { return *m_opaque_ap; } +ValueListImpl &SBValueList::operator*() { return *m_opaque_up; } const ValueListImpl *SBValueList::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } -const ValueListImpl &SBValueList::operator*() const { return *m_opaque_ap; } +const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; } void SBValueList::Append(const SBValue &val_obj) { CreateIfNeeded(); - m_opaque_ap->Append(val_obj); + m_opaque_up->Append(val_obj); } void SBValueList::Append(lldb::ValueObjectSP &val_obj_sp) { if (val_obj_sp) { CreateIfNeeded(); - m_opaque_ap->Append(SBValue(val_obj_sp)); + m_opaque_up->Append(SBValue(val_obj_sp)); } } void SBValueList::Append(const lldb::SBValueList &value_list) { if (value_list.IsValid()) { CreateIfNeeded(); - m_opaque_ap->Append(*value_list); + m_opaque_up->Append(*value_list); } } @@ -149,15 +149,15 @@ SBValue SBValueList::GetValueAtIndex(uint32_t idx) const { // idx); SBValue sb_value; - if (m_opaque_ap) - sb_value = m_opaque_ap->GetValueAtIndex(idx); + if (m_opaque_up) + sb_value = m_opaque_up->GetValueAtIndex(idx); if (log) { SBStream sstr; sb_value.GetDescription(sstr); log->Printf("SBValueList::GetValueAtIndex (this.ap=%p, idx=%d) => SBValue " "(this.sp = %p, '%s')", - static_cast<void *>(m_opaque_ap.get()), idx, + static_cast<void *>(m_opaque_up.get()), idx, static_cast<void *>(sb_value.GetSP().get()), sstr.GetData()); } @@ -171,38 +171,38 @@ uint32_t SBValueList::GetSize() const { // log->Printf ("SBValueList::GetSize ()"); uint32_t size = 0; - if (m_opaque_ap) - size = m_opaque_ap->GetSize(); + if (m_opaque_up) + size = m_opaque_up->GetSize(); if (log) log->Printf("SBValueList::GetSize (this.ap=%p) => %d", - static_cast<void *>(m_opaque_ap.get()), size); + static_cast<void *>(m_opaque_up.get()), size); return size; } void SBValueList::CreateIfNeeded() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new ValueListImpl()); + if (m_opaque_up == NULL) + m_opaque_up.reset(new ValueListImpl()); } SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) { SBValue sb_value; - if (m_opaque_ap) - sb_value = m_opaque_ap->FindValueByUID(uid); + if (m_opaque_up) + sb_value = m_opaque_up->FindValueByUID(uid); return sb_value; } SBValue SBValueList::GetFirstValueByName(const char *name) const { SBValue sb_value; - if (m_opaque_ap) - sb_value = m_opaque_ap->GetFirstValueByName(name); + if (m_opaque_up) + sb_value = m_opaque_up->GetFirstValueByName(name); return sb_value; } -void *SBValueList::opaque_ptr() { return m_opaque_ap.get(); } +void *SBValueList::opaque_ptr() { return m_opaque_up.get(); } ValueListImpl &SBValueList::ref() { CreateIfNeeded(); - return *m_opaque_ap; + return *m_opaque_up; } diff --git a/source/API/SBVariablesOptions.cpp b/source/API/SBVariablesOptions.cpp index 42eafaa8c..69c684d99 100644 --- a/source/API/SBVariablesOptions.cpp +++ b/source/API/SBVariablesOptions.cpp @@ -80,98 +80,98 @@ private: }; SBVariablesOptions::SBVariablesOptions() - : m_opaque_ap(new VariablesOptionsImpl()) {} + : m_opaque_up(new VariablesOptionsImpl()) {} SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options) - : m_opaque_ap(new VariablesOptionsImpl(options.ref())) {} + : m_opaque_up(new VariablesOptionsImpl(options.ref())) {} SBVariablesOptions &SBVariablesOptions:: operator=(const SBVariablesOptions &options) { - m_opaque_ap.reset(new VariablesOptionsImpl(options.ref())); + m_opaque_up.reset(new VariablesOptionsImpl(options.ref())); return *this; } SBVariablesOptions::~SBVariablesOptions() = default; -bool SBVariablesOptions::IsValid() const { return m_opaque_ap != nullptr; } +bool SBVariablesOptions::IsValid() const { return m_opaque_up != nullptr; } bool SBVariablesOptions::GetIncludeArguments() const { - return m_opaque_ap->GetIncludeArguments(); + return m_opaque_up->GetIncludeArguments(); } void SBVariablesOptions::SetIncludeArguments(bool arguments) { - m_opaque_ap->SetIncludeArguments(arguments); + m_opaque_up->SetIncludeArguments(arguments); } bool SBVariablesOptions::GetIncludeRecognizedArguments( const lldb::SBTarget &target) const { - return m_opaque_ap->GetIncludeRecognizedArguments(target.GetSP()); + return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP()); } void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) { - m_opaque_ap->SetIncludeRecognizedArguments(arguments); + m_opaque_up->SetIncludeRecognizedArguments(arguments); } bool SBVariablesOptions::GetIncludeLocals() const { - return m_opaque_ap->GetIncludeLocals(); + return m_opaque_up->GetIncludeLocals(); } void SBVariablesOptions::SetIncludeLocals(bool locals) { - m_opaque_ap->SetIncludeLocals(locals); + m_opaque_up->SetIncludeLocals(locals); } bool SBVariablesOptions::GetIncludeStatics() const { - return m_opaque_ap->GetIncludeStatics(); + return m_opaque_up->GetIncludeStatics(); } void SBVariablesOptions::SetIncludeStatics(bool statics) { - m_opaque_ap->SetIncludeStatics(statics); + m_opaque_up->SetIncludeStatics(statics); } bool SBVariablesOptions::GetInScopeOnly() const { - return m_opaque_ap->GetInScopeOnly(); + return m_opaque_up->GetInScopeOnly(); } void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) { - m_opaque_ap->SetInScopeOnly(in_scope_only); + m_opaque_up->SetInScopeOnly(in_scope_only); } bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const { - return m_opaque_ap->GetIncludeRuntimeSupportValues(); + return m_opaque_up->GetIncludeRuntimeSupportValues(); } void SBVariablesOptions::SetIncludeRuntimeSupportValues( bool runtime_support_values) { - m_opaque_ap->SetIncludeRuntimeSupportValues(runtime_support_values); + m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values); } lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const { - return m_opaque_ap->GetUseDynamic(); + return m_opaque_up->GetUseDynamic(); } void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) { - m_opaque_ap->SetUseDynamic(dynamic); + m_opaque_up->SetUseDynamic(dynamic); } VariablesOptionsImpl *SBVariablesOptions::operator->() { - return m_opaque_ap.operator->(); + return m_opaque_up.operator->(); } const VariablesOptionsImpl *SBVariablesOptions::operator->() const { - return m_opaque_ap.operator->(); + return m_opaque_up.operator->(); } -VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_ap.get(); } +VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_up.get(); } -VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_ap; } +VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_up; } const VariablesOptionsImpl &SBVariablesOptions::ref() const { - return *m_opaque_ap; + return *m_opaque_up; } SBVariablesOptions::SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr) - : m_opaque_ap(std::move(lldb_object_ptr)) {} + : m_opaque_up(std::move(lldb_object_ptr)) {} void SBVariablesOptions::SetOptions(VariablesOptionsImpl *lldb_object_ptr) { - m_opaque_ap.reset(std::move(lldb_object_ptr)); + m_opaque_up.reset(std::move(lldb_object_ptr)); } diff --git a/source/Breakpoint/BreakpointLocation.cpp b/source/Breakpoint/BreakpointLocation.cpp index d59272c70..b718e2aee 100644 --- a/source/Breakpoint/BreakpointLocation.cpp +++ b/source/Breakpoint/BreakpointLocation.cpp @@ -35,7 +35,7 @@ BreakpointLocation::BreakpointLocation(break_id_t loc_id, Breakpoint &owner, hardware), m_being_created(true), m_should_resolve_indirect_functions(false), m_is_reexported(false), m_is_indirect(false), m_address(addr), - m_owner(owner), m_options_ap(), m_bp_site_sp(), m_condition_mutex() { + m_owner(owner), m_options_up(), m_bp_site_sp(), m_condition_mutex() { if (check_for_resolver) { Symbol *symbol = m_address.CalculateSymbolContextSymbol(); if (symbol && symbol->IsIndirect()) { @@ -56,10 +56,10 @@ lldb::addr_t BreakpointLocation::GetLoadAddress() const { const BreakpointOptions * BreakpointLocation::GetOptionsSpecifyingKind(BreakpointOptions::OptionKind kind) const { - if (m_options_ap && m_options_ap->IsOptionSet(kind)) - return m_options_ap.get(); - else - return m_owner.GetOptions(); + if (m_options_up && m_options_up->IsOptionSet(kind)) + return m_options_up.get(); + else + return m_owner.GetOptions(); } Address &BreakpointLocation::GetAddress() { return m_address; } @@ -71,8 +71,8 @@ Target &BreakpointLocation::GetTarget() { return m_owner.GetTarget(); } bool BreakpointLocation::IsEnabled() const { if (!m_owner.IsEnabled()) return false; - else if (m_options_ap != nullptr) - return m_options_ap->IsEnabled(); + else if (m_options_up != nullptr) + return m_options_up->IsEnabled(); else return true; } @@ -89,9 +89,9 @@ void BreakpointLocation::SetEnabled(bool enabled) { } bool BreakpointLocation::IsAutoContinue() const { - if (m_options_ap - && m_options_ap->IsOptionSet(BreakpointOptions::eAutoContinue)) - return m_options_ap->IsAutoContinue(); + if (m_options_up && + m_options_up->IsOptionSet(BreakpointOptions::eAutoContinue)) + return m_options_up->IsAutoContinue(); else return m_owner.IsAutoContinue(); } @@ -107,8 +107,8 @@ void BreakpointLocation::SetThreadID(lldb::tid_t thread_id) { else { // If we're resetting this to an invalid thread id, then don't make an // options pointer just to do that. - if (m_options_ap != nullptr) - m_options_ap->SetThreadID(thread_id); + if (m_options_up != nullptr) + m_options_up->SetThreadID(thread_id); } SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged); } @@ -129,8 +129,8 @@ void BreakpointLocation::SetThreadIndex(uint32_t index) { else { // If we're resetting this to an invalid thread id, then don't make an // options pointer just to do that. - if (m_options_ap != nullptr) - m_options_ap->GetThreadSpec()->SetIndex(index); + if (m_options_up != nullptr) + m_options_up->GetThreadSpec()->SetIndex(index); } SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged); } @@ -151,8 +151,8 @@ void BreakpointLocation::SetThreadName(const char *thread_name) { else { // If we're resetting this to an invalid thread id, then don't make an // options pointer just to do that. - if (m_options_ap != nullptr) - m_options_ap->GetThreadSpec()->SetName(thread_name); + if (m_options_up != nullptr) + m_options_up->GetThreadSpec()->SetName(thread_name); } SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged); } @@ -173,8 +173,8 @@ void BreakpointLocation::SetQueueName(const char *queue_name) { else { // If we're resetting this to an invalid thread id, then don't make an // options pointer just to do that. - if (m_options_ap != nullptr) - m_options_ap->GetThreadSpec()->SetQueueName(queue_name); + if (m_options_up != nullptr) + m_options_up->GetThreadSpec()->SetQueueName(queue_name); } SendBreakpointLocationChangedEvent(eBreakpointEventTypeThreadChanged); } @@ -190,8 +190,8 @@ const char *BreakpointLocation::GetQueueName() const { } bool BreakpointLocation::InvokeCallback(StoppointCallbackContext *context) { - if (m_options_ap != nullptr && m_options_ap->HasCallback()) - return m_options_ap->InvokeCallback(context, m_owner.GetID(), GetID()); + if (m_options_up != nullptr && m_options_up->HasCallback()) + return m_options_up->InvokeCallback(context, m_owner.GetID(), GetID()); else return m_owner.InvokeCallback(context, GetID()); } @@ -344,16 +344,16 @@ void BreakpointLocation::SetIgnoreCount(uint32_t n) { } void BreakpointLocation::DecrementIgnoreCount() { - if (m_options_ap != nullptr) { - uint32_t loc_ignore = m_options_ap->GetIgnoreCount(); + if (m_options_up != nullptr) { + uint32_t loc_ignore = m_options_up->GetIgnoreCount(); if (loc_ignore != 0) - m_options_ap->SetIgnoreCount(loc_ignore - 1); + m_options_up->SetIgnoreCount(loc_ignore - 1); } } bool BreakpointLocation::IgnoreCountShouldStop() { - if (m_options_ap != nullptr) { - uint32_t loc_ignore = m_options_ap->GetIgnoreCount(); + if (m_options_up != nullptr) { + uint32_t loc_ignore = m_options_up->GetIgnoreCount(); if (loc_ignore != 0) { m_owner.DecrementIgnoreCount(); DecrementIgnoreCount(); // Have to decrement our owners' ignore count, @@ -369,11 +369,10 @@ BreakpointOptions *BreakpointLocation::GetLocationOptions() { // If we make the copy we don't copy the callbacks because that is // potentially expensive and we don't want to do that for the simple case // where someone is just disabling the location. - if (m_options_ap == nullptr) - m_options_ap.reset( - new BreakpointOptions(false)); + if (m_options_up == nullptr) + m_options_up.reset(new BreakpointOptions(false)); - return m_options_ap.get(); + return m_options_up.get(); } bool BreakpointLocation::ValidForThisThread(Thread *thread) { @@ -603,17 +602,17 @@ void BreakpointLocation::GetDescription(Stream *s, s->Indent(); s->Printf("hit count = %-4u\n", GetHitCount()); - if (m_options_ap) { + if (m_options_up) { s->Indent(); - m_options_ap->GetDescription(s, level); + m_options_up->GetDescription(s, level); s->EOL(); } s->IndentLess(); } else if (level != eDescriptionLevelInitial) { s->Printf(", %sresolved, hit count = %u ", (IsResolved() ? "" : "un"), GetHitCount()); - if (m_options_ap) { - m_options_ap->GetDescription(s, level); + if (m_options_up) { + m_options_up->GetDescription(s, level); } } } @@ -629,7 +628,7 @@ void BreakpointLocation::Dump(Stream *s) const { "hw_index = %i hit_count = %-4u ignore_count = %-4u", GetID(), tid, (uint64_t)m_address.GetOpcodeLoadAddress(&m_owner.GetTarget()), - (m_options_ap ? m_options_ap->IsEnabled() : m_owner.IsEnabled()) + (m_options_up ? m_options_up->IsEnabled() : m_owner.IsEnabled()) ? "enabled " : "disabled", IsHardware() ? "hardware" : "software", GetHardwareIndex(), diff --git a/source/Breakpoint/BreakpointOptions.cpp b/source/Breakpoint/BreakpointOptions.cpp index 8bd732e77..491273cfb 100644 --- a/source/Breakpoint/BreakpointOptions.cpp +++ b/source/Breakpoint/BreakpointOptions.cpp @@ -125,12 +125,12 @@ bool BreakpointOptions::NullCallback(void *baton, BreakpointOptions::BreakpointOptions(bool all_flags_set) : m_callback(BreakpointOptions::NullCallback), m_callback_baton_sp(), m_baton_is_command_baton(false), m_callback_is_synchronous(false), - m_enabled(true), m_one_shot(false), m_ignore_count(0), m_thread_spec_ap(), + m_enabled(true), m_one_shot(false), m_ignore_count(0), m_thread_spec_up(), m_condition_text(), m_condition_text_hash(0), m_auto_continue(false), m_set_flags(0) { - if (all_flags_set) - m_set_flags.Set(~((Flags::ValueType) 0)); - } + if (all_flags_set) + m_set_flags.Set(~((Flags::ValueType)0)); +} BreakpointOptions::BreakpointOptions(const char *condition, bool enabled, int32_t ignore, bool one_shot, @@ -155,11 +155,10 @@ BreakpointOptions::BreakpointOptions(const BreakpointOptions &rhs) m_baton_is_command_baton(rhs.m_baton_is_command_baton), m_callback_is_synchronous(rhs.m_callback_is_synchronous), m_enabled(rhs.m_enabled), m_one_shot(rhs.m_one_shot), - m_ignore_count(rhs.m_ignore_count), m_thread_spec_ap(), - m_auto_continue(rhs.m_auto_continue), - m_set_flags(rhs.m_set_flags) { - if (rhs.m_thread_spec_ap != nullptr) - m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap)); + m_ignore_count(rhs.m_ignore_count), m_thread_spec_up(), + m_auto_continue(rhs.m_auto_continue), m_set_flags(rhs.m_set_flags) { + if (rhs.m_thread_spec_up != nullptr) + m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up)); m_condition_text = rhs.m_condition_text; m_condition_text_hash = rhs.m_condition_text_hash; } @@ -176,8 +175,8 @@ operator=(const BreakpointOptions &rhs) { m_enabled = rhs.m_enabled; m_one_shot = rhs.m_one_shot; m_ignore_count = rhs.m_ignore_count; - if (rhs.m_thread_spec_ap != nullptr) - m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap)); + if (rhs.m_thread_spec_up != nullptr) + m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up)); m_condition_text = rhs.m_condition_text; m_condition_text_hash = rhs.m_condition_text_hash; m_auto_continue = rhs.m_auto_continue; @@ -228,12 +227,11 @@ void BreakpointOptions::CopyOverSetOptions(const BreakpointOptions &incoming) m_auto_continue = incoming.m_auto_continue; m_set_flags.Set(eAutoContinue); } - if (incoming.m_set_flags.Test(eThreadSpec) && incoming.m_thread_spec_ap) - { - if (!m_thread_spec_ap) - m_thread_spec_ap.reset(new ThreadSpec(*incoming.m_thread_spec_ap)); + if (incoming.m_set_flags.Test(eThreadSpec) && incoming.m_thread_spec_up) { + if (!m_thread_spec_up) + m_thread_spec_up.reset(new ThreadSpec(*incoming.m_thread_spec_up)); else - *m_thread_spec_ap = *incoming.m_thread_spec_ap; + *m_thread_spec_up = *incoming.m_thread_spec_up; m_set_flags.Set(eThreadSpec); } } @@ -404,9 +402,9 @@ StructuredData::ObjectSP BreakpointOptions::SerializeToStructuredData() { BreakpointOptions::CommandData::GetSerializationKey(), commands_sp); } } - if (m_set_flags.Test(eThreadSpec) && m_thread_spec_ap) { + if (m_set_flags.Test(eThreadSpec) && m_thread_spec_up) { StructuredData::ObjectSP thread_spec_sp = - m_thread_spec_ap->SerializeToStructuredData(); + m_thread_spec_up->SerializeToStructuredData(); options_dict_sp->AddItem(ThreadSpec::GetSerializationKey(), thread_spec_sp); } @@ -521,16 +519,16 @@ const char *BreakpointOptions::GetConditionText(size_t *hash) const { } const ThreadSpec *BreakpointOptions::GetThreadSpecNoCreate() const { - return m_thread_spec_ap.get(); + return m_thread_spec_up.get(); } ThreadSpec *BreakpointOptions::GetThreadSpec() { - if (m_thread_spec_ap == nullptr) { + if (m_thread_spec_up == nullptr) { m_set_flags.Set(eThreadSpec); - m_thread_spec_ap.reset(new ThreadSpec()); + m_thread_spec_up.reset(new ThreadSpec()); } - return m_thread_spec_ap.get(); + return m_thread_spec_up.get(); } void BreakpointOptions::SetThreadID(lldb::tid_t thread_id) { @@ -540,7 +538,7 @@ void BreakpointOptions::SetThreadID(lldb::tid_t thread_id) { void BreakpointOptions::SetThreadSpec( std::unique_ptr<ThreadSpec> &thread_spec_up) { - m_thread_spec_ap = std::move(thread_spec_up); + m_thread_spec_up = std::move(thread_spec_up); m_set_flags.Set(eThreadSpec); } @@ -572,8 +570,8 @@ void BreakpointOptions::GetDescription(Stream *s, if (m_auto_continue) s->Printf("auto-continue "); - if (m_thread_spec_ap) - m_thread_spec_ap->GetDescription(s, level); + if (m_thread_spec_up) + m_thread_spec_up->GetDescription(s, level); if (level == lldb::eDescriptionLevelFull) { s->IndentLess(); @@ -678,7 +676,7 @@ bool BreakpointOptions::BreakpointOptionsCallbackFunction( void BreakpointOptions::Clear() { m_set_flags.Clear(); - m_thread_spec_ap.release(); + m_thread_spec_up.release(); m_one_shot = false; m_ignore_count = 0; m_auto_continue = false; diff --git a/source/Breakpoint/Watchpoint.cpp b/source/Breakpoint/Watchpoint.cpp index 844d8bb58..6481ad1a7 100644 --- a/source/Breakpoint/Watchpoint.cpp +++ b/source/Breakpoint/Watchpoint.cpp @@ -272,26 +272,26 @@ bool Watchpoint::InvokeCallback(StoppointCallbackContext *context) { void Watchpoint::SetCondition(const char *condition) { if (condition == nullptr || condition[0] == '\0') { - if (m_condition_ap) - m_condition_ap.reset(); + if (m_condition_up) + m_condition_up.reset(); } else { // Pass nullptr for expr_prefix (no translation-unit level definitions). Status error; - m_condition_ap.reset(m_target.GetUserExpressionForLanguage( + m_condition_up.reset(m_target.GetUserExpressionForLanguage( condition, llvm::StringRef(), lldb::eLanguageTypeUnknown, - UserExpression::eResultTypeAny, EvaluateExpressionOptions(), - nullptr, error)); + UserExpression::eResultTypeAny, EvaluateExpressionOptions(), nullptr, + error)); if (error.Fail()) { // FIXME: Log something... - m_condition_ap.reset(); + m_condition_up.reset(); } } SendWatchpointChangedEvent(eWatchpointEventTypeConditionChanged); } const char *Watchpoint::GetConditionText() const { - if (m_condition_ap) - return m_condition_ap->GetUserText(); + if (m_condition_up) + return m_condition_up->GetUserText(); else return nullptr; } diff --git a/source/Breakpoint/WatchpointOptions.cpp b/source/Breakpoint/WatchpointOptions.cpp index 8c796b7de..842cbc252 100644 --- a/source/Breakpoint/WatchpointOptions.cpp +++ b/source/Breakpoint/WatchpointOptions.cpp @@ -30,7 +30,7 @@ bool WatchpointOptions::NullCallback(void *baton, //---------------------------------------------------------------------- WatchpointOptions::WatchpointOptions() : m_callback(WatchpointOptions::NullCallback), m_callback_baton_sp(), - m_callback_is_synchronous(false), m_thread_spec_ap() {} + m_callback_is_synchronous(false), m_thread_spec_up() {} //---------------------------------------------------------------------- // WatchpointOptions copy constructor @@ -38,9 +38,9 @@ WatchpointOptions::WatchpointOptions() WatchpointOptions::WatchpointOptions(const WatchpointOptions &rhs) : m_callback(rhs.m_callback), m_callback_baton_sp(rhs.m_callback_baton_sp), m_callback_is_synchronous(rhs.m_callback_is_synchronous), - m_thread_spec_ap() { - if (rhs.m_thread_spec_ap != nullptr) - m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap)); + m_thread_spec_up() { + if (rhs.m_thread_spec_up != nullptr) + m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up)); } //---------------------------------------------------------------------- @@ -51,8 +51,8 @@ operator=(const WatchpointOptions &rhs) { m_callback = rhs.m_callback; m_callback_baton_sp = rhs.m_callback_baton_sp; m_callback_is_synchronous = rhs.m_callback_is_synchronous; - if (rhs.m_thread_spec_ap != nullptr) - m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap)); + if (rhs.m_thread_spec_up != nullptr) + m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up)); return *this; } @@ -113,14 +113,14 @@ bool WatchpointOptions::HasCallback() { } const ThreadSpec *WatchpointOptions::GetThreadSpecNoCreate() const { - return m_thread_spec_ap.get(); + return m_thread_spec_up.get(); } ThreadSpec *WatchpointOptions::GetThreadSpec() { - if (m_thread_spec_ap == nullptr) - m_thread_spec_ap.reset(new ThreadSpec()); + if (m_thread_spec_up == nullptr) + m_thread_spec_up.reset(new ThreadSpec()); - return m_thread_spec_ap.get(); + return m_thread_spec_up.get(); } void WatchpointOptions::SetThreadID(lldb::tid_t thread_id) { @@ -152,8 +152,8 @@ void WatchpointOptions::GetDescription(Stream *s, } else s->PutCString(" Options: "); - if (m_thread_spec_ap) - m_thread_spec_ap->GetDescription(s, level); + if (m_thread_spec_up) + m_thread_spec_up->GetDescription(s, level); else if (level == eDescriptionLevelBrief) s->PutCString("thread spec: no "); if (level == lldb::eDescriptionLevelFull) { diff --git a/source/Commands/CommandObjectCommands.cpp b/source/Commands/CommandObjectCommands.cpp index adce74717..df6ec6492 100644 --- a/source/Commands/CommandObjectCommands.cpp +++ b/source/Commands/CommandObjectCommands.cpp @@ -890,11 +890,11 @@ protected: auto command_name = args[0].ref; if (!m_interpreter.CommandExists(command_name)) { StreamString error_msg_stream; - const bool generate_apropos = true; + const bool generate_upropos = true; const bool generate_type_lookup = false; CommandObjectHelp::GenerateAdditionalHelpAvenuesMessage( &error_msg_stream, command_name, llvm::StringRef(), llvm::StringRef(), - generate_apropos, generate_type_lookup); + generate_upropos, generate_type_lookup); result.AppendError(error_msg_stream.GetString()); result.SetStatus(eReturnStatusFailed); return false; @@ -988,7 +988,7 @@ protected: void IOHandlerInputComplete(IOHandler &io_handler, std::string &data) override { io_handler.SetIsDone(true); - if (m_regex_cmd_ap) { + if (m_regex_cmd_up) { StringList lines; if (lines.SplitIntoLines(data)) { const size_t num_lines = lines.GetSize(); @@ -1007,8 +1007,8 @@ protected: } } } - if (m_regex_cmd_ap->HasRegexEntries()) { - CommandObjectSP cmd_sp(m_regex_cmd_ap.release()); + if (m_regex_cmd_up->HasRegexEntries()) { + CommandObjectSP cmd_sp(m_regex_cmd_up.release()); m_interpreter.AddCommand(cmd_sp->GetCommandName(), cmd_sp, true); } } @@ -1025,7 +1025,7 @@ protected: Status error; auto name = command[0].ref; - m_regex_cmd_ap = llvm::make_unique<CommandObjectRegexCommand>( + m_regex_cmd_up = llvm::make_unique<CommandObjectRegexCommand>( m_interpreter, name, m_options.GetHelp(), m_options.GetSyntax(), 10, 0, true); @@ -1070,7 +1070,7 @@ protected: bool check_only) { Status error; - if (!m_regex_cmd_ap) { + if (!m_regex_cmd_up) { error.SetErrorStringWithFormat( "invalid regular expression command object for: '%.*s'", (int)regex_sed.size(), regex_sed.data()); @@ -1156,22 +1156,22 @@ protected: std::string subst(regex_sed.substr(second_separator_char_pos + 1, third_separator_char_pos - second_separator_char_pos - 1)); - m_regex_cmd_ap->AddRegexCommand(regex.c_str(), subst.c_str()); + m_regex_cmd_up->AddRegexCommand(regex.c_str(), subst.c_str()); } return error; } void AddRegexCommandToInterpreter() { - if (m_regex_cmd_ap) { - if (m_regex_cmd_ap->HasRegexEntries()) { - CommandObjectSP cmd_sp(m_regex_cmd_ap.release()); + if (m_regex_cmd_up) { + if (m_regex_cmd_up->HasRegexEntries()) { + CommandObjectSP cmd_sp(m_regex_cmd_up.release()); m_interpreter.AddCommand(cmd_sp->GetCommandName(), cmd_sp, true); } } } private: - std::unique_ptr<CommandObjectRegexCommand> m_regex_cmd_ap; + std::unique_ptr<CommandObjectRegexCommand> m_regex_cmd_up; class CommandOptions : public Options { public: diff --git a/source/Commands/CommandObjectHelp.cpp b/source/Commands/CommandObjectHelp.cpp index b39323e0a..3804bbe68 100644 --- a/source/Commands/CommandObjectHelp.cpp +++ b/source/Commands/CommandObjectHelp.cpp @@ -20,8 +20,9 @@ using namespace lldb_private; //------------------------------------------------------------------------- void CommandObjectHelp::GenerateAdditionalHelpAvenuesMessage( - Stream *s, llvm::StringRef command, llvm::StringRef prefix, llvm::StringRef subcommand, - bool include_apropos, bool include_type_lookup) { + Stream *s, llvm::StringRef command, llvm::StringRef prefix, + llvm::StringRef subcommand, bool include_upropos, + bool include_type_lookup) { if (!s || command.empty()) return; @@ -32,7 +33,7 @@ void CommandObjectHelp::GenerateAdditionalHelpAvenuesMessage( s->Printf("'%s' is not a known command.\n", command_str.c_str()); s->Printf("Try '%shelp' to see a current list of commands.\n", prefix.str().c_str()); - if (include_apropos) { + if (include_upropos) { s->Printf("Try '%sapropos %s' for a list of related commands.\n", prefix_str.c_str(), lookup_str.c_str()); } diff --git a/source/Commands/CommandObjectHelp.h b/source/Commands/CommandObjectHelp.h index d957a43ca..e4dd7af71 100644 --- a/source/Commands/CommandObjectHelp.h +++ b/source/Commands/CommandObjectHelp.h @@ -29,7 +29,7 @@ public: static void GenerateAdditionalHelpAvenuesMessage( Stream *s, llvm::StringRef command, llvm::StringRef prefix, - llvm::StringRef subcommand, bool include_apropos = true, + llvm::StringRef subcommand, bool include_upropos = true, bool include_type_lookup = true); class CommandOptions : public Options { diff --git a/source/Commands/CommandObjectTarget.cpp b/source/Commands/CommandObjectTarget.cpp index b84df68b7..b2488b758 100644 --- a/source/Commands/CommandObjectTarget.cpp +++ b/source/Commands/CommandObjectTarget.cpp @@ -4770,49 +4770,49 @@ protected: Target::StopHookSP new_hook_sp = target->CreateStopHook(); // First step, make the specifier. - std::unique_ptr<SymbolContextSpecifier> specifier_ap; + std::unique_ptr<SymbolContextSpecifier> specifier_up; if (m_options.m_sym_ctx_specified) { - specifier_ap.reset(new SymbolContextSpecifier( + specifier_up.reset(new SymbolContextSpecifier( m_interpreter.GetDebugger().GetSelectedTarget())); if (!m_options.m_module_name.empty()) { - specifier_ap->AddSpecification( + specifier_up->AddSpecification( m_options.m_module_name.c_str(), SymbolContextSpecifier::eModuleSpecified); } if (!m_options.m_class_name.empty()) { - specifier_ap->AddSpecification( + specifier_up->AddSpecification( m_options.m_class_name.c_str(), SymbolContextSpecifier::eClassOrNamespaceSpecified); } if (!m_options.m_file_name.empty()) { - specifier_ap->AddSpecification( + specifier_up->AddSpecification( m_options.m_file_name.c_str(), SymbolContextSpecifier::eFileSpecified); } if (m_options.m_line_start != 0) { - specifier_ap->AddLineSpecification( + specifier_up->AddLineSpecification( m_options.m_line_start, SymbolContextSpecifier::eLineStartSpecified); } if (m_options.m_line_end != UINT_MAX) { - specifier_ap->AddLineSpecification( + specifier_up->AddLineSpecification( m_options.m_line_end, SymbolContextSpecifier::eLineEndSpecified); } if (!m_options.m_function_name.empty()) { - specifier_ap->AddSpecification( + specifier_up->AddSpecification( m_options.m_function_name.c_str(), SymbolContextSpecifier::eFunctionSpecified); } } - if (specifier_ap) - new_hook_sp->SetSpecifier(specifier_ap.release()); + if (specifier_up) + new_hook_sp->SetSpecifier(specifier_up.release()); // Next see if any of the thread options have been entered: diff --git a/source/Commands/CommandObjectWatchpointCommand.cpp b/source/Commands/CommandObjectWatchpointCommand.cpp index 05bdcb3b9..dfb888190 100644 --- a/source/Commands/CommandObjectWatchpointCommand.cpp +++ b/source/Commands/CommandObjectWatchpointCommand.cpp @@ -225,12 +225,12 @@ are no syntax errors may indicate that a function was declared but never called. WatchpointOptions *wp_options = (WatchpointOptions *)io_handler.GetUserData(); if (wp_options) { - std::unique_ptr<WatchpointOptions::CommandData> data_ap( + std::unique_ptr<WatchpointOptions::CommandData> data_up( new WatchpointOptions::CommandData()); - if (data_ap) { - data_ap->user_source.SplitIntoLines(line); + if (data_up) { + data_up->user_source.SplitIntoLines(line); auto baton_sp = std::make_shared<WatchpointOptions::CommandBaton>( - std::move(data_ap)); + std::move(data_up)); wp_options->SetCallback(WatchpointOptionsCallbackFunction, baton_sp); } } @@ -249,19 +249,19 @@ are no syntax errors may indicate that a function was declared but never called. /// Set a one-liner as the callback for the watchpoint. void SetWatchpointCommandCallback(WatchpointOptions *wp_options, const char *oneliner) { - std::unique_ptr<WatchpointOptions::CommandData> data_ap( + std::unique_ptr<WatchpointOptions::CommandData> data_up( new WatchpointOptions::CommandData()); // It's necessary to set both user_source and script_source to the // oneliner. The former is used to generate callback description (as in // watchpoint command list) while the latter is used for Python to // interpret during the actual callback. - data_ap->user_source.AppendString(oneliner); - data_ap->script_source.assign(oneliner); - data_ap->stop_on_error = m_options.m_stop_on_error; + data_up->user_source.AppendString(oneliner); + data_up->script_source.assign(oneliner); + data_up->stop_on_error = m_options.m_stop_on_error; auto baton_sp = - std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_ap)); + std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up)); wp_options->SetCallback(WatchpointOptionsCallbackFunction, baton_sp); } diff --git a/source/Core/Debugger.cpp b/source/Core/Debugger.cpp index 93e7eaa16..459a712fd 100644 --- a/source/Core/Debugger.cpp +++ b/source/Core/Debugger.cpp @@ -763,8 +763,8 @@ Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton) m_broadcaster_manager_sp(BroadcasterManager::MakeBroadcasterManager()), m_terminal_state(), m_target_list(*this), m_platform_list(), m_listener_sp(Listener::MakeListener("lldb.Debugger")), - m_source_manager_ap(), m_source_file_cache(), - m_command_interpreter_ap(llvm::make_unique<CommandInterpreter>( + m_source_manager_up(), m_source_file_cache(), + m_command_interpreter_up(llvm::make_unique<CommandInterpreter>( *this, eScriptLanguageDefault, false)), m_input_reader_stack(), m_instance_name(), m_loaded_plugins(), m_event_handler_thread(), m_io_handler_thread(), @@ -776,7 +776,7 @@ Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton) if (log_callback) m_log_callback_stream_sp = std::make_shared<StreamCallback>(log_callback, baton); - m_command_interpreter_ap->Initialize(); + m_command_interpreter_up->Initialize(); // Always add our default platform to the platform list PlatformSP default_platform_sp(Platform::GetHostPlatform()); assert(default_platform_sp); @@ -793,11 +793,11 @@ Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton) m_collection_sp->AppendProperty( ConstString("symbols"), ConstString("Symbol lookup and cache settings."), true, ModuleList::GetGlobalModuleListProperties().GetValueProperties()); - if (m_command_interpreter_ap) { + if (m_command_interpreter_up) { m_collection_sp->AppendProperty( ConstString("interpreter"), ConstString("Settings specify to the debugger's command interpreter."), - true, m_command_interpreter_ap->GetValueProperties()); + true, m_command_interpreter_up->GetValueProperties()); } OptionValueSInt64 *term_width = m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64( @@ -856,7 +856,7 @@ void Debugger::Clear() { if (m_input_file_sp) m_input_file_sp->GetFile().Close(); - m_command_interpreter_ap->Clear(); + m_command_interpreter_up->Clear(); }); } @@ -870,11 +870,11 @@ void Debugger::SetCloseInputOnEOF(bool b) { } bool Debugger::GetAsyncExecution() { - return !m_command_interpreter_ap->GetSynchronous(); + return !m_command_interpreter_up->GetSynchronous(); } void Debugger::SetAsyncExecution(bool async_execution) { - m_command_interpreter_ap->SetSynchronous(!async_execution); + m_command_interpreter_up->SetSynchronous(!async_execution); } void Debugger::SetInputFileHandle(FILE *fh, bool tranfer_ownership) { @@ -1286,9 +1286,9 @@ bool Debugger::EnableLog(llvm::StringRef channel, } SourceManager &Debugger::GetSourceManager() { - if (!m_source_manager_ap) - m_source_manager_ap = llvm::make_unique<SourceManager>(shared_from_this()); - return *m_source_manager_ap; + if (!m_source_manager_up) + m_source_manager_up = llvm::make_unique<SourceManager>(shared_from_this()); + return *m_source_manager_up; } // This function handles events that were broadcast by the process. @@ -1536,7 +1536,7 @@ void Debugger::DefaultEventHandler() { listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp, thread_event_spec); listener_sp->StartListeningForEvents( - m_command_interpreter_ap.get(), + m_command_interpreter_up.get(), CommandInterpreter::eBroadcastBitQuitCommandReceived | CommandInterpreter::eBroadcastBitAsynchronousOutputData | CommandInterpreter::eBroadcastBitAsynchronousErrorData); @@ -1563,7 +1563,7 @@ void Debugger::DefaultEventHandler() { } } else if (broadcaster_class == broadcaster_class_thread) { HandleThreadEvent(event_sp); - } else if (broadcaster == m_command_interpreter_ap.get()) { + } else if (broadcaster == m_command_interpreter_up.get()) { if (event_type & CommandInterpreter::eBroadcastBitQuitCommandReceived) { done = true; diff --git a/source/Core/Disassembler.cpp b/source/Core/Disassembler.cpp index c67677dbc..5f037d800 100644 --- a/source/Core/Disassembler.cpp +++ b/source/Core/Disassembler.cpp @@ -741,11 +741,11 @@ void Instruction::Dump(lldb_private::Stream *s, uint32_t max_opcode_byte_size, } bool Instruction::DumpEmulation(const ArchSpec &arch) { - std::unique_ptr<EmulateInstruction> insn_emulator_ap( + std::unique_ptr<EmulateInstruction> insn_emulator_up( EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr)); - if (insn_emulator_ap) { - insn_emulator_ap->SetInstruction(GetOpcode(), GetAddress(), nullptr); - return insn_emulator_ap->EvaluateInstruction(0); + if (insn_emulator_up) { + insn_emulator_up->SetInstruction(GetOpcode(), GetAddress(), nullptr); + return insn_emulator_up->EvaluateInstruction(0); } return false; @@ -992,11 +992,11 @@ bool Instruction::TestEmulation(Stream *out_stream, const char *file_name) { arch.SetTriple(llvm::Triple(value_sp->GetStringValue())); bool success = false; - std::unique_ptr<EmulateInstruction> insn_emulator_ap( + std::unique_ptr<EmulateInstruction> insn_emulator_up( EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr)); - if (insn_emulator_ap) + if (insn_emulator_up) success = - insn_emulator_ap->TestEmulation(out_stream, arch, data_dictionary); + insn_emulator_up->TestEmulation(out_stream, arch, data_dictionary); if (success) out_stream->Printf("Emulation test succeeded."); @@ -1012,14 +1012,14 @@ bool Instruction::Emulate( EmulateInstruction::WriteMemoryCallback write_mem_callback, EmulateInstruction::ReadRegisterCallback read_reg_callback, EmulateInstruction::WriteRegisterCallback write_reg_callback) { - std::unique_ptr<EmulateInstruction> insn_emulator_ap( + std::unique_ptr<EmulateInstruction> insn_emulator_up( EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr)); - if (insn_emulator_ap) { - insn_emulator_ap->SetBaton(baton); - insn_emulator_ap->SetCallbacks(read_mem_callback, write_mem_callback, + if (insn_emulator_up) { + insn_emulator_up->SetBaton(baton); + insn_emulator_up->SetCallbacks(read_mem_callback, write_mem_callback, read_reg_callback, write_reg_callback); - insn_emulator_ap->SetInstruction(GetOpcode(), GetAddress(), nullptr); - return insn_emulator_ap->EvaluateInstruction(evaluate_options); + insn_emulator_up->SetInstruction(GetOpcode(), GetAddress(), nullptr); + return insn_emulator_up->EvaluateInstruction(evaluate_options); } return false; diff --git a/source/Core/DumpDataExtractor.cpp b/source/Core/DumpDataExtractor.cpp index e96155a21..aa84370e2 100644 --- a/source/Core/DumpDataExtractor.cpp +++ b/source/Core/DumpDataExtractor.cpp @@ -551,7 +551,7 @@ lldb::offset_t lldb_private::DumpDataExtractor( case eFormatFloat: { TargetSP target_sp; - bool used_apfloat = false; + bool used_upfloat = false; if (exe_scope) target_sp = exe_scope->CalculateTarget(); if (target_sp) { @@ -600,13 +600,13 @@ lldb::offset_t lldb_private::DumpDataExtractor( if (!sv.empty()) { s->Printf("%*.*s", (int)sv.size(), (int)sv.size(), sv.data()); - used_apfloat = true; + used_upfloat = true; } } } } - if (!used_apfloat) { + if (!used_upfloat) { std::ostringstream ss; if (item_byte_size == sizeof(float) || item_byte_size == 2) { float f; diff --git a/source/Core/DynamicLoader.cpp b/source/Core/DynamicLoader.cpp index 2e42f55b0..a5805399b 100644 --- a/source/Core/DynamicLoader.cpp +++ b/source/Core/DynamicLoader.cpp @@ -38,10 +38,10 @@ DynamicLoader *DynamicLoader::FindPlugin(Process *process, PluginManager::GetDynamicLoaderCreateCallbackForPluginName( const_plugin_name); if (create_callback) { - std::unique_ptr<DynamicLoader> instance_ap( + std::unique_ptr<DynamicLoader> instance_up( create_callback(process, true)); - if (instance_ap) - return instance_ap.release(); + if (instance_up) + return instance_up.release(); } } else { for (uint32_t idx = 0; @@ -49,10 +49,10 @@ DynamicLoader *DynamicLoader::FindPlugin(Process *process, PluginManager::GetDynamicLoaderCreateCallbackAtIndex(idx)) != nullptr; ++idx) { - std::unique_ptr<DynamicLoader> instance_ap( + std::unique_ptr<DynamicLoader> instance_up( create_callback(process, false)); - if (instance_ap) - return instance_ap.release(); + if (instance_up) + return instance_up.release(); } } return nullptr; diff --git a/source/Core/IOHandler.cpp b/source/Core/IOHandler.cpp index 85b2f1e01..f90984e15 100644 --- a/source/Core/IOHandler.cpp +++ b/source/Core/IOHandler.cpp @@ -284,7 +284,7 @@ IOHandlerEditline::IOHandlerEditline( IOHandlerDelegate &delegate) : IOHandler(debugger, type, input_sp, output_sp, error_sp, flags), #ifndef LLDB_DISABLE_LIBEDIT - m_editline_ap(), + m_editline_up(), #endif m_delegate(delegate), m_prompt(), m_continuation_prompt(), m_current_lines_ptr(nullptr), m_base_line_number(line_number_start), @@ -299,17 +299,17 @@ IOHandlerEditline::IOHandlerEditline( use_editline = m_input_sp->GetFile().GetIsRealTerminal(); if (use_editline) { - m_editline_ap.reset(new Editline(editline_name, GetInputFILE(), + m_editline_up.reset(new Editline(editline_name, GetInputFILE(), GetOutputFILE(), GetErrorFILE(), m_color_prompts)); - m_editline_ap->SetIsInputCompleteCallback(IsInputCompleteCallback, this); - m_editline_ap->SetAutoCompleteCallback(AutoCompleteCallback, this); + m_editline_up->SetIsInputCompleteCallback(IsInputCompleteCallback, this); + m_editline_up->SetAutoCompleteCallback(AutoCompleteCallback, this); // See if the delegate supports fixing indentation const char *indent_chars = delegate.IOHandlerGetFixIndentationCharacters(); if (indent_chars) { // The delegate does support indentation, hook it up so when any // indentation character is typed, the delegate gets a chance to fix it - m_editline_ap->SetFixIndentationCallback(FixIndentationCallback, this, + m_editline_up->SetFixIndentationCallback(FixIndentationCallback, this, indent_chars); } } @@ -321,7 +321,7 @@ IOHandlerEditline::IOHandlerEditline( IOHandlerEditline::~IOHandlerEditline() { #ifndef LLDB_DISABLE_LIBEDIT - m_editline_ap.reset(); + m_editline_up.reset(); #endif } @@ -337,8 +337,8 @@ void IOHandlerEditline::Deactivate() { bool IOHandlerEditline::GetLine(std::string &line, bool &interrupted) { #ifndef LLDB_DISABLE_LIBEDIT - if (m_editline_ap) { - return m_editline_ap->GetLine(line, interrupted); + if (m_editline_up) { + return m_editline_up->GetLine(line, interrupted); } else { #endif line.clear(); @@ -440,8 +440,8 @@ int IOHandlerEditline::AutoCompleteCallback( const char *IOHandlerEditline::GetPrompt() { #ifndef LLDB_DISABLE_LIBEDIT - if (m_editline_ap) { - return m_editline_ap->GetPrompt(); + if (m_editline_up) { + return m_editline_up->GetPrompt(); } else { #endif if (m_prompt.empty()) @@ -456,8 +456,8 @@ bool IOHandlerEditline::SetPrompt(llvm::StringRef prompt) { m_prompt = prompt; #ifndef LLDB_DISABLE_LIBEDIT - if (m_editline_ap) - m_editline_ap->SetPrompt(m_prompt.empty() ? nullptr : m_prompt.c_str()); + if (m_editline_up) + m_editline_up->SetPrompt(m_prompt.empty() ? nullptr : m_prompt.c_str()); #endif return true; } @@ -471,8 +471,8 @@ void IOHandlerEditline::SetContinuationPrompt(llvm::StringRef prompt) { m_continuation_prompt = prompt; #ifndef LLDB_DISABLE_LIBEDIT - if (m_editline_ap) - m_editline_ap->SetContinuationPrompt(m_continuation_prompt.empty() + if (m_editline_up) + m_editline_up->SetContinuationPrompt(m_continuation_prompt.empty() ? nullptr : m_continuation_prompt.c_str()); #endif @@ -484,8 +484,8 @@ void IOHandlerEditline::SetBaseLineNumber(uint32_t line) { uint32_t IOHandlerEditline::GetCurrentLineIndex() const { #ifndef LLDB_DISABLE_LIBEDIT - if (m_editline_ap) - return m_editline_ap->GetCurrentLine(); + if (m_editline_up) + return m_editline_up->GetCurrentLine(); #endif return m_curr_line_idx; } @@ -495,8 +495,8 @@ bool IOHandlerEditline::GetLines(StringList &lines, bool &interrupted) { bool success = false; #ifndef LLDB_DISABLE_LIBEDIT - if (m_editline_ap) { - return m_editline_ap->GetLines(m_base_line_number, lines, interrupted); + if (m_editline_up) { + return m_editline_up->GetLines(m_base_line_number, lines, interrupted); } else { #endif bool done = false; @@ -564,8 +564,8 @@ void IOHandlerEditline::Run() { void IOHandlerEditline::Cancel() { #ifndef LLDB_DISABLE_LIBEDIT - if (m_editline_ap) - m_editline_ap->Cancel(); + if (m_editline_up) + m_editline_up->Cancel(); #endif } @@ -575,23 +575,23 @@ bool IOHandlerEditline::Interrupt() { return true; #ifndef LLDB_DISABLE_LIBEDIT - if (m_editline_ap) - return m_editline_ap->Interrupt(); + if (m_editline_up) + return m_editline_up->Interrupt(); #endif return false; } void IOHandlerEditline::GotEOF() { #ifndef LLDB_DISABLE_LIBEDIT - if (m_editline_ap) - m_editline_ap->Interrupt(); + if (m_editline_up) + m_editline_up->Interrupt(); #endif } void IOHandlerEditline::PrintAsync(Stream *stream, const char *s, size_t len) { #ifndef LLDB_DISABLE_LIBEDIT - if (m_editline_ap) - m_editline_ap->PrintAsync(stream, s, len); + if (m_editline_up) + m_editline_up->PrintAsync(stream, s, len); else #endif { @@ -1122,10 +1122,10 @@ public: const char *text = m_delegate_sp->WindowDelegateGetHelpText(); KeyHelp *key_help = m_delegate_sp->WindowDelegateGetKeyHelp(); if ((text && text[0]) || key_help) { - std::unique_ptr<HelpDialogDelegate> help_delegate_ap( + std::unique_ptr<HelpDialogDelegate> help_delegate_up( new HelpDialogDelegate(text, key_help)); - const size_t num_lines = help_delegate_ap->GetNumLines(); - const size_t max_length = help_delegate_ap->GetMaxLineLength(); + const size_t num_lines = help_delegate_up->GetNumLines(); + const size_t max_length = help_delegate_up->GetMaxLineLength(); Rect bounds = GetBounds(); bounds.Inset(1, 1); if (max_length + 4 < static_cast<size_t>(bounds.size.width)) { @@ -1156,7 +1156,7 @@ public: else help_window_sp = CreateSubWindow("Help", bounds, true); help_window_sp->SetDelegate( - WindowDelegateSP(help_delegate_ap.release())); + WindowDelegateSP(help_delegate_up.release())); return true; } } diff --git a/source/Core/Module.cpp b/source/Core/Module.cpp index 77d1ab123..d247e6eb1 100644 --- a/source/Core/Module.cpp +++ b/source/Core/Module.cpp @@ -277,8 +277,8 @@ Module::~Module() { // function calls back into this module object. The ordering is important // here because symbol files can require the module object file. So we tear // down the symbol file first, then the object file. - m_sections_ap.reset(); - m_symfile_ap.reset(); + m_sections_up.reset(); + m_symfile_up.reset(); m_objfile_sp.reset(); } @@ -291,13 +291,13 @@ 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_ap = llvm::make_unique<DataBufferHeap>(size_to_read, 0); + auto data_up = llvm::make_unique<DataBufferHeap>(size_to_read, 0); Status readmem_error; const size_t bytes_read = - process_sp->ReadMemory(header_addr, data_ap->GetBytes(), - data_ap->GetByteSize(), readmem_error); + process_sp->ReadMemory(header_addr, data_up->GetBytes(), + data_up->GetByteSize(), readmem_error); if (bytes_read == size_to_read) { - DataBufferSP data_sp(data_ap.release()); + DataBufferSP data_sp(data_up.release()); m_objfile_sp = ObjectFile::FindPlugin(shared_from_this(), process_sp, header_addr, data_sp); if (m_objfile_sp) { @@ -1049,13 +1049,13 @@ SymbolVendor *Module::GetSymbolVendor(bool can_create, if (obj_file != nullptr) { static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION); - m_symfile_ap.reset( + m_symfile_up.reset( SymbolVendor::FindPlugin(shared_from_this(), feedback_strm)); m_did_load_symbol_vendor = true; } } } - return m_symfile_ap.get(); + return m_symfile_up.get(); } void Module::SetFileSpecAndObjectName(const FileSpec &file, @@ -1278,13 +1278,13 @@ ObjectFile *Module::GetObjectFile() { } SectionList *Module::GetSectionList() { - // Populate m_sections_ap with sections from objfile. - if (!m_sections_ap) { + // Populate m_sections_up with sections from objfile. + if (!m_sections_up) { ObjectFile *obj_file = GetObjectFile(); if (obj_file != nullptr) obj_file->CreateSections(*GetUnifiedSectionList()); } - return m_sections_ap.get(); + return m_sections_up.get(); } void Module::SectionFileAddressesChanged() { @@ -1297,9 +1297,9 @@ void Module::SectionFileAddressesChanged() { } SectionList *Module::GetUnifiedSectionList() { - if (!m_sections_ap) - m_sections_ap = llvm::make_unique<SectionList>(); - return m_sections_ap.get(); + if (!m_sections_up) + m_sections_up = llvm::make_unique<SectionList>(); + return m_sections_up.get(); } const Symbol *Module::FindFirstSymbolWithNameAndType(const ConstString &name, @@ -1419,11 +1419,11 @@ void Module::PreloadSymbols() { void Module::SetSymbolFileFileSpec(const FileSpec &file) { if (!FileSystem::Instance().Exists(file)) return; - if (m_symfile_ap) { + if (m_symfile_up) { // Remove any sections in the unified section list that come from the // current symbol vendor. SectionList *section_list = GetSectionList(); - SymbolFile *symbol_file = m_symfile_ap->GetSymbolFile(); + SymbolFile *symbol_file = m_symfile_up->GetSymbolFile(); if (section_list && symbol_file) { ObjectFile *obj_file = symbol_file->GetObjectFile(); // Make sure we have an object file and that the symbol vendor's objfile @@ -1471,10 +1471,10 @@ void Module::SetSymbolFileFileSpec(const FileSpec &file) { } // Keep all old symbol files around in case there are any lingering type // references in any SBValue objects that might have been handed out. - m_old_symfiles.push_back(std::move(m_symfile_ap)); + m_old_symfiles.push_back(std::move(m_symfile_up)); } m_symfile_spec = file; - m_symfile_ap.reset(); + m_symfile_up.reset(); m_did_load_symbol_vendor = false; } diff --git a/source/Core/ValueObjectSyntheticFilter.cpp b/source/Core/ValueObjectSyntheticFilter.cpp index db28b58bc..a701d9246 100644 --- a/source/Core/ValueObjectSyntheticFilter.cpp +++ b/source/Core/ValueObjectSyntheticFilter.cpp @@ -72,7 +72,7 @@ ConstString ValueObjectSynthetic::GetQualifiedTypeName() { } ConstString ValueObjectSynthetic::GetDisplayTypeName() { - if (ConstString synth_name = m_synth_filter_ap->GetSyntheticTypeName()) + if (ConstString synth_name = m_synth_filter_up->GetSyntheticTypeName()) return synth_name; return m_parent->GetDisplayTypeName(); @@ -86,7 +86,7 @@ size_t ValueObjectSynthetic::CalculateNumChildren(uint32_t max) { return m_synthetic_children_count <= max ? m_synthetic_children_count : max; if (max < UINT32_MAX) { - size_t num_children = m_synth_filter_ap->CalculateNumChildren(max); + size_t num_children = m_synth_filter_up->CalculateNumChildren(max); if (log) log->Printf("[ValueObjectSynthetic::CalculateNumChildren] for VO of name " "%s and type %s, the filter returned %zu child values", @@ -95,7 +95,7 @@ size_t ValueObjectSynthetic::CalculateNumChildren(uint32_t max) { return num_children; } else { size_t num_children = (m_synthetic_children_count = - m_synth_filter_ap->CalculateNumChildren(max)); + m_synth_filter_up->CalculateNumChildren(max)); if (log) log->Printf("[ValueObjectSynthetic::CalculateNumChildren] for VO of name " "%s and type %s, the filter returned %zu child values", @@ -117,7 +117,7 @@ ValueObjectSynthetic::GetDynamicValue(lldb::DynamicValueType valueType) { bool ValueObjectSynthetic::MightHaveChildren() { if (m_might_have_children == eLazyBoolCalculate) m_might_have_children = - (m_synth_filter_ap->MightHaveChildren() ? eLazyBoolYes : eLazyBoolNo); + (m_synth_filter_up->MightHaveChildren() ? eLazyBoolYes : eLazyBoolNo); return (m_might_have_children != eLazyBoolNo); } @@ -140,9 +140,9 @@ void ValueObjectSynthetic::CreateSynthFilter() { valobj_for_frontend = deref_sp.get(); } } - m_synth_filter_ap = (m_synth_sp->GetFrontEnd(*valobj_for_frontend)); - if (!m_synth_filter_ap) - m_synth_filter_ap = llvm::make_unique<DummySyntheticFrontEnd>(*m_parent); + 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); } bool ValueObjectSynthetic::UpdateValue() { @@ -173,7 +173,7 @@ bool ValueObjectSynthetic::UpdateValue() { } // let our backend do its update - if (!m_synth_filter_ap->Update()) { + if (!m_synth_filter_up->Update()) { if (log) log->Printf("[ValueObjectSynthetic::UpdateValue] name=%s, synthetic " "filter said caches are stale - clearing", @@ -198,7 +198,7 @@ bool ValueObjectSynthetic::UpdateValue() { m_provides_value = eLazyBoolCalculate; - lldb::ValueObjectSP synth_val(m_synth_filter_ap->GetSyntheticValue()); + lldb::ValueObjectSP synth_val(m_synth_filter_up->GetSyntheticValue()); if (synth_val && synth_val->CanProvideValue()) { if (log) @@ -235,13 +235,13 @@ lldb::ValueObjectSP ValueObjectSynthetic::GetChildAtIndex(size_t idx, ValueObject *valobj; if (!m_children_byindex.GetValueForKey(idx, valobj)) { - if (can_create && m_synth_filter_ap != nullptr) { + if (can_create && m_synth_filter_up != nullptr) { if (log) log->Printf("[ValueObjectSynthetic::GetChildAtIndex] name=%s, child at " "index %zu not cached and will be created", GetName().AsCString(), idx); - lldb::ValueObjectSP synth_guy = m_synth_filter_ap->GetChildAtIndex(idx); + lldb::ValueObjectSP synth_guy = m_synth_filter_up->GetChildAtIndex(idx); if (log) log->Printf( @@ -268,7 +268,7 @@ lldb::ValueObjectSP ValueObjectSynthetic::GetChildAtIndex(size_t idx, "index %zu not cached and cannot " "be created (can_create = %s, synth_filter = %p)", GetName().AsCString(), idx, can_create ? "yes" : "no", - static_cast<void *>(m_synth_filter_ap.get())); + static_cast<void *>(m_synth_filter_up.get())); return lldb::ValueObjectSP(); } @@ -301,13 +301,13 @@ size_t ValueObjectSynthetic::GetIndexOfChildWithName(const ConstString &name) { uint32_t found_index = UINT32_MAX; bool did_find = m_name_toindex.GetValueForKey(name.GetCString(), found_index); - if (!did_find && m_synth_filter_ap != nullptr) { - uint32_t index = m_synth_filter_ap->GetIndexOfChildWithName(name); + if (!did_find && m_synth_filter_up != nullptr) { + uint32_t index = m_synth_filter_up->GetIndexOfChildWithName(name); if (index == UINT32_MAX) return index; m_name_toindex.SetValueForKey(name.GetCString(), index); return index; - } else if (!did_find && m_synth_filter_ap == nullptr) + } else if (!did_find && m_synth_filter_up == nullptr) return UINT32_MAX; else /*if (iter != m_name_toindex.end())*/ return found_index; diff --git a/source/Expression/DWARFExpression.cpp b/source/Expression/DWARFExpression.cpp index 8c7db6f78..679b77955 100644 --- a/source/Expression/DWARFExpression.cpp +++ b/source/Expression/DWARFExpression.cpp @@ -995,12 +995,12 @@ bool DWARFExpression::Update_DW_OP_addr(lldb::addr_t file_addr) { // for this expression // So first we copy the data into a heap buffer - std::unique_ptr<DataBufferHeap> head_data_ap( + std::unique_ptr<DataBufferHeap> head_data_up( new DataBufferHeap(m_data.GetDataStart(), m_data.GetByteSize())); // Make en encoder so we can write the address into the buffer using the // correct byte order (endianness) - DataEncoder encoder(head_data_ap->GetBytes(), head_data_ap->GetByteSize(), + DataEncoder encoder(head_data_up->GetBytes(), head_data_up->GetByteSize(), m_data.GetByteOrder(), addr_byte_size); // Replace the address in the new buffer @@ -1009,7 +1009,7 @@ bool DWARFExpression::Update_DW_OP_addr(lldb::addr_t file_addr) { // All went well, so now we can reset the data using a shared pointer to // the heap data so "m_data" will now correctly manage the heap data. - m_data.SetData(DataBufferSP(head_data_ap.release())); + m_data.SetData(DataBufferSP(head_data_up.release())); return true; } else { const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op); diff --git a/source/Expression/IRExecutionUnit.cpp b/source/Expression/IRExecutionUnit.cpp index 19b3d076d..6528a2744 100644 --- a/source/Expression/IRExecutionUnit.cpp +++ b/source/Expression/IRExecutionUnit.cpp @@ -36,14 +36,14 @@ using namespace lldb_private; -IRExecutionUnit::IRExecutionUnit(std::unique_ptr<llvm::LLVMContext> &context_ap, - std::unique_ptr<llvm::Module> &module_ap, +IRExecutionUnit::IRExecutionUnit(std::unique_ptr<llvm::LLVMContext> &context_up, + std::unique_ptr<llvm::Module> &module_up, ConstString &name, const lldb::TargetSP &target_sp, const SymbolContext &sym_ctx, std::vector<std::string> &cpu_features) - : IRMemoryMap(target_sp), m_context_ap(context_ap.release()), - m_module_ap(module_ap.release()), m_module(m_module_ap.get()), + : IRMemoryMap(target_sp), m_context_up(context_up.release()), + m_module_up(module_up.release()), m_module(m_module_up.get()), m_cpu_features(cpu_features), m_name(name), m_sym_ctx(sym_ctx), m_did_jit(false), m_function_load_addr(LLDB_INVALID_ADDRESS), m_function_end_load_addr(LLDB_INVALID_ADDRESS), @@ -267,10 +267,10 @@ void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr, relocModel = llvm::Reloc::PIC_; } - m_module_ap->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError, + m_module_up->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError, &error); - llvm::EngineBuilder builder(std::move(m_module_ap)); + llvm::EngineBuilder builder(std::move(m_module_up)); builder.setEngineKind(llvm::EngineKind::JIT) .setErrorStr(&error_string) @@ -289,12 +289,12 @@ void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr, llvm::TargetMachine *target_machine = builder.selectTarget(triple, mArch, mCPU, mAttrs); - m_execution_engine_ap.reset(builder.create(target_machine)); + m_execution_engine_up.reset(builder.create(target_machine)); m_strip_underscore = - (m_execution_engine_ap->getDataLayout().getGlobalPrefix() == '_'); + (m_execution_engine_up->getDataLayout().getGlobalPrefix() == '_'); - if (!m_execution_engine_ap) { + if (!m_execution_engine_up) { error.SetErrorToGenericError(); error.SetErrorStringWithFormat("Couldn't JIT the function: %s", error_string.c_str()); @@ -323,15 +323,15 @@ void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr, }; if (process_sp->GetTarget().GetEnableSaveObjects()) { - m_object_cache_ap = llvm::make_unique<ObjectDumper>(); - m_execution_engine_ap->setObjectCache(m_object_cache_ap.get()); + m_object_cache_up = llvm::make_unique<ObjectDumper>(); + m_execution_engine_up->setObjectCache(m_object_cache_up.get()); } // Make sure we see all sections, including ones that don't have // relocations... - m_execution_engine_ap->setProcessAllSections(true); + m_execution_engine_up->setProcessAllSections(true); - m_execution_engine_ap->DisableLazyCompilation(); + m_execution_engine_up->DisableLazyCompilation(); for (llvm::Function &function : *m_module) { if (function.isDeclaration() || function.hasPrivateLinkage()) @@ -340,7 +340,7 @@ void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr, const bool external = function.hasExternalLinkage() || function.hasLinkOnceODRLinkage(); - void *fun_ptr = m_execution_engine_ap->getPointerToFunction(&function); + void *fun_ptr = m_execution_engine_up->getPointerToFunction(&function); if (!error.Success()) { // We got an error through our callback! @@ -359,7 +359,7 @@ void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr, } CommitAllocations(process_sp); - ReportAllocations(*m_execution_engine_ap); + ReportAllocations(*m_execution_engine_up); // We have to do this after calling ReportAllocations because for the MCJIT, // getGlobalValueAddress will cause the JIT to perform all relocations. That @@ -371,7 +371,7 @@ void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr, llvm::GlobalValue &val) { if (val.hasExternalLinkage() && !val.isDeclaration()) { uint64_t var_ptr_addr = - m_execution_engine_ap->getGlobalValueAddress(val.getName().str()); + m_execution_engine_up->getGlobalValueAddress(val.getName().str()); lldb::addr_t remote_addr = GetRemoteAddressForLocal(var_ptr_addr); @@ -488,13 +488,13 @@ void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr, } IRExecutionUnit::~IRExecutionUnit() { - m_module_ap.reset(); - m_execution_engine_ap.reset(); - m_context_ap.reset(); + m_module_up.reset(); + m_execution_engine_up.reset(); + m_context_up.reset(); } IRExecutionUnit::MemoryManager::MemoryManager(IRExecutionUnit &parent) - : m_default_mm_ap(new llvm::SectionMemoryManager()), m_parent(parent) {} + : m_default_mm_up(new llvm::SectionMemoryManager()), m_parent(parent) {} IRExecutionUnit::MemoryManager::~MemoryManager() {} @@ -596,7 +596,7 @@ uint8_t *IRExecutionUnit::MemoryManager::allocateCodeSection( llvm::StringRef SectionName) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); - uint8_t *return_value = m_default_mm_ap->allocateCodeSection( + uint8_t *return_value = m_default_mm_up->allocateCodeSection( Size, Alignment, SectionID, SectionName); m_parent.m_records.push_back(AllocationRecord( @@ -627,7 +627,7 @@ uint8_t *IRExecutionUnit::MemoryManager::allocateDataSection( llvm::StringRef SectionName, bool IsReadOnly) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); - uint8_t *return_value = m_default_mm_ap->allocateDataSection( + uint8_t *return_value = m_default_mm_up->allocateDataSection( Size, Alignment, SectionID, SectionName, IsReadOnly); uint32_t permissions = lldb::ePermissionsReadable; diff --git a/source/Expression/IRInterpreter.cpp b/source/Expression/IRInterpreter.cpp index 484ddde13..85eb78f53 100644 --- a/source/Expression/IRInterpreter.cpp +++ b/source/Expression/IRInterpreter.cpp @@ -1600,16 +1600,16 @@ bool IRInterpreter::Interpret(llvm::Module &module, llvm::Function &function, "unable to locate host data for transfer to device"); // Create the required buffer rawArgs[i].size = dataSize; - rawArgs[i].data_ap.reset(new uint8_t[dataSize + 1]); + rawArgs[i].data_up.reset(new uint8_t[dataSize + 1]); // Read string from host memory - execution_unit.ReadMemory(rawArgs[i].data_ap.get(), addr, dataSize, + execution_unit.ReadMemory(rawArgs[i].data_up.get(), addr, dataSize, error); assert(!error.Fail() && "we have failed to read the string from memory"); // Add null terminator - rawArgs[i].data_ap[dataSize] = '\0'; + rawArgs[i].data_up[dataSize] = '\0'; rawArgs[i].type = lldb_private::ABI::CallArgument::HostPointer; } else /* if ( arg_ty->isPointerTy() ) */ { diff --git a/source/Expression/LLVMUserExpression.cpp b/source/Expression/LLVMUserExpression.cpp index 9ee9c04ad..8afde07e0 100644 --- a/source/Expression/LLVMUserExpression.cpp +++ b/source/Expression/LLVMUserExpression.cpp @@ -45,15 +45,12 @@ LLVMUserExpression::LLVMUserExpression(ExecutionContextScope &exe_scope, const EvaluateExpressionOptions &options) : UserExpression(exe_scope, expr, prefix, language, desired_type, options), m_stack_frame_bottom(LLDB_INVALID_ADDRESS), - m_stack_frame_top(LLDB_INVALID_ADDRESS), - m_allow_cxx(false), - m_allow_objc(false), - m_transformed_text(), - m_execution_unit_sp(), m_materializer_ap(), m_jit_module_wp(), - m_enforce_valid_object(true), m_in_cplusplus_method(false), - m_in_objectivec_method(false), m_in_static_method(false), - m_needs_object_ptr(false), m_target(NULL), m_can_interpret(false), - m_materialized_address(LLDB_INVALID_ADDRESS) {} + m_stack_frame_top(LLDB_INVALID_ADDRESS), m_allow_cxx(false), + m_allow_objc(false), m_transformed_text(), m_execution_unit_sp(), + m_materializer_up(), m_jit_module_wp(), m_enforce_valid_object(true), + m_in_cplusplus_method(false), m_in_objectivec_method(false), + m_in_static_method(false), m_needs_object_ptr(false), m_target(NULL), + m_can_interpret(false), m_materialized_address(LLDB_INVALID_ADDRESS) {} LLVMUserExpression::~LLVMUserExpression() { if (m_target) { @@ -312,8 +309,8 @@ bool LLVMUserExpression::PrepareToExecuteJITExpression( const bool zero_memory = false; m_materialized_address = m_execution_unit_sp->Malloc( - m_materializer_ap->GetStructByteSize(), - m_materializer_ap->GetStructAlignment(), + m_materializer_up->GetStructByteSize(), + m_materializer_up->GetStructAlignment(), lldb::ePermissionsReadable | lldb::ePermissionsWritable, policy, zero_memory, alloc_error); @@ -353,7 +350,7 @@ bool LLVMUserExpression::PrepareToExecuteJITExpression( Status materialize_error; - m_dematerializer_sp = m_materializer_ap->Materialize( + m_dematerializer_sp = m_materializer_up->Materialize( frame, *m_execution_unit_sp, struct_address, materialize_error); if (!materialize_error.Success()) { diff --git a/source/Host/common/File.cpp b/source/Host/common/File.cpp index 04fbf17ff..bf462135a 100644 --- a/source/Host/common/File.cpp +++ b/source/Host/common/File.cpp @@ -528,18 +528,18 @@ Status File::Read(size_t &num_bytes, off_t &offset, bool null_terminate, num_bytes = bytes_left; size_t num_bytes_plus_nul_char = num_bytes + (null_terminate ? 1 : 0); - std::unique_ptr<DataBufferHeap> data_heap_ap; - data_heap_ap.reset(new DataBufferHeap()); - data_heap_ap->SetByteSize(num_bytes_plus_nul_char); + std::unique_ptr<DataBufferHeap> data_heap_up; + data_heap_up.reset(new DataBufferHeap()); + data_heap_up->SetByteSize(num_bytes_plus_nul_char); - if (data_heap_ap) { - error = Read(data_heap_ap->GetBytes(), num_bytes, offset); + if (data_heap_up) { + error = Read(data_heap_up->GetBytes(), num_bytes, offset); if (error.Success()) { // Make sure we read exactly what we asked for and if we got // less, adjust the array - if (num_bytes_plus_nul_char < data_heap_ap->GetByteSize()) - data_heap_ap->SetByteSize(num_bytes_plus_nul_char); - data_buffer_sp.reset(data_heap_ap.release()); + if (num_bytes_plus_nul_char < data_heap_up->GetByteSize()) + data_heap_up->SetByteSize(num_bytes_plus_nul_char); + data_buffer_sp.reset(data_heap_up.release()); return error; } } diff --git a/source/Host/common/Terminal.cpp b/source/Host/common/Terminal.cpp index b6d6f5670..aa3d0e6b3 100644 --- a/source/Host/common/Terminal.cpp +++ b/source/Host/common/Terminal.cpp @@ -87,7 +87,7 @@ bool Terminal::SetCanonical(bool enabled) { TerminalState::TerminalState() : m_tty(), m_tflags(-1), #ifdef LLDB_CONFIG_TERMIOS_SUPPORTED - m_termios_ap(), + m_termios_up(), #endif m_process_group(-1) { } @@ -101,7 +101,7 @@ void TerminalState::Clear() { m_tty.Clear(); m_tflags = -1; #ifdef LLDB_CONFIG_TERMIOS_SUPPORTED - m_termios_ap.reset(); + m_termios_up.reset(); #endif m_process_group = -1; } @@ -118,11 +118,11 @@ bool TerminalState::Save(int fd, bool save_process_group) { m_tflags = ::fcntl(fd, F_GETFL, 0); #endif #ifdef LLDB_CONFIG_TERMIOS_SUPPORTED - if (m_termios_ap == NULL) - m_termios_ap.reset(new struct termios); - int err = ::tcgetattr(fd, m_termios_ap.get()); + if (m_termios_up == NULL) + m_termios_up.reset(new struct termios); + int err = ::tcgetattr(fd, m_termios_up.get()); if (err != 0) - m_termios_ap.reset(); + m_termios_up.reset(); #endif // #ifdef LLDB_CONFIG_TERMIOS_SUPPORTED #ifndef LLDB_DISABLE_POSIX if (save_process_group) @@ -134,7 +134,7 @@ bool TerminalState::Save(int fd, bool save_process_group) { m_tty.Clear(); m_tflags = -1; #ifdef LLDB_CONFIG_TERMIOS_SUPPORTED - m_termios_ap.reset(); + m_termios_up.reset(); #endif m_process_group = -1; } @@ -154,7 +154,7 @@ bool TerminalState::Restore() const { #ifdef LLDB_CONFIG_TERMIOS_SUPPORTED if (TTYStateIsValid()) - tcsetattr(fd, TCSANOW, m_termios_ap.get()); + tcsetattr(fd, TCSANOW, m_termios_up.get()); #endif // #ifdef LLDB_CONFIG_TERMIOS_SUPPORTED if (ProcessGroupIsValid()) { @@ -191,7 +191,7 @@ bool TerminalState::TFlagsIsValid() const { return m_tflags != -1; } //---------------------------------------------------------------------- bool TerminalState::TTYStateIsValid() const { #ifdef LLDB_CONFIG_TERMIOS_SUPPORTED - return m_termios_ap != 0; + return m_termios_up != 0; #else return false; #endif diff --git a/source/Interpreter/CommandInterpreter.cpp b/source/Interpreter/CommandInterpreter.cpp index 77883b389..55b96af72 100644 --- a/source/Interpreter/CommandInterpreter.cpp +++ b/source/Interpreter/CommandInterpreter.cpp @@ -522,7 +522,7 @@ void CommandInterpreter::LoadCommandDictionary() { size_t num_regexes = llvm::array_lengthof(break_regexes); - std::unique_ptr<CommandObjectRegexCommand> break_regex_cmd_ap( + std::unique_ptr<CommandObjectRegexCommand> break_regex_cmd_up( new CommandObjectRegexCommand( *this, "_regexp-break", "Set a breakpoint using one of several shorthand formats.", @@ -550,28 +550,29 @@ void CommandInterpreter::LoadCommandDictionary() { "current file\n" " // containing text 'break " "here'.\n", - 2, CommandCompletions::eSymbolCompletion | - CommandCompletions::eSourceFileCompletion, + 2, + CommandCompletions::eSymbolCompletion | + CommandCompletions::eSourceFileCompletion, false)); - if (break_regex_cmd_ap) { + if (break_regex_cmd_up) { bool success = true; for (size_t i = 0; i < num_regexes; i++) { - success = break_regex_cmd_ap->AddRegexCommand(break_regexes[i][0], + success = break_regex_cmd_up->AddRegexCommand(break_regexes[i][0], break_regexes[i][1]); if (!success) break; } success = - break_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full"); + break_regex_cmd_up->AddRegexCommand("^$", "breakpoint list --full"); if (success) { - CommandObjectSP break_regex_cmd_sp(break_regex_cmd_ap.release()); + CommandObjectSP break_regex_cmd_sp(break_regex_cmd_up.release()); m_command_dict[break_regex_cmd_sp->GetCommandName()] = break_regex_cmd_sp; } } - std::unique_ptr<CommandObjectRegexCommand> tbreak_regex_cmd_ap( + std::unique_ptr<CommandObjectRegexCommand> tbreak_regex_cmd_up( new CommandObjectRegexCommand( *this, "_regexp-tbreak", "Set a one-shot breakpoint using one of several shorthand formats.", @@ -599,11 +600,12 @@ void CommandInterpreter::LoadCommandDictionary() { "current file\n" " // containing text 'break " "here'.\n", - 2, CommandCompletions::eSymbolCompletion | - CommandCompletions::eSourceFileCompletion, + 2, + CommandCompletions::eSymbolCompletion | + CommandCompletions::eSourceFileCompletion, false)); - if (tbreak_regex_cmd_ap) { + if (tbreak_regex_cmd_up) { bool success = true; for (size_t i = 0; i < num_regexes; i++) { // If you add a resultant command string longer than 1024 characters be @@ -614,155 +616,158 @@ void CommandInterpreter::LoadCommandDictionary() { lldbassert(num_printed < 1024); UNUSED_IF_ASSERT_DISABLED(num_printed); success = - tbreak_regex_cmd_ap->AddRegexCommand(break_regexes[i][0], buffer); + tbreak_regex_cmd_up->AddRegexCommand(break_regexes[i][0], buffer); if (!success) break; } success = - tbreak_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full"); + tbreak_regex_cmd_up->AddRegexCommand("^$", "breakpoint list --full"); if (success) { - CommandObjectSP tbreak_regex_cmd_sp(tbreak_regex_cmd_ap.release()); + CommandObjectSP tbreak_regex_cmd_sp(tbreak_regex_cmd_up.release()); m_command_dict[tbreak_regex_cmd_sp->GetCommandName()] = tbreak_regex_cmd_sp; } } - std::unique_ptr<CommandObjectRegexCommand> attach_regex_cmd_ap( + std::unique_ptr<CommandObjectRegexCommand> attach_regex_cmd_up( new CommandObjectRegexCommand( *this, "_regexp-attach", "Attach to process by ID or name.", "_regexp-attach <pid> | <process-name>", 2, 0, false)); - if (attach_regex_cmd_ap) { - if (attach_regex_cmd_ap->AddRegexCommand("^([0-9]+)[[:space:]]*$", + if (attach_regex_cmd_up) { + if (attach_regex_cmd_up->AddRegexCommand("^([0-9]+)[[:space:]]*$", "process attach --pid %1") && - attach_regex_cmd_ap->AddRegexCommand( + attach_regex_cmd_up->AddRegexCommand( "^(-.*|.* -.*)$", "process attach %1") && // Any options that are // specified get passed to // 'process attach' - attach_regex_cmd_ap->AddRegexCommand("^(.+)$", + attach_regex_cmd_up->AddRegexCommand("^(.+)$", "process attach --name '%1'") && - attach_regex_cmd_ap->AddRegexCommand("^$", "process attach")) { - CommandObjectSP attach_regex_cmd_sp(attach_regex_cmd_ap.release()); + attach_regex_cmd_up->AddRegexCommand("^$", "process attach")) { + CommandObjectSP attach_regex_cmd_sp(attach_regex_cmd_up.release()); m_command_dict[attach_regex_cmd_sp->GetCommandName()] = attach_regex_cmd_sp; } } - std::unique_ptr<CommandObjectRegexCommand> down_regex_cmd_ap( + std::unique_ptr<CommandObjectRegexCommand> down_regex_cmd_up( new CommandObjectRegexCommand(*this, "_regexp-down", "Select a newer stack frame. Defaults to " "moving one frame, a numeric argument can " "specify an arbitrary number.", "_regexp-down [<count>]", 2, 0, false)); - if (down_regex_cmd_ap) { - if (down_regex_cmd_ap->AddRegexCommand("^$", "frame select -r -1") && - down_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", + if (down_regex_cmd_up) { + if (down_regex_cmd_up->AddRegexCommand("^$", "frame select -r -1") && + down_regex_cmd_up->AddRegexCommand("^([0-9]+)$", "frame select -r -%1")) { - CommandObjectSP down_regex_cmd_sp(down_regex_cmd_ap.release()); + CommandObjectSP down_regex_cmd_sp(down_regex_cmd_up.release()); m_command_dict[down_regex_cmd_sp->GetCommandName()] = down_regex_cmd_sp; } } - std::unique_ptr<CommandObjectRegexCommand> up_regex_cmd_ap( + std::unique_ptr<CommandObjectRegexCommand> up_regex_cmd_up( new CommandObjectRegexCommand( *this, "_regexp-up", "Select an older stack frame. Defaults to moving one " "frame, a numeric argument can specify an arbitrary number.", "_regexp-up [<count>]", 2, 0, false)); - if (up_regex_cmd_ap) { - if (up_regex_cmd_ap->AddRegexCommand("^$", "frame select -r 1") && - up_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "frame select -r %1")) { - CommandObjectSP up_regex_cmd_sp(up_regex_cmd_ap.release()); + if (up_regex_cmd_up) { + if (up_regex_cmd_up->AddRegexCommand("^$", "frame select -r 1") && + up_regex_cmd_up->AddRegexCommand("^([0-9]+)$", "frame select -r %1")) { + CommandObjectSP up_regex_cmd_sp(up_regex_cmd_up.release()); m_command_dict[up_regex_cmd_sp->GetCommandName()] = up_regex_cmd_sp; } } - std::unique_ptr<CommandObjectRegexCommand> display_regex_cmd_ap( + std::unique_ptr<CommandObjectRegexCommand> display_regex_cmd_up( new CommandObjectRegexCommand( *this, "_regexp-display", "Evaluate an expression at every stop (see 'help target stop-hook'.)", "_regexp-display expression", 2, 0, false)); - if (display_regex_cmd_ap) { - if (display_regex_cmd_ap->AddRegexCommand( + if (display_regex_cmd_up) { + if (display_regex_cmd_up->AddRegexCommand( "^(.+)$", "target stop-hook add -o \"expr -- %1\"")) { - CommandObjectSP display_regex_cmd_sp(display_regex_cmd_ap.release()); + CommandObjectSP display_regex_cmd_sp(display_regex_cmd_up.release()); m_command_dict[display_regex_cmd_sp->GetCommandName()] = display_regex_cmd_sp; } } - std::unique_ptr<CommandObjectRegexCommand> undisplay_regex_cmd_ap( - new CommandObjectRegexCommand( - *this, "_regexp-undisplay", "Stop displaying expression at every " - "stop (specified by stop-hook index.)", - "_regexp-undisplay stop-hook-number", 2, 0, false)); - if (undisplay_regex_cmd_ap) { - if (undisplay_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", + std::unique_ptr<CommandObjectRegexCommand> undisplay_regex_cmd_up( + new CommandObjectRegexCommand(*this, "_regexp-undisplay", + "Stop displaying expression at every " + "stop (specified by stop-hook index.)", + "_regexp-undisplay stop-hook-number", 2, 0, + false)); + if (undisplay_regex_cmd_up) { + if (undisplay_regex_cmd_up->AddRegexCommand("^([0-9]+)$", "target stop-hook delete %1")) { - CommandObjectSP undisplay_regex_cmd_sp(undisplay_regex_cmd_ap.release()); + CommandObjectSP undisplay_regex_cmd_sp(undisplay_regex_cmd_up.release()); m_command_dict[undisplay_regex_cmd_sp->GetCommandName()] = undisplay_regex_cmd_sp; } } - std::unique_ptr<CommandObjectRegexCommand> connect_gdb_remote_cmd_ap( + std::unique_ptr<CommandObjectRegexCommand> connect_gdb_remote_cmd_up( new CommandObjectRegexCommand( - *this, "gdb-remote", "Connect to a process via remote GDB server. " - "If no host is specifed, localhost is assumed.", + *this, "gdb-remote", + "Connect to a process via remote GDB server. " + "If no host is specifed, localhost is assumed.", "gdb-remote [<hostname>:]<portnum>", 2, 0, false)); - if (connect_gdb_remote_cmd_ap) { - if (connect_gdb_remote_cmd_ap->AddRegexCommand( + if (connect_gdb_remote_cmd_up) { + if (connect_gdb_remote_cmd_up->AddRegexCommand( "^([^:]+|\\[[0-9a-fA-F:]+.*\\]):([0-9]+)$", "process connect --plugin gdb-remote connect://%1:%2") && - connect_gdb_remote_cmd_ap->AddRegexCommand( + connect_gdb_remote_cmd_up->AddRegexCommand( "^([[:digit:]]+)$", "process connect --plugin gdb-remote connect://localhost:%1")) { - CommandObjectSP command_sp(connect_gdb_remote_cmd_ap.release()); + CommandObjectSP command_sp(connect_gdb_remote_cmd_up.release()); m_command_dict[command_sp->GetCommandName()] = command_sp; } } - std::unique_ptr<CommandObjectRegexCommand> connect_kdp_remote_cmd_ap( + std::unique_ptr<CommandObjectRegexCommand> connect_kdp_remote_cmd_up( new CommandObjectRegexCommand( - *this, "kdp-remote", "Connect to a process via remote KDP server. " - "If no UDP port is specified, port 41139 is " - "assumed.", + *this, "kdp-remote", + "Connect to a process via remote KDP server. " + "If no UDP port is specified, port 41139 is " + "assumed.", "kdp-remote <hostname>[:<portnum>]", 2, 0, false)); - if (connect_kdp_remote_cmd_ap) { - if (connect_kdp_remote_cmd_ap->AddRegexCommand( + if (connect_kdp_remote_cmd_up) { + if (connect_kdp_remote_cmd_up->AddRegexCommand( "^([^:]+:[[:digit:]]+)$", "process connect --plugin kdp-remote udp://%1") && - connect_kdp_remote_cmd_ap->AddRegexCommand( + connect_kdp_remote_cmd_up->AddRegexCommand( "^(.+)$", "process connect --plugin kdp-remote udp://%1:41139")) { - CommandObjectSP command_sp(connect_kdp_remote_cmd_ap.release()); + CommandObjectSP command_sp(connect_kdp_remote_cmd_up.release()); m_command_dict[command_sp->GetCommandName()] = command_sp; } } - std::unique_ptr<CommandObjectRegexCommand> bt_regex_cmd_ap( + std::unique_ptr<CommandObjectRegexCommand> bt_regex_cmd_up( new CommandObjectRegexCommand( *this, "_regexp-bt", "Show the current thread's call stack. Any numeric argument " "displays at most that many " "frames. The argument 'all' displays all threads.", "bt [<digit> | all]", 2, 0, false)); - if (bt_regex_cmd_ap) { + if (bt_regex_cmd_up) { // accept but don't document "bt -c <number>" -- before bt was a regex // command if you wanted to backtrace three frames you would do "bt -c 3" // but the intention is to have this emulate the gdb "bt" command and so // now "bt 3" is the preferred form, in line with gdb. - if (bt_regex_cmd_ap->AddRegexCommand("^([[:digit:]]+)$", + if (bt_regex_cmd_up->AddRegexCommand("^([[:digit:]]+)$", "thread backtrace -c %1") && - bt_regex_cmd_ap->AddRegexCommand("^-c ([[:digit:]]+)$", + bt_regex_cmd_up->AddRegexCommand("^-c ([[:digit:]]+)$", "thread backtrace -c %1") && - bt_regex_cmd_ap->AddRegexCommand("^all$", "thread backtrace all") && - bt_regex_cmd_ap->AddRegexCommand("^$", "thread backtrace")) { - CommandObjectSP command_sp(bt_regex_cmd_ap.release()); + bt_regex_cmd_up->AddRegexCommand("^all$", "thread backtrace all") && + bt_regex_cmd_up->AddRegexCommand("^$", "thread backtrace")) { + CommandObjectSP command_sp(bt_regex_cmd_up.release()); m_command_dict[command_sp->GetCommandName()] = command_sp; } } - std::unique_ptr<CommandObjectRegexCommand> list_regex_cmd_ap( + std::unique_ptr<CommandObjectRegexCommand> list_regex_cmd_up( new CommandObjectRegexCommand( *this, "_regexp-list", "List relevant source code using one of several shorthand formats.", @@ -775,30 +780,30 @@ void CommandInterpreter::LoadCommandDictionary() { "_regexp-list -[<count>] // List previous <count> lines\n" "_regexp-list // List subsequent lines", 2, CommandCompletions::eSourceFileCompletion, false)); - if (list_regex_cmd_ap) { - if (list_regex_cmd_ap->AddRegexCommand("^([0-9]+)[[:space:]]*$", + if (list_regex_cmd_up) { + if (list_regex_cmd_up->AddRegexCommand("^([0-9]+)[[:space:]]*$", "source list --line %1") && - list_regex_cmd_ap->AddRegexCommand( + list_regex_cmd_up->AddRegexCommand( "^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]" "]*$", "source list --file '%1' --line %2") && - list_regex_cmd_ap->AddRegexCommand( + list_regex_cmd_up->AddRegexCommand( "^\\*?(0x[[:xdigit:]]+)[[:space:]]*$", "source list --address %1") && - list_regex_cmd_ap->AddRegexCommand("^-[[:space:]]*$", + list_regex_cmd_up->AddRegexCommand("^-[[:space:]]*$", "source list --reverse") && - list_regex_cmd_ap->AddRegexCommand( + list_regex_cmd_up->AddRegexCommand( "^-([[:digit:]]+)[[:space:]]*$", "source list --reverse --count %1") && - list_regex_cmd_ap->AddRegexCommand("^(.+)$", + list_regex_cmd_up->AddRegexCommand("^(.+)$", "source list --name \"%1\"") && - list_regex_cmd_ap->AddRegexCommand("^$", "source list")) { - CommandObjectSP list_regex_cmd_sp(list_regex_cmd_ap.release()); + list_regex_cmd_up->AddRegexCommand("^$", "source list")) { + CommandObjectSP list_regex_cmd_sp(list_regex_cmd_up.release()); m_command_dict[list_regex_cmd_sp->GetCommandName()] = list_regex_cmd_sp; } } - std::unique_ptr<CommandObjectRegexCommand> env_regex_cmd_ap( + std::unique_ptr<CommandObjectRegexCommand> env_regex_cmd_up( new CommandObjectRegexCommand( *this, "_regexp-env", "Shorthand for viewing and setting environment variables.", @@ -806,17 +811,17 @@ void CommandInterpreter::LoadCommandDictionary() { "_regexp-env // Show enrivonment\n" "_regexp-env <name>=<value> // Set an environment variable", 2, 0, false)); - if (env_regex_cmd_ap) { - if (env_regex_cmd_ap->AddRegexCommand("^$", + if (env_regex_cmd_up) { + if (env_regex_cmd_up->AddRegexCommand("^$", "settings show target.env-vars") && - env_regex_cmd_ap->AddRegexCommand("^([A-Za-z_][A-Za-z_0-9]*=.*)$", + env_regex_cmd_up->AddRegexCommand("^([A-Za-z_][A-Za-z_0-9]*=.*)$", "settings set target.env-vars %1")) { - CommandObjectSP env_regex_cmd_sp(env_regex_cmd_ap.release()); + CommandObjectSP env_regex_cmd_sp(env_regex_cmd_up.release()); m_command_dict[env_regex_cmd_sp->GetCommandName()] = env_regex_cmd_sp; } } - std::unique_ptr<CommandObjectRegexCommand> jump_regex_cmd_ap( + std::unique_ptr<CommandObjectRegexCommand> jump_regex_cmd_up( new CommandObjectRegexCommand( *this, "_regexp-jump", "Set the program counter to a new address.", "\n" @@ -825,16 +830,16 @@ void CommandInterpreter::LoadCommandDictionary() { "_regexp-jump <file>:<line>\n" "_regexp-jump *<addr>\n", 2, 0, false)); - if (jump_regex_cmd_ap) { - if (jump_regex_cmd_ap->AddRegexCommand("^\\*(.*)$", + if (jump_regex_cmd_up) { + if (jump_regex_cmd_up->AddRegexCommand("^\\*(.*)$", "thread jump --addr %1") && - jump_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", + jump_regex_cmd_up->AddRegexCommand("^([0-9]+)$", "thread jump --line %1") && - jump_regex_cmd_ap->AddRegexCommand("^([^:]+):([0-9]+)$", + jump_regex_cmd_up->AddRegexCommand("^([^:]+):([0-9]+)$", "thread jump --file %1 --line %2") && - jump_regex_cmd_ap->AddRegexCommand("^([+\\-][0-9]+)$", + jump_regex_cmd_up->AddRegexCommand("^([+\\-][0-9]+)$", "thread jump --by %1")) { - CommandObjectSP jump_regex_cmd_sp(jump_regex_cmd_ap.release()); + CommandObjectSP jump_regex_cmd_sp(jump_regex_cmd_up.release()); m_command_dict[jump_regex_cmd_sp->GetCommandName()] = jump_regex_cmd_sp; } } diff --git a/source/Interpreter/Options.cpp b/source/Interpreter/Options.cpp index bd29d5d83..87e09e56a 100644 --- a/source/Interpreter/Options.cpp +++ b/source/Interpreter/Options.cpp @@ -760,7 +760,7 @@ bool Options::HandleOptionArgumentCompletion( CompletionRequest &request, OptionElementVector &opt_element_vector, int opt_element_index, CommandInterpreter &interpreter) { auto opt_defs = GetDefinitions(); - std::unique_ptr<SearchFilter> filter_ap; + std::unique_ptr<SearchFilter> filter_up; int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos; int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index; @@ -831,7 +831,7 @@ bool Options::HandleOptionArgumentCompletion( interpreter.GetDebugger().GetSelectedTarget(); // Search filters require a target... if (target_sp) - filter_ap.reset(new SearchFilterByModule(target_sp, module_spec)); + filter_up.reset(new SearchFilterByModule(target_sp, module_spec)); } break; } @@ -839,7 +839,7 @@ bool Options::HandleOptionArgumentCompletion( } return CommandCompletions::InvokeCommonCompletionCallbacks( - interpreter, completion_mask, request, filter_ap.get()); + interpreter, completion_mask, request, filter_up.get()); } void OptionGroupOptions::Append(OptionGroup *group) { diff --git a/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp b/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp index 7757b9c31..de1f7d9fb 100644 --- a/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp +++ b/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp @@ -1604,7 +1604,7 @@ ValueObjectSP ABIMacOSX_arm::GetReturnValueObjectImpl( r2_reg_info->byte_size + r3_reg_info->byte_size && process_sp) { - std::unique_ptr<DataBufferHeap> heap_data_ap( + std::unique_ptr<DataBufferHeap> heap_data_up( new DataBufferHeap(*byte_size, 0)); const ByteOrder byte_order = process_sp->GetByteOrder(); RegisterValue r0_reg_value; @@ -1617,18 +1617,18 @@ ValueObjectSP ABIMacOSX_arm::GetReturnValueObjectImpl( reg_ctx->ReadRegister(r3_reg_info, r3_reg_value)) { Status error; if (r0_reg_value.GetAsMemoryData(r0_reg_info, - heap_data_ap->GetBytes() + 0, + heap_data_up->GetBytes() + 0, 4, byte_order, error) && r1_reg_value.GetAsMemoryData(r1_reg_info, - heap_data_ap->GetBytes() + 4, + heap_data_up->GetBytes() + 4, 4, byte_order, error) && r2_reg_value.GetAsMemoryData(r2_reg_info, - heap_data_ap->GetBytes() + 8, + heap_data_up->GetBytes() + 8, 4, byte_order, error) && r3_reg_value.GetAsMemoryData(r3_reg_info, - heap_data_ap->GetBytes() + 12, + heap_data_up->GetBytes() + 12, 4, byte_order, error)) { - DataExtractor data(DataBufferSP(heap_data_ap.release()), + DataExtractor data(DataBufferSP(heap_data_up.release()), byte_order, process_sp->GetAddressByteSize()); diff --git a/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp b/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp index 00f5dea30..6f952ffbc 100644 --- a/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp +++ b/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp @@ -2114,7 +2114,7 @@ static bool LoadValueFromConsecutiveGPRRegisters( if (!byte_size || *byte_size == 0) return false; - std::unique_ptr<DataBufferHeap> heap_data_ap( + std::unique_ptr<DataBufferHeap> heap_data_up( new DataBufferHeap(*byte_size, 0)); const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder(); Status error; @@ -2148,10 +2148,10 @@ static bool LoadValueFromConsecutiveGPRRegisters( if (!reg_ctx->ReadRegister(reg_info, reg_value)) return false; - // Make sure we have enough room in "heap_data_ap" - if ((data_offset + *base_byte_size) <= heap_data_ap->GetByteSize()) { + // Make sure we have enough room in "heap_data_up" + if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) { const size_t bytes_copied = reg_value.GetAsMemoryData( - reg_info, heap_data_ap->GetBytes() + data_offset, *base_byte_size, + reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size, byte_order, error); if (bytes_copied != *base_byte_size) return false; @@ -2162,7 +2162,7 @@ static bool LoadValueFromConsecutiveGPRRegisters( } data.SetByteOrder(byte_order); data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize()); - data.SetData(DataBufferSP(heap_data_ap.release())); + data.SetData(DataBufferSP(heap_data_up.release())); return true; } } @@ -2191,7 +2191,7 @@ static bool LoadValueFromConsecutiveGPRRegisters( const size_t curr_byte_size = std::min<size_t>(8, bytes_left); const size_t bytes_copied = reg_value.GetAsMemoryData( - reg_info, heap_data_ap->GetBytes() + data_offset, curr_byte_size, + reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size, byte_order, error); if (bytes_copied == 0) return false; @@ -2235,15 +2235,15 @@ static bool LoadValueFromConsecutiveGPRRegisters( return false; if (exe_ctx.GetProcessRef().ReadMemory( - value_addr, heap_data_ap->GetBytes(), heap_data_ap->GetByteSize(), - error) != heap_data_ap->GetByteSize()) { + value_addr, heap_data_up->GetBytes(), heap_data_up->GetByteSize(), + error) != heap_data_up->GetByteSize()) { return false; } } data.SetByteOrder(byte_order); data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize()); - data.SetData(DataBufferSP(heap_data_ap.release())); + data.SetData(DataBufferSP(heap_data_up.release())); return true; } @@ -2295,7 +2295,7 @@ ValueObjectSP ABIMacOSX_arm64::GetReturnValueObjectImpl( if (x1_reg_info) { if (*byte_size <= x0_reg_info->byte_size + x1_reg_info->byte_size) { - std::unique_ptr<DataBufferHeap> heap_data_ap( + std::unique_ptr<DataBufferHeap> heap_data_up( new DataBufferHeap(*byte_size, 0)); const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder(); @@ -2305,13 +2305,13 @@ ValueObjectSP ABIMacOSX_arm64::GetReturnValueObjectImpl( reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) { Status error; if (x0_reg_value.GetAsMemoryData( - x0_reg_info, heap_data_ap->GetBytes() + 0, 8, + x0_reg_info, heap_data_up->GetBytes() + 0, 8, byte_order, error) && x1_reg_value.GetAsMemoryData( - x1_reg_info, heap_data_ap->GetBytes() + 8, 8, + x1_reg_info, heap_data_up->GetBytes() + 8, 8, byte_order, error)) { DataExtractor data( - DataBufferSP(heap_data_ap.release()), byte_order, + DataBufferSP(heap_data_up.release()), byte_order, exe_ctx.GetProcessRef().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create( @@ -2395,16 +2395,16 @@ ValueObjectSP ABIMacOSX_arm64::GetReturnValueObjectImpl( if (v0_info) { if (*byte_size <= v0_info->byte_size) { - std::unique_ptr<DataBufferHeap> heap_data_ap( + std::unique_ptr<DataBufferHeap> heap_data_up( new DataBufferHeap(*byte_size, 0)); const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder(); RegisterValue reg_value; if (reg_ctx->ReadRegister(v0_info, reg_value)) { Status error; - if (reg_value.GetAsMemoryData(v0_info, heap_data_ap->GetBytes(), - heap_data_ap->GetByteSize(), + if (reg_value.GetAsMemoryData(v0_info, heap_data_up->GetBytes(), + heap_data_up->GetByteSize(), byte_order, error)) { - DataExtractor data(DataBufferSP(heap_data_ap.release()), + DataExtractor data(DataBufferSP(heap_data_up.release()), byte_order, exe_ctx.GetProcessRef().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create( diff --git a/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp b/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp index a84218986..a3daaef66 100644 --- a/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp +++ b/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp @@ -2090,7 +2090,7 @@ static bool LoadValueFromConsecutiveGPRRegisters( if (byte_size || *byte_size == 0) return false; - std::unique_ptr<DataBufferHeap> heap_data_ap( + std::unique_ptr<DataBufferHeap> heap_data_up( new DataBufferHeap(*byte_size, 0)); const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder(); Status error; @@ -2124,10 +2124,10 @@ static bool LoadValueFromConsecutiveGPRRegisters( if (!reg_ctx->ReadRegister(reg_info, reg_value)) return false; - // Make sure we have enough room in "heap_data_ap" - if ((data_offset + *base_byte_size) <= heap_data_ap->GetByteSize()) { + // Make sure we have enough room in "heap_data_up" + if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) { const size_t bytes_copied = reg_value.GetAsMemoryData( - reg_info, heap_data_ap->GetBytes() + data_offset, *base_byte_size, + reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size, byte_order, error); if (bytes_copied != *base_byte_size) return false; @@ -2138,7 +2138,7 @@ static bool LoadValueFromConsecutiveGPRRegisters( } data.SetByteOrder(byte_order); data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize()); - data.SetData(DataBufferSP(heap_data_ap.release())); + data.SetData(DataBufferSP(heap_data_up.release())); return true; } } @@ -2163,7 +2163,7 @@ static bool LoadValueFromConsecutiveGPRRegisters( const size_t curr_byte_size = std::min<size_t>(8, bytes_left); const size_t bytes_copied = reg_value.GetAsMemoryData( - reg_info, heap_data_ap->GetBytes() + data_offset, curr_byte_size, + reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size, byte_order, error); if (bytes_copied == 0) return false; @@ -2204,15 +2204,15 @@ static bool LoadValueFromConsecutiveGPRRegisters( return false; if (exe_ctx.GetProcessRef().ReadMemory( - value_addr, heap_data_ap->GetBytes(), heap_data_ap->GetByteSize(), - error) != heap_data_ap->GetByteSize()) { + value_addr, heap_data_up->GetBytes(), heap_data_up->GetByteSize(), + error) != heap_data_up->GetByteSize()) { return false; } } data.SetByteOrder(byte_order); data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize()); - data.SetData(DataBufferSP(heap_data_ap.release())); + data.SetData(DataBufferSP(heap_data_up.release())); return true; } @@ -2266,7 +2266,7 @@ ValueObjectSP ABISysV_arm64::GetReturnValueObjectImpl( if (x1_reg_info) { if (*byte_size <= x0_reg_info->byte_size + x1_reg_info->byte_size) { - std::unique_ptr<DataBufferHeap> heap_data_ap( + std::unique_ptr<DataBufferHeap> heap_data_up( new DataBufferHeap(*byte_size, 0)); const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder(); @@ -2276,13 +2276,13 @@ ValueObjectSP ABISysV_arm64::GetReturnValueObjectImpl( reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) { Status error; if (x0_reg_value.GetAsMemoryData( - x0_reg_info, heap_data_ap->GetBytes() + 0, 8, + x0_reg_info, heap_data_up->GetBytes() + 0, 8, byte_order, error) && x1_reg_value.GetAsMemoryData( - x1_reg_info, heap_data_ap->GetBytes() + 8, 8, + x1_reg_info, heap_data_up->GetBytes() + 8, 8, byte_order, error)) { DataExtractor data( - DataBufferSP(heap_data_ap.release()), byte_order, + DataBufferSP(heap_data_up.release()), byte_order, exe_ctx.GetProcessRef().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create( @@ -2364,16 +2364,16 @@ ValueObjectSP ABISysV_arm64::GetReturnValueObjectImpl( const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0); if (v0_info) { - std::unique_ptr<DataBufferHeap> heap_data_ap( + std::unique_ptr<DataBufferHeap> heap_data_up( new DataBufferHeap(*byte_size, 0)); const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder(); RegisterValue reg_value; if (reg_ctx->ReadRegister(v0_info, reg_value)) { Status error; - if (reg_value.GetAsMemoryData(v0_info, heap_data_ap->GetBytes(), - heap_data_ap->GetByteSize(), byte_order, + if (reg_value.GetAsMemoryData(v0_info, heap_data_up->GetBytes(), + heap_data_up->GetByteSize(), byte_order, error)) { - DataExtractor data(DataBufferSP(heap_data_ap.release()), byte_order, + DataExtractor data(DataBufferSP(heap_data_up.release()), byte_order, exe_ctx.GetProcessRef().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create( &thread, return_compiler_type, ConstString(""), data); diff --git a/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp b/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp index 80b7d0198..402808ad4 100644 --- a/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp +++ b/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp @@ -1103,7 +1103,7 @@ bool ABISysV_hexagon::PrepareTrivialCall( sp -= argSize; // write this argument onto the stack of the host process - proc->WriteMemory(sp, arg.data_ap.get(), arg.size, error); + proc->WriteMemory(sp, arg.data_up.get(), arg.size, error); if (error.Fail()) return false; diff --git a/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp b/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp index 1d390bf1f..d823c278d 100644 --- a/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp +++ b/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp @@ -648,19 +648,20 @@ ValueObjectSP ABISysV_i386::GetReturnValueObjectSimple( if (*byte_size <= vec_reg->byte_size) { ProcessSP process_sp(thread.GetProcess()); if (process_sp) { - std::unique_ptr<DataBufferHeap> heap_data_ap( + std::unique_ptr<DataBufferHeap> heap_data_up( new DataBufferHeap(*byte_size, 0)); const ByteOrder byte_order = process_sp->GetByteOrder(); RegisterValue reg_value; if (reg_ctx->ReadRegister(vec_reg, reg_value)) { Status error; - if (reg_value.GetAsMemoryData(vec_reg, heap_data_ap->GetBytes(), - heap_data_ap->GetByteSize(), + if (reg_value.GetAsMemoryData(vec_reg, heap_data_up->GetBytes(), + heap_data_up->GetByteSize(), byte_order, error)) { - DataExtractor data(DataBufferSP(heap_data_ap.release()), - byte_order, process_sp->GetTarget() - .GetArchitecture() - .GetAddressByteSize()); + DataExtractor data(DataBufferSP(heap_data_up.release()), + byte_order, + process_sp->GetTarget() + .GetArchitecture() + .GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create( &thread, return_compiler_type, ConstString(""), data); } @@ -672,7 +673,7 @@ ValueObjectSP ABISysV_i386::GetReturnValueObjectSimple( if (vec_reg2) { ProcessSP process_sp(thread.GetProcess()); if (process_sp) { - std::unique_ptr<DataBufferHeap> heap_data_ap( + std::unique_ptr<DataBufferHeap> heap_data_up( new DataBufferHeap(*byte_size, 0)); const ByteOrder byte_order = process_sp->GetByteOrder(); RegisterValue reg_value; @@ -681,17 +682,18 @@ ValueObjectSP ABISysV_i386::GetReturnValueObjectSimple( reg_ctx->ReadRegister(vec_reg2, reg_value2)) { Status error; - if (reg_value.GetAsMemoryData(vec_reg, heap_data_ap->GetBytes(), + if (reg_value.GetAsMemoryData(vec_reg, heap_data_up->GetBytes(), vec_reg->byte_size, byte_order, error) && reg_value2.GetAsMemoryData( - vec_reg2, heap_data_ap->GetBytes() + vec_reg->byte_size, - heap_data_ap->GetByteSize() - vec_reg->byte_size, + vec_reg2, heap_data_up->GetBytes() + vec_reg->byte_size, + heap_data_up->GetByteSize() - vec_reg->byte_size, byte_order, error)) { - DataExtractor data(DataBufferSP(heap_data_ap.release()), - byte_order, process_sp->GetTarget() - .GetArchitecture() - .GetAddressByteSize()); + DataExtractor data(DataBufferSP(heap_data_up.release()), + byte_order, + process_sp->GetTarget() + .GetArchitecture() + .GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create( &thread, return_compiler_type, ConstString(""), data); } diff --git a/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp b/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp index c26ccd72d..15762f8a0 100644 --- a/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp +++ b/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp @@ -618,16 +618,16 @@ ValueObjectSP ABISysV_ppc::GetReturnValueObjectSimple( if (*byte_size <= altivec_reg->byte_size) { ProcessSP process_sp(thread.GetProcess()); if (process_sp) { - std::unique_ptr<DataBufferHeap> heap_data_ap( + std::unique_ptr<DataBufferHeap> heap_data_up( new DataBufferHeap(*byte_size, 0)); const ByteOrder byte_order = process_sp->GetByteOrder(); RegisterValue reg_value; if (reg_ctx->ReadRegister(altivec_reg, reg_value)) { Status error; if (reg_value.GetAsMemoryData( - altivec_reg, heap_data_ap->GetBytes(), - heap_data_ap->GetByteSize(), byte_order, error)) { - DataExtractor data(DataBufferSP(heap_data_ap.release()), + altivec_reg, heap_data_up->GetBytes(), + heap_data_up->GetByteSize(), byte_order, error)) { + DataExtractor data(DataBufferSP(heap_data_up.release()), byte_order, process_sp->GetTarget() .GetArchitecture() diff --git a/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp b/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp index 983cec478..50e280d46 100644 --- a/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp +++ b/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp @@ -560,7 +560,7 @@ private: Thread &m_thread; CompilerType &m_type; uint64_t m_byte_size; - std::unique_ptr<DataBufferHeap> m_data_ap; + std::unique_ptr<DataBufferHeap> m_data_up; int32_t m_src_offs = 0; int32_t m_dst_offs = 0; bool m_packed = false; @@ -577,7 +577,7 @@ private: RegisterContext *reg_ctx, ProcessSP process_sp) : m_thread(thread), m_type(type), m_byte_size(m_type.GetByteSize(nullptr).getValueOr(0)), - m_data_ap(new DataBufferHeap(m_byte_size, 0)), m_reg_ctx(reg_ctx), + m_data_up(new DataBufferHeap(m_byte_size, 0)), m_reg_ctx(reg_ctx), m_process_sp(process_sp), m_byte_order(process_sp->GetByteOrder()), m_addr_size( process_sp->GetTarget().GetArchitecture().GetAddressByteSize()) {} @@ -686,7 +686,7 @@ private: // build the ValueObject from our data buffer ValueObjectSP BuildValueObject() { - DataExtractor de(DataBufferSP(m_data_ap.release()), m_byte_order, + DataExtractor de(DataBufferSP(m_data_up.release()), m_byte_order, m_addr_size); return ValueObjectConstResult::Create(&m_thread, m_type, ConstString(""), de); @@ -751,7 +751,7 @@ private: offs = vr_size - m_byte_size; // copy extracted data to our buffer - memcpy(m_data_ap->GetBytes(), vr_data->GetBytes() + offs, m_byte_size); + memcpy(m_data_up->GetBytes(), vr_data->GetBytes() + offs, m_byte_size); return BuildValueObject(); } @@ -765,7 +765,7 @@ private: return {}; Status error; - size_t rc = m_process_sp->ReadMemory(addr, m_data_ap->GetBytes(), + size_t rc = m_process_sp->ReadMemory(addr, m_data_up->GetBytes(), m_byte_size, error); if (rc != m_byte_size) { LLDB_LOG(m_log, LOG_PREFIX "Failed to read memory pointed by r3"); @@ -803,7 +803,8 @@ private: // copy to buffer Status error; size_t rc = val_sp->GetScalar().GetAsMemoryData( - m_data_ap->GetBytes() + m_dst_offs, *elem_size, m_byte_order, error); + m_data_up->GetBytes() + m_dst_offs, *elem_size, m_byte_order, + error); if (rc != *elem_size) { LLDB_LOG(m_log, LOG_PREFIX "Failed to get float data"); return {}; @@ -887,7 +888,7 @@ private: LOG_PREFIX "Extracting {0} alignment bytes at offset {1}", n, m_src_offs); // get alignment bytes - if (!ExtractFromRegs(m_src_offs, n, m_data_ap->GetBytes() + m_dst_offs)) + if (!ExtractFromRegs(m_src_offs, n, m_data_up->GetBytes() + m_dst_offs)) return false; m_src_offs += n; m_dst_offs += n; @@ -897,7 +898,7 @@ private: // get field LLDB_LOG(m_log, LOG_PREFIX "Extracting {0} field bytes at offset {1}", size, m_src_offs); - if (!ExtractFromRegs(m_src_offs, size, m_data_ap->GetBytes() + m_dst_offs)) + if (!ExtractFromRegs(m_src_offs, size, m_data_up->GetBytes() + m_dst_offs)) return false; m_src_offs += size; m_dst_offs += size; diff --git a/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp b/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp index 3d3576cf1..e20aad76b 100644 --- a/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp +++ b/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp @@ -1499,19 +1499,20 @@ ValueObjectSP ABISysV_x86_64::GetReturnValueObjectSimple( if (*byte_size <= altivec_reg->byte_size) { ProcessSP process_sp(thread.GetProcess()); if (process_sp) { - std::unique_ptr<DataBufferHeap> heap_data_ap( + std::unique_ptr<DataBufferHeap> heap_data_up( new DataBufferHeap(*byte_size, 0)); const ByteOrder byte_order = process_sp->GetByteOrder(); RegisterValue reg_value; if (reg_ctx->ReadRegister(altivec_reg, reg_value)) { Status error; if (reg_value.GetAsMemoryData( - altivec_reg, heap_data_ap->GetBytes(), - heap_data_ap->GetByteSize(), byte_order, error)) { - DataExtractor data(DataBufferSP(heap_data_ap.release()), - byte_order, process_sp->GetTarget() - .GetArchitecture() - .GetAddressByteSize()); + altivec_reg, heap_data_up->GetBytes(), + heap_data_up->GetByteSize(), byte_order, error)) { + DataExtractor data(DataBufferSP(heap_data_up.release()), + byte_order, + process_sp->GetTarget() + .GetArchitecture() + .GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create( &thread, return_compiler_type, ConstString(""), data); } @@ -1523,7 +1524,7 @@ ValueObjectSP ABISysV_x86_64::GetReturnValueObjectSimple( if (altivec_reg2) { ProcessSP process_sp(thread.GetProcess()); if (process_sp) { - std::unique_ptr<DataBufferHeap> heap_data_ap( + std::unique_ptr<DataBufferHeap> heap_data_up( new DataBufferHeap(*byte_size, 0)); const ByteOrder byte_order = process_sp->GetByteOrder(); RegisterValue reg_value; @@ -1533,17 +1534,18 @@ ValueObjectSP ABISysV_x86_64::GetReturnValueObjectSimple( Status error; if (reg_value.GetAsMemoryData( - altivec_reg, heap_data_ap->GetBytes(), + altivec_reg, heap_data_up->GetBytes(), altivec_reg->byte_size, byte_order, error) && reg_value2.GetAsMemoryData( altivec_reg2, - heap_data_ap->GetBytes() + altivec_reg->byte_size, - heap_data_ap->GetByteSize() - altivec_reg->byte_size, + heap_data_up->GetBytes() + altivec_reg->byte_size, + heap_data_up->GetByteSize() - altivec_reg->byte_size, byte_order, error)) { - DataExtractor data(DataBufferSP(heap_data_ap.release()), - byte_order, process_sp->GetTarget() - .GetArchitecture() - .GetAddressByteSize()); + DataExtractor data(DataBufferSP(heap_data_up.release()), + byte_order, + process_sp->GetTarget() + .GetArchitecture() + .GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create( &thread, return_compiler_type, ConstString(""), data); } diff --git a/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp b/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp index e53d741ad..ca53a18e1 100644 --- a/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp +++ b/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp @@ -1196,7 +1196,7 @@ DisassemblerLLVMC::DisassemblerLLVMC(const ArchSpec &arch, if (triple.getArch() == llvm::Triple::aarch64) features_str += "+v8.2a"; - // We use m_disasm_ap.get() to tell whether we are valid or not, so if this + // We use m_disasm_up.get() to tell whether we are valid or not, so if this // isn't good for some reason, we won't be valid and FindPlugin will fail and // we won't get used. m_disasm_up = MCDisasmInstance::Create(triple_str, cpu, features_str.c_str(), @@ -1237,11 +1237,11 @@ DisassemblerLLVMC::~DisassemblerLLVMC() = default; Disassembler *DisassemblerLLVMC::CreateInstance(const ArchSpec &arch, const char *flavor) { if (arch.GetTriple().getArch() != llvm::Triple::UnknownArch) { - std::unique_ptr<DisassemblerLLVMC> disasm_ap( + std::unique_ptr<DisassemblerLLVMC> disasm_up( new DisassemblerLLVMC(arch, flavor)); - if (disasm_ap.get() && disasm_ap->IsValid()) - return disasm_ap.release(); + if (disasm_up.get() && disasm_up->IsValid()) + return disasm_up.release(); } return NULL; } diff --git a/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp b/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp index 65fdc5515..266b1e229 100644 --- a/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp +++ b/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp @@ -1062,10 +1062,10 @@ lldb_private::Status ClangExpressionParser::PrepareForExecution( lldb_private::Status err; - std::unique_ptr<llvm::Module> llvm_module_ap( + std::unique_ptr<llvm::Module> llvm_module_up( m_code_generator->ReleaseModule()); - if (!llvm_module_ap) { + if (!llvm_module_up) { err.SetErrorToGenericError(); err.SetErrorString("IR doesn't contain a module"); return err; @@ -1076,7 +1076,7 @@ lldb_private::Status ClangExpressionParser::PrepareForExecution( if (execution_policy != eExecutionPolicyTopLevel) { // Find the actual name of the function (it's often mangled somehow) - if (!FindFunctionInModule(function_name, llvm_module_ap.get(), + if (!FindFunctionInModule(function_name, llvm_module_up.get(), m_expr.FunctionName())) { err.SetErrorToGenericError(); err.SetErrorStringWithFormat("Couldn't find %s() in the module", @@ -1117,13 +1117,13 @@ lldb_private::Status ClangExpressionParser::PrepareForExecution( "expression module '%s'", __FUNCTION__, m_expr.FunctionName()); - custom_passes.EarlyPasses->run(*llvm_module_ap); + custom_passes.EarlyPasses->run(*llvm_module_up); } execution_unit_sp = std::make_shared<IRExecutionUnit>( m_llvm_context, // handed off here - llvm_module_ap, // handed off here - function_name, exe_ctx.GetTargetSP(), sc, + llvm_module_up, // handed off here + function_name, exe_ctx.GetTargetSP(), sc, m_compiler->getTargetOpts().Features); ClangExpressionHelper *type_system_helper = diff --git a/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp b/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp index fb72d673e..bc725c9af 100644 --- a/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp +++ b/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp @@ -489,13 +489,13 @@ bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager, // Parse the expression // - m_materializer_ap.reset(new Materializer()); + m_materializer_up.reset(new Materializer()); ResetDeclMap(exe_ctx, m_result_delegate, keep_result_in_memory); OnExit on_exit([this]() { ResetDeclMap(); }); - if (!DeclMap()->WillParse(exe_ctx, m_materializer_ap.get())) { + if (!DeclMap()->WillParse(exe_ctx, m_materializer_up.get())) { diagnostic_manager.PutString( eDiagnosticSeverityError, "current process state is unsuitable for expression parsing"); @@ -678,13 +678,13 @@ bool ClangUserExpression::Complete(ExecutionContext &exe_ctx, // Parse the expression // - m_materializer_ap.reset(new Materializer()); + m_materializer_up.reset(new Materializer()); ResetDeclMap(exe_ctx, m_result_delegate, /*keep result in memory*/ true); OnExit on_exit([this]() { ResetDeclMap(); }); - if (!DeclMap()->WillParse(exe_ctx, m_materializer_ap.get())) { + if (!DeclMap()->WillParse(exe_ctx, m_materializer_up.get())) { diagnostic_manager.PutString( eDiagnosticSeverityError, "current process state is unsuitable for expression parsing"); diff --git a/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp b/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp index fb54aaaf2..86f5cefe0 100644 --- a/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp +++ b/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp @@ -739,17 +739,17 @@ EmulateInstructionARM::CreateInstance(const ArchSpec &arch, if (EmulateInstructionARM::SupportsEmulatingInstructionsOfTypeStatic( inst_type)) { if (arch.GetTriple().getArch() == llvm::Triple::arm) { - std::unique_ptr<EmulateInstructionARM> emulate_insn_ap( + std::unique_ptr<EmulateInstructionARM> emulate_insn_up( new EmulateInstructionARM(arch)); - if (emulate_insn_ap) - return emulate_insn_ap.release(); + if (emulate_insn_up) + return emulate_insn_up.release(); } else if (arch.GetTriple().getArch() == llvm::Triple::thumb) { - std::unique_ptr<EmulateInstructionARM> emulate_insn_ap( + std::unique_ptr<EmulateInstructionARM> emulate_insn_up( new EmulateInstructionARM(arch)); - if (emulate_insn_ap) - return emulate_insn_ap.release(); + if (emulate_insn_up) + return emulate_insn_up.release(); } } diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp index 6081af646..7e4d6dff6 100644 --- a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp +++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp @@ -51,7 +51,7 @@ AppleObjCRuntime::~AppleObjCRuntime() {} AppleObjCRuntime::AppleObjCRuntime(Process *process) : ObjCLanguageRuntime(process), m_read_objc_library(false), - m_objc_trampoline_handler_ap(), m_Foundation_major() { + m_objc_trampoline_handler_up(), m_Foundation_major() { ReadObjCLibraryIfNeeded(process->GetTarget().GetImages()); } @@ -327,9 +327,9 @@ bool AppleObjCRuntime::ReadObjCLibrary(const ModuleSP &module_sp) { // Maybe check here and if we have a handler already, and the UUID of this // module is the same as the one in the current module, then we don't have to // reread it? - m_objc_trampoline_handler_ap.reset( + m_objc_trampoline_handler_up.reset( new AppleObjCTrampolineHandler(m_process->shared_from_this(), module_sp)); - if (m_objc_trampoline_handler_ap != NULL) { + if (m_objc_trampoline_handler_up != NULL) { m_read_objc_library = true; return true; } else @@ -339,8 +339,8 @@ bool AppleObjCRuntime::ReadObjCLibrary(const ModuleSP &module_sp) { ThreadPlanSP AppleObjCRuntime::GetStepThroughTrampolinePlan(Thread &thread, bool stop_others) { ThreadPlanSP thread_plan_sp; - if (m_objc_trampoline_handler_ap) - thread_plan_sp = m_objc_trampoline_handler_ap->GetStepThroughDispatchPlan( + if (m_objc_trampoline_handler_up) + thread_plan_sp = m_objc_trampoline_handler_up->GetStepThroughDispatchPlan( thread, stop_others); return thread_plan_sp; } diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h index 8cb58521a..bd72cd734 100644 --- a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h +++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h @@ -119,7 +119,7 @@ protected: std::unique_ptr<Address> m_PrintForDebugger_addr; bool m_read_objc_library; std::unique_ptr<lldb_private::AppleObjCTrampolineHandler> - m_objc_trampoline_handler_ap; + m_objc_trampoline_handler_up; lldb::BreakpointSP m_objc_exception_bp_sp; lldb::ModuleWP m_objc_module_wp; std::unique_ptr<FunctionCaller> m_print_object_caller_up; diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h index 79cca67cf..47214ff3b 100644 --- a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h +++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h @@ -147,7 +147,7 @@ protected: HashTableSignature m_hash_signature; lldb::addr_t m_isa_hash_table_ptr; - std::unique_ptr<DeclVendor> m_decl_vendor_ap; + std::unique_ptr<DeclVendor> m_decl_vendor_up; private: AppleObjCRuntimeV1(Process *process); diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp index 85ffc7996..3408ad6b6 100644 --- a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp +++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp @@ -384,14 +384,13 @@ AppleObjCRuntimeV2::AppleObjCRuntimeV2(Process *process, m_get_class_info_args(LLDB_INVALID_ADDRESS), m_get_class_info_args_mutex(), m_get_shared_cache_class_info_code(), m_get_shared_cache_class_info_args(LLDB_INVALID_ADDRESS), - m_get_shared_cache_class_info_args_mutex(), m_decl_vendor_ap(), + m_get_shared_cache_class_info_args_mutex(), m_decl_vendor_up(), m_tagged_pointer_obfuscator(LLDB_INVALID_ADDRESS), - m_isa_hash_table_ptr(LLDB_INVALID_ADDRESS), - m_hash_signature(), + m_isa_hash_table_ptr(LLDB_INVALID_ADDRESS), m_hash_signature(), m_has_object_getClass(false), m_loaded_objc_opt(false), - m_non_pointer_isa_cache_ap( + m_non_pointer_isa_cache_up( NonPointerISACache::CreateInstance(*this, objc_module_sp)), - m_tagged_pointer_vendor_ap( + m_tagged_pointer_vendor_up( TaggedPointerVendorV2::CreateInstance(*this, objc_module_sp)), m_encoding_to_type_sp(), m_noclasses_warning_emitted(false), m_CFBoolean_values() { @@ -921,9 +920,9 @@ size_t AppleObjCRuntimeV2::GetByteOffsetForIvar(CompilerType &parent_ast_type, // computational effort as possible whether something could possibly be a // tagged pointer - false positives are possible but false negatives shouldn't bool AppleObjCRuntimeV2::IsTaggedPointer(addr_t ptr) { - if (!m_tagged_pointer_vendor_ap) + if (!m_tagged_pointer_vendor_up) return false; - return m_tagged_pointer_vendor_ap->IsPossibleTaggedPointer(ptr); + return m_tagged_pointer_vendor_up->IsPossibleTaggedPointer(ptr); } class RemoteNXMapTable { @@ -1148,8 +1147,8 @@ bool AppleObjCRuntimeV2::HashTableSignature::NeedsUpdate( ObjCLanguageRuntime::ClassDescriptorSP AppleObjCRuntimeV2::GetClassDescriptorFromISA(ObjCISA isa) { ObjCLanguageRuntime::ClassDescriptorSP class_descriptor_sp; - if (m_non_pointer_isa_cache_ap) - class_descriptor_sp = m_non_pointer_isa_cache_ap->GetClassDescriptor(isa); + if (m_non_pointer_isa_cache_up) + class_descriptor_sp = m_non_pointer_isa_cache_up->GetClassDescriptor(isa); if (!class_descriptor_sp) class_descriptor_sp = ObjCLanguageRuntime::GetClassDescriptorFromISA(isa); return class_descriptor_sp; @@ -1176,7 +1175,7 @@ AppleObjCRuntimeV2::GetClassDescriptor(ValueObject &valobj) { // tagged pointer if (IsTaggedPointer(isa_pointer)) { - return m_tagged_pointer_vendor_ap->GetClassDescriptor(isa_pointer); + return m_tagged_pointer_vendor_up->GetClassDescriptor(isa_pointer); } else { ExecutionContext exe_ctx(valobj.GetExecutionContextRef()); @@ -1946,10 +1945,10 @@ AppleObjCRuntimeV2::GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa) { } DeclVendor *AppleObjCRuntimeV2::GetDeclVendor() { - if (!m_decl_vendor_ap) - m_decl_vendor_ap.reset(new AppleObjCDeclVendor(*this)); + if (!m_decl_vendor_up) + m_decl_vendor_up.reset(new AppleObjCDeclVendor(*this)); - return m_decl_vendor_ap.get(); + return m_decl_vendor_up.get(); } lldb::addr_t AppleObjCRuntimeV2::LookupRuntimeSymbol(const ConstString &name) { @@ -2559,8 +2558,8 @@ lldb_private::AppleObjCRuntime::ObjCISA AppleObjCRuntimeV2::GetPointerISA(ObjCISA isa) { ObjCISA ret = isa; - if (m_non_pointer_isa_cache_ap) - m_non_pointer_isa_cache_ap->EvaluateNonPointerISA(isa, ret); + if (m_non_pointer_isa_cache_up) + m_non_pointer_isa_cache_up->EvaluateNonPointerISA(isa, ret); return ret; } diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h index d9135e58b..1129309cb 100644 --- a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h +++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h @@ -86,7 +86,7 @@ public: bool IsTaggedPointer(lldb::addr_t ptr) override; TaggedPointerVendor *GetTaggedPointerVendor() override { - return m_tagged_pointer_vendor_ap.get(); + return m_tagged_pointer_vendor_up.get(); } lldb::addr_t GetTaggedPointerObfuscator(); @@ -326,14 +326,14 @@ private: lldb::addr_t m_get_shared_cache_class_info_args; std::mutex m_get_shared_cache_class_info_args_mutex; - std::unique_ptr<DeclVendor> m_decl_vendor_ap; + std::unique_ptr<DeclVendor> m_decl_vendor_up; lldb::addr_t m_tagged_pointer_obfuscator; lldb::addr_t m_isa_hash_table_ptr; HashTableSignature m_hash_signature; bool m_has_object_getClass; bool m_loaded_objc_opt; - std::unique_ptr<NonPointerISACache> m_non_pointer_isa_cache_ap; - std::unique_ptr<TaggedPointerVendor> m_tagged_pointer_vendor_ap; + std::unique_ptr<NonPointerISACache> m_non_pointer_isa_cache_up; + std::unique_ptr<TaggedPointerVendor> m_tagged_pointer_vendor_up; EncodingToTypeSP m_encoding_to_type_sp; bool m_noclasses_warning_emitted; llvm::Optional<std::pair<lldb::addr_t, lldb::addr_t>> m_CFBoolean_values; diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp index 4270d2a7c..377c8b3c7 100644 --- a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp +++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp @@ -748,9 +748,9 @@ AppleObjCTrampolineHandler::AppleObjCTrampolineHandler( } // Build our vtable dispatch handler here: - m_vtables_ap.reset(new AppleObjCVTables(process_sp, m_objc_module_sp)); - if (m_vtables_ap) - m_vtables_ap->ReadRegions(); + m_vtables_up.reset(new AppleObjCVTables(process_sp, m_objc_module_sp)); + if (m_vtables_up) + m_vtables_up->ReadRegions(); } lldb::addr_t @@ -864,8 +864,8 @@ AppleObjCTrampolineHandler::GetStepThroughDispatchPlan(Thread &thread, if (!found_it) { uint32_t flags; - if (m_vtables_ap) { - found_it = m_vtables_ap->IsAddressInVTables(curr_pc, flags); + if (m_vtables_up) { + found_it = m_vtables_up->IsAddressInVTables(curr_pc, flags); if (found_it) { this_dispatch.name = "vtable"; this_dispatch.stret_return = diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h index ed93fc194..a172c54eb 100644 --- a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h +++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h @@ -149,7 +149,7 @@ private: lldb::addr_t m_impl_stret_fn_addr; lldb::addr_t m_msg_forward_addr; lldb::addr_t m_msg_forward_stret_addr; - std::unique_ptr<AppleObjCVTables> m_vtables_ap; + std::unique_ptr<AppleObjCVTables> m_vtables_up; }; } // namespace lldb_private diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp index fd02e71d8..e1068e8d4 100644 --- a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp +++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp @@ -23,8 +23,8 @@ using namespace lldb_utility; AppleObjCTypeEncodingParser::AppleObjCTypeEncodingParser( ObjCLanguageRuntime &runtime) : ObjCLanguageRuntime::EncodingToType(), m_runtime(runtime) { - if (!m_scratch_ast_ctx_ap) - m_scratch_ast_ctx_ap.reset(new ClangASTContext(runtime.GetProcess() + if (!m_scratch_ast_ctx_up) + m_scratch_ast_ctx_up.reset(new ClangASTContext(runtime.GetProcess() ->GetTarget() .GetArchitecture() .GetTriple() diff --git a/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp b/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp index b6739345c..7dd3b87a3 100644 --- a/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp +++ b/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp @@ -1502,9 +1502,9 @@ void RenderScriptRuntime::CaptureAllocationDestroy(RuntimeHook *hook, uint64_t(args[eRsContext]), uint64_t(args[eRsAlloc])); for (auto iter = m_allocations.begin(); iter != m_allocations.end(); ++iter) { - auto &allocation_ap = *iter; // get the unique pointer - if (allocation_ap->address.isValid() && - *allocation_ap->address.get() == addr_t(args[eRsAlloc])) { + auto &allocation_up = *iter; // get the unique pointer + if (allocation_up->address.isValid() && + *allocation_up->address.get() == addr_t(args[eRsAlloc])) { m_allocations.erase(iter); if (log) log->Printf("%s - deleted allocation entry.", __FUNCTION__); diff --git a/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp b/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp index 64de17154..50e474917 100644 --- a/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp +++ b/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp @@ -320,18 +320,18 @@ ObjectContainer *ObjectContainerBSDArchive::CreateInstance( Archive::shared_ptr archive_sp(Archive::FindCachedArchive( *file, module_sp->GetArchitecture(), module_sp->GetModificationTime(), file_offset)); - std::unique_ptr<ObjectContainerBSDArchive> container_ap( + std::unique_ptr<ObjectContainerBSDArchive> container_up( new ObjectContainerBSDArchive(module_sp, archive_data_sp, archive_data_offset, file, file_offset, length)); - if (container_ap) { + if (container_up) { if (archive_sp) { // We already have this archive in our cache, use it - container_ap->SetArchive(archive_sp); - return container_ap.release(); - } else if (container_ap->ParseHeader()) - return container_ap.release(); + container_up->SetArchive(archive_sp); + return container_up.release(); + } else if (container_up->ParseHeader()) + return container_up.release(); } } } else { @@ -340,14 +340,14 @@ ObjectContainer *ObjectContainerBSDArchive::CreateInstance( *file, module_sp->GetArchitecture(), module_sp->GetModificationTime(), file_offset)); if (archive_sp) { - std::unique_ptr<ObjectContainerBSDArchive> container_ap( + std::unique_ptr<ObjectContainerBSDArchive> container_up( new ObjectContainerBSDArchive(module_sp, data_sp, data_offset, file, file_offset, length)); - if (container_ap) { + if (container_up) { // We already have this archive in our cache, use it - container_ap->SetArchive(archive_sp); - return container_ap.release(); + container_up->SetArchive(archive_sp); + return container_up.release(); } } } diff --git a/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp b/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp index 808e4691c..9e4dc5af0 100644 --- a/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp +++ b/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp @@ -49,11 +49,11 @@ ObjectContainer *ObjectContainerUniversalMachO::CreateInstance( DataExtractor data; data.SetData(data_sp, data_offset, length); if (ObjectContainerUniversalMachO::MagicBytesMatch(data)) { - std::unique_ptr<ObjectContainerUniversalMachO> container_ap( + std::unique_ptr<ObjectContainerUniversalMachO> container_up( new ObjectContainerUniversalMachO(module_sp, data_sp, data_offset, file, file_offset, length)); - if (container_ap->ParseHeader()) { - return container_ap.release(); + if (container_up->ParseHeader()) { + return container_up.release(); } } } diff --git a/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp b/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp index 5f36638f5..ab6898569 100644 --- a/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp +++ b/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp @@ -123,9 +123,9 @@ Symtab *ObjectFileBreakpad::GetSymtab() { } void ObjectFileBreakpad::CreateSections(SectionList &unified_section_list) { - if (m_sections_ap) + if (m_sections_up) return; - m_sections_ap = llvm::make_unique<SectionList>(); + m_sections_up = llvm::make_unique<SectionList>(); llvm::Optional<Record::Kind> current_section; offset_t section_start; @@ -141,7 +141,7 @@ void ObjectFileBreakpad::CreateSections(SectionList &unified_section_list) { ConstString(toString(*current_section)), eSectionTypeOther, /*file_vm_addr*/ 0, /*vm_size*/ 0, section_start, end_offset - section_start, /*log2align*/ 0, /*flags*/ 0); - m_sections_ap->AddSection(section_sp); + m_sections_up->AddSection(section_sp); unified_section_list.AddSection(section_sp); }; while (!text.empty()) { diff --git a/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp b/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp index eaafa84db..e6a39dbc5 100644 --- a/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp +++ b/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp @@ -435,11 +435,11 @@ ObjectFile *ObjectFileELF::CreateInstance(const lldb::ModuleSP &module_sp, unsigned address_size = ELFHeader::AddressSizeInBytes(magic); if (address_size == 4 || address_size == 8) { - std::unique_ptr<ObjectFileELF> objfile_ap(new ObjectFileELF( + std::unique_ptr<ObjectFileELF> objfile_up(new ObjectFileELF( module_sp, data_sp, data_offset, file, file_offset, length)); - ArchSpec spec = objfile_ap->GetArchitecture(); - if (spec && objfile_ap->SetModulesArchitecture(spec)) - return objfile_ap.release(); + ArchSpec spec = objfile_up->GetArchitecture(); + if (spec && objfile_up->SetModulesArchitecture(spec)) + return objfile_up.release(); } return NULL; @@ -453,11 +453,11 @@ ObjectFile *ObjectFileELF::CreateMemoryInstance( if (ELFHeader::MagicBytesMatch(magic)) { unsigned address_size = ELFHeader::AddressSizeInBytes(magic); if (address_size == 4 || address_size == 8) { - std::unique_ptr<ObjectFileELF> objfile_ap( + std::unique_ptr<ObjectFileELF> objfile_up( new ObjectFileELF(module_sp, data_sp, process_sp, header_addr)); - ArchSpec spec = objfile_ap->GetArchitecture(); - if (spec && objfile_ap->SetModulesArchitecture(spec)) - return objfile_ap.release(); + ArchSpec spec = objfile_up->GetArchitecture(); + if (spec && objfile_up->SetModulesArchitecture(spec)) + return objfile_up.release(); } } } @@ -774,7 +774,7 @@ ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp, : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset), m_header(), m_uuid(), m_gnu_debuglink_file(), m_gnu_debuglink_crc(0), m_program_headers(), m_section_headers(), m_dynamic_symbols(), - m_filespec_ap(), m_entry_point_address(), m_arch_spec() { + m_filespec_up(), m_entry_point_address(), m_arch_spec() { if (file) m_file = *file; ::memset(&m_header, 0, sizeof(m_header)); @@ -787,7 +787,7 @@ ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp, : ObjectFile(module_sp, process_sp, header_addr, header_data_sp), m_header(), m_uuid(), m_gnu_debuglink_file(), m_gnu_debuglink_crc(0), m_program_headers(), m_section_headers(), m_dynamic_symbols(), - m_filespec_ap(), m_entry_point_address(), m_arch_spec() { + m_filespec_up(), m_entry_point_address(), m_arch_spec() { ::memset(&m_header, 0, sizeof(m_header)); } @@ -950,7 +950,7 @@ uint32_t ObjectFileELF::GetDependentModules(FileSpecList &files) { uint32_t num_specs = 0; for (unsigned i = 0; i < num_modules; ++i) { - if (files.AppendIfUnique(m_filespec_ap->GetFileSpecAtIndex(i))) + if (files.AppendIfUnique(m_filespec_up->GetFileSpecAtIndex(i))) num_specs++; } @@ -1057,10 +1057,10 @@ Address ObjectFileELF::GetBaseAddress() { // ParseDependentModules //---------------------------------------------------------------------- size_t ObjectFileELF::ParseDependentModules() { - if (m_filespec_ap) - return m_filespec_ap->GetSize(); + if (m_filespec_up) + return m_filespec_up->GetSize(); - m_filespec_ap.reset(new FileSpecList()); + m_filespec_up.reset(new FileSpecList()); if (!ParseSectionHeaders()) return 0; @@ -1107,11 +1107,11 @@ size_t ObjectFileELF::ParseDependentModules() { const char *lib_name = dynstr_data.PeekCStr(str_index); FileSpec file_spec(lib_name); FileSystem::Instance().Resolve(file_spec); - m_filespec_ap->Append(file_spec); + m_filespec_up->Append(file_spec); } } - return m_filespec_ap->GetSize(); + return m_filespec_up->GetSize(); } //---------------------------------------------------------------------- @@ -1931,10 +1931,10 @@ public: } void ObjectFileELF::CreateSections(SectionList &unified_section_list) { - if (m_sections_ap) + if (m_sections_up) return; - m_sections_ap = llvm::make_unique<SectionList>(); + m_sections_up = llvm::make_unique<SectionList>(); VMAddressProvider address_provider(CalculateType()); size_t LoadID = 0; @@ -1954,7 +1954,7 @@ void ObjectFileELF::CreateSections(SectionList &unified_section_list) { eSectionTypeContainer, InfoOr->GetRangeBase(), InfoOr->GetByteSize(), PHdr.p_offset, PHdr.p_filesz, Log2Align, /*flags*/ 0); Segment->SetPermissions(GetPermissions(PHdr)); - m_sections_ap->AddSection(Segment); + m_sections_up->AddSection(Segment); address_provider.AddSegment(*InfoOr, std::move(Segment)); } @@ -2000,7 +2000,7 @@ void ObjectFileELF::CreateSections(SectionList &unified_section_list) { section_sp->SetPermissions(GetPermissions(header)); section_sp->SetIsThreadSpecific(header.sh_flags & SHF_TLS); - (InfoOr->Segment ? InfoOr->Segment->GetChildren() : *m_sections_ap) + (InfoOr->Segment ? InfoOr->Segment->GetChildren() : *m_sections_up) .AddSection(section_sp); address_provider.AddSection(std::move(*InfoOr), std::move(section_sp)); } @@ -2008,7 +2008,7 @@ void ObjectFileELF::CreateSections(SectionList &unified_section_list) { // For eTypeDebugInfo files, the Symbol Vendor will take care of updating the // unified section list. if (GetType() != eTypeDebugInfo) - unified_section_list = *m_sections_ap; + unified_section_list = *m_sections_up; } // Find the arm/aarch64 mapping symbol character in the given symbol name. @@ -2384,7 +2384,7 @@ unsigned ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, } // Get section list for this object file. - SectionList *section_list = m_sections_ap.get(); + SectionList *section_list = m_sections_up.get(); if (!section_list) return 0; @@ -2612,7 +2612,7 @@ ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, user_id_t start_id, if (!sym_hdr) return 0; - SectionList *section_list = m_sections_ap.get(); + SectionList *section_list = m_sections_up.get(); if (!section_list) return 0; @@ -2805,7 +2805,7 @@ Symtab *ObjectFileELF::GetSymtab() { if (module_obj_file && module_obj_file != this) return module_obj_file->GetSymtab(); - if (m_symtab_ap == NULL) { + if (m_symtab_up == NULL) { SectionList *section_list = module_sp->GetSectionList(); if (!section_list) return NULL; @@ -2829,8 +2829,8 @@ Symtab *ObjectFileELF::GetSymtab() { .get(); } if (symtab) { - m_symtab_ap.reset(new Symtab(symtab->GetObjectFile())); - symbol_id += ParseSymbolTable(m_symtab_ap.get(), symbol_id, symtab); + m_symtab_up.reset(new Symtab(symtab->GetObjectFile())); + symbol_id += ParseSymbolTable(m_symtab_up.get(), symbol_id, symtab); } // DT_JMPREL @@ -2854,30 +2854,30 @@ Symtab *ObjectFileELF::GetSymtab() { GetSectionHeaderByIndex(reloc_id); assert(reloc_header); - if (m_symtab_ap == nullptr) - m_symtab_ap.reset(new Symtab(reloc_section->GetObjectFile())); + if (m_symtab_up == nullptr) + m_symtab_up.reset(new Symtab(reloc_section->GetObjectFile())); - ParseTrampolineSymbols(m_symtab_ap.get(), symbol_id, reloc_header, + ParseTrampolineSymbols(m_symtab_up.get(), symbol_id, reloc_header, reloc_id); } } DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo(); if (eh_frame) { - if (m_symtab_ap == nullptr) - m_symtab_ap.reset(new Symtab(this)); - ParseUnwindSymbols(m_symtab_ap.get(), eh_frame); + if (m_symtab_up == nullptr) + m_symtab_up.reset(new Symtab(this)); + ParseUnwindSymbols(m_symtab_up.get(), eh_frame); } // If we still don't have any symtab then create an empty instance to avoid // do the section lookup next time. - if (m_symtab_ap == nullptr) - m_symtab_ap.reset(new Symtab(this)); + if (m_symtab_up == nullptr) + m_symtab_up.reset(new Symtab(this)); - m_symtab_ap->CalculateSymbolSizes(); + m_symtab_up->CalculateSymbolSizes(); } - return m_symtab_ap.get(); + return m_symtab_up.get(); } void ObjectFileELF::RelocateSection(lldb_private::Section *section) @@ -3276,7 +3276,7 @@ void ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) { if (num_modules > 0) { s->PutCString("Dependent Modules:\n"); for (unsigned i = 0; i < num_modules; ++i) { - const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i); + const FileSpec &spec = m_filespec_up->GetFileSpecAtIndex(i); s->Printf(" %s\n", spec.GetFilename().GetCString()); } } diff --git a/source/Plugins/ObjectFile/ELF/ObjectFileELF.h b/source/Plugins/ObjectFile/ELF/ObjectFileELF.h index fb51212a0..668cfa365 100644 --- a/source/Plugins/ObjectFile/ELF/ObjectFileELF.h +++ b/source/Plugins/ObjectFile/ELF/ObjectFileELF.h @@ -210,7 +210,7 @@ private: /// List of file specifications corresponding to the modules (shared /// libraries) on which this object file depends. - mutable std::unique_ptr<lldb_private::FileSpecList> m_filespec_ap; + mutable std::unique_ptr<lldb_private::FileSpecList> m_filespec_up; /// Cached value of the entry point for this module. lldb_private::Address m_entry_point_address; @@ -264,7 +264,7 @@ private: lldb_private::ArchSpec &arch_spec); /// Scans the dynamic section and locates all dependent modules (shared - /// libraries) populating m_filespec_ap. This method will compute the + /// libraries) populating m_filespec_up. This method will compute the /// dependent module list only once. Returns the number of dependent /// modules parsed. size_t ParseDependentModules(); @@ -274,7 +274,7 @@ private: /// number of dynamic symbols parsed. size_t ParseDynamicSymbols(); - /// Populates m_symtab_ap will all non-dynamic linker symbols. This method + /// Populates m_symtab_up will all non-dynamic linker symbols. This method /// will parse the symbols only once. Returns the number of symbols parsed. unsigned ParseSymbolTable(lldb_private::Symtab *symbol_table, lldb::user_id_t start_id, diff --git a/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp b/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp index 46daa5e9c..2c9fed26b 100644 --- a/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp +++ b/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp @@ -115,18 +115,18 @@ Symtab *ObjectFileJIT::GetSymtab() { ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_symtab_ap == NULL) { - m_symtab_ap.reset(new Symtab(this)); + if (m_symtab_up == NULL) { + m_symtab_up.reset(new Symtab(this)); std::lock_guard<std::recursive_mutex> symtab_guard( - m_symtab_ap->GetMutex()); + m_symtab_up->GetMutex()); ObjectFileJITDelegateSP delegate_sp(m_delegate_wp.lock()); if (delegate_sp) - delegate_sp->PopulateSymtab(this, *m_symtab_ap); + delegate_sp->PopulateSymtab(this, *m_symtab_up); // TODO: get symbols from delegate - m_symtab_ap->Finalize(); + m_symtab_up->Finalize(); } } - return m_symtab_ap.get(); + return m_symtab_up.get(); } bool ObjectFileJIT::IsStripped() { @@ -134,12 +134,12 @@ bool ObjectFileJIT::IsStripped() { } void ObjectFileJIT::CreateSections(SectionList &unified_section_list) { - if (!m_sections_ap) { - m_sections_ap.reset(new SectionList()); + if (!m_sections_up) { + m_sections_up.reset(new SectionList()); ObjectFileJITDelegateSP delegate_sp(m_delegate_wp.lock()); if (delegate_sp) { - delegate_sp->PopulateSectionList(this, *m_sections_ap); - unified_section_list = *m_sections_ap; + delegate_sp->PopulateSectionList(this, *m_sections_up); + unified_section_list = *m_sections_up; } } } @@ -161,8 +161,8 @@ void ObjectFileJIT::Dump(Stream *s) { if (sections) sections->Dump(s, NULL, true, UINT32_MAX); - if (m_symtab_ap) - m_symtab_ap->Dump(s, NULL, eSortOrderNone); + if (m_symtab_up) + m_symtab_up->Dump(s, NULL, eSortOrderNone); } } diff --git a/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp b/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp index 22839990d..035142a34 100644 --- a/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp +++ b/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp @@ -872,22 +872,22 @@ ObjectFile *ObjectFileMachO::CreateInstance(const lldb::ModuleSP &module_sp, return nullptr; data_offset = 0; } - auto objfile_ap = llvm::make_unique<ObjectFileMachO>( + auto objfile_up = llvm::make_unique<ObjectFileMachO>( module_sp, data_sp, data_offset, file, file_offset, length); - if (!objfile_ap || !objfile_ap->ParseHeader()) + if (!objfile_up || !objfile_up->ParseHeader()) return nullptr; - return objfile_ap.release(); + return objfile_up.release(); } ObjectFile *ObjectFileMachO::CreateMemoryInstance( const lldb::ModuleSP &module_sp, DataBufferSP &data_sp, const ProcessSP &process_sp, lldb::addr_t header_addr) { if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) { - std::unique_ptr<ObjectFile> objfile_ap( + std::unique_ptr<ObjectFile> objfile_up( new ObjectFileMachO(module_sp, data_sp, process_sp, header_addr)); - if (objfile_ap.get() && objfile_ap->ParseHeader()) - return objfile_ap.release(); + if (objfile_up.get() && objfile_up->ParseHeader()) + return objfile_up.release(); } return NULL; } @@ -1312,15 +1312,15 @@ Symtab *ObjectFileMachO::GetSymtab() { ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_symtab_ap == NULL) { - m_symtab_ap.reset(new Symtab(this)); + if (m_symtab_up == NULL) { + m_symtab_up.reset(new Symtab(this)); std::lock_guard<std::recursive_mutex> symtab_guard( - m_symtab_ap->GetMutex()); + m_symtab_up->GetMutex()); ParseSymtab(); - m_symtab_ap->Finalize(); + m_symtab_up->Finalize(); } } - return m_symtab_ap.get(); + return m_symtab_up.get(); } bool ObjectFileMachO::IsStripped() { @@ -1668,7 +1668,7 @@ void ObjectFileMachO::ProcessSegmentCommand(const load_command &load_cmd_, load_cmd.flags); // Flags for this section segment_sp->SetIsEncrypted(segment_is_encrypted); - m_sections_ap->AddSection(segment_sp); + m_sections_up->AddSection(segment_sp); segment_sp->SetPermissions(segment_permissions); if (add_to_unified) context.UnifiedList.AddSection(segment_sp); @@ -1697,7 +1697,7 @@ void ObjectFileMachO::ProcessSegmentCommand(const load_command &load_cmd_, context.FileAddressesChanged = true; } } - m_sections_ap->AddSection(unified_section_sp); + m_sections_up->AddSection(unified_section_sp); } struct section_64 sect64; @@ -1810,7 +1810,7 @@ void ObjectFileMachO::ProcessSegmentCommand(const load_command &load_cmd_, load_cmd.flags); // Flags for this section segment_sp->SetIsFake(true); segment_sp->SetPermissions(segment_permissions); - m_sections_ap->AddSection(segment_sp); + m_sections_up->AddSection(segment_sp); if (add_to_unified) context.UnifiedList.AddSection(segment_sp); segment_sp->SetIsEncrypted(segment_is_encrypted); @@ -1877,10 +1877,10 @@ void ObjectFileMachO::ProcessDysymtabCommand(const load_command &load_cmd, } void ObjectFileMachO::CreateSections(SectionList &unified_section_list) { - if (m_sections_ap) + if (m_sections_up) return; - m_sections_ap.reset(new SectionList()); + m_sections_up.reset(new SectionList()); lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic); // bool dump_sections = false; @@ -2213,7 +2213,7 @@ size_t ObjectFileMachO::ParseSymtab() { } if (symtab_load_command.cmd) { - Symtab *symtab = m_symtab_ap.get(); + Symtab *symtab = m_symtab_up.get(); SectionList *section_list = GetSectionList(); if (section_list == NULL) return 0; @@ -4842,8 +4842,8 @@ void ObjectFileMachO::Dump(Stream *s) { if (sections) sections->Dump(s, NULL, true, UINT32_MAX); - if (m_symtab_ap) - m_symtab_ap->Dump(s, NULL, eSortOrderNone); + if (m_symtab_up) + m_symtab_up->Dump(s, NULL, eSortOrderNone); } } diff --git a/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp b/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp index 5ad6abe4d..ddc59aea6 100644 --- a/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp +++ b/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp @@ -83,16 +83,16 @@ ObjectFile *ObjectFilePECOFF::CreateInstance(const lldb::ModuleSP &module_sp, return nullptr; } - auto objfile_ap = llvm::make_unique<ObjectFilePECOFF>( + auto objfile_up = llvm::make_unique<ObjectFilePECOFF>( module_sp, data_sp, data_offset, file, file_offset, length); - if (!objfile_ap || !objfile_ap->ParseHeader()) + if (!objfile_up || !objfile_up->ParseHeader()) return nullptr; // Cache coff binary. - if (!objfile_ap->CreateBinary()) + if (!objfile_up->CreateBinary()) return nullptr; - return objfile_ap.release(); + return objfile_up.release(); } ObjectFile *ObjectFilePECOFF::CreateMemoryInstance( @@ -100,10 +100,10 @@ ObjectFile *ObjectFilePECOFF::CreateMemoryInstance( const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) { if (!data_sp || !ObjectFilePECOFF::MagicBytesMatch(data_sp)) return nullptr; - auto objfile_ap = llvm::make_unique<ObjectFilePECOFF>( + auto objfile_up = llvm::make_unique<ObjectFilePECOFF>( module_sp, data_sp, process_sp, header_addr); - if (objfile_ap.get() && objfile_ap->ParseHeader()) { - return objfile_ap.release(); + if (objfile_up.get() && objfile_up->ParseHeader()) { + return objfile_up.release(); } return nullptr; } @@ -477,13 +477,13 @@ DataExtractor ObjectFilePECOFF::ReadImageData(uint32_t offset, size_t size) { ProcessSP process_sp(m_process_wp.lock()); DataExtractor data; if (process_sp) { - auto data_ap = llvm::make_unique<DataBufferHeap>(size, 0); + auto data_up = llvm::make_unique<DataBufferHeap>(size, 0); Status readmem_error; size_t bytes_read = - process_sp->ReadMemory(m_image_base + offset, data_ap->GetBytes(), - data_ap->GetByteSize(), readmem_error); + process_sp->ReadMemory(m_image_base + offset, data_up->GetBytes(), + data_up->GetByteSize(), readmem_error); if (bytes_read == size) { - DataBufferSP buffer_sp(data_ap.release()); + DataBufferSP buffer_sp(data_up.release()); data.SetData(buffer_sp, 0, buffer_sp->GetByteSize()); } } @@ -552,10 +552,10 @@ Symtab *ObjectFilePECOFF::GetSymtab() { ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_symtab_ap == NULL) { + if (m_symtab_up == NULL) { SectionList *sect_list = GetSectionList(); - m_symtab_ap.reset(new Symtab(this)); - std::lock_guard<std::recursive_mutex> guard(m_symtab_ap->GetMutex()); + m_symtab_up.reset(new Symtab(this)); + std::lock_guard<std::recursive_mutex> guard(m_symtab_up->GetMutex()); const uint32_t num_syms = m_coff_header.nsyms; @@ -579,7 +579,7 @@ Symtab *ObjectFilePECOFF::GetSymtab() { offset = 0; std::string symbol_name; - Symbol *symbols = m_symtab_ap->Resize(num_syms); + Symbol *symbols = m_symtab_up->Resize(num_syms); for (uint32_t i = 0; i < num_syms; ++i) { coff_symbol_t symbol; const uint32_t symbol_offset = offset; @@ -660,7 +660,7 @@ Symtab *ObjectFilePECOFF::GetSymtab() { lldb::offset_t name_ordinal_offset = export_table.address_of_name_ordinals - data_start; - Symbol *symbols = m_symtab_ap->Resize(export_table.number_of_names); + Symbol *symbols = m_symtab_up->Resize(export_table.number_of_names); std::string symbol_name; @@ -687,10 +687,10 @@ Symtab *ObjectFilePECOFF::GetSymtab() { symbols[i].SetDebug(true); } } - m_symtab_ap->CalculateSymbolSizes(); + m_symtab_up->CalculateSymbolSizes(); } } - return m_symtab_ap.get(); + return m_symtab_up.get(); } bool ObjectFilePECOFF::IsStripped() { @@ -699,9 +699,9 @@ bool ObjectFilePECOFF::IsStripped() { } void ObjectFilePECOFF::CreateSections(SectionList &unified_section_list) { - if (m_sections_ap) + if (m_sections_up) return; - m_sections_ap.reset(new SectionList()); + m_sections_up.reset(new SectionList()); ModuleSP module_sp(GetModule()); if (module_sp) { @@ -832,7 +832,7 @@ void ObjectFilePECOFF::CreateSections(SectionList &unified_section_list) { // section_sp->SetIsEncrypted (segment_is_encrypted); unified_section_list.AddSection(section_sp); - m_sections_ap->AddSection(section_sp); + m_sections_up->AddSection(section_sp); } } } @@ -948,8 +948,8 @@ void ObjectFilePECOFF::Dump(Stream *s) { if (sections) sections->Dump(s, NULL, true, UINT32_MAX); - if (m_symtab_ap) - m_symtab_ap->Dump(s, NULL, eSortOrderNone); + if (m_symtab_up) + m_symtab_up->Dump(s, NULL, eSortOrderNone); if (m_dos_header.e_magic) DumpDOSHeader(s, m_dos_header); diff --git a/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp b/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp index dd5f4339f..be7e98493 100644 --- a/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp +++ b/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp @@ -54,10 +54,10 @@ OperatingSystem *OperatingSystemPython::CreateInstance(Process *process, FileSpec python_os_plugin_spec(process->GetPythonOSPluginPath()); if (python_os_plugin_spec && FileSystem::Instance().Exists(python_os_plugin_spec)) { - std::unique_ptr<OperatingSystemPython> os_ap( + std::unique_ptr<OperatingSystemPython> os_up( new OperatingSystemPython(process, python_os_plugin_spec)); - if (os_ap.get() && os_ap->IsValid()) - return os_ap.release(); + if (os_up.get() && os_up->IsValid()) + return os_up.release(); } return NULL; } @@ -74,7 +74,7 @@ const char *OperatingSystemPython::GetPluginDescriptionStatic() { OperatingSystemPython::OperatingSystemPython(lldb_private::Process *process, const FileSpec &python_module_path) - : OperatingSystem(process), m_thread_list_valobj_sp(), m_register_info_ap(), + : OperatingSystem(process), m_thread_list_valobj_sp(), m_register_info_up(), m_interpreter(NULL), m_python_object_sp() { if (!process) return; @@ -116,7 +116,7 @@ OperatingSystemPython::OperatingSystemPython(lldb_private::Process *process, OperatingSystemPython::~OperatingSystemPython() {} DynamicRegisterInfo *OperatingSystemPython::GetDynamicRegisterInfo() { - if (m_register_info_ap == NULL) { + if (m_register_info_up == NULL) { if (!m_interpreter || !m_python_object_sp) return NULL; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS)); @@ -131,12 +131,12 @@ DynamicRegisterInfo *OperatingSystemPython::GetDynamicRegisterInfo() { if (!dictionary) return NULL; - m_register_info_ap.reset(new DynamicRegisterInfo( + m_register_info_up.reset(new DynamicRegisterInfo( *dictionary, m_process->GetTarget().GetArchitecture())); - assert(m_register_info_ap->GetNumRegisters() > 0); - assert(m_register_info_ap->GetNumRegisterSets() > 0); + assert(m_register_info_up->GetNumRegisters() > 0); + assert(m_register_info_up->GetNumRegisterSets() > 0); } - return m_register_info_ap.get(); + return m_register_info_up.get(); } //------------------------------------------------------------------ diff --git a/source/Plugins/OperatingSystem/Python/OperatingSystemPython.h b/source/Plugins/OperatingSystem/Python/OperatingSystemPython.h index 3d6414521..b57790900 100644 --- a/source/Plugins/OperatingSystem/Python/OperatingSystemPython.h +++ b/source/Plugins/OperatingSystem/Python/OperatingSystemPython.h @@ -83,7 +83,7 @@ protected: DynamicRegisterInfo *GetDynamicRegisterInfo(); lldb::ValueObjectSP m_thread_list_valobj_sp; - std::unique_ptr<DynamicRegisterInfo> m_register_info_ap; + std::unique_ptr<DynamicRegisterInfo> m_register_info_up; lldb_private::ScriptInterpreter *m_interpreter; lldb_private::StructuredData::ObjectSP m_python_object_sp; }; diff --git a/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp b/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp index 68d53c2ca..ff9c5aa97 100644 --- a/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp +++ b/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp @@ -1700,12 +1700,12 @@ PlatformDarwin::FindBundleBinaryInExecSearchPaths (const ModuleSpec &module_spec // "UIFoundation" and "UIFoundation.framework" -- most likely the latter // will be the one we find there. - FileSpec platform_pull_apart(platform_file); + FileSpec platform_pull_upart(platform_file); std::vector<std::string> path_parts; path_parts.push_back( - platform_pull_apart.GetLastPathComponent().AsCString()); - while (platform_pull_apart.RemoveLastPathComponent()) { - ConstString part = platform_pull_apart.GetLastPathComponent(); + platform_pull_upart.GetLastPathComponent().AsCString()); + while (platform_pull_upart.RemoveLastPathComponent()) { + ConstString part = platform_pull_upart.GetLastPathComponent(); path_parts.push_back(part.AsCString()); } const size_t path_parts_size = path_parts.size(); diff --git a/source/Plugins/Process/Darwin/NativeThreadDarwin.cpp b/source/Plugins/Process/Darwin/NativeThreadDarwin.cpp index a1979c5a6..bcd6d8c2c 100644 --- a/source/Plugins/Process/Darwin/NativeThreadDarwin.cpp +++ b/source/Plugins/Process/Darwin/NativeThreadDarwin.cpp @@ -138,7 +138,7 @@ bool NativeThreadDarwin::NotifyException(MachException::Data &exc) { // Allow the arch specific protocol to process (MachException::Data &)exc // first before possible reassignment of m_stop_exception with exc. See // also MachThread::GetStopException(). - bool handled = m_arch_ap->NotifyException(exc); + bool handled = m_arch_up->NotifyException(exc); if (m_stop_exception.IsValid()) { @@ -175,7 +175,7 @@ bool NativeThreadDarwin::ShouldStop(bool &step_more) const { } else { - if (m_arch_ap->StepNotComplete()) + if (m_arch_up->StepNotComplete()) { step_more = true; return false; @@ -217,7 +217,7 @@ void NativeThreadDarwin::ThreadDidStop() { // When this method gets called, the process state is still in the state it // was in while running so we can act accordingly. - m_arch_ap->ThreadDidStop(); + m_arch_up->ThreadDidStop(); // We may have suspended this thread so the primary thread could step diff --git a/source/Plugins/Process/FreeBSD/FreeBSDThread.cpp b/source/Plugins/Process/FreeBSD/FreeBSDThread.cpp index 397b9315d..749835531 100644 --- a/source/Plugins/Process/FreeBSD/FreeBSDThread.cpp +++ b/source/Plugins/Process/FreeBSD/FreeBSDThread.cpp @@ -51,7 +51,7 @@ using namespace lldb; using namespace lldb_private; FreeBSDThread::FreeBSDThread(Process &process, lldb::tid_t tid) - : Thread(process, tid), m_frame_ap(), m_breakpoint(), + : Thread(process, tid), m_frame_up(), m_breakpoint(), m_thread_name_valid(false), m_thread_name(), m_posix_thread(nullptr) { Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD)); LLDB_LOGV(log, "tid = {0}", tid); @@ -276,10 +276,10 @@ bool FreeBSDThread::CalculateStopInfo() { } Unwind *FreeBSDThread::GetUnwinder() { - if (!m_unwinder_ap) - m_unwinder_ap.reset(new UnwindLLDB(*this)); + if (!m_unwinder_up) + m_unwinder_up.reset(new UnwindLLDB(*this)); - return m_unwinder_ap.get(); + return m_unwinder_up.get(); } void FreeBSDThread::DidStop() { diff --git a/source/Plugins/Process/FreeBSD/FreeBSDThread.h b/source/Plugins/Process/FreeBSD/FreeBSDThread.h index 83a987cf7..92faee748 100644 --- a/source/Plugins/Process/FreeBSD/FreeBSDThread.h +++ b/source/Plugins/Process/FreeBSD/FreeBSDThread.h @@ -86,7 +86,7 @@ protected: return m_posix_thread; } - std::unique_ptr<lldb_private::StackFrame> m_frame_ap; + std::unique_ptr<lldb_private::StackFrame> m_frame_up; lldb::BreakpointSiteSP m_breakpoint; diff --git a/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp b/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp index c8d041798..d985a52ce 100644 --- a/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp +++ b/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp @@ -1035,11 +1035,11 @@ bool ProcessFreeBSD::SupportHardwareSingleStepping() const { } Status ProcessFreeBSD::SetupSoftwareSingleStepping(lldb::tid_t tid) { - std::unique_ptr<EmulateInstruction> emulator_ap( + std::unique_ptr<EmulateInstruction> emulator_up( EmulateInstruction::FindPlugin(GetTarget().GetArchitecture(), eInstructionTypePCModifying, nullptr)); - if (emulator_ap == nullptr) + if (emulator_up == nullptr) return Status("Instruction emulator not found!"); FreeBSDThread *thread = static_cast<FreeBSDThread *>( @@ -1050,17 +1050,17 @@ Status ProcessFreeBSD::SetupSoftwareSingleStepping(lldb::tid_t tid) { lldb::RegisterContextSP register_context_sp = thread->GetRegisterContext(); EmulatorBaton baton(this, register_context_sp.get()); - emulator_ap->SetBaton(&baton); - emulator_ap->SetReadMemCallback(&ReadMemoryCallback); - emulator_ap->SetReadRegCallback(&ReadRegisterCallback); - emulator_ap->SetWriteMemCallback(&WriteMemoryCallback); - emulator_ap->SetWriteRegCallback(&WriteRegisterCallback); + emulator_up->SetBaton(&baton); + emulator_up->SetReadMemCallback(&ReadMemoryCallback); + emulator_up->SetReadRegCallback(&ReadRegisterCallback); + emulator_up->SetWriteMemCallback(&WriteMemoryCallback); + emulator_up->SetWriteRegCallback(&WriteRegisterCallback); - if (!emulator_ap->ReadInstruction()) + if (!emulator_up->ReadInstruction()) return Status("Read instruction failed!"); bool emulation_result = - emulator_ap->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC); + emulator_up->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC); const RegisterInfo *reg_info_pc = register_context_sp->GetRegisterInfo( eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); auto pc_it = @@ -1077,7 +1077,7 @@ Status ProcessFreeBSD::SetupSoftwareSingleStepping(lldb::tid_t tid) { // PC modifying instruction should be successful. The failure most // likely caused by a not supported instruction which don't modify PC. next_pc = - register_context_sp->GetPC() + emulator_ap->GetOpcode().GetByteSize(); + register_context_sp->GetPC() + emulator_up->GetOpcode().GetByteSize(); } else { // The instruction emulation failed after it modified the PC. It is an // unknown error where we can't continue because the next instruction is diff --git a/source/Plugins/Process/Linux/NativeProcessLinux.cpp b/source/Plugins/Process/Linux/NativeProcessLinux.cpp index f5204a6e6..bab2a71de 100644 --- a/source/Plugins/Process/Linux/NativeProcessLinux.cpp +++ b/source/Plugins/Process/Linux/NativeProcessLinux.cpp @@ -948,25 +948,25 @@ NativeProcessLinux::SetupSoftwareSingleStepping(NativeThreadLinux &thread) { Status error; NativeRegisterContext& register_context = thread.GetRegisterContext(); - std::unique_ptr<EmulateInstruction> emulator_ap( + std::unique_ptr<EmulateInstruction> emulator_up( EmulateInstruction::FindPlugin(m_arch, eInstructionTypePCModifying, nullptr)); - if (emulator_ap == nullptr) + if (emulator_up == nullptr) return Status("Instruction emulator not found!"); EmulatorBaton baton(*this, register_context); - emulator_ap->SetBaton(&baton); - emulator_ap->SetReadMemCallback(&ReadMemoryCallback); - emulator_ap->SetReadRegCallback(&ReadRegisterCallback); - emulator_ap->SetWriteMemCallback(&WriteMemoryCallback); - emulator_ap->SetWriteRegCallback(&WriteRegisterCallback); + emulator_up->SetBaton(&baton); + emulator_up->SetReadMemCallback(&ReadMemoryCallback); + emulator_up->SetReadRegCallback(&ReadRegisterCallback); + emulator_up->SetWriteMemCallback(&WriteMemoryCallback); + emulator_up->SetWriteRegCallback(&WriteRegisterCallback); - if (!emulator_ap->ReadInstruction()) + if (!emulator_up->ReadInstruction()) return Status("Read instruction failed!"); bool emulation_result = - emulator_ap->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC); + emulator_up->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC); const RegisterInfo *reg_info_pc = register_context.GetRegisterInfo( eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); @@ -994,7 +994,7 @@ NativeProcessLinux::SetupSoftwareSingleStepping(NativeThreadLinux &thread) { // the size of the current opcode because the emulation of all // PC modifying instruction should be successful. The failure most // likely caused by a not supported instruction which don't modify PC. - next_pc = register_context.GetPC() + emulator_ap->GetOpcode().GetByteSize(); + next_pc = register_context.GetPC() + emulator_up->GetOpcode().GetByteSize(); next_flags = ReadFlags(register_context); } else { // The instruction emulation failed after it modified the PC. It is an diff --git a/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp b/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp index 3f5210adc..590e8075a 100644 --- a/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp +++ b/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp @@ -940,25 +940,25 @@ NativeRegisterContextLinux_mips64::GetWatchpointHitAddress(uint32_t wp_index) { lldb_private::ArchSpec arch; arch = GetRegisterInfoInterface().GetTargetArchitecture(); - std::unique_ptr<EmulateInstruction> emulator_ap( + std::unique_ptr<EmulateInstruction> emulator_up( EmulateInstruction::FindPlugin(arch, lldb_private::eInstructionTypeAny, nullptr)); - if (emulator_ap == nullptr) + if (emulator_up == nullptr) return LLDB_INVALID_ADDRESS; EmulatorBaton baton( static_cast<NativeProcessLinux *>(&m_thread.GetProcess()), this); - emulator_ap->SetBaton(&baton); - emulator_ap->SetReadMemCallback(&ReadMemoryCallback); - emulator_ap->SetReadRegCallback(&ReadRegisterCallback); - emulator_ap->SetWriteMemCallback(&WriteMemoryCallback); - emulator_ap->SetWriteRegCallback(&WriteRegisterCallback); + emulator_up->SetBaton(&baton); + emulator_up->SetReadMemCallback(&ReadMemoryCallback); + emulator_up->SetReadRegCallback(&ReadRegisterCallback); + emulator_up->SetWriteMemCallback(&WriteMemoryCallback); + emulator_up->SetWriteRegCallback(&WriteRegisterCallback); - if (!emulator_ap->ReadInstruction()) + if (!emulator_up->ReadInstruction()) return LLDB_INVALID_ADDRESS; - if (emulator_ap->EvaluateInstruction(lldb::eEmulateInstructionOptionNone)) + if (emulator_up->EvaluateInstruction(lldb::eEmulateInstructionOptionNone)) return baton.m_watch_hit_addr; return LLDB_INVALID_ADDRESS; diff --git a/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp b/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp index b29559029..93c59dd61 100644 --- a/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp +++ b/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp @@ -231,27 +231,27 @@ Status ProcessKDP::DoConnectRemote(Stream *strm, llvm::StringRef remote_url) { return error; } - std::unique_ptr<ConnectionFileDescriptor> conn_ap( + std::unique_ptr<ConnectionFileDescriptor> conn_up( new ConnectionFileDescriptor()); - if (conn_ap) { + if (conn_up) { // Only try once for now. // TODO: check if we should be retrying? const uint32_t max_retry_count = 1; for (uint32_t retry_count = 0; retry_count < max_retry_count; ++retry_count) { - if (conn_ap->Connect(remote_url, &error) == eConnectionStatusSuccess) + if (conn_up->Connect(remote_url, &error) == eConnectionStatusSuccess) break; usleep(100000); } } - if (conn_ap->IsConnected()) { + if (conn_up->IsConnected()) { const TCPSocket &socket = - static_cast<const TCPSocket &>(*conn_ap->GetReadObject()); + static_cast<const TCPSocket &>(*conn_up->GetReadObject()); const uint16_t reply_port = socket.GetLocalPortNumber(); if (reply_port != 0) { - m_comm.SetConnection(conn_ap.release()); + m_comm.SetConnection(conn_up.release()); if (m_comm.SendRequestReattach(reply_port)) { if (m_comm.SendRequestConnect(reply_port, reply_port, @@ -408,11 +408,11 @@ void ProcessKDP::DidAttach(ArchSpec &process_arch) { addr_t ProcessKDP::GetImageInfoAddress() { return m_kernel_load_addr; } lldb_private::DynamicLoader *ProcessKDP::GetDynamicLoader() { - if (m_dyld_ap.get() == NULL) - m_dyld_ap.reset(DynamicLoader::FindPlugin( + if (m_dyld_up.get() == NULL) + m_dyld_up.reset(DynamicLoader::FindPlugin( this, m_dyld_plugin_name.IsEmpty() ? NULL : m_dyld_plugin_name.GetCString())); - return m_dyld_ap.get(); + return m_dyld_up.get(); } Status ProcessKDP::WillResume() { return Status(); } diff --git a/source/Plugins/Process/Utility/HistoryThread.cpp b/source/Plugins/Process/Utility/HistoryThread.cpp index a2b71b587..23f6077b3 100644 --- a/source/Plugins/Process/Utility/HistoryThread.cpp +++ b/source/Plugins/Process/Utility/HistoryThread.cpp @@ -32,7 +32,7 @@ HistoryThread::HistoryThread(lldb_private::Process &process, lldb::tid_t tid, m_extended_unwind_token(LLDB_INVALID_ADDRESS), m_queue_name(), m_thread_name(), m_originating_unique_thread_id(tid), m_queue_id(LLDB_INVALID_QUEUE_ID) { - m_unwinder_ap.reset(new HistoryUnwind(*this, pcs, stop_id_is_valid)); + m_unwinder_up.reset(new HistoryUnwind(*this, pcs, stop_id_is_valid)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT)); if (log) log->Printf("%p HistoryThread::HistoryThread", static_cast<void *>(this)); @@ -59,7 +59,7 @@ lldb::RegisterContextSP HistoryThread::GetRegisterContext() { lldb::RegisterContextSP HistoryThread::CreateRegisterContextForFrame(StackFrame *frame) { - return m_unwinder_ap->CreateRegisterContextForFrame(frame); + return m_unwinder_up->CreateRegisterContextForFrame(frame); } lldb::StackFrameListSP HistoryThread::GetStackFrameList() { diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_arm.cpp b/source/Plugins/Process/Utility/RegisterContextPOSIX_arm.cpp index 3c9efab83..7366130dd 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_arm.cpp +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_arm.cpp @@ -86,7 +86,7 @@ RegisterContextPOSIX_arm::RegisterContextPOSIX_arm( lldb_private::Thread &thread, uint32_t concrete_frame_idx, lldb_private::RegisterInfoInterface *register_info) : lldb_private::RegisterContext(thread, concrete_frame_idx) { - m_register_info_ap.reset(register_info); + m_register_info_up.reset(register_info); switch (register_info->m_target_arch.GetMachine()) { case llvm::Triple::arm: @@ -131,14 +131,14 @@ size_t RegisterContextPOSIX_arm::GetRegisterCount() { } size_t RegisterContextPOSIX_arm::GetGPRSize() { - return m_register_info_ap->GetGPRSize(); + return m_register_info_up->GetGPRSize(); } const lldb_private::RegisterInfo *RegisterContextPOSIX_arm::GetRegisterInfo() { // Commonly, this method is overridden and g_register_infos is copied and // specialized. So, use GetRegisterInfo() rather than g_register_infos in // this scope. - return m_register_info_ap->GetRegisterInfo(); + return m_register_info_up->GetRegisterInfo(); } const lldb_private::RegisterInfo * @@ -162,7 +162,7 @@ size_t RegisterContextPOSIX_arm::GetRegisterSetCount() { const lldb_private::RegisterSet * RegisterContextPOSIX_arm::GetRegisterSet(size_t set) { if (IsRegisterSetAvailable(set)) { - switch (m_register_info_ap->m_target_arch.GetMachine()) { + switch (m_register_info_up->m_target_arch.GetMachine()) { case llvm::Triple::arm: return &g_reg_sets_arm[set]; default: diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_arm.h b/source/Plugins/Process/Utility/RegisterContextPOSIX_arm.h index 70409efd2..603ba7643 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_arm.h +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_arm.h @@ -83,7 +83,7 @@ protected: struct RegisterContextPOSIX_arm::FPU m_fpr; // floating-point registers including extended register sets. std::unique_ptr<lldb_private::RegisterInfoInterface> - m_register_info_ap; // Register Info Interface (FreeBSD or Linux) + m_register_info_up; // Register Info Interface (FreeBSD or Linux) // Determines if an extended register set is supported on the processor // running the inferior process. diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.cpp b/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.cpp index 586cb7009..5fb9f1f85 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.cpp +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.cpp @@ -105,7 +105,7 @@ RegisterContextPOSIX_arm64::RegisterContextPOSIX_arm64( lldb_private::Thread &thread, uint32_t concrete_frame_idx, lldb_private::RegisterInfoInterface *register_info) : lldb_private::RegisterContext(thread, concrete_frame_idx) { - m_register_info_ap.reset(register_info); + m_register_info_up.reset(register_info); switch (register_info->m_target_arch.GetMachine()) { case llvm::Triple::aarch64: @@ -150,7 +150,7 @@ size_t RegisterContextPOSIX_arm64::GetRegisterCount() { } size_t RegisterContextPOSIX_arm64::GetGPRSize() { - return m_register_info_ap->GetGPRSize(); + return m_register_info_up->GetGPRSize(); } const lldb_private::RegisterInfo * @@ -158,7 +158,7 @@ RegisterContextPOSIX_arm64::GetRegisterInfo() { // Commonly, this method is overridden and g_register_infos is copied and // specialized. So, use GetRegisterInfo() rather than g_register_infos in // this scope. - return m_register_info_ap->GetRegisterInfo(); + return m_register_info_up->GetRegisterInfo(); } const lldb_private::RegisterInfo * @@ -182,7 +182,7 @@ size_t RegisterContextPOSIX_arm64::GetRegisterSetCount() { const lldb_private::RegisterSet * RegisterContextPOSIX_arm64::GetRegisterSet(size_t set) { if (IsRegisterSetAvailable(set)) { - switch (m_register_info_ap->m_target_arch.GetMachine()) { + switch (m_register_info_up->m_target_arch.GetMachine()) { case llvm::Triple::aarch64: return &g_reg_sets_arm64[set]; default: diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.h b/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.h index b8d967ee7..49a49b69d 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.h +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.h @@ -83,7 +83,7 @@ protected: struct RegisterContextPOSIX_arm64::FPU m_fpr; // floating-point registers including extended register sets. std::unique_ptr<lldb_private::RegisterInfoInterface> - m_register_info_ap; // Register Info Interface (FreeBSD or Linux) + m_register_info_up; // Register Info Interface (FreeBSD or Linux) // Determines if an extended register set is supported on the processor // running the inferior process. diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.cpp b/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.cpp index 84d89864d..cedbcd423 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.cpp +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.cpp @@ -44,7 +44,7 @@ RegisterContextPOSIX_mips64::RegisterContextPOSIX_mips64( Thread &thread, uint32_t concrete_frame_idx, RegisterInfoInterface *register_info) : RegisterContext(thread, concrete_frame_idx) { - m_register_info_ap.reset(register_info); + m_register_info_up.reset(register_info); m_num_registers = GetRegisterCount(); int set = GetRegisterSetCount(); @@ -77,18 +77,18 @@ unsigned RegisterContextPOSIX_mips64::GetRegisterSize(unsigned reg) { } size_t RegisterContextPOSIX_mips64::GetRegisterCount() { - return m_register_info_ap->GetRegisterCount(); + return m_register_info_up->GetRegisterCount(); } size_t RegisterContextPOSIX_mips64::GetGPRSize() { - return m_register_info_ap->GetGPRSize(); + return m_register_info_up->GetGPRSize(); } const RegisterInfo *RegisterContextPOSIX_mips64::GetRegisterInfo() { // Commonly, this method is overridden and g_register_infos is copied and // specialized. So, use GetRegisterInfo() rather than g_register_infos in // this scope. - return m_register_info_ap->GetRegisterInfo(); + return m_register_info_up->GetRegisterInfo(); } const RegisterInfo * @@ -100,22 +100,22 @@ RegisterContextPOSIX_mips64::GetRegisterInfoAtIndex(size_t reg) { } size_t RegisterContextPOSIX_mips64::GetRegisterSetCount() { - ArchSpec target_arch = m_register_info_ap->GetTargetArchitecture(); + ArchSpec target_arch = m_register_info_up->GetTargetArchitecture(); switch (target_arch.GetTriple().getOS()) { case llvm::Triple::Linux: { if ((target_arch.GetMachine() == llvm::Triple::mipsel) || (target_arch.GetMachine() == llvm::Triple::mips)) { - const auto *context = static_cast<const RegisterContextLinux_mips *> - (m_register_info_ap.get()); + const auto *context = static_cast<const RegisterContextLinux_mips *>( + m_register_info_up.get()); return context->GetRegisterSetCount(); } - const auto *context = static_cast<const RegisterContextLinux_mips64 *> - (m_register_info_ap.get()); + const auto *context = static_cast<const RegisterContextLinux_mips64 *>( + m_register_info_up.get()); return context->GetRegisterSetCount(); } default: { - const auto *context = static_cast<const RegisterContextFreeBSD_mips64 *> - (m_register_info_ap.get()); + const auto *context = static_cast<const RegisterContextFreeBSD_mips64 *>( + m_register_info_up.get()); return context->GetRegisterSetCount(); } @@ -123,22 +123,22 @@ size_t RegisterContextPOSIX_mips64::GetRegisterSetCount() { } const RegisterSet *RegisterContextPOSIX_mips64::GetRegisterSet(size_t set) { - ArchSpec target_arch = m_register_info_ap->GetTargetArchitecture(); + ArchSpec target_arch = m_register_info_up->GetTargetArchitecture(); switch (target_arch.GetTriple().getOS()) { case llvm::Triple::Linux: { if ((target_arch.GetMachine() == llvm::Triple::mipsel) || (target_arch.GetMachine() == llvm::Triple::mips)) { - const auto *context = static_cast<const RegisterContextLinux_mips *> - (m_register_info_ap.get()); + const auto *context = static_cast<const RegisterContextLinux_mips *>( + m_register_info_up.get()); return context->GetRegisterSet(set); } - const auto *context = static_cast<const RegisterContextLinux_mips64 *> - (m_register_info_ap.get()); + const auto *context = static_cast<const RegisterContextLinux_mips64 *>( + m_register_info_up.get()); return context->GetRegisterSet(set); } default: { - const auto *context = static_cast<const RegisterContextFreeBSD_mips64 *> - (m_register_info_ap.get()); + const auto *context = static_cast<const RegisterContextFreeBSD_mips64 *>( + m_register_info_up.get()); return context->GetRegisterSet(set); } } diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h b/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h index 087ba923c..c507e14bd 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.h @@ -61,7 +61,7 @@ protected: uint32_t m_num_registers; uint8_t m_registers_count[register_set_count]; std::unique_ptr<lldb_private::RegisterInfoInterface> - m_register_info_ap; // Register Info Interface (FreeBSD or Linux) + m_register_info_up; // Register Info Interface (FreeBSD or Linux) // Determines if an extended register set is supported on the processor // running the inferior process. diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.cpp b/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.cpp index b651850c6..9698b2d84 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.cpp +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.cpp @@ -93,7 +93,7 @@ RegisterContextPOSIX_powerpc::RegisterContextPOSIX_powerpc( Thread &thread, uint32_t concrete_frame_idx, RegisterInfoInterface *register_info) : RegisterContext(thread, concrete_frame_idx) { - m_register_info_ap.reset(register_info); + m_register_info_up.reset(register_info); } RegisterContextPOSIX_powerpc::~RegisterContextPOSIX_powerpc() {} @@ -118,14 +118,14 @@ size_t RegisterContextPOSIX_powerpc::GetRegisterCount() { } size_t RegisterContextPOSIX_powerpc::GetGPRSize() { - return m_register_info_ap->GetGPRSize(); + return m_register_info_up->GetGPRSize(); } const RegisterInfo *RegisterContextPOSIX_powerpc::GetRegisterInfo() { // Commonly, this method is overridden and g_register_infos is copied and // specialized. So, use GetRegisterInfo() rather than g_register_infos in // this scope. - return m_register_info_ap->GetRegisterInfo(); + return m_register_info_up->GetRegisterInfo(); } const RegisterInfo * diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h b/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h index dc8c08ff7..dbb3e6fa6 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h @@ -177,7 +177,7 @@ protected: m_fpr_powerpc[k_num_fpr_registers_powerpc]; // floating point registers. uint32_t m_vmx_powerpc[k_num_vmx_registers_powerpc][4]; std::unique_ptr<lldb_private::RegisterInfoInterface> - m_register_info_ap; // Register Info Interface (FreeBSD or Linux) + m_register_info_up; // Register Info Interface (FreeBSD or Linux) // Determines if an extended register set is supported on the processor // running the inferior process. diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.cpp b/source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.cpp index d6d46f4f4..2b380797f 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.cpp +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.cpp @@ -115,7 +115,7 @@ RegisterContextPOSIX_ppc64le::RegisterContextPOSIX_ppc64le( Thread &thread, uint32_t concrete_frame_idx, RegisterInfoInterface *register_info) : RegisterContext(thread, concrete_frame_idx) { - m_register_info_ap.reset(register_info); + m_register_info_up.reset(register_info); } void RegisterContextPOSIX_ppc64le::InvalidateAllRegisters() {} @@ -136,14 +136,14 @@ size_t RegisterContextPOSIX_ppc64le::GetRegisterCount() { } size_t RegisterContextPOSIX_ppc64le::GetGPRSize() { - return m_register_info_ap->GetGPRSize(); + return m_register_info_up->GetGPRSize(); } const RegisterInfo *RegisterContextPOSIX_ppc64le::GetRegisterInfo() { // Commonly, this method is overridden and g_register_infos is copied and // specialized. So, use GetRegisterInfo() rather than g_register_infos in // this scope. - return m_register_info_ap->GetRegisterInfo(); + return m_register_info_up->GetRegisterInfo(); } const RegisterInfo * diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.h b/source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.h index 06405352a..37079775a 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.h +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.h @@ -55,7 +55,7 @@ protected: // VSX registers. uint64_t m_vsx_ppc64le[k_num_vsx_registers_ppc64le * 2]; - std::unique_ptr<lldb_private::RegisterInfoInterface> m_register_info_ap; + std::unique_ptr<lldb_private::RegisterInfoInterface> m_register_info_up; // Determines if an extended register set is supported on the processor // running the inferior process. diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.cpp b/source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.cpp index 5dbf6bf6a..2301c8229 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.cpp +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.cpp @@ -81,7 +81,7 @@ RegisterContextPOSIX_s390x::RegisterContextPOSIX_s390x( Thread &thread, uint32_t concrete_frame_idx, RegisterInfoInterface *register_info) : RegisterContext(thread, concrete_frame_idx) { - m_register_info_ap.reset(register_info); + m_register_info_up.reset(register_info); switch (register_info->m_target_arch.GetMachine()) { case llvm::Triple::systemz: @@ -105,7 +105,7 @@ void RegisterContextPOSIX_s390x::Invalidate() {} void RegisterContextPOSIX_s390x::InvalidateAllRegisters() {} const RegisterInfo *RegisterContextPOSIX_s390x::GetRegisterInfo() { - return m_register_info_ap->GetRegisterInfo(); + return m_register_info_up->GetRegisterInfo(); } const RegisterInfo * @@ -151,7 +151,7 @@ size_t RegisterContextPOSIX_s390x::GetRegisterSetCount() { const RegisterSet *RegisterContextPOSIX_s390x::GetRegisterSet(size_t set) { if (IsRegisterSetAvailable(set)) { - switch (m_register_info_ap->m_target_arch.GetMachine()) { + switch (m_register_info_up->m_target_arch.GetMachine()) { case llvm::Triple::systemz: return &g_reg_sets_s390x[set]; default: diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.h b/source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.h index 54191e839..54993ce6c 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.h +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.h @@ -58,7 +58,7 @@ protected: }; RegInfo m_reg_info; - std::unique_ptr<lldb_private::RegisterInfoInterface> m_register_info_ap; + std::unique_ptr<lldb_private::RegisterInfoInterface> m_register_info_up; virtual bool IsRegisterSetAvailable(size_t set_index); diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp b/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp index 43c6973d6..ee4476424 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp @@ -318,7 +318,7 @@ RegisterContextPOSIX_x86::RegisterContextPOSIX_x86( Thread &thread, uint32_t concrete_frame_idx, RegisterInfoInterface *register_info) : RegisterContext(thread, concrete_frame_idx) { - m_register_info_ap.reset(register_info); + m_register_info_up.reset(register_info); switch (register_info->m_target_arch.GetMachine()) { case llvm::Triple::x86: @@ -404,7 +404,7 @@ size_t RegisterContextPOSIX_x86::GetRegisterCount() { } size_t RegisterContextPOSIX_x86::GetGPRSize() { - return m_register_info_ap->GetGPRSize(); + return m_register_info_up->GetGPRSize(); } size_t RegisterContextPOSIX_x86::GetFXSAVEOffset() { @@ -415,7 +415,7 @@ const RegisterInfo *RegisterContextPOSIX_x86::GetRegisterInfo() { // Commonly, this method is overridden and g_register_infos is copied and // specialized. So, use GetRegisterInfo() rather than g_register_infos in // this scope. - return m_register_info_ap->GetRegisterInfo(); + return m_register_info_up->GetRegisterInfo(); } const RegisterInfo * @@ -438,7 +438,7 @@ size_t RegisterContextPOSIX_x86::GetRegisterSetCount() { const RegisterSet *RegisterContextPOSIX_x86::GetRegisterSet(size_t set) { if (IsRegisterSetAvailable(set)) { - switch (m_register_info_ap->m_target_arch.GetMachine()) { + switch (m_register_info_up->m_target_arch.GetMachine()) { case llvm::Triple::x86: return &g_reg_sets_i386[set]; case llvm::Triple::x86_64: diff --git a/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.h b/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.h index 8291d6585..1642d5202 100644 --- a/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.h +++ b/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.h @@ -148,7 +148,7 @@ protected: // register sets. lldb_private::YMM m_ymm_set; // copy of ymmh and xmm register halves. std::unique_ptr<lldb_private::RegisterInfoInterface> - m_register_info_ap; // Register Info Interface (FreeBSD or Linux) + m_register_info_up; // Register Info Interface (FreeBSD or Linux) // Determines if an extended register set is supported on the processor // running the inferior process. diff --git a/source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp b/source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp index be5846d0b..2f36ffb1b 100644 --- a/source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp +++ b/source/Plugins/Process/Windows/Common/TargetThreadWindows.cpp @@ -105,9 +105,9 @@ bool TargetThreadWindows::CalculateStopInfo() { Unwind *TargetThreadWindows::GetUnwinder() { // FIXME: Implement an unwinder based on the Windows unwinder exposed through // DIA SDK. - if (!m_unwinder_ap) - m_unwinder_ap.reset(new UnwindLLDB(*this)); - return m_unwinder_ap.get(); + if (!m_unwinder_up) + m_unwinder_up.reset(new UnwindLLDB(*this)); + return m_unwinder_up.get(); } Status TargetThreadWindows::DoResume() { diff --git a/source/Plugins/Process/elf-core/ProcessElfCore.cpp b/source/Plugins/Process/elf-core/ProcessElfCore.cpp index 708609aad..9db6ebcaf 100644 --- a/source/Plugins/Process/elf-core/ProcessElfCore.cpp +++ b/source/Plugins/Process/elf-core/ProcessElfCore.cpp @@ -254,10 +254,10 @@ Status ProcessElfCore::DoLoadCore() { } lldb_private::DynamicLoader *ProcessElfCore::GetDynamicLoader() { - if (m_dyld_ap.get() == NULL) - m_dyld_ap.reset(DynamicLoader::FindPlugin( + if (m_dyld_up.get() == NULL) + m_dyld_up.reset(DynamicLoader::FindPlugin( this, DynamicLoaderPOSIXDYLD::GetPluginNameStatic().GetCString())); - return m_dyld_ap.get(); + return m_dyld_up.get(); } bool ProcessElfCore::UpdateThreadList(ThreadList &old_thread_list, diff --git a/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp b/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp index e15ba78c2..3601f3b3b 100644 --- a/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp +++ b/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp @@ -52,7 +52,7 @@ bool RegisterContextCorePOSIX_mips64::ReadRegister(const RegisterInfo *reg_info, RegisterValue &value) { lldb::offset_t offset = reg_info->byte_offset; - lldb_private::ArchSpec arch = m_register_info_ap->GetTargetArchitecture(); + lldb_private::ArchSpec arch = m_register_info_up->GetTargetArchitecture(); uint64_t v; if (IsGPR(reg_info->kinds[lldb::eRegisterKindLLDB])) { if (reg_info->byte_size == 4 && !(arch.GetMachine() == llvm::Triple::mips64el)) diff --git a/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp index 1969d6527..74a00dfd6 100644 --- a/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp +++ b/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp @@ -1020,14 +1020,14 @@ Status ProcessGDBRemote::ConnectToDebugserver(llvm::StringRef connect_url) { if (log) log->Printf("ProcessGDBRemote::%s Connecting to %s", __FUNCTION__, connect_url.str().c_str()); - std::unique_ptr<ConnectionFileDescriptor> conn_ap( + std::unique_ptr<ConnectionFileDescriptor> conn_up( new ConnectionFileDescriptor()); - if (conn_ap) { + if (conn_up) { const uint32_t max_retry_count = 50; uint32_t retry_count = 0; while (!m_gdb_comm.IsConnected()) { - if (conn_ap->Connect(connect_url, &error) == eConnectionStatusSuccess) { - m_gdb_comm.SetConnection(conn_ap.release()); + if (conn_up->Connect(connect_url, &error) == eConnectionStatusSuccess) { + m_gdb_comm.SetConnection(conn_up.release()); break; } else if (error.WasInterrupted()) { // If we were interrupted, don't keep retrying. @@ -4032,9 +4032,9 @@ bool ProcessGDBRemote::StopNoticingNewThreads() { } DynamicLoader *ProcessGDBRemote::GetDynamicLoader() { - if (m_dyld_ap.get() == NULL) - m_dyld_ap.reset(DynamicLoader::FindPlugin(this, NULL)); - return m_dyld_ap.get(); + if (m_dyld_up.get() == NULL) + m_dyld_up.reset(DynamicLoader::FindPlugin(this, NULL)); + return m_dyld_up.get(); } Status ProcessGDBRemote::SendEventData(const char *data) { diff --git a/source/Plugins/Process/mach-core/ProcessMachCore.cpp b/source/Plugins/Process/mach-core/ProcessMachCore.cpp index 05f378d7f..ed2cb7f2a 100644 --- a/source/Plugins/Process/mach-core/ProcessMachCore.cpp +++ b/source/Plugins/Process/mach-core/ProcessMachCore.cpp @@ -455,11 +455,11 @@ Status ProcessMachCore::DoLoadCore() { } lldb_private::DynamicLoader *ProcessMachCore::GetDynamicLoader() { - if (m_dyld_ap.get() == NULL) - m_dyld_ap.reset(DynamicLoader::FindPlugin( + if (m_dyld_up.get() == NULL) + m_dyld_up.reset(DynamicLoader::FindPlugin( this, m_dyld_plugin_name.IsEmpty() ? NULL : m_dyld_plugin_name.GetCString())); - return m_dyld_ap.get(); + return m_dyld_up.get(); } bool ProcessMachCore::UpdateThreadList(ThreadList &old_thread_list, diff --git a/source/Plugins/Process/minidump/ProcessMinidump.cpp b/source/Plugins/Process/minidump/ProcessMinidump.cpp index 91075cce0..c702d8438 100644 --- a/source/Plugins/Process/minidump/ProcessMinidump.cpp +++ b/source/Plugins/Process/minidump/ProcessMinidump.cpp @@ -409,10 +409,10 @@ bool ProcessMinidump::GetProcessInfo(ProcessInstanceInfo &info) { // try to set up symbolic breakpoints, which in turn may force loading more // debug information than needed. JITLoaderList &ProcessMinidump::GetJITLoaders() { - if (!m_jit_loaders_ap) { - m_jit_loaders_ap = llvm::make_unique<JITLoaderList>(); + if (!m_jit_loaders_up) { + m_jit_loaders_up = llvm::make_unique<JITLoaderList>(); } - return *m_jit_loaders_ap; + return *m_jit_loaders_up; } #define INIT_BOOL(VAR, LONG, SHORT, DESC) \ diff --git a/source/Plugins/Process/minidump/ThreadMinidump.cpp b/source/Plugins/Process/minidump/ThreadMinidump.cpp index 44880970c..63ddcbf77 100644 --- a/source/Plugins/Process/minidump/ThreadMinidump.cpp +++ b/source/Plugins/Process/minidump/ThreadMinidump.cpp @@ -108,8 +108,8 @@ ThreadMinidump::CreateRegisterContextForFrame(StackFrame *frame) { } reg_ctx_sp = m_thread_reg_ctx_sp; - } else if (m_unwinder_ap) { - reg_ctx_sp = m_unwinder_ap->CreateRegisterContextForFrame(frame); + } else if (m_unwinder_up) { + reg_ctx_sp = m_unwinder_up->CreateRegisterContextForFrame(frame); } return reg_ctx_sp; diff --git a/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp b/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp index 294c4b005..93497f13d 100644 --- a/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp +++ b/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp @@ -473,16 +473,16 @@ void ScriptInterpreterPython::IOHandlerInputComplete(IOHandler &io_handler, if (!bp_options) continue; - auto data_ap = llvm::make_unique<CommandDataPython>(); - if (!data_ap) + auto data_up = llvm::make_unique<CommandDataPython>(); + if (!data_up) break; - data_ap->user_source.SplitIntoLines(data); + data_up->user_source.SplitIntoLines(data); - if (GenerateBreakpointCommandCallbackData(data_ap->user_source, - data_ap->script_source) + if (GenerateBreakpointCommandCallbackData(data_up->user_source, + data_up->script_source) .Success()) { auto baton_sp = std::make_shared<BreakpointOptions::CommandBaton>( - std::move(data_ap)); + std::move(data_up)); bp_options->SetCallback( ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp); } else if (!batch_mode) { @@ -498,13 +498,13 @@ void ScriptInterpreterPython::IOHandlerInputComplete(IOHandler &io_handler, case eIOHandlerWatchpoint: { WatchpointOptions *wp_options = (WatchpointOptions *)io_handler.GetUserData(); - auto data_ap = llvm::make_unique<WatchpointOptions::CommandData>(); - data_ap->user_source.SplitIntoLines(data); + auto data_up = llvm::make_unique<WatchpointOptions::CommandData>(); + data_up->user_source.SplitIntoLines(data); - if (GenerateWatchpointCommandCallbackData(data_ap->user_source, - data_ap->script_source)) { + if (GenerateWatchpointCommandCallbackData(data_up->user_source, + data_up->script_source)) { auto baton_sp = - std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_ap)); + std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up)); wp_options->SetCallback( ScriptInterpreterPython::WatchpointCallbackFunction, baton_sp); } else if (!batch_mode) { @@ -797,15 +797,15 @@ bool ScriptInterpreterPython::ExecuteOneLine( #if defined(_WIN32) lldb::file_t read_file = pipe.GetReadNativeHandle(); pipe.ReleaseReadFileDescriptor(); - std::unique_ptr<ConnectionGenericFile> conn_ap( + std::unique_ptr<ConnectionGenericFile> conn_up( new ConnectionGenericFile(read_file, true)); #else - std::unique_ptr<ConnectionFileDescriptor> conn_ap( + std::unique_ptr<ConnectionFileDescriptor> conn_up( new ConnectionFileDescriptor(pipe.ReleaseReadFileDescriptor(), true)); #endif - if (conn_ap->IsConnected()) { - output_comm.SetConnection(conn_ap.release()); + if (conn_up->IsConnected()) { + output_comm.SetConnection(conn_up.release()); output_comm.SetReadThreadBytesReceivedCallback( ReadThreadBytesReceived, &result->GetOutputStream()); output_comm.StartReadThread(); @@ -1299,19 +1299,19 @@ Status ScriptInterpreterPython::SetBreakpointCommandCallback( // Set a Python one-liner as the callback for the breakpoint. Status ScriptInterpreterPython::SetBreakpointCommandCallback( BreakpointOptions *bp_options, const char *command_body_text) { - auto data_ap = llvm::make_unique<CommandDataPython>(); + auto data_up = llvm::make_unique<CommandDataPython>(); // Split the command_body_text into lines, and pass that to // GenerateBreakpointCommandCallbackData. That will wrap the body in an // auto-generated function, and return the function name in script_source. // That is what the callback will actually invoke. - data_ap->user_source.SplitIntoLines(command_body_text); - Status error = GenerateBreakpointCommandCallbackData(data_ap->user_source, - data_ap->script_source); + data_up->user_source.SplitIntoLines(command_body_text); + Status error = GenerateBreakpointCommandCallbackData(data_up->user_source, + data_up->script_source); if (error.Success()) { auto baton_sp = - std::make_shared<BreakpointOptions::CommandBaton>(std::move(data_ap)); + std::make_shared<BreakpointOptions::CommandBaton>(std::move(data_up)); bp_options->SetCallback(ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp); return error; @@ -1322,20 +1322,20 @@ Status ScriptInterpreterPython::SetBreakpointCommandCallback( // Set a Python one-liner as the callback for the watchpoint. void ScriptInterpreterPython::SetWatchpointCommandCallback( WatchpointOptions *wp_options, const char *oneliner) { - auto data_ap = llvm::make_unique<WatchpointOptions::CommandData>(); + auto data_up = llvm::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 // command list) while the latter is used for Python to interpret during the // actual callback. - data_ap->user_source.AppendString(oneliner); - data_ap->script_source.assign(oneliner); + data_up->user_source.AppendString(oneliner); + data_up->script_source.assign(oneliner); - if (GenerateWatchpointCommandCallbackData(data_ap->user_source, - data_ap->script_source)) { + if (GenerateWatchpointCommandCallbackData(data_up->user_source, + data_up->script_source)) { auto baton_sp = - std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_ap)); + std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up)); wp_options->SetCallback(ScriptInterpreterPython::WatchpointCallbackFunction, baton_sp); } diff --git a/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp b/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp index 936111b3d..aa759c453 100644 --- a/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp +++ b/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp @@ -118,10 +118,10 @@ struct BitfieldInfo { }; ClangASTImporter &DWARFASTParserClang::GetClangASTImporter() { - if (!m_clang_ast_importer_ap) { - m_clang_ast_importer_ap.reset(new ClangASTImporter); + if (!m_clang_ast_importer_up) { + m_clang_ast_importer_up.reset(new ClangASTImporter); } - return *m_clang_ast_importer_ap; + return *m_clang_ast_importer_up; } /// Detect a forward declaration that is nested in a DW_TAG_module. @@ -608,7 +608,7 @@ TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc, // the stack, put it on the heap. This function is often called // recursively and clang isn't good and sharing the stack space for // variables in different blocks. - std::unique_ptr<UniqueDWARFASTType> unique_ast_entry_ap( + std::unique_ptr<UniqueDWARFASTType> unique_ast_entry_up( new UniqueDWARFASTType()); ConstString unique_typename(type_name_const_str); @@ -628,8 +628,8 @@ TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc, if (dwarf->GetUniqueDWARFASTTypeMap().Find( unique_typename, die, unique_decl, - byte_size ? *byte_size : -1, *unique_ast_entry_ap)) { - type_sp = unique_ast_entry_ap->m_type_sp; + byte_size ? *byte_size : -1, *unique_ast_entry_up)) { + type_sp = unique_ast_entry_up->m_type_sp; if (type_sp) { dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get(); return type_sp; @@ -853,12 +853,12 @@ TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc, // Add our type to the unique type map so we don't end up creating many // copies of the same type over and over in the ASTContext for our // module - unique_ast_entry_ap->m_type_sp = type_sp; - unique_ast_entry_ap->m_die = die; - unique_ast_entry_ap->m_declaration = unique_decl; - unique_ast_entry_ap->m_byte_size = byte_size.getValueOr(0); + unique_ast_entry_up->m_type_sp = type_sp; + unique_ast_entry_up->m_die = die; + unique_ast_entry_up->m_declaration = unique_decl; + unique_ast_entry_up->m_byte_size = byte_size.getValueOr(0); dwarf->GetUniqueDWARFASTTypeMap().Insert(unique_typename, - *unique_ast_entry_ap); + *unique_ast_entry_up); if (is_forward_declaration && die.HasChildren()) { // Check to see if the DIE actually has a definition, some version of @@ -1919,8 +1919,8 @@ public: m_property_getter_name(property_getter_name), m_property_attributes(property_attributes) { if (metadata != NULL) { - m_metadata_ap.reset(new ClangASTMetadata()); - *m_metadata_ap = *metadata; + m_metadata_up.reset(new ClangASTMetadata()); + *m_metadata_up = *metadata; } } @@ -1938,9 +1938,9 @@ public: m_property_getter_name = rhs.m_property_getter_name; m_property_attributes = rhs.m_property_attributes; - if (rhs.m_metadata_ap) { - m_metadata_ap.reset(new ClangASTMetadata()); - *m_metadata_ap = *rhs.m_metadata_ap; + if (rhs.m_metadata_up) { + m_metadata_up.reset(new ClangASTMetadata()); + *m_metadata_up = *rhs.m_metadata_up; } return *this; } @@ -1949,7 +1949,7 @@ public: return ClangASTContext::AddObjCClassProperty( m_class_opaque_type, m_property_name, m_property_opaque_type, m_ivar_decl, m_property_setter_name, m_property_getter_name, - m_property_attributes, m_metadata_ap.get()); + m_property_attributes, m_metadata_up.get()); } private: @@ -1960,7 +1960,7 @@ private: const char *m_property_setter_name; const char *m_property_getter_name; uint32_t m_property_attributes; - std::unique_ptr<ClangASTMetadata> m_metadata_ap; + std::unique_ptr<ClangASTMetadata> m_metadata_up; }; bool DWARFASTParserClang::ParseTemplateDIE( @@ -2640,9 +2640,9 @@ Function *DWARFASTParserClang::ParseFunctionFromDWARF(CompileUnit &comp_unit, func_name.SetValue(ConstString(name), false); FunctionSP func_sp; - std::unique_ptr<Declaration> decl_ap; + std::unique_ptr<Declaration> decl_up; if (decl_file != 0 || decl_line != 0 || decl_column != 0) - decl_ap.reset(new Declaration( + decl_up.reset(new Declaration( comp_unit.GetSupportFiles().GetFileSpecAtIndex(decl_file), decl_line, decl_column)); diff --git a/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h b/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h index 75411c220..0ad97e5fe 100644 --- a/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h +++ b/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h @@ -149,7 +149,7 @@ protected: DeclToDIEMap m_decl_to_die; DIEToDeclContextMap m_die_to_decl_ctx; DeclContextToDIEMap m_decl_ctx_to_die; - std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_ap; + std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_up; }; #endif // SymbolFileDWARF_DWARFASTParserClang_h_ diff --git a/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp b/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp index d36208999..f5b698382 100644 --- a/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp +++ b/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp @@ -32,7 +32,7 @@ using namespace std; // Constructor //---------------------------------------------------------------------- DWARFDebugInfo::DWARFDebugInfo() - : m_dwarf2Data(NULL), m_compile_units(), m_cu_aranges_ap() {} + : m_dwarf2Data(NULL), m_compile_units(), m_cu_aranges_up() {} //---------------------------------------------------------------------- // SetDwarfData @@ -43,10 +43,10 @@ void DWARFDebugInfo::SetDwarfData(SymbolFileDWARF *dwarf2Data) { } DWARFDebugAranges &DWARFDebugInfo::GetCompileUnitAranges() { - if (m_cu_aranges_ap == NULL && m_dwarf2Data) { + if (m_cu_aranges_up == NULL && m_dwarf2Data) { Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_ARANGES)); - m_cu_aranges_ap.reset(new DWARFDebugAranges()); + m_cu_aranges_up.reset(new DWARFDebugAranges()); const DWARFDataExtractor &debug_aranges_data = m_dwarf2Data->get_debug_aranges_data(); if (debug_aranges_data.GetByteSize() > 0) { @@ -55,13 +55,13 @@ DWARFDebugAranges &DWARFDebugInfo::GetCompileUnitAranges() { "DWARFDebugInfo::GetCompileUnitAranges() for \"%s\" from " ".debug_aranges", m_dwarf2Data->GetObjectFile()->GetFileSpec().GetPath().c_str()); - m_cu_aranges_ap->Extract(debug_aranges_data); + m_cu_aranges_up->Extract(debug_aranges_data); } // Make a list of all CUs represented by the arange data in the file. std::set<dw_offset_t> cus_with_data; - for (size_t n = 0; n < m_cu_aranges_ap->GetNumRanges(); n++) { - dw_offset_t offset = m_cu_aranges_ap->OffsetAtIndex(n); + for (size_t n = 0; n < m_cu_aranges_up->GetNumRanges(); n++) { + dw_offset_t offset = m_cu_aranges_up->OffsetAtIndex(n); if (offset != DW_INVALID_OFFSET) cus_with_data.insert(offset); } @@ -82,14 +82,14 @@ DWARFDebugAranges &DWARFDebugInfo::GetCompileUnitAranges() { m_dwarf2Data->GetObjectFile()->GetFileSpec().GetPath().c_str()); printed = true; } - cu->BuildAddressRangeTable(m_dwarf2Data, m_cu_aranges_ap.get()); + cu->BuildAddressRangeTable(m_dwarf2Data, m_cu_aranges_up.get()); } } const bool minimize = true; - m_cu_aranges_ap->Sort(minimize); + m_cu_aranges_up->Sort(minimize); } - return *m_cu_aranges_ap; + return *m_cu_aranges_up; } void DWARFDebugInfo::ParseCompileUnitHeadersIfNeeded() { diff --git a/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h b/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h index 4e92d1aab..2468272ee 100644 --- a/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h +++ b/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h @@ -64,7 +64,7 @@ protected: SymbolFileDWARF *m_dwarf2Data; CompileUnitColl m_compile_units; std::unique_ptr<DWARFDebugAranges> - m_cu_aranges_ap; // A quick address to compile unit table + m_cu_aranges_up; // A quick address to compile unit table private: // All parsing needs to be done partially any managed by this class as diff --git a/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp b/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp index c9ece8a9f..0ffbe9859 100644 --- a/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp +++ b/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp @@ -843,8 +843,8 @@ SymbolFileDWARFDwo *DWARFUnit::GetDwoSymbolFile() const { dw_offset_t DWARFUnit::GetBaseObjOffset() const { return m_base_obj_offset; } const DWARFDebugAranges &DWARFUnit::GetFunctionAranges() { - if (m_func_aranges_ap == NULL) { - m_func_aranges_ap.reset(new DWARFDebugAranges()); + if (m_func_aranges_up == NULL) { + m_func_aranges_up.reset(new DWARFDebugAranges()); Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_ARANGES)); if (log) { @@ -857,19 +857,19 @@ const DWARFDebugAranges &DWARFUnit::GetFunctionAranges() { const DWARFDebugInfoEntry *die = DIEPtr(); if (die) die->BuildFunctionAddressRangeTable(m_dwarf, this, - m_func_aranges_ap.get()); + m_func_aranges_up.get()); if (m_dwo_symbol_file) { DWARFUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit(); const DWARFDebugInfoEntry *dwo_die = dwo_cu->DIEPtr(); if (dwo_die) dwo_die->BuildFunctionAddressRangeTable(m_dwo_symbol_file.get(), dwo_cu, - m_func_aranges_ap.get()); + m_func_aranges_up.get()); } const bool minimize = false; - m_func_aranges_ap->Sort(minimize); + m_func_aranges_up->Sort(minimize); } - return *m_func_aranges_ap; + return *m_func_aranges_up; } diff --git a/source/Plugins/SymbolFile/DWARF/DWARFUnit.h b/source/Plugins/SymbolFile/DWARF/DWARFUnit.h index be820e9e2..0bfa4c04e 100644 --- a/source/Plugins/SymbolFile/DWARF/DWARFUnit.h +++ b/source/Plugins/SymbolFile/DWARF/DWARFUnit.h @@ -202,7 +202,7 @@ protected: llvm::sys::RWMutex m_first_die_mutex; // A table similar to the .debug_aranges table, but this one points to the // exact DW_TAG_subprogram DIEs - std::unique_ptr<DWARFDebugAranges> m_func_aranges_ap; + std::unique_ptr<DWARFDebugAranges> m_func_aranges_up; dw_addr_t m_base_addr = 0; dw_offset_t m_length = 0; uint16_t m_version = 0; diff --git a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp index 24e5cfc7e..6a1e67411 100644 --- a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp +++ b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp @@ -952,7 +952,7 @@ bool SymbolFileDWARF::ParseImportedModules( struct ParseDWARFLineTableCallbackInfo { LineTable *line_table; - std::unique_ptr<LineSequence> sequence_ap; + std::unique_ptr<LineSequence> sequence_up; lldb::addr_t addr_mask; }; @@ -972,19 +972,19 @@ static void ParseDWARFLineTableCallback(dw_offset_t offset, LineTable *line_table = info->line_table; // If this is our first time here, we need to create a sequence container. - if (!info->sequence_ap) { - info->sequence_ap.reset(line_table->CreateLineSequenceContainer()); - assert(info->sequence_ap.get()); + if (!info->sequence_up) { + info->sequence_up.reset(line_table->CreateLineSequenceContainer()); + assert(info->sequence_up.get()); } line_table->AppendLineEntryToSequence( - info->sequence_ap.get(), state.address & info->addr_mask, state.line, + info->sequence_up.get(), state.address & info->addr_mask, state.line, state.column, state.file, state.is_stmt, state.basic_block, state.prologue_end, state.epilogue_begin, state.end_sequence); if (state.end_sequence) { // First, put the current sequence into the line table. - line_table->InsertSequence(info->sequence_ap.get()); + line_table->InsertSequence(info->sequence_up.get()); // Then, empty it to prepare for the next sequence. - info->sequence_ap->Clear(); + info->sequence_up->Clear(); } } } @@ -1002,10 +1002,10 @@ bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) { dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list, DW_INVALID_OFFSET); if (cu_line_offset != DW_INVALID_OFFSET) { - std::unique_ptr<LineTable> line_table_ap(new LineTable(&comp_unit)); - if (line_table_ap) { + std::unique_ptr<LineTable> line_table_up(new LineTable(&comp_unit)); + if (line_table_up) { ParseDWARFLineTableCallbackInfo info; - info.line_table = line_table_ap.get(); + info.line_table = line_table_up.get(); /* * MIPS: @@ -1038,9 +1038,9 @@ bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) { // addresses that are relative to the .o file into addresses for // the main executable. comp_unit.SetLineTable( - debug_map_symfile->LinkOSOLineTable(this, line_table_ap.get())); + debug_map_symfile->LinkOSOLineTable(this, line_table_up.get())); } else { - comp_unit.SetLineTable(line_table_ap.release()); + comp_unit.SetLineTable(line_table_up.release()); return true; } } @@ -1174,20 +1174,20 @@ size_t SymbolFileDWARF::ParseBlocksRecursive( if (tag != DW_TAG_subprogram && (name != NULL || mangled_name != NULL)) { - std::unique_ptr<Declaration> decl_ap; + std::unique_ptr<Declaration> decl_up; if (decl_file != 0 || decl_line != 0 || decl_column != 0) - decl_ap.reset(new Declaration( + decl_up.reset(new Declaration( comp_unit.GetSupportFiles().GetFileSpecAtIndex(decl_file), decl_line, decl_column)); - std::unique_ptr<Declaration> call_ap; + std::unique_ptr<Declaration> call_up; if (call_file != 0 || call_line != 0 || call_column != 0) - call_ap.reset(new Declaration( + call_up.reset(new Declaration( comp_unit.GetSupportFiles().GetFileSpecAtIndex(call_file), call_line, call_column)); - block->SetInlinedFunctionInfo(name, mangled_name, decl_ap.get(), - call_ap.get()); + block->SetInlinedFunctionInfo(name, mangled_name, decl_up.get(), + call_up.get()); } ++blocks_added; @@ -1674,8 +1674,8 @@ void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() { } SymbolFileDWARF::GlobalVariableMap &SymbolFileDWARF::GetGlobalAranges() { - if (!m_global_aranges_ap) { - m_global_aranges_ap.reset(new GlobalVariableMap()); + if (!m_global_aranges_up) { + m_global_aranges_up.reset(new GlobalVariableMap()); ModuleSP module_sp = GetObjectFile()->GetModule(); if (module_sp) { @@ -1702,7 +1702,7 @@ SymbolFileDWARF::GlobalVariableMap &SymbolFileDWARF::GetGlobalAranges() { if (var_sp->GetType()) byte_size = var_sp->GetType()->GetByteSize().getValueOr(0); - m_global_aranges_ap->Append(GlobalVariableMap::Entry( + m_global_aranges_up->Append(GlobalVariableMap::Entry( file_addr, byte_size, var_sp.get())); } } @@ -1712,9 +1712,9 @@ SymbolFileDWARF::GlobalVariableMap &SymbolFileDWARF::GetGlobalAranges() { } } } - m_global_aranges_ap->Sort(); + m_global_aranges_up->Sort(); } - return *m_global_aranges_ap; + return *m_global_aranges_up; } uint32_t SymbolFileDWARF::ResolveSymbolContext(const Address &so_addr, diff --git a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h index da1a0f330..36c267a2d 100644 --- a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h +++ b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h @@ -489,7 +489,7 @@ protected: std::unique_ptr<DWARFDebugAbbrev> m_abbr; std::unique_ptr<DWARFDebugInfo> m_info; std::unique_ptr<DWARFDebugLine> m_line; - std::unique_ptr<GlobalVariableMap> m_global_aranges_ap; + std::unique_ptr<GlobalVariableMap> m_global_aranges_up; typedef std::unordered_map<lldb::offset_t, lldb_private::DebugMacrosSP> DebugMacrosMap; diff --git a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp index 5fca171e0..eccc757bf 100644 --- a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp +++ b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp @@ -179,8 +179,8 @@ public: GetSymbolVendor(bool can_create = true, lldb_private::Stream *feedback_strm = NULL) override { // Scope for locker - if (m_symfile_ap.get() || !can_create) - return m_symfile_ap.get(); + if (m_symfile_up.get() || !can_create) + return m_symfile_up.get(); ModuleSP exe_module_sp(m_exe_module_wp.lock()); if (exe_module_sp) { diff --git a/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp b/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp index b6b0f98dd..53e32586d 100644 --- a/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp +++ b/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp @@ -56,11 +56,11 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly( return false; if (range.GetByteSize() > 0 && range.GetBaseAddress().IsValid() && - m_inst_emulator_ap.get()) { + m_inst_emulator_up.get()) { // The instruction emulation subclass setup the unwind plan for the first // instruction. - m_inst_emulator_ap->CreateFunctionEntryUnwind(unwind_plan); + m_inst_emulator_up->CreateFunctionEntryUnwind(unwind_plan); // CreateFunctionEntryUnwind should have created the first row. If it // doesn't, then we are done. @@ -82,7 +82,7 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly( const uint32_t addr_byte_size = m_arch.GetAddressByteSize(); const bool show_address = true; const bool show_bytes = true; - m_inst_emulator_ap->GetRegisterInfo(unwind_plan.GetRegisterKind(), + m_inst_emulator_up->GetRegisterInfo(unwind_plan.GetRegisterKind(), unwind_plan.GetInitialCFARegister(), m_cfa_reg_info); @@ -128,14 +128,14 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly( // cache the pc register number (in whatever register numbering this // UnwindPlan uses) for quick reference during instruction parsing. RegisterInfo pc_reg_info; - m_inst_emulator_ap->GetRegisterInfo( + m_inst_emulator_up->GetRegisterInfo( eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc_reg_info); // cache the return address register number (in whatever register // numbering this UnwindPlan uses) for quick reference during // instruction parsing. RegisterInfo ra_reg_info; - m_inst_emulator_ap->GetRegisterInfo( + m_inst_emulator_up->GetRegisterInfo( eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA, ra_reg_info); // The architecture dependent condition code of the last processed @@ -169,12 +169,12 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly( m_register_values = it->second.second; } - m_inst_emulator_ap->SetInstruction(inst->GetOpcode(), + m_inst_emulator_up->SetInstruction(inst->GetOpcode(), inst->GetAddress(), nullptr); if (last_condition != - m_inst_emulator_ap->GetInstructionCondition()) { - if (m_inst_emulator_ap->GetInstructionCondition() != + m_inst_emulator_up->GetInstructionCondition()) { + if (m_inst_emulator_up->GetInstructionCondition() != EmulateInstruction::UnconditionalCondition && saved_unwind_states.count(current_offset) == 0) { // If we don't have a saved row for the current offset then @@ -219,9 +219,9 @@ bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly( log->PutString(strm.GetString()); } - last_condition = m_inst_emulator_ap->GetInstructionCondition(); + last_condition = m_inst_emulator_up->GetInstructionCondition(); - m_inst_emulator_ap->EvaluateInstruction( + m_inst_emulator_up->EvaluateInstruction( eEmulateInstructionOptionIgnoreConditions); // If the current instruction is a branch forward then save the @@ -296,12 +296,12 @@ bool UnwindAssemblyInstEmulation::FirstNonPrologueInsn( UnwindAssembly * UnwindAssemblyInstEmulation::CreateInstance(const ArchSpec &arch) { - std::unique_ptr<EmulateInstruction> inst_emulator_ap( + std::unique_ptr<EmulateInstruction> inst_emulator_up( EmulateInstruction::FindPlugin(arch, eInstructionTypePrologueEpilogue, NULL)); // Make sure that all prologue instructions are handled - if (inst_emulator_ap) - return new UnwindAssemblyInstEmulation(arch, inst_emulator_ap.release()); + if (inst_emulator_up) + return new UnwindAssemblyInstEmulation(arch, inst_emulator_up.release()); return NULL; } diff --git a/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h b/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h index 3bbccc01e..704865ce5 100644 --- a/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h +++ b/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h @@ -66,14 +66,14 @@ private: // Call CreateInstance to get an instance of this class UnwindAssemblyInstEmulation(const lldb_private::ArchSpec &arch, lldb_private::EmulateInstruction *inst_emulator) - : UnwindAssembly(arch), m_inst_emulator_ap(inst_emulator), + : UnwindAssembly(arch), m_inst_emulator_up(inst_emulator), m_range_ptr(NULL), m_unwind_plan_ptr(NULL), m_curr_row(), m_cfa_reg_info(), m_fp_is_cfa(false), m_register_values(), m_pushed_regs(), m_curr_row_modified(false), m_forward_branch_offset(0) { - if (m_inst_emulator_ap.get()) { - m_inst_emulator_ap->SetBaton(this); - m_inst_emulator_ap->SetCallbacks(ReadMemory, WriteMemory, ReadRegister, + if (m_inst_emulator_up.get()) { + m_inst_emulator_up->SetBaton(this); + m_inst_emulator_up->SetCallbacks(ReadMemory, WriteMemory, ReadRegister, WriteRegister); } } @@ -128,7 +128,7 @@ private: bool GetRegisterValue(const lldb_private::RegisterInfo ®_info, lldb_private::RegisterValue ®_value); - std::unique_ptr<lldb_private::EmulateInstruction> m_inst_emulator_ap; + std::unique_ptr<lldb_private::EmulateInstruction> m_inst_emulator_up; lldb_private::AddressRange *m_range_ptr; lldb_private::UnwindPlan *m_unwind_plan_ptr; lldb_private::UnwindPlan::RowSP m_curr_row; diff --git a/source/Symbol/ClangASTContext.cpp b/source/Symbol/ClangASTContext.cpp index 424401a51..190dd77f4 100644 --- a/source/Symbol/ClangASTContext.cpp +++ b/source/Symbol/ClangASTContext.cpp @@ -653,10 +653,10 @@ static void ParseLangArgs(LangOptions &Opts, InputKind IK, const char *triple) { } ClangASTContext::ClangASTContext(const char *target_triple) - : TypeSystem(TypeSystem::eKindClang), m_target_triple(), m_ast_ap(), - m_language_options_ap(), m_source_manager_ap(), m_diagnostics_engine_ap(), - m_target_options_rp(), m_target_info_ap(), m_identifier_table_ap(), - m_selector_table_ap(), m_builtins_ap(), m_callback_tag_decl(nullptr), + : TypeSystem(TypeSystem::eKindClang), m_target_triple(), m_ast_up(), + m_language_options_up(), m_source_manager_up(), m_diagnostics_engine_up(), + m_target_options_rp(), m_target_info_up(), m_identifier_table_up(), + m_selector_table_up(), m_builtins_up(), m_callback_tag_decl(nullptr), m_callback_objc_decl(nullptr), m_callback_baton(nullptr), m_pointer_byte_size(0), m_ast_owned(false) { if (target_triple && target_triple[0]) @@ -714,13 +714,13 @@ lldb::TypeSystemSP ClangASTContext::CreateInstance(lldb::LanguageType language, new ClangASTContextForExpressions(*target)); if (ast_sp) { ast_sp->SetArchitecture(fixed_arch); - ast_sp->m_scratch_ast_source_ap.reset( + ast_sp->m_scratch_ast_source_up.reset( new ClangASTSource(target->shared_from_this())); lldbassert(ast_sp->getFileManager()); - ast_sp->m_scratch_ast_source_ap->InstallASTContext( + ast_sp->m_scratch_ast_source_up->InstallASTContext( *ast_sp->getASTContext(), *ast_sp->getFileManager(), true); llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> proxy_ast_source( - ast_sp->m_scratch_ast_source_ap->CreateProxy()); + ast_sp->m_scratch_ast_source_up->CreateProxy()); ast_sp->SetExternalSource(proxy_ast_source); return ast_sp; } @@ -763,34 +763,34 @@ void ClangASTContext::Terminate() { } void ClangASTContext::Finalize() { - if (m_ast_ap) { - GetASTMap().Erase(m_ast_ap.get()); + if (m_ast_up) { + GetASTMap().Erase(m_ast_up.get()); if (!m_ast_owned) - m_ast_ap.release(); + m_ast_up.release(); } - m_builtins_ap.reset(); - m_selector_table_ap.reset(); - m_identifier_table_ap.reset(); - m_target_info_ap.reset(); + m_builtins_up.reset(); + m_selector_table_up.reset(); + m_identifier_table_up.reset(); + m_target_info_up.reset(); m_target_options_rp.reset(); - m_diagnostics_engine_ap.reset(); - m_source_manager_ap.reset(); - m_language_options_ap.reset(); - m_ast_ap.reset(); - m_scratch_ast_source_ap.reset(); + m_diagnostics_engine_up.reset(); + m_source_manager_up.reset(); + m_language_options_up.reset(); + m_ast_up.reset(); + m_scratch_ast_source_up.reset(); } void ClangASTContext::Clear() { - m_ast_ap.reset(); - m_language_options_ap.reset(); - m_source_manager_ap.reset(); - m_diagnostics_engine_ap.reset(); + m_ast_up.reset(); + m_language_options_up.reset(); + m_source_manager_up.reset(); + m_diagnostics_engine_up.reset(); m_target_options_rp.reset(); - m_target_info_ap.reset(); - m_identifier_table_ap.reset(); - m_selector_table_ap.reset(); - m_builtins_ap.reset(); + m_target_info_up.reset(); + m_identifier_table_up.reset(); + m_selector_table_up.reset(); + m_builtins_up.reset(); m_pointer_byte_size = 0; } @@ -815,10 +815,10 @@ bool ClangASTContext::HasExternalSource() { } void ClangASTContext::SetExternalSource( - llvm::IntrusiveRefCntPtr<ExternalASTSource> &ast_source_ap) { + llvm::IntrusiveRefCntPtr<ExternalASTSource> &ast_source_up) { ASTContext *ast = getASTContext(); if (ast) { - ast->setExternalSource(ast_source_ap); + ast->setExternalSource(ast_source_up); ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true); } } @@ -827,52 +827,52 @@ void ClangASTContext::RemoveExternalSource() { ASTContext *ast = getASTContext(); if (ast) { - llvm::IntrusiveRefCntPtr<ExternalASTSource> empty_ast_source_ap; - ast->setExternalSource(empty_ast_source_ap); + llvm::IntrusiveRefCntPtr<ExternalASTSource> empty_ast_source_up; + ast->setExternalSource(empty_ast_source_up); ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false); } } void ClangASTContext::setASTContext(clang::ASTContext *ast_ctx) { if (!m_ast_owned) { - m_ast_ap.release(); + m_ast_up.release(); } m_ast_owned = false; - m_ast_ap.reset(ast_ctx); + m_ast_up.reset(ast_ctx); GetASTMap().Insert(ast_ctx, this); } ASTContext *ClangASTContext::getASTContext() { - if (m_ast_ap == nullptr) { + if (m_ast_up == nullptr) { m_ast_owned = true; - m_ast_ap.reset(new ASTContext(*getLanguageOptions(), *getSourceManager(), + m_ast_up.reset(new ASTContext(*getLanguageOptions(), *getSourceManager(), *getIdentifierTable(), *getSelectorTable(), *getBuiltinContext())); - m_ast_ap->getDiagnostics().setClient(getDiagnosticConsumer(), false); + m_ast_up->getDiagnostics().setClient(getDiagnosticConsumer(), false); // This can be NULL if we don't know anything about the architecture or if // the target for an architecture isn't enabled in the llvm/clang that we // built TargetInfo *target_info = getTargetInfo(); if (target_info) - m_ast_ap->InitBuiltinTypes(*target_info); + m_ast_up->InitBuiltinTypes(*target_info); if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton) { - m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage(); - // m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage(); + m_ast_up->getTranslationUnitDecl()->setHasExternalLexicalStorage(); + // m_ast_up->getTranslationUnitDecl()->setHasExternalVisibleStorage(); } - GetASTMap().Insert(m_ast_ap.get(), this); + GetASTMap().Insert(m_ast_up.get(), this); - llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_ap( + llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_up( new ClangExternalASTSourceCallbacks( ClangASTContext::CompleteTagDecl, ClangASTContext::CompleteObjCInterfaceDecl, nullptr, ClangASTContext::LayoutRecordType, this)); - SetExternalSource(ast_source_ap); + SetExternalSource(ast_source_up); } - return m_ast_ap.get(); + return m_ast_up.get(); } ClangASTContext *ClangASTContext::GetASTContext(clang::ASTContext *ast) { @@ -881,61 +881,61 @@ ClangASTContext *ClangASTContext::GetASTContext(clang::ASTContext *ast) { } Builtin::Context *ClangASTContext::getBuiltinContext() { - if (m_builtins_ap == nullptr) - m_builtins_ap.reset(new Builtin::Context()); - return m_builtins_ap.get(); + if (m_builtins_up == nullptr) + m_builtins_up.reset(new Builtin::Context()); + return m_builtins_up.get(); } IdentifierTable *ClangASTContext::getIdentifierTable() { - if (m_identifier_table_ap == nullptr) - m_identifier_table_ap.reset( + if (m_identifier_table_up == nullptr) + m_identifier_table_up.reset( new IdentifierTable(*ClangASTContext::getLanguageOptions(), nullptr)); - return m_identifier_table_ap.get(); + return m_identifier_table_up.get(); } LangOptions *ClangASTContext::getLanguageOptions() { - if (m_language_options_ap == nullptr) { - m_language_options_ap.reset(new LangOptions()); - ParseLangArgs(*m_language_options_ap, InputKind::ObjCXX, GetTargetTriple()); - // InitializeLangOptions(*m_language_options_ap, InputKind::ObjCXX); + if (m_language_options_up == nullptr) { + m_language_options_up.reset(new LangOptions()); + ParseLangArgs(*m_language_options_up, InputKind::ObjCXX, GetTargetTriple()); + // InitializeLangOptions(*m_language_options_up, InputKind::ObjCXX); } - return m_language_options_ap.get(); + return m_language_options_up.get(); } SelectorTable *ClangASTContext::getSelectorTable() { - if (m_selector_table_ap == nullptr) - m_selector_table_ap.reset(new SelectorTable()); - return m_selector_table_ap.get(); + if (m_selector_table_up == nullptr) + m_selector_table_up.reset(new SelectorTable()); + return m_selector_table_up.get(); } clang::FileManager *ClangASTContext::getFileManager() { - if (m_file_manager_ap == nullptr) { + if (m_file_manager_up == nullptr) { clang::FileSystemOptions file_system_options; - m_file_manager_ap.reset(new clang::FileManager(file_system_options)); + m_file_manager_up.reset(new clang::FileManager(file_system_options)); } - return m_file_manager_ap.get(); + return m_file_manager_up.get(); } clang::SourceManager *ClangASTContext::getSourceManager() { - if (m_source_manager_ap == nullptr) - m_source_manager_ap.reset( + if (m_source_manager_up == nullptr) + m_source_manager_up.reset( new clang::SourceManager(*getDiagnosticsEngine(), *getFileManager())); - return m_source_manager_ap.get(); + return m_source_manager_up.get(); } clang::DiagnosticsEngine *ClangASTContext::getDiagnosticsEngine() { - if (m_diagnostics_engine_ap == nullptr) { + if (m_diagnostics_engine_up == nullptr) { llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs()); - m_diagnostics_engine_ap.reset( + m_diagnostics_engine_up.reset( new DiagnosticsEngine(diag_id_sp, new DiagnosticOptions())); } - return m_diagnostics_engine_ap.get(); + return m_diagnostics_engine_up.get(); } clang::MangleContext *ClangASTContext::getMangleContext() { - if (m_mangle_ctx_ap == nullptr) - m_mangle_ctx_ap.reset(getASTContext()->createMangleContext()); - return m_mangle_ctx_ap.get(); + if (m_mangle_ctx_up == nullptr) + m_mangle_ctx_up.reset(getASTContext()->createMangleContext()); + return m_mangle_ctx_up.get(); } class NullDiagnosticConsumer : public DiagnosticConsumer { @@ -963,10 +963,10 @@ private: }; DiagnosticConsumer *ClangASTContext::getDiagnosticConsumer() { - if (m_diagnostic_consumer_ap == nullptr) - m_diagnostic_consumer_ap.reset(new NullDiagnosticConsumer); + if (m_diagnostic_consumer_up == nullptr) + m_diagnostic_consumer_up.reset(new NullDiagnosticConsumer); - return m_diagnostic_consumer_ap.get(); + return m_diagnostic_consumer_up.get(); } std::shared_ptr<clang::TargetOptions> &ClangASTContext::getTargetOptions() { @@ -980,10 +980,10 @@ std::shared_ptr<clang::TargetOptions> &ClangASTContext::getTargetOptions() { TargetInfo *ClangASTContext::getTargetInfo() { // target_triple should be something like "x86_64-apple-macosx" - if (m_target_info_ap == nullptr && !m_target_triple.empty()) - m_target_info_ap.reset(TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(), + if (m_target_info_up == nullptr && !m_target_triple.empty()) + m_target_info_up.reset(TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(), getTargetOptions())); - return m_target_info_ap.get(); + return m_target_info_up.get(); } #pragma mark Basic Types @@ -2232,7 +2232,7 @@ void ClangASTContext::SetFunctionParameters(FunctionDecl *function_decl, CompilerType ClangASTContext::CreateBlockPointerType(const CompilerType &function_type) { - QualType block_type = m_ast_ap->getBlockPointerType( + QualType block_type = m_ast_up->getBlockPointerType( clang::QualType::getFromOpaquePtr(function_type.GetOpaqueQualType())); return CompilerType(this, block_type.getAsOpaquePtr()); @@ -3322,7 +3322,7 @@ bool ClangASTContext::IsBlockPointerType( const clang::BlockPointerType *block_pointer_type = qual_type->getAs<clang::BlockPointerType>(); QualType pointee_type = block_pointer_type->getPointeeType(); - QualType function_pointer_type = m_ast_ap->getPointerType(pointee_type); + QualType function_pointer_type = m_ast_up->getPointerType(pointee_type); *function_pointer_type_ptr = CompilerType(getASTContext(), function_pointer_type); } @@ -9877,15 +9877,15 @@ void ClangASTContext::CompleteObjCInterfaceDecl( } DWARFASTParser *ClangASTContext::GetDWARFParser() { - if (!m_dwarf_ast_parser_ap) - m_dwarf_ast_parser_ap.reset(new DWARFASTParserClang(*this)); - return m_dwarf_ast_parser_ap.get(); + if (!m_dwarf_ast_parser_up) + m_dwarf_ast_parser_up.reset(new DWARFASTParserClang(*this)); + return m_dwarf_ast_parser_up.get(); } PDBASTParser *ClangASTContext::GetPDBParser() { - if (!m_pdb_ast_parser_ap) - m_pdb_ast_parser_ap.reset(new PDBASTParser(*this)); - return m_pdb_ast_parser_ap.get(); + if (!m_pdb_ast_parser_up) + m_pdb_ast_parser_up.reset(new PDBASTParser(*this)); + return m_pdb_ast_parser_up.get(); } bool ClangASTContext::LayoutRecordType( @@ -9898,10 +9898,10 @@ bool ClangASTContext::LayoutRecordType( &vbase_offsets) { ClangASTContext *ast = (ClangASTContext *)baton; lldb_private::ClangASTImporter *importer = nullptr; - if (ast->m_dwarf_ast_parser_ap) - importer = &ast->m_dwarf_ast_parser_ap->GetClangASTImporter(); - if (!importer && ast->m_pdb_ast_parser_ap) - importer = &ast->m_pdb_ast_parser_ap->GetClangASTImporter(); + if (ast->m_dwarf_ast_parser_up) + importer = &ast->m_dwarf_ast_parser_up->GetClangASTImporter(); + if (!importer && ast->m_pdb_ast_parser_up) + importer = &ast->m_pdb_ast_parser_up->GetClangASTImporter(); if (!importer) return false; @@ -10359,6 +10359,6 @@ ClangASTContextForExpressions::GetPersistentExpressionState() { clang::ExternalASTMerger & ClangASTContextForExpressions::GetMergerUnchecked() { - lldbassert(m_scratch_ast_source_ap != nullptr); - return m_scratch_ast_source_ap->GetMergerUnchecked(); + lldbassert(m_scratch_ast_source_up != nullptr); + return m_scratch_ast_source_up->GetMergerUnchecked(); } diff --git a/source/Symbol/CompileUnit.cpp b/source/Symbol/CompileUnit.cpp index c0246b7ed..940090be1 100644 --- a/source/Symbol/CompileUnit.cpp +++ b/source/Symbol/CompileUnit.cpp @@ -22,7 +22,7 @@ CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data, lldb_private::LazyBool is_optimized) : ModuleChild(module_sp), FileSpec(pathname), UserID(cu_sym_id), m_user_data(user_data), m_language(language), m_flags(0), - m_support_files(), m_line_table_ap(), m_variables(), + m_support_files(), m_line_table_up(), m_variables(), m_is_optimized(is_optimized) { if (language != eLanguageTypeUnknown) m_flags.Set(flagsParsedLanguage); @@ -35,7 +35,7 @@ CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data, lldb_private::LazyBool is_optimized) : ModuleChild(module_sp), FileSpec(fspec), UserID(cu_sym_id), m_user_data(user_data), m_language(language), m_flags(0), - m_support_files(), m_line_table_ap(), m_variables(), + m_support_files(), m_line_table_up(), m_variables(), m_is_optimized(is_optimized) { if (language != eLanguageTypeUnknown) m_flags.Set(flagsParsedLanguage); @@ -189,7 +189,7 @@ lldb::LanguageType CompileUnit::GetLanguage() { } LineTable *CompileUnit::GetLineTable() { - if (m_line_table_ap == nullptr) { + if (m_line_table_up == nullptr) { if (m_flags.IsClear(flagsParsedLineTable)) { m_flags.Set(flagsParsedLineTable); SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor(); @@ -197,7 +197,7 @@ LineTable *CompileUnit::GetLineTable() { symbol_vendor->ParseLineTable(*this); } } - return m_line_table_ap.get(); + return m_line_table_up.get(); } void CompileUnit::SetLineTable(LineTable *line_table) { @@ -205,7 +205,7 @@ void CompileUnit::SetLineTable(LineTable *line_table) { m_flags.Clear(flagsParsedLineTable); else m_flags.Set(flagsParsedLineTable); - m_line_table_ap.reset(line_table); + m_line_table_up.reset(line_table); } DebugMacros *CompileUnit::GetDebugMacros() { diff --git a/source/Symbol/LineTable.cpp b/source/Symbol/LineTable.cpp index 91fc94fb4..7f95b0584 100644 --- a/source/Symbol/LineTable.cpp +++ b/source/Symbol/LineTable.cpp @@ -444,7 +444,7 @@ size_t LineTable::GetContiguousFileAddressRanges(FileAddressRanges &file_ranges, } LineTable *LineTable::LinkLineTable(const FileRangeMap &file_range_map) { - std::unique_ptr<LineTable> line_table_ap(new LineTable(m_comp_unit)); + std::unique_ptr<LineTable> line_table_up(new LineTable(m_comp_unit)); LineSequenceImpl sequence; const size_t count = m_entries.size(); LineEntry line_entry; @@ -507,7 +507,7 @@ LineTable *LineTable::LinkLineTable(const FileRangeMap &file_range_map) { sequence.m_entries.back().is_terminal_entry = true; // Append the sequence since we just terminated the previous one - line_table_ap->InsertSequence(&sequence); + line_table_up->InsertSequence(&sequence); sequence.Clear(); } @@ -523,7 +523,7 @@ LineTable *LineTable::LinkLineTable(const FileRangeMap &file_range_map) { // insert this sequence into our new line table. if (!sequence.m_entries.empty() && sequence.m_entries.back().is_terminal_entry) { - line_table_ap->InsertSequence(&sequence); + line_table_up->InsertSequence(&sequence); sequence.Clear(); prev_entry_was_linked = false; } else { @@ -532,7 +532,7 @@ LineTable *LineTable::LinkLineTable(const FileRangeMap &file_range_map) { prev_file_addr = entry.file_addr; range_changed = false; } - if (line_table_ap->m_entries.empty()) + if (line_table_up->m_entries.empty()) return nullptr; - return line_table_ap.release(); + return line_table_up.release(); } diff --git a/source/Symbol/ObjectFile.cpp b/source/Symbol/ObjectFile.cpp index 8d9545029..5c7c1b7c3 100644 --- a/source/Symbol/ObjectFile.cpp +++ b/source/Symbol/ObjectFile.cpp @@ -56,13 +56,13 @@ ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file, PluginManager::GetObjectContainerCreateCallbackAtIndex( idx)) != nullptr; ++idx) { - std::unique_ptr<ObjectContainer> object_container_ap( + std::unique_ptr<ObjectContainer> object_container_up( create_object_container_callback(module_sp, data_sp, data_offset, file, file_offset, file_size)); - if (object_container_ap) - object_file_sp = object_container_ap->GetObjectFile(file); + if (object_container_up) + object_file_sp = object_container_up->GetObjectFile(file); if (object_file_sp.get()) return object_file_sp; @@ -105,13 +105,13 @@ ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file, PluginManager::GetObjectContainerCreateCallbackAtIndex( idx)) != nullptr; ++idx) { - std::unique_ptr<ObjectContainer> object_container_ap( + std::unique_ptr<ObjectContainer> object_container_up( create_object_container_callback(module_sp, data_sp, data_offset, file, file_offset, file_size)); - if (object_container_ap) - object_file_sp = object_container_ap->GetObjectFile(file); + if (object_container_up) + object_file_sp = object_container_up->GetObjectFile(file); if (object_file_sp.get()) return object_file_sp; @@ -147,12 +147,12 @@ ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file, PluginManager::GetObjectContainerCreateCallbackAtIndex( idx)) != nullptr; ++idx) { - std::unique_ptr<ObjectContainer> object_container_ap( + std::unique_ptr<ObjectContainer> object_container_up( create_object_container_callback(module_sp, data_sp, data_offset, file, file_offset, file_size)); - if (object_container_ap) - object_file_sp = object_container_ap->GetObjectFile(file); + if (object_container_up) + object_file_sp = object_container_up->GetObjectFile(file); if (object_file_sp.get()) return object_file_sp; @@ -265,7 +265,7 @@ ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp, m_type(eTypeInvalid), m_strata(eStrataInvalid), m_file_offset(file_offset), m_length(length), m_data(), m_unwind_table(*this), m_process_wp(), - m_memory_addr(LLDB_INVALID_ADDRESS), m_sections_ap(), m_symtab_ap(), + m_memory_addr(LLDB_INVALID_ADDRESS), m_sections_up(), m_symtab_up(), m_synthetic_symbol_idx(0) { if (file_spec_ptr) m_file = *file_spec_ptr; @@ -287,7 +287,7 @@ ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp, : ModuleChild(module_sp), m_file(), m_type(eTypeInvalid), m_strata(eStrataInvalid), m_file_offset(0), m_length(0), m_data(), m_unwind_table(*this), m_process_wp(process_sp), - m_memory_addr(header_addr), m_sections_ap(), m_symtab_ap(), + m_memory_addr(header_addr), m_sections_up(), m_symtab_up(), m_synthetic_symbol_idx(0) { if (header_data_sp) m_data.SetData(header_data_sp, 0, header_data_sp->GetByteSize()); @@ -463,12 +463,12 @@ DataBufferSP ObjectFile::ReadMemory(const ProcessSP &process_sp, lldb::addr_t addr, size_t byte_size) { DataBufferSP data_sp; if (process_sp) { - std::unique_ptr<DataBufferHeap> data_ap(new DataBufferHeap(byte_size, 0)); + std::unique_ptr<DataBufferHeap> data_up(new DataBufferHeap(byte_size, 0)); Status error; const size_t bytes_read = process_sp->ReadMemory( - addr, data_ap->GetBytes(), data_ap->GetByteSize(), error); + addr, data_up->GetBytes(), data_up->GetByteSize(), error); if (bytes_read == byte_size) - data_sp.reset(data_ap.release()); + data_sp.reset(data_up.release()); } return data_sp; } @@ -601,13 +601,13 @@ void ObjectFile::ClearSymtab() { if (log) log->Printf("%p ObjectFile::ClearSymtab () symtab = %p", static_cast<void *>(this), - static_cast<void *>(m_symtab_ap.get())); - m_symtab_ap.reset(); + static_cast<void *>(m_symtab_up.get())); + m_symtab_up.reset(); } } SectionList *ObjectFile::GetSectionList(bool update_module_section_list) { - if (m_sections_ap == nullptr) { + if (m_sections_up == nullptr) { if (update_module_section_list) { ModuleSP module_sp(GetModule()); if (module_sp) { @@ -619,7 +619,7 @@ SectionList *ObjectFile::GetSectionList(bool update_module_section_list) { CreateSections(unified_section_list); } } - return m_sections_ap.get(); + return m_sections_up.get(); } lldb::SymbolType diff --git a/source/Symbol/SymbolContext.cpp b/source/Symbol/SymbolContext.cpp index 274928676..bc014a772 100644 --- a/source/Symbol/SymbolContext.cpp +++ b/source/Symbol/SymbolContext.cpp @@ -956,9 +956,9 @@ SymbolContext::FindBestGlobalDataSymbol(const ConstString &name, Status &error) //---------------------------------------------------------------------- SymbolContextSpecifier::SymbolContextSpecifier(const TargetSP &target_sp) - : m_target_sp(target_sp), m_module_spec(), m_module_sp(), m_file_spec_ap(), + : m_target_sp(target_sp), m_module_spec(), m_module_sp(), m_file_spec_up(), m_start_line(0), m_end_line(0), m_function_spec(), m_class_name(), - m_address_range_ap(), m_type(eNothingSpecified) {} + m_address_range_up(), m_type(eNothingSpecified) {} SymbolContextSpecifier::~SymbolContextSpecifier() {} @@ -1007,7 +1007,7 @@ bool SymbolContextSpecifier::AddSpecification(const char *spec_string, // CompUnits can't necessarily be resolved here, since an inlined function // might show up in a number of CompUnits. Instead we just convert to a // FileSpec and store it away. - m_file_spec_ap.reset(new FileSpec(spec_string)); + m_file_spec_up.reset(new FileSpec(spec_string)); m_type |= eFileSpecified; break; case eLineStartSpecified: @@ -1039,12 +1039,12 @@ bool SymbolContextSpecifier::AddSpecification(const char *spec_string, void SymbolContextSpecifier::Clear() { m_module_spec.clear(); - m_file_spec_ap.reset(); + m_file_spec_up.reset(); m_function_spec.clear(); m_class_name.clear(); m_start_line = 0; m_end_line = 0; - m_address_range_ap.reset(); + m_address_range_up.reset(); m_type = eNothingSpecified; } @@ -1070,7 +1070,7 @@ bool SymbolContextSpecifier::SymbolContextMatches(SymbolContext &sc) { } } if (m_type & eFileSpecified) { - if (m_file_spec_ap) { + if (m_file_spec_up) { // If we don't have a block or a comp_unit, then we aren't going to match // a source file. if (sc.block == nullptr && sc.comp_unit == nullptr) @@ -1084,7 +1084,7 @@ bool SymbolContextSpecifier::SymbolContextMatches(SymbolContext &sc) { if (inline_info != nullptr) { was_inlined = true; if (!FileSpec::Equal(inline_info->GetDeclaration().GetFile(), - *(m_file_spec_ap.get()), false)) + *(m_file_spec_up.get()), false)) return false; } } @@ -1092,7 +1092,7 @@ bool SymbolContextSpecifier::SymbolContextMatches(SymbolContext &sc) { // Next check the comp unit, but only if the SymbolContext was not // inlined. if (!was_inlined && sc.comp_unit != nullptr) { - if (!FileSpec::Equal(*(sc.comp_unit), *(m_file_spec_ap.get()), false)) + if (!FileSpec::Equal(*(sc.comp_unit), *(m_file_spec_up.get()), false)) return false; } } @@ -1165,8 +1165,8 @@ void SymbolContextSpecifier::GetDescription( s->Printf("Module: %s\n", m_module_spec.c_str()); } - if (m_type == eFileSpecified && m_file_spec_ap != nullptr) { - m_file_spec_ap->GetPath(path_str, PATH_MAX); + if (m_type == eFileSpecified && m_file_spec_up != nullptr) { + m_file_spec_up->GetPath(path_str, PATH_MAX); s->Indent(); s->Printf("File: %s", path_str); if (m_type == eLineStartSpecified) { @@ -1203,10 +1203,10 @@ void SymbolContextSpecifier::GetDescription( s->Printf("Class name: %s.\n", m_class_name.c_str()); } - if (m_type == eAddressRangeSpecified && m_address_range_ap != nullptr) { + if (m_type == eAddressRangeSpecified && m_address_range_up != nullptr) { s->Indent(); s->PutCString("Address range: "); - m_address_range_ap->Dump(s, m_target_sp.get(), + m_address_range_up->Dump(s, m_target_sp.get(), Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress); s->PutCString("\n"); diff --git a/source/Symbol/SymbolFile.cpp b/source/Symbol/SymbolFile.cpp index 4576bcfd1..85242aeac 100644 --- a/source/Symbol/SymbolFile.cpp +++ b/source/Symbol/SymbolFile.cpp @@ -31,7 +31,7 @@ std::recursive_mutex &SymbolFile::GetModuleMutex() const { } SymbolFile *SymbolFile::FindPlugin(ObjectFile *obj_file) { - std::unique_ptr<SymbolFile> best_symfile_ap; + std::unique_ptr<SymbolFile> best_symfile_up; if (obj_file != nullptr) { // We need to test the abilities of this section list. So create what it @@ -57,13 +57,13 @@ SymbolFile *SymbolFile::FindPlugin(ObjectFile *obj_file) { (create_callback = PluginManager::GetSymbolFileCreateCallbackAtIndex( idx)) != nullptr; ++idx) { - std::unique_ptr<SymbolFile> curr_symfile_ap(create_callback(obj_file)); + std::unique_ptr<SymbolFile> curr_symfile_up(create_callback(obj_file)); - if (curr_symfile_ap) { - const uint32_t sym_file_abilities = curr_symfile_ap->GetAbilities(); + if (curr_symfile_up) { + const uint32_t sym_file_abilities = curr_symfile_up->GetAbilities(); if (sym_file_abilities > best_symfile_abilities) { best_symfile_abilities = sym_file_abilities; - best_symfile_ap.reset(curr_symfile_ap.release()); + best_symfile_up.reset(curr_symfile_up.release()); // If any symbol file parser has all of the abilities, then we should // just stop looking. if ((kAllAbilities & sym_file_abilities) == kAllAbilities) @@ -71,13 +71,13 @@ SymbolFile *SymbolFile::FindPlugin(ObjectFile *obj_file) { } } } - if (best_symfile_ap) { + if (best_symfile_up) { // Let the winning symbol file parser initialize itself more completely // now that it has been chosen - best_symfile_ap->InitializeObject(); + best_symfile_up->InitializeObject(); } } - return best_symfile_ap.release(); + return best_symfile_up.release(); } TypeList *SymbolFile::GetTypeList() { diff --git a/source/Symbol/SymbolVendor.cpp b/source/Symbol/SymbolVendor.cpp index 583f1b168..c0f0b6728 100644 --- a/source/Symbol/SymbolVendor.cpp +++ b/source/Symbol/SymbolVendor.cpp @@ -27,17 +27,17 @@ using namespace lldb_private; //---------------------------------------------------------------------- SymbolVendor *SymbolVendor::FindPlugin(const lldb::ModuleSP &module_sp, lldb_private::Stream *feedback_strm) { - std::unique_ptr<SymbolVendor> instance_ap; + std::unique_ptr<SymbolVendor> instance_up; SymbolVendorCreateInstance create_callback; for (size_t idx = 0; (create_callback = PluginManager::GetSymbolVendorCreateCallbackAtIndex( idx)) != nullptr; ++idx) { - instance_ap.reset(create_callback(module_sp, feedback_strm)); + instance_up.reset(create_callback(module_sp, feedback_strm)); - if (instance_ap) { - return instance_ap.release(); + if (instance_up) { + return instance_up.release(); } } // The default implementation just tries to create debug information using @@ -53,17 +53,17 @@ SymbolVendor *SymbolVendor::FindPlugin(const lldb::ModuleSP &module_sp, } if (!sym_objfile_sp) sym_objfile_sp = module_sp->GetObjectFile()->shared_from_this(); - instance_ap.reset(new SymbolVendor(module_sp)); - instance_ap->AddSymbolFileRepresentation(sym_objfile_sp); - return instance_ap.release(); + instance_up.reset(new SymbolVendor(module_sp)); + instance_up->AddSymbolFileRepresentation(sym_objfile_sp); + return instance_up.release(); } //---------------------------------------------------------------------- // SymbolVendor constructor //---------------------------------------------------------------------- SymbolVendor::SymbolVendor(const lldb::ModuleSP &module_sp) - : ModuleChild(module_sp), m_type_list(), m_compile_units(), - m_sym_file_ap(), m_symtab() {} + : ModuleChild(module_sp), m_type_list(), m_compile_units(), m_sym_file_up(), + m_symtab() {} //---------------------------------------------------------------------- // Destructor @@ -79,7 +79,7 @@ void SymbolVendor::AddSymbolFileRepresentation(const ObjectFileSP &objfile_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); if (objfile_sp) { m_objfile_sp = objfile_sp; - m_sym_file_ap.reset(SymbolFile::FindPlugin(objfile_sp.get())); + m_sym_file_up.reset(SymbolFile::FindPlugin(objfile_sp.get())); } } } @@ -112,12 +112,12 @@ size_t SymbolVendor::GetNumCompileUnits() { if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); if (m_compile_units.empty()) { - if (m_sym_file_ap) { + if (m_sym_file_up) { // Resize our array of compile unit shared pointers -- which will each // remain NULL until someone asks for the actual compile unit // information. When this happens, the symbol file will be asked to // parse this compile unit information. - m_compile_units.resize(m_sym_file_ap->GetNumCompileUnits()); + m_compile_units.resize(m_sym_file_up->GetNumCompileUnits()); } } } @@ -128,8 +128,8 @@ lldb::LanguageType SymbolVendor::ParseLanguage(CompileUnit &comp_unit) { ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ParseLanguage(comp_unit); + if (m_sym_file_up) + return m_sym_file_up->ParseLanguage(comp_unit); } return eLanguageTypeUnknown; } @@ -138,8 +138,8 @@ size_t SymbolVendor::ParseFunctions(CompileUnit &comp_unit) { ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ParseFunctions(comp_unit); + if (m_sym_file_up) + return m_sym_file_up->ParseFunctions(comp_unit); } return 0; } @@ -148,8 +148,8 @@ bool SymbolVendor::ParseLineTable(CompileUnit &comp_unit) { ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ParseLineTable(comp_unit); + if (m_sym_file_up) + return m_sym_file_up->ParseLineTable(comp_unit); } return false; } @@ -158,8 +158,8 @@ bool SymbolVendor::ParseDebugMacros(CompileUnit &comp_unit) { ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ParseDebugMacros(comp_unit); + if (m_sym_file_up) + return m_sym_file_up->ParseDebugMacros(comp_unit); } return false; } @@ -168,8 +168,8 @@ bool SymbolVendor::ParseSupportFiles(CompileUnit &comp_unit, ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ParseSupportFiles(comp_unit, support_files); + if (m_sym_file_up) + return m_sym_file_up->ParseSupportFiles(comp_unit, support_files); } return false; } @@ -178,8 +178,8 @@ bool SymbolVendor::ParseIsOptimized(CompileUnit &comp_unit) { ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ParseIsOptimized(comp_unit); + if (m_sym_file_up) + return m_sym_file_up->ParseIsOptimized(comp_unit); } return false; } @@ -189,8 +189,8 @@ bool SymbolVendor::ParseImportedModules( ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ParseImportedModules(sc, imported_modules); + if (m_sym_file_up) + return m_sym_file_up->ParseImportedModules(sc, imported_modules); } return false; } @@ -199,8 +199,8 @@ size_t SymbolVendor::ParseBlocksRecursive(Function &func) { ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ParseBlocksRecursive(func); + if (m_sym_file_up) + return m_sym_file_up->ParseBlocksRecursive(func); } return 0; } @@ -209,8 +209,8 @@ size_t SymbolVendor::ParseTypes(CompileUnit &comp_unit) { ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ParseTypes(comp_unit); + if (m_sym_file_up) + return m_sym_file_up->ParseTypes(comp_unit); } return 0; } @@ -219,8 +219,8 @@ size_t SymbolVendor::ParseVariablesForContext(const SymbolContext &sc) { ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ParseVariablesForContext(sc); + if (m_sym_file_up) + return m_sym_file_up->ParseVariablesForContext(sc); } return 0; } @@ -229,8 +229,8 @@ Type *SymbolVendor::ResolveTypeUID(lldb::user_id_t type_uid) { ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ResolveTypeUID(type_uid); + if (m_sym_file_up) + return m_sym_file_up->ResolveTypeUID(type_uid); } return nullptr; } @@ -241,8 +241,8 @@ uint32_t SymbolVendor::ResolveSymbolContext(const Address &so_addr, ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ResolveSymbolContext(so_addr, resolve_scope, sc); + if (m_sym_file_up) + return m_sym_file_up->ResolveSymbolContext(so_addr, resolve_scope, sc); } return 0; } @@ -254,8 +254,8 @@ uint32_t SymbolVendor::ResolveSymbolContext(const FileSpec &file_spec, ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->ResolveSymbolContext(file_spec, line, check_inlines, + if (m_sym_file_up) + return m_sym_file_up->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope, sc_list); } return 0; @@ -268,8 +268,8 @@ SymbolVendor::FindGlobalVariables(const ConstString &name, ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->FindGlobalVariables(name, parent_decl_ctx, + if (m_sym_file_up) + return m_sym_file_up->FindGlobalVariables(name, parent_decl_ctx, max_matches, variables); } return 0; @@ -281,8 +281,8 @@ size_t SymbolVendor::FindGlobalVariables(const RegularExpression ®ex, ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->FindGlobalVariables(regex, max_matches, variables); + if (m_sym_file_up) + return m_sym_file_up->FindGlobalVariables(regex, max_matches, variables); } return 0; } @@ -295,8 +295,8 @@ size_t SymbolVendor::FindFunctions(const ConstString &name, ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->FindFunctions(name, parent_decl_ctx, name_type_mask, + if (m_sym_file_up) + return m_sym_file_up->FindFunctions(name, parent_decl_ctx, name_type_mask, include_inlines, append, sc_list); } return 0; @@ -308,8 +308,8 @@ size_t SymbolVendor::FindFunctions(const RegularExpression ®ex, ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->FindFunctions(regex, include_inlines, append, + if (m_sym_file_up) + return m_sym_file_up->FindFunctions(regex, include_inlines, append, sc_list); } return 0; @@ -323,8 +323,8 @@ size_t SymbolVendor::FindTypes( ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->FindTypes(name, parent_decl_ctx, append, + if (m_sym_file_up) + return m_sym_file_up->FindTypes(name, parent_decl_ctx, append, max_matches, searched_symbol_files, types); } @@ -338,8 +338,8 @@ size_t SymbolVendor::FindTypes(const std::vector<CompilerContext> &context, ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->FindTypes(context, append, types); + if (m_sym_file_up) + return m_sym_file_up->FindTypes(context, append, types); } if (!append) types.Clear(); @@ -351,8 +351,8 @@ size_t SymbolVendor::GetTypes(SymbolContextScope *sc_scope, TypeClass type_mask, ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - return m_sym_file_ap->GetTypes(sc_scope, type_mask, type_list); + if (m_sym_file_up) + return m_sym_file_up->GetTypes(sc_scope, type_mask, type_list); } return 0; } @@ -364,8 +364,8 @@ SymbolVendor::FindNamespace(const ConstString &name, ModuleSP module_sp(GetModule()); if (module_sp) { std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); - if (m_sym_file_ap) - namespace_decl_ctx = m_sym_file_ap->FindNamespace(name, parent_decl_ctx); + if (m_sym_file_up) + namespace_decl_ctx = m_sym_file_up->FindNamespace(name, parent_decl_ctx); } return namespace_decl_ctx; } @@ -380,9 +380,9 @@ void SymbolVendor::Dump(Stream *s) { s->Printf("%p: ", static_cast<void *>(this)); s->Indent(); s->PutCString("SymbolVendor"); - if (m_sym_file_ap) { - *s << " " << m_sym_file_ap->GetPluginName(); - ObjectFile *objfile = m_sym_file_ap->GetObjectFile(); + if (m_sym_file_up) { + *s << " " << m_sym_file_up->GetPluginName(); + ObjectFile *objfile = m_sym_file_up->GetObjectFile(); if (objfile) { const FileSpec &objfile_file_spec = objfile->GetFileSpec(); if (objfile_file_spec) { @@ -393,8 +393,8 @@ void SymbolVendor::Dump(Stream *s) { } } s->EOL(); - if (m_sym_file_ap) - m_sym_file_ap->Dump(*s); + if (m_sym_file_up) + m_sym_file_up->Dump(*s); s->IndentMore(); m_type_list.Dump(s, show_context); @@ -422,7 +422,7 @@ CompUnitSP SymbolVendor::GetCompileUnitAtIndex(size_t idx) { if (idx < num_compile_units) { cu_sp = m_compile_units[idx]; if (cu_sp.get() == nullptr) { - m_compile_units[idx] = m_sym_file_ap->ParseCompileUnitAtIndex(idx); + m_compile_units[idx] = m_sym_file_up->ParseCompileUnitAtIndex(idx); cu_sp = m_compile_units[idx]; } } @@ -431,8 +431,8 @@ CompUnitSP SymbolVendor::GetCompileUnitAtIndex(size_t idx) { } FileSpec SymbolVendor::GetMainFileSpec() const { - if (m_sym_file_ap) { - const ObjectFile *symfile_objfile = m_sym_file_ap->GetObjectFile(); + if (m_sym_file_up) { + const ObjectFile *symfile_objfile = m_sym_file_up->GetObjectFile(); if (symfile_objfile) return symfile_objfile->GetFileSpec(); } @@ -455,8 +455,8 @@ Symtab *SymbolVendor::GetSymtab() { return nullptr; m_symtab = objfile->GetSymtab(); - if (m_symtab && m_sym_file_ap) - m_sym_file_ap->AddSymbols(*m_symtab); + if (m_symtab && m_sym_file_up) + m_sym_file_up->AddSymbols(*m_symtab); return m_symtab; } @@ -476,8 +476,8 @@ void SymbolVendor::SectionFileAddressesChanged() { ModuleSP module_sp(GetModule()); if (module_sp) { ObjectFile *module_objfile = module_sp->GetObjectFile(); - if (m_sym_file_ap) { - ObjectFile *symfile_objfile = m_sym_file_ap->GetObjectFile(); + if (m_sym_file_up) { + ObjectFile *symfile_objfile = m_sym_file_up->GetObjectFile(); if (symfile_objfile != module_objfile) symfile_objfile->SectionFileAddressesChanged(); } diff --git a/source/Target/LanguageRuntime.cpp b/source/Target/LanguageRuntime.cpp index 8203c9efa..d00800683 100644 --- a/source/Target/LanguageRuntime.cpp +++ b/source/Target/LanguageRuntime.cpp @@ -201,7 +201,7 @@ protected: LanguageRuntime *LanguageRuntime::FindPlugin(Process *process, lldb::LanguageType language) { - std::unique_ptr<LanguageRuntime> language_runtime_ap; + std::unique_ptr<LanguageRuntime> language_runtime_up; LanguageRuntimeCreateInstance create_callback; for (uint32_t idx = 0; @@ -209,10 +209,10 @@ LanguageRuntime *LanguageRuntime::FindPlugin(Process *process, PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) != nullptr; ++idx) { - language_runtime_ap.reset(create_callback(process, language)); + language_runtime_up.reset(create_callback(process, language)); - if (language_runtime_ap) - return language_runtime_ap.release(); + if (language_runtime_up) + return language_runtime_up.release(); } return nullptr; diff --git a/source/Target/Memory.cpp b/source/Target/Memory.cpp index c0597b687..979553ffa 100644 --- a/source/Target/Memory.cpp +++ b/source/Target/Memory.cpp @@ -229,17 +229,17 @@ size_t MemoryCache::Read(addr_t addr, void *dst, size_t dst_len, if (bytes_left > 0) { assert((curr_addr % cache_line_byte_size) == 0); - std::unique_ptr<DataBufferHeap> data_buffer_heap_ap( + std::unique_ptr<DataBufferHeap> data_buffer_heap_up( new DataBufferHeap(cache_line_byte_size, 0)); size_t process_bytes_read = m_process.ReadMemoryFromInferior( - curr_addr, data_buffer_heap_ap->GetBytes(), - data_buffer_heap_ap->GetByteSize(), error); + curr_addr, data_buffer_heap_up->GetBytes(), + data_buffer_heap_up->GetByteSize(), error); if (process_bytes_read == 0) return dst_len - bytes_left; if (process_bytes_read != cache_line_byte_size) - data_buffer_heap_ap->SetByteSize(process_bytes_read); - m_L2_cache[curr_addr] = DataBufferSP(data_buffer_heap_ap.release()); + data_buffer_heap_up->SetByteSize(process_bytes_read); + m_L2_cache[curr_addr] = DataBufferSP(data_buffer_heap_up.release()); // We have read data and put it into the cache, continue through the // loop again to get the data out of the cache... } diff --git a/source/Target/ObjCLanguageRuntime.cpp b/source/Target/ObjCLanguageRuntime.cpp index 7e0838e2d..fac1fae68 100644 --- a/source/Target/ObjCLanguageRuntime.cpp +++ b/source/Target/ObjCLanguageRuntime.cpp @@ -302,8 +302,8 @@ ObjCLanguageRuntime::GetNonKVOClassDescriptor(ObjCISA isa) { CompilerType ObjCLanguageRuntime::EncodingToType::RealizeType(const char *name, bool for_expression) { - if (m_scratch_ast_ctx_ap) - return RealizeType(*m_scratch_ast_ctx_ap, name, for_expression); + if (m_scratch_ast_ctx_up) + return RealizeType(*m_scratch_ast_ctx_up, name, for_expression); return CompilerType(); } diff --git a/source/Target/OperatingSystem.cpp b/source/Target/OperatingSystem.cpp index a950f5e32..c78c197db 100644 --- a/source/Target/OperatingSystem.cpp +++ b/source/Target/OperatingSystem.cpp @@ -22,10 +22,10 @@ OperatingSystem *OperatingSystem::FindPlugin(Process *process, PluginManager::GetOperatingSystemCreateCallbackForPluginName( const_plugin_name); if (create_callback) { - std::unique_ptr<OperatingSystem> instance_ap( + std::unique_ptr<OperatingSystem> instance_up( create_callback(process, true)); - if (instance_ap) - return instance_ap.release(); + if (instance_up) + return instance_up.release(); } } else { for (uint32_t idx = 0; @@ -33,10 +33,10 @@ OperatingSystem *OperatingSystem::FindPlugin(Process *process, PluginManager::GetOperatingSystemCreateCallbackAtIndex(idx)) != nullptr; ++idx) { - std::unique_ptr<OperatingSystem> instance_ap( + std::unique_ptr<OperatingSystem> instance_up( create_callback(process, false)); - if (instance_ap) - return instance_ap.release(); + if (instance_up) + return instance_up.release(); } } return nullptr; diff --git a/source/Target/Process.cpp b/source/Target/Process.cpp index 58d85a2d7..994b52a97 100644 --- a/source/Target/Process.cpp +++ b/source/Target/Process.cpp @@ -734,13 +734,13 @@ Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp, m_thread_list(this), m_extended_thread_list(this), m_extended_thread_stop_id(0), m_queue_list(this), m_queue_list_stop_id(0), m_notifications(), m_image_tokens(), m_listener_sp(listener_sp), - m_breakpoint_site_list(), m_dynamic_checkers_ap(), + m_breakpoint_site_list(), m_dynamic_checkers_up(), m_unix_signals_sp(unix_signals_sp), m_abi_sp(), m_process_input_reader(), m_stdio_communication("process.stdio"), m_stdio_communication_mutex(), m_stdin_forward(false), m_stdout_data(), m_stderr_data(), m_profile_data_comm_mutex(), m_profile_data(), m_iohandler_sync(0), m_memory_cache(*this), m_allocated_memory_cache(*this), - m_should_detach(false), m_next_event_action_ap(), m_public_run_lock(), + m_should_detach(false), m_next_event_action_up(), m_public_run_lock(), m_private_run_lock(), m_finalizing(false), m_finalize_called(false), m_clear_thread_plans_on_stop(false), m_force_next_event_delivery(false), m_last_broadcast_state(eStateInvalid), m_destroy_in_process(false), @@ -848,12 +848,12 @@ void Process::Finalize() { // We need to destroy the loader before the derived Process class gets // destroyed since it is very likely that undoing the loader will require // access to the real process. - m_dynamic_checkers_ap.reset(); + m_dynamic_checkers_up.reset(); m_abi_sp.reset(); - m_os_ap.reset(); - m_system_runtime_ap.reset(); - m_dyld_ap.reset(); - m_jit_loaders_ap.reset(); + m_os_up.reset(); + m_system_runtime_up.reset(); + m_dyld_up.reset(); + m_jit_loaders_up.reset(); m_thread_list_real.Destroy(); m_thread_list.Destroy(); m_extended_thread_list.Destroy(); @@ -866,7 +866,7 @@ void Process::Finalize() { m_allocated_memory_cache.Clear(); m_language_runtimes.clear(); m_instrumentation_runtimes.clear(); - m_next_event_action_ap.reset(); + m_next_event_action_up.reset(); // Clear the last natural stop ID since it has a strong reference to this // process m_mod_id.SetStopEventForLastNaturalStopID(EventSP()); @@ -1506,12 +1506,12 @@ void Process::UpdateThreadListIfNeeded() { } void Process::UpdateQueueListIfNeeded() { - if (m_system_runtime_ap) { + if (m_system_runtime_up) { if (m_queue_list.GetSize() == 0 || m_queue_list_stop_id != GetLastNaturalStopID()) { const StateType state = GetPrivateState(); if (StateIsStoppedState(state, true)) { - m_system_runtime_ap->PopulateQueueList(m_queue_list); + m_system_runtime_up->PopulateQueueList(m_queue_list); m_queue_list_stop_id = GetLastNaturalStopID(); } } @@ -1792,7 +1792,7 @@ bool Process::IsPossibleDynamicValue(ValueObject &in_value) { } void Process::SetDynamicCheckers(DynamicCheckerFunctions *dynamic_checkers) { - m_dynamic_checkers_ap.reset(dynamic_checkers); + m_dynamic_checkers_up.reset(dynamic_checkers); } BreakpointSiteList &Process::GetBreakpointSiteList() { @@ -2708,7 +2708,7 @@ Process::WaitForProcessStopPrivate(EventSP &event_sp, void Process::LoadOperatingSystemPlugin(bool flush) { if (flush) m_thread_list.Clear(); - m_os_ap.reset(OperatingSystem::FindPlugin(this, nullptr)); + m_os_up.reset(OperatingSystem::FindPlugin(this, nullptr)); if (flush) Flush(); } @@ -2716,10 +2716,10 @@ void Process::LoadOperatingSystemPlugin(bool flush) { Status Process::Launch(ProcessLaunchInfo &launch_info) { Status error; m_abi_sp.reset(); - m_dyld_ap.reset(); - m_jit_loaders_ap.reset(); - m_system_runtime_ap.reset(); - m_os_ap.reset(); + m_dyld_up.reset(); + m_jit_loaders_up.reset(); + m_system_runtime_up.reset(); + m_os_up.reset(); m_process_input_reader.reset(); Module *exe_module = GetTarget().GetExecutableModulePointer(); @@ -2789,8 +2789,8 @@ Status Process::Launch(ProcessLaunchInfo &launch_info) { if (system_runtime) system_runtime->DidLaunch(); - if (!m_os_ap) - LoadOperatingSystemPlugin(false); + if (!m_os_up) + LoadOperatingSystemPlugin(false); // We successfully launched the process and stopped, now it the // right time to set up signal filters before resuming. @@ -2850,7 +2850,7 @@ Status Process::LoadCore() { if (system_runtime) system_runtime->DidAttach(); - if (!m_os_ap) + if (!m_os_up) LoadOperatingSystemPlugin(false); // We successfully loaded a core file, now pretend we stopped so we can @@ -2876,25 +2876,25 @@ Status Process::LoadCore() { } DynamicLoader *Process::GetDynamicLoader() { - if (!m_dyld_ap) - m_dyld_ap.reset(DynamicLoader::FindPlugin(this, nullptr)); - return m_dyld_ap.get(); + if (!m_dyld_up) + m_dyld_up.reset(DynamicLoader::FindPlugin(this, nullptr)); + return m_dyld_up.get(); } const lldb::DataBufferSP Process::GetAuxvData() { return DataBufferSP(); } JITLoaderList &Process::GetJITLoaders() { - if (!m_jit_loaders_ap) { - m_jit_loaders_ap.reset(new JITLoaderList()); - JITLoader::LoadPlugins(this, *m_jit_loaders_ap); + if (!m_jit_loaders_up) { + m_jit_loaders_up.reset(new JITLoaderList()); + JITLoader::LoadPlugins(this, *m_jit_loaders_up); } - return *m_jit_loaders_ap; + return *m_jit_loaders_up; } SystemRuntime *Process::GetSystemRuntime() { - if (!m_system_runtime_ap) - m_system_runtime_ap.reset(SystemRuntime::FindPlugin(this)); - return m_system_runtime_ap.get(); + if (!m_system_runtime_up) + m_system_runtime_up.reset(SystemRuntime::FindPlugin(this)); + return m_system_runtime_up.get(); } Process::AttachCompletionHandler::AttachCompletionHandler(Process *process, @@ -2984,10 +2984,10 @@ ListenerSP ProcessAttachInfo::GetListenerForProcess(Debugger &debugger) { Status Process::Attach(ProcessAttachInfo &attach_info) { m_abi_sp.reset(); m_process_input_reader.reset(); - m_dyld_ap.reset(); - m_jit_loaders_ap.reset(); - m_system_runtime_ap.reset(); - m_os_ap.reset(); + m_dyld_up.reset(); + m_jit_loaders_up.reset(); + m_system_runtime_up.reset(); + m_os_up.reset(); lldb::pid_t attach_pid = attach_info.GetProcessID(); Status error; @@ -3193,7 +3193,7 @@ void Process::CompleteAttach() { } } - if (!m_os_ap) + if (!m_os_up) LoadOperatingSystemPlugin(false); // Figure out which one is the executable, and set that in our target: const ModuleList &target_modules = GetTarget().GetImages(); @@ -3851,9 +3851,9 @@ void Process::HandlePrivateEvent(EventSP &event_sp) { Process::ProcessEventData::GetStateFromEvent(event_sp.get()); // First check to see if anybody wants a shot at this event: - if (m_next_event_action_ap) { + if (m_next_event_action_up) { NextEventAction::EventActionResult action_result = - m_next_event_action_ap->PerformAction(event_sp); + m_next_event_action_up->PerformAction(event_sp); if (log) log->Printf("Ran next event action, result was %d.", action_result); @@ -3871,7 +3871,7 @@ void Process::HandlePrivateEvent(EventSP &event_sp) { // to exit so the next event will kill us. if (new_state != eStateExited) { // FIXME: should cons up an exited event, and discard this one. - SetExitStatus(0, m_next_event_action_ap->GetExitString()); + SetExitStatus(0, m_next_event_action_up->GetExitString()); SetNextEventAction(nullptr); return; } @@ -4658,11 +4658,11 @@ protected: void Process::SetSTDIOFileDescriptor(int fd) { // First set up the Read Thread for reading/handling process I/O - std::unique_ptr<ConnectionFileDescriptor> conn_ap( + std::unique_ptr<ConnectionFileDescriptor> conn_up( new ConnectionFileDescriptor(fd, true)); - if (conn_ap) { - m_stdio_communication.SetConnection(conn_ap.release()); + if (conn_up) { + m_stdio_communication.SetConnection(conn_up.release()); if (m_stdio_communication.IsConnected()) { m_stdio_communication.SetReadThreadBytesReceivedCallback( STDIOReadThreadBytesReceived, this); @@ -5783,12 +5783,12 @@ void Process::DidExec() { Target &target = GetTarget(); target.CleanupProcess(); target.ClearModules(false); - m_dynamic_checkers_ap.reset(); + m_dynamic_checkers_up.reset(); m_abi_sp.reset(); - m_system_runtime_ap.reset(); - m_os_ap.reset(); - m_dyld_ap.reset(); - m_jit_loaders_ap.reset(); + m_system_runtime_up.reset(); + m_os_up.reset(); + m_dyld_up.reset(); + m_jit_loaders_up.reset(); m_image_tokens.clear(); m_allocated_memory_cache.Clear(); m_language_runtimes.clear(); @@ -5872,7 +5872,7 @@ void Process::ModulesDidLoad(ModuleList &module_list) { // If we don't have an operating system plug-in, try to load one since // loading shared libraries might cause a new one to try and load - if (!m_os_ap) + if (!m_os_up) LoadOperatingSystemPlugin(false); // Give structured-data plugins a chance to see the modified modules. diff --git a/source/Target/StackFrameList.cpp b/source/Target/StackFrameList.cpp index a36fba45c..de80ae70f 100644 --- a/source/Target/StackFrameList.cpp +++ b/source/Target/StackFrameList.cpp @@ -819,11 +819,11 @@ void StackFrameList::Clear() { m_concrete_frames_fetched = 0; } -void StackFrameList::Merge(std::unique_ptr<StackFrameList> &curr_ap, +void StackFrameList::Merge(std::unique_ptr<StackFrameList> &curr_up, lldb::StackFrameListSP &prev_sp) { std::unique_lock<std::recursive_mutex> current_lock, previous_lock; - if (curr_ap) - current_lock = std::unique_lock<std::recursive_mutex>(curr_ap->m_mutex); + if (curr_up) + current_lock = std::unique_lock<std::recursive_mutex>(curr_up->m_mutex); if (prev_sp) previous_lock = std::unique_lock<std::recursive_mutex>(prev_sp->m_mutex); @@ -835,18 +835,18 @@ void StackFrameList::Merge(std::unique_ptr<StackFrameList> &curr_ap, else s.PutCString("NULL"); s.PutCString("\nCurr:\n"); - if (curr_ap) - curr_ap->Dump(&s); + if (curr_up) + curr_up->Dump(&s); else s.PutCString("NULL"); s.EOL(); #endif - if (!curr_ap || curr_ap->GetNumFrames(false) == 0) { + if (!curr_up || curr_up->GetNumFrames(false) == 0) { #if defined(DEBUG_STACK_FRAMES) s.PutCString("No current frames, leave previous frames alone...\n"); #endif - curr_ap.release(); + curr_up.release(); return; } @@ -857,11 +857,11 @@ void StackFrameList::Merge(std::unique_ptr<StackFrameList> &curr_ap, // We either don't have any previous frames, or since we have more than one // current frames it means we have all the frames and can safely replace // our previous frames. - prev_sp.reset(curr_ap.release()); + prev_sp.reset(curr_up.release()); return; } - const uint32_t num_curr_frames = curr_ap->GetNumFrames(false); + const uint32_t num_curr_frames = curr_up->GetNumFrames(false); if (num_curr_frames > 1) { #if defined(DEBUG_STACK_FRAMES) @@ -870,7 +870,7 @@ void StackFrameList::Merge(std::unique_ptr<StackFrameList> &curr_ap, #endif // We have more than one current frames it means we have all the frames and // can safely replace our previous frames. - prev_sp.reset(curr_ap.release()); + prev_sp.reset(curr_up.release()); #if defined(DEBUG_STACK_FRAMES) s.PutCString("\nMerged:\n"); @@ -880,7 +880,7 @@ void StackFrameList::Merge(std::unique_ptr<StackFrameList> &curr_ap, } StackFrameSP prev_frame_zero_sp(prev_sp->GetFrameAtIndex(0)); - StackFrameSP curr_frame_zero_sp(curr_ap->GetFrameAtIndex(0)); + StackFrameSP curr_frame_zero_sp(curr_up->GetFrameAtIndex(0)); StackID curr_stack_id(curr_frame_zero_sp->GetStackID()); StackID prev_stack_id(prev_frame_zero_sp->GetStackID()); @@ -910,7 +910,7 @@ void StackFrameList::Merge(std::unique_ptr<StackFrameList> &curr_ap, prev_sp->m_frames.insert(prev_sp->m_frames.begin(), curr_frame_zero_sp); } - curr_ap.release(); + curr_up.release(); #if defined(DEBUG_STACK_FRAMES) s.PutCString("\nMerged:\n"); diff --git a/source/Target/SystemRuntime.cpp b/source/Target/SystemRuntime.cpp index 2006ba584..e53816acb 100644 --- a/source/Target/SystemRuntime.cpp +++ b/source/Target/SystemRuntime.cpp @@ -20,9 +20,9 @@ SystemRuntime *SystemRuntime::FindPlugin(Process *process) { (create_callback = PluginManager::GetSystemRuntimeCreateCallbackAtIndex( idx)) != nullptr; ++idx) { - std::unique_ptr<SystemRuntime> instance_ap(create_callback(process)); - if (instance_ap) - return instance_ap.release(); + std::unique_ptr<SystemRuntime> instance_up(create_callback(process)); + if (instance_up) + return instance_up.release(); } return nullptr; } diff --git a/source/Target/Target.cpp b/source/Target/Target.cpp index cf9f454c1..f581f073c 100644 --- a/source/Target/Target.cpp +++ b/source/Target/Target.cpp @@ -91,7 +91,7 @@ Target::Target(Debugger &debugger, const ArchSpec &target_arch, m_breakpoint_list(false), m_internal_breakpoint_list(true), m_watchpoint_list(), m_process_sp(), m_search_filter_sp(), m_image_search_paths(ImageSearchPathsChanged, this), m_ast_importer_sp(), - m_source_manager_ap(), m_stop_hooks(), m_stop_hook_next_id(0), + m_source_manager_up(), m_stop_hooks(), m_stop_hook_next_id(0), m_valid(true), m_suppress_stop_hooks(false), m_is_dummy_target(is_dummy_target), m_stats_storage(static_cast<int>(StatisticKind::StatisticMax)) @@ -2468,9 +2468,9 @@ lldb::addr_t Target::GetBreakableLoadAddress(lldb::addr_t addr) { } SourceManager &Target::GetSourceManager() { - if (!m_source_manager_ap) - m_source_manager_ap.reset(new SourceManager(shared_from_this())); - return *m_source_manager_ap; + if (!m_source_manager_up) + m_source_manager_up.reset(new SourceManager(shared_from_this())); + return *m_source_manager_up; } ClangModulesDeclVendor *Target::GetClangModulesDeclVendor() { @@ -2481,13 +2481,13 @@ ClangModulesDeclVendor *Target::GetClangModulesDeclVendor() { { std::lock_guard<std::mutex> guard(s_clang_modules_decl_vendor_mutex); - if (!m_clang_modules_decl_vendor_ap) { - m_clang_modules_decl_vendor_ap.reset( + if (!m_clang_modules_decl_vendor_up) { + m_clang_modules_decl_vendor_up.reset( ClangModulesDeclVendor::Create(*this)); } } - return m_clang_modules_decl_vendor_ap.get(); + return m_clang_modules_decl_vendor_up.get(); } Target::StopHookSP Target::CreateStopHook() { @@ -3143,14 +3143,14 @@ void Target::FinalizeFileActions(ProcessLaunchInfo &info) { //-------------------------------------------------------------- Target::StopHook::StopHook(lldb::TargetSP target_sp, lldb::user_id_t uid) : UserID(uid), m_target_sp(target_sp), m_commands(), m_specifier_sp(), - m_thread_spec_ap(), m_active(true) {} + m_thread_spec_up(), m_active(true) {} Target::StopHook::StopHook(const StopHook &rhs) : UserID(rhs.GetID()), m_target_sp(rhs.m_target_sp), m_commands(rhs.m_commands), m_specifier_sp(rhs.m_specifier_sp), - m_thread_spec_ap(), m_active(rhs.m_active) { - if (rhs.m_thread_spec_ap) - m_thread_spec_ap.reset(new ThreadSpec(*rhs.m_thread_spec_ap)); + m_thread_spec_up(), m_active(rhs.m_active) { + if (rhs.m_thread_spec_up) + m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up)); } Target::StopHook::~StopHook() = default; @@ -3160,7 +3160,7 @@ void Target::StopHook::SetSpecifier(SymbolContextSpecifier *specifier) { } void Target::StopHook::SetThreadSpecifier(ThreadSpec *specifier) { - m_thread_spec_ap.reset(specifier); + m_thread_spec_up.reset(specifier); } void Target::StopHook::GetDescription(Stream *s, @@ -3183,10 +3183,10 @@ void Target::StopHook::GetDescription(Stream *s, s->SetIndentLevel(indent_level + 2); } - if (m_thread_spec_ap) { + if (m_thread_spec_up) { StreamString tmp; s->Indent("Thread:\n"); - m_thread_spec_ap->GetDescription(&tmp, level); + m_thread_spec_up->GetDescription(&tmp, level); s->SetIndentLevel(indent_level + 4); s->Indent(tmp.GetString()); s->PutCString("\n"); diff --git a/source/Target/Thread.cpp b/source/Target/Thread.cpp index 2bb358235..82564f7c5 100644 --- a/source/Target/Thread.cpp +++ b/source/Target/Thread.cpp @@ -256,7 +256,7 @@ Thread::Thread(Process &process, lldb::tid_t tid, bool use_invalid_index_id) m_curr_frames_sp(), m_prev_frames_sp(), m_resume_signal(LLDB_INVALID_SIGNAL_NUMBER), m_resume_state(eStateRunning), m_temporary_resume_state(eStateRunning), - m_unwinder_ap(), m_destroy_called(false), + m_unwinder_up(), m_destroy_called(false), m_override_should_notify(eLazyBoolCalculate), m_extended_info_fetched(false), m_extended_info() { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT)); @@ -306,7 +306,7 @@ void Thread::DestroyThread() { m_stop_info_sp.reset(); m_reg_context_sp.reset(); - m_unwinder_ap.reset(); + m_unwinder_up.reset(); std::lock_guard<std::recursive_mutex> guard(m_frame_mutex); m_curr_frames_sp.reset(); m_prev_frames_sp.reset(); @@ -562,8 +562,8 @@ bool Thread::RestoreRegisterStateFromCheckpoint( // Clear out all stack frames as our world just changed. ClearStackFrames(); reg_ctx_sp->InvalidateIfNeeded(true); - if (m_unwinder_ap) - m_unwinder_ap->Clear(); + if (m_unwinder_up) + m_unwinder_up->Clear(); return ret; } } @@ -2054,7 +2054,7 @@ size_t Thread::GetStackFrameStatus(Stream &strm, uint32_t first_frame, } Unwind *Thread::GetUnwinder() { - if (!m_unwinder_ap) { + if (!m_unwinder_up) { const ArchSpec target_arch(CalculateTarget()->GetArchitecture()); const llvm::Triple::ArchType machine = target_arch.GetMachine(); switch (machine) { @@ -2072,16 +2072,16 @@ Unwind *Thread::GetUnwinder() { case llvm::Triple::ppc64le: case llvm::Triple::systemz: case llvm::Triple::hexagon: - m_unwinder_ap.reset(new UnwindLLDB(*this)); + m_unwinder_up.reset(new UnwindLLDB(*this)); break; default: if (target_arch.GetTriple().getVendor() == llvm::Triple::Apple) - m_unwinder_ap.reset(new UnwindMacOSXFrameBackchain(*this)); + m_unwinder_up.reset(new UnwindMacOSXFrameBackchain(*this)); break; } } - return m_unwinder_ap.get(); + return m_unwinder_up.get(); } void Thread::Flush() { diff --git a/source/Target/ThreadPlanStepInRange.cpp b/source/Target/ThreadPlanStepInRange.cpp index 98387b9aa..6e8fc9841 100644 --- a/source/Target/ThreadPlanStepInRange.cpp +++ b/source/Target/ThreadPlanStepInRange.cpp @@ -314,10 +314,10 @@ bool ThreadPlanStepInRange::ShouldStop(Event *event_ptr) { void ThreadPlanStepInRange::SetAvoidRegexp(const char *name) { auto name_ref = llvm::StringRef::withNullAsEmpty(name); - if (!m_avoid_regexp_ap) - m_avoid_regexp_ap.reset(new RegularExpression(name_ref)); + if (!m_avoid_regexp_up) + m_avoid_regexp_up.reset(new RegularExpression(name_ref)); - m_avoid_regexp_ap->Compile(name_ref); + m_avoid_regexp_up->Compile(name_ref); } void ThreadPlanStepInRange::SetDefaultFlagValue(uint32_t new_value) { @@ -350,7 +350,7 @@ bool ThreadPlanStepInRange::FrameMatchesAvoidCriteria() { if (libraries_say_avoid) return true; - const RegularExpression *avoid_regexp_to_use = m_avoid_regexp_ap.get(); + const RegularExpression *avoid_regexp_to_use = m_avoid_regexp_up.get(); if (avoid_regexp_to_use == nullptr) avoid_regexp_to_use = GetThread().GetSymbolsToAvoidRegexp(); diff --git a/source/Target/UnwindAssembly.cpp b/source/Target/UnwindAssembly.cpp index 869cf8486..d3d806868 100644 --- a/source/Target/UnwindAssembly.cpp +++ b/source/Target/UnwindAssembly.cpp @@ -21,9 +21,9 @@ UnwindAssemblySP UnwindAssembly::FindPlugin(const ArchSpec &arch) { (create_callback = PluginManager::GetUnwindAssemblyCreateCallbackAtIndex( idx)) != nullptr; ++idx) { - UnwindAssemblySP assembly_profiler_ap(create_callback(arch)); - if (assembly_profiler_ap) - return assembly_profiler_ap; + UnwindAssemblySP assembly_profiler_up(create_callback(arch)); + if (assembly_profiler_up) + return assembly_profiler_up; } return nullptr; } |