aboutsummaryrefslogtreecommitdiffstats
path: root/source/Core
diff options
context:
space:
mode:
authorDimitry Andric <dim@FreeBSD.org>2019-01-19 10:06:29 +0000
committerDimitry Andric <dim@FreeBSD.org>2019-01-19 10:06:29 +0000
commit94994d372d014ce4c8758b9605d63fae651bd8aa (patch)
tree51c0b708bd59f205d6b35cb2a8c24d62f0c33d77 /source/Core
parent39be7ce23363d12ae3e49aeb1fdb2bfeb892e836 (diff)
downloadsrc-94994d372d014ce4c8758b9605d63fae651bd8aa.tar.gz
src-94994d372d014ce4c8758b9605d63fae651bd8aa.zip
Vendor import of lldb trunk r351319 (just before the release_80 branchvendor/lldb/lldb-trunk-r351319
Notes
Notes: svn path=/vendor/lldb/dist/; revision=343181 svn path=/vendor/lldb/lldb-trunk-r351319/; revision=343182; tag=vendor/lldb/lldb-trunk-r351319
Diffstat (limited to 'source/Core')
-rw-r--r--source/Core/Address.cpp59
-rw-r--r--source/Core/AddressRange.cpp12
-rw-r--r--source/Core/AddressResolverFileLine.cpp24
-rw-r--r--source/Core/AddressResolverName.cpp28
-rw-r--r--source/Core/Broadcaster.cpp479
-rw-r--r--source/Core/CMakeLists.txt12
-rw-r--r--source/Core/Communication.cpp28
-rw-r--r--source/Core/Debugger.cpp224
-rw-r--r--source/Core/Disassembler.cpp56
-rw-r--r--source/Core/DumpDataExtractor.cpp34
-rw-r--r--source/Core/DumpRegisterValue.cpp2
-rw-r--r--source/Core/DynamicLoader.cpp24
-rw-r--r--source/Core/EmulateInstruction.cpp20
-rw-r--r--source/Core/Event.cpp301
-rw-r--r--source/Core/FileLineResolver.cpp13
-rw-r--r--source/Core/FileSpecList.cpp6
-rw-r--r--source/Core/FormatEntity.cpp75
-rw-r--r--source/Core/Highlighter.cpp81
-rw-r--r--source/Core/IOHandler.cpp88
-rw-r--r--source/Core/Listener.cpp470
-rw-r--r--source/Core/Mangled.cpp186
-rw-r--r--source/Core/Module.cpp196
-rw-r--r--source/Core/ModuleList.cpp108
-rw-r--r--source/Core/Opcode.cpp33
-rw-r--r--source/Core/PluginManager.cpp62
-rw-r--r--source/Core/RegisterValue.cpp905
-rw-r--r--source/Core/RichManglingContext.cpp175
-rw-r--r--source/Core/Scalar.cpp2852
-rw-r--r--source/Core/SearchFilter.cpp119
-rw-r--r--source/Core/Section.cpp28
-rw-r--r--source/Core/SourceManager.cpp177
-rw-r--r--source/Core/State.cpp115
-rw-r--r--source/Core/StreamAsynchronousIO.cpp4
-rw-r--r--source/Core/StreamFile.cpp19
-rw-r--r--source/Core/UserSettingsController.cpp2
-rw-r--r--source/Core/Value.cpp62
-rw-r--r--source/Core/ValueObject.cpp153
-rw-r--r--source/Core/ValueObjectCast.cpp8
-rw-r--r--source/Core/ValueObjectChild.cpp36
-rw-r--r--source/Core/ValueObjectConstResult.cpp20
-rw-r--r--source/Core/ValueObjectConstResultChild.cpp7
-rw-r--r--source/Core/ValueObjectConstResultImpl.cpp24
-rw-r--r--source/Core/ValueObjectDynamicValue.cpp15
-rw-r--r--source/Core/ValueObjectList.cpp8
-rw-r--r--source/Core/ValueObjectMemory.cpp22
-rw-r--r--source/Core/ValueObjectRegister.cpp23
-rw-r--r--source/Core/ValueObjectSyntheticFilter.cpp16
-rw-r--r--source/Core/ValueObjectVariable.cpp31
48 files changed, 1372 insertions, 6070 deletions
diff --git a/source/Core/Address.cpp b/source/Core/Address.cpp
index f183245f7d36..a4dc364b701b 100644
--- a/source/Core/Address.cpp
+++ b/source/Core/Address.cpp
@@ -10,43 +10,43 @@
#include "lldb/Core/Address.h"
#include "lldb/Core/DumpDataExtractor.h"
#include "lldb/Core/Module.h"
-#include "lldb/Core/ModuleList.h" // for ModuleList
+#include "lldb/Core/ModuleList.h"
#include "lldb/Core/Section.h"
#include "lldb/Symbol/Block.h"
-#include "lldb/Symbol/Declaration.h" // for Declaration
-#include "lldb/Symbol/LineEntry.h" // for LineEntry
+#include "lldb/Symbol/Declaration.h"
+#include "lldb/Symbol/LineEntry.h"
#include "lldb/Symbol/ObjectFile.h"
-#include "lldb/Symbol/Symbol.h" // for Symbol
-#include "lldb/Symbol/SymbolContext.h" // for SymbolContext
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/SymbolVendor.h"
-#include "lldb/Symbol/Symtab.h" // for Symtab
-#include "lldb/Symbol/Type.h" // for Type
+#include "lldb/Symbol/Symtab.h"
+#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/ExecutionContextScope.h" // for ExecutionContextScope
+#include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/Utility/DataExtractor.h" // for DataExtractor
-#include "lldb/Utility/Endian.h" // for InlHostByteOrder
-#include "lldb/Utility/FileSpec.h" // for FileSpec
-#include "lldb/Utility/Status.h" // for Status
-#include "lldb/Utility/Stream.h" // for Stream
-#include "lldb/Utility/StreamString.h" // for StreamString
-
-#include "llvm/ADT/StringRef.h" // for StringRef
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Endian.h"
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StreamString.h"
+
+#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Triple.h"
-#include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH
+#include "llvm/Support/Compiler.h"
-#include <cstdint> // for uint8_t, uint32_t
-#include <memory> // for shared_ptr, operator!=
-#include <vector> // for vector
+#include <cstdint>
+#include <memory>
+#include <vector>
-#include <assert.h> // for assert
-#include <inttypes.h> // for PRIu64, PRIx64
-#include <string.h> // for size_t, strlen
+#include <assert.h>
+#include <inttypes.h>
+#include <string.h>
namespace lldb_private {
class CompileUnit;
@@ -779,8 +779,9 @@ bool Address::SectionWasDeletedPrivate() const {
m_section_wp.owner_before(empty_section_wp);
}
-uint32_t Address::CalculateSymbolContext(SymbolContext *sc,
- uint32_t resolve_scope) const {
+uint32_t
+Address::CalculateSymbolContext(SymbolContext *sc,
+ SymbolContextItem resolve_scope) const {
sc->Clear(false);
// Absolute addresses don't have enough information to reconstruct even their
// target.
@@ -987,8 +988,10 @@ AddressClass Address::GetAddressClass() const {
if (module_sp) {
ObjectFile *obj_file = module_sp->GetObjectFile();
if (obj_file) {
- // Give the symbol vendor a chance to add to the unified section list.
- module_sp->GetSymbolVendor();
+ // Give the symbol vendor a chance to add to the unified section list
+ // and to symtab from symbol file
+ if (SymbolVendor *vendor = module_sp->GetSymbolVendor())
+ vendor->GetSymtab();
return obj_file->GetAddressClass(GetFileAddress());
}
}
diff --git a/source/Core/AddressRange.cpp b/source/Core/AddressRange.cpp
index e125b693d6f6..1afe4fa223db 100644
--- a/source/Core/AddressRange.cpp
+++ b/source/Core/AddressRange.cpp
@@ -10,16 +10,16 @@
#include "lldb/Core/AddressRange.h"
#include "lldb/Core/Module.h"
#include "lldb/Target/Target.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/Utility/FileSpec.h" // for FileSpec
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Stream.h"
-#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
+#include "lldb/lldb-defines.h"
-#include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH
+#include "llvm/Support/Compiler.h"
-#include <memory> // for shared_ptr
+#include <memory>
-#include <inttypes.h> // for PRIx64
+#include <inttypes.h>
namespace lldb_private {
class SectionList;
diff --git a/source/Core/AddressResolverFileLine.cpp b/source/Core/AddressResolverFileLine.cpp
index 798a9b50079e..203ab2787fe3 100644
--- a/source/Core/AddressResolverFileLine.cpp
+++ b/source/Core/AddressResolverFileLine.cpp
@@ -9,21 +9,21 @@
#include "lldb/Core/AddressResolverFileLine.h"
-#include "lldb/Core/Address.h" // for Address
-#include "lldb/Core/AddressRange.h" // for AddressRange
+#include "lldb/Core/Address.h"
+#include "lldb/Core/AddressRange.h"
#include "lldb/Symbol/CompileUnit.h"
-#include "lldb/Symbol/LineEntry.h" // for LineEntry
+#include "lldb/Symbol/LineEntry.h"
#include "lldb/Symbol/SymbolContext.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
+#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Log.h"
-#include "lldb/Utility/Logging.h" // for GetLogIfAllCategoriesSet, LIB...
-#include "lldb/Utility/Stream.h" // for Stream
+#include "lldb/Utility/Logging.h"
+#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
-#include "lldb/lldb-enumerations.h" // for SymbolContextItem::eSymbolCon...
-#include "lldb/lldb-types.h" // for addr_t
+#include "lldb/lldb-enumerations.h"
+#include "lldb/lldb-types.h"
-#include <inttypes.h> // for PRIx64
-#include <vector> // for vector
+#include <inttypes.h>
+#include <vector>
using namespace lldb;
using namespace lldb_private;
@@ -78,8 +78,8 @@ AddressResolverFileLine::SearchCallback(SearchFilter &filter,
return Searcher::eCallbackReturnContinue;
}
-Searcher::Depth AddressResolverFileLine::GetDepth() {
- return Searcher::eDepthCompUnit;
+lldb::SearchDepth AddressResolverFileLine::GetDepth() {
+ return lldb::eSearchDepthCompUnit;
}
void AddressResolverFileLine::GetDescription(Stream *s) {
diff --git a/source/Core/AddressResolverName.cpp b/source/Core/AddressResolverName.cpp
index c3dab6d10810..7683e391e0cf 100644
--- a/source/Core/AddressResolverName.cpp
+++ b/source/Core/AddressResolverName.cpp
@@ -9,25 +9,25 @@
#include "lldb/Core/AddressResolverName.h"
-#include "lldb/Core/Address.h" // for Address, operator==
-#include "lldb/Core/AddressRange.h" // for AddressRange
+#include "lldb/Core/Address.h"
+#include "lldb/Core/AddressRange.h"
#include "lldb/Core/Module.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/Log.h"
-#include "lldb/Utility/Logging.h" // for GetLogIfAllCategoriesSet, LIB...
-#include "lldb/Utility/Stream.h" // for Stream
-#include "lldb/lldb-enumerations.h" // for SymbolType::eSymbolTypeCode
-#include "lldb/lldb-forward.h" // for ModuleSP
-#include "lldb/lldb-types.h" // for addr_t
-#include "llvm/ADT/StringRef.h" // for StringRef
+#include "lldb/Utility/Logging.h"
+#include "lldb/Utility/Stream.h"
+#include "lldb/lldb-enumerations.h"
+#include "lldb/lldb-forward.h"
+#include "lldb/lldb-types.h"
+#include "llvm/ADT/StringRef.h"
-#include <memory> // for shared_ptr
-#include <string> // for string
-#include <vector> // for vector
+#include <memory>
+#include <string>
+#include <vector>
-#include <stdint.h> // for uint32_t
+#include <stdint.h>
using namespace lldb;
using namespace lldb_private;
@@ -186,8 +186,8 @@ AddressResolverName::SearchCallback(SearchFilter &filter,
return Searcher::eCallbackReturnContinue;
}
-Searcher::Depth AddressResolverName::GetDepth() {
- return Searcher::eDepthModule;
+lldb::SearchDepth AddressResolverName::GetDepth() {
+ return lldb::eSearchDepthModule;
}
void AddressResolverName::GetDescription(Stream *s) {
diff --git a/source/Core/Broadcaster.cpp b/source/Core/Broadcaster.cpp
deleted file mode 100644
index 198434b46c29..000000000000
--- a/source/Core/Broadcaster.cpp
+++ /dev/null
@@ -1,479 +0,0 @@
-//===-- Broadcaster.cpp -----------------------------------------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Core/Broadcaster.h"
-
-#include "lldb/Core/Event.h"
-#include "lldb/Core/Listener.h"
-#include "lldb/Utility/Log.h"
-#include "lldb/Utility/Logging.h" // for GetLogIfAnyCategoriesSet, Get...
-#include "lldb/Utility/Stream.h" // for Stream
-#include "lldb/Utility/StreamString.h"
-
-#include <algorithm> // for find_if
-#include <memory> // for make_shared
-#include <type_traits> // for move
-
-#include <assert.h> // for assert
-#include <stddef.h> // for size_t
-
-using namespace lldb;
-using namespace lldb_private;
-
-Broadcaster::Broadcaster(BroadcasterManagerSP manager_sp, const char *name)
- : m_broadcaster_sp(std::make_shared<BroadcasterImpl>(*this)),
- m_manager_sp(manager_sp), m_broadcaster_name(name) {
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
- if (log)
- log->Printf("%p Broadcaster::Broadcaster(\"%s\")",
- static_cast<void *>(this), GetBroadcasterName().AsCString());
-}
-
-Broadcaster::BroadcasterImpl::BroadcasterImpl(Broadcaster &broadcaster)
- : m_broadcaster(broadcaster), m_listeners(), m_listeners_mutex(),
- m_hijacking_listeners(), m_hijacking_masks() {}
-
-Broadcaster::~Broadcaster() {
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
- if (log)
- log->Printf("%p Broadcaster::~Broadcaster(\"%s\")",
- static_cast<void *>(this), m_broadcaster_name.AsCString());
-
- Clear();
-}
-
-void Broadcaster::CheckInWithManager() {
- if (m_manager_sp) {
- m_manager_sp->SignUpListenersForBroadcaster(*this);
- }
-}
-
-llvm::SmallVector<std::pair<ListenerSP, uint32_t &>, 4>
-Broadcaster::BroadcasterImpl::GetListeners() {
- llvm::SmallVector<std::pair<ListenerSP, uint32_t &>, 4> listeners;
- listeners.reserve(m_listeners.size());
-
- for (auto it = m_listeners.begin(); it != m_listeners.end();) {
- lldb::ListenerSP curr_listener_sp(it->first.lock());
- if (curr_listener_sp && it->second) {
- listeners.emplace_back(std::move(curr_listener_sp), it->second);
- ++it;
- } else
- it = m_listeners.erase(it);
- }
-
- return listeners;
-}
-
-void Broadcaster::BroadcasterImpl::Clear() {
- std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
-
- // Make sure the listener forgets about this broadcaster. We do this in the
- // broadcaster in case the broadcaster object initiates the removal.
- for (auto &pair : GetListeners())
- pair.first->BroadcasterWillDestruct(&m_broadcaster);
-
- m_listeners.clear();
-}
-
-Broadcaster *Broadcaster::BroadcasterImpl::GetBroadcaster() {
- return &m_broadcaster;
-}
-
-bool Broadcaster::BroadcasterImpl::GetEventNames(
- Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const {
- uint32_t num_names_added = 0;
- if (event_mask && !m_event_names.empty()) {
- event_names_map::const_iterator end = m_event_names.end();
- for (uint32_t bit = 1u, mask = event_mask; mask != 0 && bit != 0;
- bit <<= 1, mask >>= 1) {
- if (mask & 1) {
- event_names_map::const_iterator pos = m_event_names.find(bit);
- if (pos != end) {
- if (num_names_added > 0)
- s.PutCString(", ");
-
- if (prefix_with_broadcaster_name) {
- s.PutCString(GetBroadcasterName());
- s.PutChar('.');
- }
- s.PutCString(pos->second);
- ++num_names_added;
- }
- }
- }
- }
- return num_names_added > 0;
-}
-
-void Broadcaster::AddInitialEventsToListener(
- const lldb::ListenerSP &listener_sp, uint32_t requested_events) {}
-
-uint32_t
-Broadcaster::BroadcasterImpl::AddListener(const lldb::ListenerSP &listener_sp,
- uint32_t event_mask) {
- if (!listener_sp)
- return 0;
-
- std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
-
- // See if we already have this listener, and if so, update its mask
-
- bool handled = false;
-
- for (auto &pair : GetListeners()) {
- if (pair.first == listener_sp) {
- handled = true;
- pair.second |= event_mask;
- m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
- break;
- }
- }
-
- if (!handled) {
- // Grant a new listener the available event bits
- m_listeners.push_back(
- std::make_pair(lldb::ListenerWP(listener_sp), event_mask));
-
- // Individual broadcasters decide whether they have outstanding data when a
- // listener attaches, and insert it into the listener with this method.
- m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
- }
-
- // Return the event bits that were granted to the listener
- return event_mask;
-}
-
-bool Broadcaster::BroadcasterImpl::EventTypeHasListeners(uint32_t event_type) {
- std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
-
- if (!m_hijacking_listeners.empty() && event_type & m_hijacking_masks.back())
- return true;
-
- for (auto &pair : GetListeners()) {
- if (pair.second & event_type)
- return true;
- }
- return false;
-}
-
-bool Broadcaster::BroadcasterImpl::RemoveListener(
- lldb_private::Listener *listener, uint32_t event_mask) {
- if (!listener)
- return false;
-
- std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
- for (auto &pair : GetListeners()) {
- if (pair.first.get() == listener) {
- pair.second &= ~event_mask;
- return true;
- }
- }
- return false;
-}
-
-bool Broadcaster::BroadcasterImpl::RemoveListener(
- const lldb::ListenerSP &listener_sp, uint32_t event_mask) {
- return RemoveListener(listener_sp.get(), event_mask);
-}
-
-void Broadcaster::BroadcasterImpl::BroadcastEvent(EventSP &event_sp) {
- return PrivateBroadcastEvent(event_sp, false);
-}
-
-void Broadcaster::BroadcasterImpl::BroadcastEventIfUnique(EventSP &event_sp) {
- return PrivateBroadcastEvent(event_sp, true);
-}
-
-void Broadcaster::BroadcasterImpl::PrivateBroadcastEvent(EventSP &event_sp,
- bool unique) {
- // Can't add a nullptr event...
- if (!event_sp)
- return;
-
- // Update the broadcaster on this event
- event_sp->SetBroadcaster(&m_broadcaster);
-
- const uint32_t event_type = event_sp->GetType();
-
- std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
-
- ListenerSP hijacking_listener_sp;
-
- if (!m_hijacking_listeners.empty()) {
- assert(!m_hijacking_masks.empty());
- hijacking_listener_sp = m_hijacking_listeners.back();
- if ((event_type & m_hijacking_masks.back()) == 0)
- hijacking_listener_sp.reset();
- }
-
- Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS));
- if (log) {
- StreamString event_description;
- event_sp->Dump(&event_description);
- log->Printf("%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, "
- "unique =%i) hijack = %p",
- static_cast<void *>(this), GetBroadcasterName(),
- event_description.GetData(), unique,
- static_cast<void *>(hijacking_listener_sp.get()));
- }
-
- if (hijacking_listener_sp) {
- if (unique &&
- hijacking_listener_sp->PeekAtNextEventForBroadcasterWithType(
- &m_broadcaster, event_type))
- return;
- hijacking_listener_sp->AddEvent(event_sp);
- } else {
- for (auto &pair : GetListeners()) {
- if (!(pair.second & event_type))
- continue;
- if (unique &&
- pair.first->PeekAtNextEventForBroadcasterWithType(&m_broadcaster,
- event_type))
- continue;
-
- pair.first->AddEvent(event_sp);
- }
- }
-}
-
-void Broadcaster::BroadcasterImpl::BroadcastEvent(uint32_t event_type,
- EventData *event_data) {
- auto event_sp = std::make_shared<Event>(event_type, event_data);
- PrivateBroadcastEvent(event_sp, false);
-}
-
-void Broadcaster::BroadcasterImpl::BroadcastEvent(
- uint32_t event_type, const lldb::EventDataSP &event_data_sp) {
- auto event_sp = std::make_shared<Event>(event_type, event_data_sp);
- PrivateBroadcastEvent(event_sp, false);
-}
-
-void Broadcaster::BroadcasterImpl::BroadcastEventIfUnique(
- uint32_t event_type, EventData *event_data) {
- auto event_sp = std::make_shared<Event>(event_type, event_data);
- PrivateBroadcastEvent(event_sp, true);
-}
-
-bool Broadcaster::BroadcasterImpl::HijackBroadcaster(
- const lldb::ListenerSP &listener_sp, uint32_t event_mask) {
- std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
-
- Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS));
- if (log)
- log->Printf(
- "%p Broadcaster(\"%s\")::HijackBroadcaster (listener(\"%s\")=%p)",
- static_cast<void *>(this), GetBroadcasterName(),
- listener_sp->m_name.c_str(), static_cast<void *>(listener_sp.get()));
- m_hijacking_listeners.push_back(listener_sp);
- m_hijacking_masks.push_back(event_mask);
- return true;
-}
-
-bool Broadcaster::BroadcasterImpl::IsHijackedForEvent(uint32_t event_mask) {
- std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
-
- if (!m_hijacking_listeners.empty())
- return (event_mask & m_hijacking_masks.back()) != 0;
- return false;
-}
-
-const char *Broadcaster::BroadcasterImpl::GetHijackingListenerName() {
- if (m_hijacking_listeners.size()) {
- return m_hijacking_listeners.back()->GetName();
- } else {
- return nullptr;
- }
-}
-
-void Broadcaster::BroadcasterImpl::RestoreBroadcaster() {
- std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
-
- if (!m_hijacking_listeners.empty()) {
- Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS));
- if (log) {
- ListenerSP listener_sp = m_hijacking_listeners.back();
- log->Printf("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop "
- "listener(\"%s\")=%p)",
- static_cast<void *>(this), GetBroadcasterName(),
- listener_sp->m_name.c_str(),
- static_cast<void *>(listener_sp.get()));
- }
- m_hijacking_listeners.pop_back();
- }
- if (!m_hijacking_masks.empty())
- m_hijacking_masks.pop_back();
-}
-
-ConstString &Broadcaster::GetBroadcasterClass() const {
- static ConstString class_name("lldb.anonymous");
- return class_name;
-}
-
-BroadcastEventSpec::BroadcastEventSpec(const BroadcastEventSpec &rhs) = default;
-
-bool BroadcastEventSpec::operator<(const BroadcastEventSpec &rhs) const {
- if (GetBroadcasterClass() == rhs.GetBroadcasterClass()) {
- return GetEventBits() < rhs.GetEventBits();
- } else {
- return GetBroadcasterClass() < rhs.GetBroadcasterClass();
- }
-}
-
-BroadcastEventSpec &BroadcastEventSpec::
-operator=(const BroadcastEventSpec &rhs) = default;
-
-BroadcasterManager::BroadcasterManager() : m_manager_mutex() {}
-
-lldb::BroadcasterManagerSP BroadcasterManager::MakeBroadcasterManager() {
- return lldb::BroadcasterManagerSP(new BroadcasterManager());
-}
-
-uint32_t BroadcasterManager::RegisterListenerForEvents(
- const lldb::ListenerSP &listener_sp, BroadcastEventSpec event_spec) {
- std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
-
- collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
- uint32_t available_bits = event_spec.GetEventBits();
-
- while (iter != end_iter &&
- (iter = find_if(iter, end_iter,
- BroadcasterClassMatches(
- event_spec.GetBroadcasterClass()))) != end_iter) {
- available_bits &= ~((*iter).first.GetEventBits());
- iter++;
- }
-
- if (available_bits != 0) {
- m_event_map.insert(event_listener_key(
- BroadcastEventSpec(event_spec.GetBroadcasterClass(), available_bits),
- listener_sp));
- m_listeners.insert(listener_sp);
- }
-
- return available_bits;
-}
-
-bool BroadcasterManager::UnregisterListenerForEvents(
- const lldb::ListenerSP &listener_sp, BroadcastEventSpec event_spec) {
- std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
- bool removed_some = false;
-
- if (m_listeners.erase(listener_sp) == 0)
- return false;
-
- ListenerMatchesAndSharedBits predicate(event_spec, listener_sp);
- std::vector<BroadcastEventSpec> to_be_readded;
- uint32_t event_bits_to_remove = event_spec.GetEventBits();
-
- // Go through the map and delete the exact matches, and build a list of
- // matches that weren't exact to re-add:
- while (true) {
- collection::iterator iter, end_iter = m_event_map.end();
- iter = find_if(m_event_map.begin(), end_iter, predicate);
- if (iter == end_iter) {
- break;
- } else {
- uint32_t iter_event_bits = (*iter).first.GetEventBits();
- removed_some = true;
-
- if (event_bits_to_remove != iter_event_bits) {
- uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
- to_be_readded.push_back(BroadcastEventSpec(
- event_spec.GetBroadcasterClass(), new_event_bits));
- }
- m_event_map.erase(iter);
- }
- }
-
- // Okay now add back the bits that weren't completely removed:
- for (size_t i = 0; i < to_be_readded.size(); i++) {
- m_event_map.insert(event_listener_key(to_be_readded[i], listener_sp));
- }
-
- return removed_some;
-}
-
-ListenerSP BroadcasterManager::GetListenerForEventSpec(
- BroadcastEventSpec event_spec) const {
- std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
-
- collection::const_iterator iter, end_iter = m_event_map.end();
- iter = find_if(m_event_map.begin(), end_iter,
- BroadcastEventSpecMatches(event_spec));
- if (iter != end_iter)
- return (*iter).second;
- else
- return nullptr;
-}
-
-void BroadcasterManager::RemoveListener(Listener *listener) {
- std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
- ListenerMatchesPointer predicate(listener);
- listener_collection::iterator iter = m_listeners.begin(),
- end_iter = m_listeners.end();
-
- std::find_if(iter, end_iter, predicate);
- if (iter != end_iter)
- m_listeners.erase(iter);
-
- while (true) {
- collection::iterator iter, end_iter = m_event_map.end();
- iter = find_if(m_event_map.begin(), end_iter, predicate);
- if (iter == end_iter)
- break;
- else
- m_event_map.erase(iter);
- }
-}
-
-void BroadcasterManager::RemoveListener(const lldb::ListenerSP &listener_sp) {
- std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
- ListenerMatches predicate(listener_sp);
-
- if (m_listeners.erase(listener_sp) == 0)
- return;
-
- while (true) {
- collection::iterator iter, end_iter = m_event_map.end();
- iter = find_if(m_event_map.begin(), end_iter, predicate);
- if (iter == end_iter)
- break;
- else
- m_event_map.erase(iter);
- }
-}
-
-void BroadcasterManager::SignUpListenersForBroadcaster(
- Broadcaster &broadcaster) {
- std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
-
- collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
-
- while (iter != end_iter &&
- (iter = find_if(iter, end_iter,
- BroadcasterClassMatches(
- broadcaster.GetBroadcasterClass()))) != end_iter) {
- (*iter).second->StartListeningForEvents(&broadcaster,
- (*iter).first.GetEventBits());
- iter++;
- }
-}
-
-void BroadcasterManager::Clear() {
- std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
- listener_collection::iterator end_iter = m_listeners.end();
-
- for (listener_collection::iterator iter = m_listeners.begin();
- iter != end_iter; iter++)
- (*iter)->BroadcasterManagerWillDestruct(this->shared_from_this());
- m_listeners.clear();
- m_event_map.clear();
-}
diff --git a/source/Core/CMakeLists.txt b/source/Core/CMakeLists.txt
index 927a0dcc2ec1..15f2dcf6ed99 100644
--- a/source/Core/CMakeLists.txt
+++ b/source/Core/CMakeLists.txt
@@ -13,7 +13,6 @@ add_lldb_library(lldbCore
AddressResolver.cpp
AddressResolverFileLine.cpp
AddressResolverName.cpp
- Broadcaster.cpp
Communication.cpp
Debugger.cpp
Disassembler.cpp
@@ -21,24 +20,21 @@ add_lldb_library(lldbCore
DumpRegisterValue.cpp
DynamicLoader.cpp
EmulateInstruction.cpp
- Event.cpp
FileLineResolver.cpp
FileSpecList.cpp
FormatEntity.cpp
+ Highlighter.cpp
IOHandler.cpp
- Listener.cpp
Mangled.cpp
Module.cpp
ModuleChild.cpp
ModuleList.cpp
Opcode.cpp
PluginManager.cpp
- RegisterValue.cpp
- Scalar.cpp
+ RichManglingContext.cpp
SearchFilter.cpp
Section.cpp
SourceManager.cpp
- State.cpp
StreamAsynchronousIO.cpp
StreamFile.cpp
UserSettingsController.cpp
@@ -81,3 +77,7 @@ add_lldb_library(lldbCore
# Needed to properly resolve references in a debug build.
# TODO: Remove once we have better layering
set_target_properties(lldbCore PROPERTIES LINK_INTERFACE_MULTIPLICITY 4)
+
+if (NOT LLDB_DISABLE_LIBEDIT)
+ target_include_directories(lldbCore PRIVATE ${libedit_INCLUDE_DIRS})
+endif()
diff --git a/source/Core/Communication.cpp b/source/Core/Communication.cpp
index 5ca338639de0..afdabc0c7ce5 100644
--- a/source/Core/Communication.cpp
+++ b/source/Core/Communication.cpp
@@ -9,28 +9,28 @@
#include "lldb/Core/Communication.h"
-#include "lldb/Core/Event.h"
-#include "lldb/Core/Listener.h"
#include "lldb/Host/HostThread.h"
#include "lldb/Host/ThreadLauncher.h"
#include "lldb/Utility/Connection.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Event.h"
+#include "lldb/Utility/Listener.h"
#include "lldb/Utility/Log.h"
-#include "lldb/Utility/Logging.h" // for LogIfAnyCategoriesSet, LIBLLDB...
-#include "lldb/Utility/Status.h" // for Status
+#include "lldb/Utility/Logging.h"
+#include "lldb/Utility/Status.h"
-#include "llvm/ADT/None.h" // for None
-#include "llvm/ADT/Optional.h" // for Optional
-#include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/Compiler.h"
-#include <algorithm> // for min
-#include <chrono> // for duration, seconds
+#include <algorithm>
+#include <chrono>
#include <cstring>
-#include <memory> // for shared_ptr
+#include <memory>
-#include <errno.h> // for EIO
-#include <inttypes.h> // for PRIu64
-#include <stdio.h> // for snprintf
+#include <errno.h>
+#include <inttypes.h>
+#include <stdio.h>
using namespace lldb;
using namespace lldb_private;
diff --git a/source/Core/Debugger.cpp b/source/Core/Debugger.cpp
index 972d0bc0a6d7..765b59c8865e 100644
--- a/source/Core/Debugger.cpp
+++ b/source/Core/Debugger.cpp
@@ -9,67 +9,71 @@
#include "lldb/Core/Debugger.h"
-#include "lldb/Breakpoint/Breakpoint.h" // for Breakpoint, Brea...
-#include "lldb/Core/Event.h" // for Event, EventData...
+#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/FormatEntity.h"
-#include "lldb/Core/Listener.h" // for Listener
-#include "lldb/Core/Mangled.h" // for Mangled
-#include "lldb/Core/ModuleList.h" // for Mangled
+#include "lldb/Core/Mangled.h"
+#include "lldb/Core/ModuleList.h"
#include "lldb/Core/PluginManager.h"
-#include "lldb/Core/State.h"
#include "lldb/Core/StreamAsynchronousIO.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/Expression/REPL.h"
-#include "lldb/Host/File.h" // for File, File::kInv...
+#include "lldb/Host/File.h"
+#include "lldb/Host/FileSystem.h"
#include "lldb/Host/HostInfo.h"
#include "lldb/Host/Terminal.h"
#include "lldb/Host/ThreadLauncher.h"
#include "lldb/Interpreter/CommandInterpreter.h"
-#include "lldb/Interpreter/OptionValue.h" // for OptionValue, Opt...
+#include "lldb/Interpreter/OptionValue.h"
#include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Interpreter/OptionValueSInt64.h"
#include "lldb/Interpreter/OptionValueString.h"
-#include "lldb/Interpreter/Property.h" // for PropertyDefinition
-#include "lldb/Interpreter/ScriptInterpreter.h" // for ScriptInterpreter
+#include "lldb/Interpreter/Property.h"
+#include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
-#include "lldb/Symbol/SymbolContext.h" // for SymbolContext
+#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/Language.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/StructuredDataPlugin.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/TargetList.h"
#include "lldb/Target/Thread.h"
-#include "lldb/Target/ThreadList.h" // for ThreadList
+#include "lldb/Target/ThreadList.h"
#include "lldb/Utility/AnsiTerminal.h"
-#include "lldb/Utility/Log.h" // for LLDB_LOG_OPTION_...
-#include "lldb/Utility/Stream.h" // for Stream
+#include "lldb/Utility/Event.h"
+#include "lldb/Utility/Listener.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Reproducer.h"
+#include "lldb/Utility/State.h"
+#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamCallback.h"
#include "lldb/Utility/StreamString.h"
#if defined(_WIN32)
-#include "lldb/Host/windows/PosixApi.h" // for PATH_MAX
+#include "lldb/Host/windows/PosixApi.h"
+#include "lldb/Host/windows/windows.h"
#endif
-#include "llvm/ADT/None.h" // for None
-#include "llvm/ADT/STLExtras.h" // for make_unique
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/iterator.h" // for iterator_facade_...
+#include "llvm/ADT/iterator.h"
#include "llvm/Support/DynamicLibrary.h"
#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Process.h"
#include "llvm/Support/Threading.h"
-#include "llvm/Support/raw_ostream.h" // for raw_fd_ostream
+#include "llvm/Support/raw_ostream.h"
-#include <list> // for list
-#include <memory> // for make_shared
+#include <list>
+#include <memory>
#include <mutex>
-#include <set> // for set
-#include <stdio.h> // for size_t, NULL
-#include <stdlib.h> // for getenv
-#include <string.h> // for strcmp
-#include <string> // for string
-#include <system_error> // for error_code
+#include <set>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+#include <system_error>
namespace lldb_private {
class Address;
@@ -89,7 +93,7 @@ static std::recursive_mutex *g_debugger_list_mutex_ptr =
static DebuggerList *g_debugger_list_ptr =
nullptr; // NOTE: intentional leak to avoid issues with C++ destructor chain
-OptionEnumValueElement g_show_disassembly_enum_values[] = {
+static constexpr OptionEnumValueElement g_show_disassembly_enum_values[] = {
{Debugger::eStopDisassemblyTypeNever, "never",
"Never show disassembly when displaying a stop context."},
{Debugger::eStopDisassemblyTypeNoDebugInfo, "no-debuginfo",
@@ -98,16 +102,14 @@ OptionEnumValueElement g_show_disassembly_enum_values[] = {
"Show disassembly when there is no source information, or the source file "
"is missing when displaying a stop context."},
{Debugger::eStopDisassemblyTypeAlways, "always",
- "Always show disassembly when displaying a stop context."},
- {0, nullptr, nullptr}};
+ "Always show disassembly when displaying a stop context."} };
-OptionEnumValueElement g_language_enumerators[] = {
+static constexpr OptionEnumValueElement g_language_enumerators[] = {
{eScriptLanguageNone, "none", "Disable scripting languages."},
{eScriptLanguagePython, "python",
"Select python as the default scripting language."},
{eScriptLanguageDefault, "default",
- "Select the lldb default as the default scripting language."},
- {0, nullptr, nullptr}};
+ "Select the lldb default as the default scripting language."} };
#define MODULE_WITH_FUNC \
"{ " \
@@ -119,9 +121,12 @@ OptionEnumValueElement g_language_enumerators[] = {
"${module.file.basename}{`${function.name-without-args}" \
"{${frame.no-debug}${function.pc-offset}}}}"
-#define FILE_AND_LINE "{ at ${line.file.basename}:${line.number}}"
+#define FILE_AND_LINE \
+ "{ at ${line.file.basename}:${line.number}{:${line.column}}}"
#define IS_OPTIMIZED "{${function.is-optimized} [opt]}"
+#define IS_ARTIFICIAL "{${frame.is-artificial} [artificial]}"
+
#define DEFAULT_THREAD_FORMAT \
"thread #${thread.index}: tid = ${thread.id%tid}" \
"{, ${frame.pc}}" MODULE_WITH_FUNC FILE_AND_LINE \
@@ -146,11 +151,11 @@ OptionEnumValueElement g_language_enumerators[] = {
#define DEFAULT_FRAME_FORMAT \
"frame #${frame.index}: ${frame.pc}" MODULE_WITH_FUNC FILE_AND_LINE \
- IS_OPTIMIZED "\\n"
+ IS_OPTIMIZED IS_ARTIFICIAL "\\n"
#define DEFAULT_FRAME_FORMAT_NO_ARGS \
"frame #${frame.index}: ${frame.pc}" MODULE_WITH_FUNC_NO_ARGS FILE_AND_LINE \
- IS_OPTIMIZED "\\n"
+ IS_OPTIMIZED IS_ARTIFICIAL "\\n"
// Three parts to this disassembly format specification:
// 1. If this is a new function/symbol (no previous symbol/function), print
@@ -162,8 +167,8 @@ OptionEnumValueElement g_language_enumerators[] = {
// address <+offset>:
#define DEFAULT_DISASSEMBLY_FORMAT \
"{${function.initial-function}{${module.file.basename}`}{${function.name-" \
- "without-args}}:\n}{${function.changed}\n{${module.file.basename}`}{${" \
- "function.name-without-args}}:\n}{${current-pc-arrow} " \
+ "without-args}}:\\n}{${function.changed}\\n{${module.file.basename}`}{${" \
+ "function.name-without-args}}:\\n}{${current-pc-arrow} " \
"}${addr-file-or-load}{ " \
"<${function.concrete-only-addr-offset-no-padding}>}: "
@@ -177,10 +182,7 @@ OptionEnumValueElement g_language_enumerators[] = {
// args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-
// without-args}}:\n}{${current-pc-arrow} }{${addr-file-or-load}}:
-#define DEFAULT_STOP_SHOW_COLUMN_ANSI_PREFIX "${ansi.underline}"
-#define DEFAULT_STOP_SHOW_COLUMN_ANSI_SUFFIX "${ansi.normal}"
-
-static OptionEnumValueElement s_stop_show_column_values[] = {
+static constexpr OptionEnumValueElement s_stop_show_column_values[] = {
{eStopShowColumnAnsiOrCaret, "ansi-or-caret",
"Highlight the stop column with ANSI terminal codes when color/ANSI mode "
"is enabled; otherwise, fall back to using a text-only caret (^) as if "
@@ -192,98 +194,95 @@ static OptionEnumValueElement s_stop_show_column_values[] = {
"Highlight the stop column with a caret character (^) underneath the stop "
"column. This method introduces a new line in source listings that "
"display thread stop locations."},
- {eStopShowColumnNone, "none", "Do not highlight the stop column."},
- {0, nullptr, nullptr}};
+ {eStopShowColumnNone, "none", "Do not highlight the stop column."}};
-static PropertyDefinition g_properties[] = {
- {"auto-confirm", OptionValue::eTypeBoolean, true, false, nullptr, nullptr,
+static constexpr PropertyDefinition g_properties[] = {
+ {"auto-confirm", OptionValue::eTypeBoolean, true, false, nullptr, {},
"If true all confirmation prompts will receive their default reply."},
{"disassembly-format", OptionValue::eTypeFormatEntity, true, 0,
- DEFAULT_DISASSEMBLY_FORMAT, nullptr,
+ DEFAULT_DISASSEMBLY_FORMAT, {},
"The default disassembly format "
"string to use when disassembling "
"instruction sequences."},
{"frame-format", OptionValue::eTypeFormatEntity, true, 0,
- DEFAULT_FRAME_FORMAT, nullptr,
+ DEFAULT_FRAME_FORMAT, {},
"The default frame format string to use "
"when displaying stack frame information "
"for threads."},
- {"notify-void", OptionValue::eTypeBoolean, true, false, nullptr, nullptr,
+ {"notify-void", OptionValue::eTypeBoolean, true, false, nullptr, {},
"Notify the user explicitly if an expression returns void (default: "
"false)."},
{"prompt", OptionValue::eTypeString, true,
- OptionValueString::eOptionEncodeCharacterEscapeSequences, "(lldb) ",
- nullptr, "The debugger command line prompt displayed for the user."},
+ OptionValueString::eOptionEncodeCharacterEscapeSequences, "(lldb) ", {},
+ "The debugger command line prompt displayed for the user."},
{"script-lang", OptionValue::eTypeEnum, true, eScriptLanguagePython,
- nullptr, g_language_enumerators,
+ nullptr, OptionEnumValues(g_language_enumerators),
"The script language to be used for evaluating user-written scripts."},
- {"stop-disassembly-count", OptionValue::eTypeSInt64, true, 4, nullptr,
- nullptr,
+ {"stop-disassembly-count", OptionValue::eTypeSInt64, true, 4, nullptr, {},
"The number of disassembly lines to show when displaying a "
"stopped context."},
{"stop-disassembly-display", OptionValue::eTypeEnum, true,
Debugger::eStopDisassemblyTypeNoDebugInfo, nullptr,
- g_show_disassembly_enum_values,
+ OptionEnumValues(g_show_disassembly_enum_values),
"Control when to display disassembly when displaying a stopped context."},
- {"stop-line-count-after", OptionValue::eTypeSInt64, true, 3, nullptr,
- nullptr,
+ {"stop-line-count-after", OptionValue::eTypeSInt64, true, 3, nullptr, {},
"The number of sources lines to display that come after the "
"current source line when displaying a stopped context."},
- {"stop-line-count-before", OptionValue::eTypeSInt64, true, 3, nullptr,
- nullptr,
+ {"stop-line-count-before", OptionValue::eTypeSInt64, true, 3, nullptr, {},
"The number of sources lines to display that come before the "
"current source line when displaying a stopped context."},
+ {"highlight-source", OptionValue::eTypeBoolean, true, true, nullptr, {},
+ "If true, LLDB will highlight the displayed source code."},
{"stop-show-column", OptionValue::eTypeEnum, false,
- eStopShowColumnAnsiOrCaret, nullptr, s_stop_show_column_values,
+ eStopShowColumnAnsiOrCaret, nullptr, OptionEnumValues(s_stop_show_column_values),
"If true, LLDB will use the column information from the debug info to "
"mark the current position when displaying a stopped context."},
- {"stop-show-column-ansi-prefix", OptionValue::eTypeFormatEntity, true, 0,
- DEFAULT_STOP_SHOW_COLUMN_ANSI_PREFIX, nullptr,
+ {"stop-show-column-ansi-prefix", OptionValue::eTypeString, true, 0,
+ "${ansi.underline}", {},
"When displaying the column marker in a color-enabled (i.e. ANSI) "
"terminal, use the ANSI terminal code specified in this format at the "
"immediately before the column to be marked."},
- {"stop-show-column-ansi-suffix", OptionValue::eTypeFormatEntity, true, 0,
- DEFAULT_STOP_SHOW_COLUMN_ANSI_SUFFIX, nullptr,
+ {"stop-show-column-ansi-suffix", OptionValue::eTypeString, true, 0,
+ "${ansi.normal}", {},
"When displaying the column marker in a color-enabled (i.e. ANSI) "
"terminal, use the ANSI terminal code specified in this format "
"immediately after the column to be marked."},
- {"term-width", OptionValue::eTypeSInt64, true, 80, nullptr, nullptr,
+ {"term-width", OptionValue::eTypeSInt64, true, 80, nullptr, {},
"The maximum number of columns to use for displaying text."},
{"thread-format", OptionValue::eTypeFormatEntity, true, 0,
- DEFAULT_THREAD_FORMAT, nullptr,
+ DEFAULT_THREAD_FORMAT, {},
"The default thread format string to use "
"when displaying thread information."},
{"thread-stop-format", OptionValue::eTypeFormatEntity, true, 0,
- DEFAULT_THREAD_STOP_FORMAT, nullptr,
+ DEFAULT_THREAD_STOP_FORMAT, {},
"The default thread format "
"string to use when displaying thread "
"information as part of the stop display."},
- {"use-external-editor", OptionValue::eTypeBoolean, true, false, nullptr,
- nullptr, "Whether to use an external editor or not."},
- {"use-color", OptionValue::eTypeBoolean, true, true, nullptr, nullptr,
+ {"use-external-editor", OptionValue::eTypeBoolean, true, false, nullptr, {},
+ "Whether to use an external editor or not."},
+ {"use-color", OptionValue::eTypeBoolean, true, true, nullptr, {},
"Whether to use Ansi color codes or not."},
{"auto-one-line-summaries", OptionValue::eTypeBoolean, true, true, nullptr,
- nullptr,
+ {},
"If true, LLDB will automatically display small structs in "
"one-liner format (default: true)."},
- {"auto-indent", OptionValue::eTypeBoolean, true, true, nullptr, nullptr,
+ {"auto-indent", OptionValue::eTypeBoolean, true, true, nullptr, {},
"If true, LLDB will auto indent/outdent code. Currently only supported in "
"the REPL (default: true)."},
- {"print-decls", OptionValue::eTypeBoolean, true, true, nullptr, nullptr,
+ {"print-decls", OptionValue::eTypeBoolean, true, true, nullptr, {},
"If true, LLDB will print the values of variables declared in an "
"expression. Currently only supported in the REPL (default: true)."},
- {"tab-size", OptionValue::eTypeUInt64, true, 4, nullptr, nullptr,
+ {"tab-size", OptionValue::eTypeUInt64, true, 4, nullptr, {},
"The tab size to use when indenting code in multi-line input mode "
"(default: 4)."},
{"escape-non-printables", OptionValue::eTypeBoolean, true, true, nullptr,
- nullptr,
+ {},
"If true, LLDB will automatically escape non-printable and "
"escape characters when formatting strings."},
{"frame-format-unique", OptionValue::eTypeFormatEntity, true, 0,
- DEFAULT_FRAME_FORMAT_NO_ARGS, nullptr,
+ DEFAULT_FRAME_FORMAT_NO_ARGS, {},
"The default frame format string to use when displaying stack frame"
- "information for threads from thread backtrace unique."},
- {nullptr, OptionValue::eTypeInvalid, true, 0, nullptr, nullptr, nullptr}};
+ "information for threads from thread backtrace unique."}};
enum {
ePropertyAutoConfirm = 0,
@@ -296,6 +295,7 @@ enum {
ePropertyStopDisassemblyDisplay,
ePropertyStopLineCountAfter,
ePropertyStopLineCountBefore,
+ ePropertyHighlightSource,
ePropertyStopShowColumn,
ePropertyStopShowColumnAnsiPrefix,
ePropertyStopShowColumnAnsiSuffix,
@@ -413,6 +413,11 @@ void Debugger::SetPrompt(llvm::StringRef p) {
GetCommandInterpreter().UpdatePrompt(new_prompt);
}
+llvm::StringRef Debugger::GetReproducerPath() const {
+ auto &r = repro::Reproducer::Instance();
+ return r.GetReproducerPath().GetCString();
+}
+
const FormatEntity::Entry *Debugger::GetThreadFormat() const {
const uint32_t idx = ePropertyThreadFormat;
return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
@@ -470,20 +475,26 @@ bool Debugger::SetUseColor(bool b) {
return ret;
}
+bool Debugger::GetHighlightSource() const {
+ const uint32_t idx = ePropertyHighlightSource;
+ return m_collection_sp->GetPropertyAtIndexAsBoolean(
+ nullptr, idx, g_properties[idx].default_uint_value);
+}
+
StopShowColumn Debugger::GetStopShowColumn() const {
const uint32_t idx = ePropertyStopShowColumn;
return (lldb::StopShowColumn)m_collection_sp->GetPropertyAtIndexAsEnumeration(
nullptr, idx, g_properties[idx].default_uint_value);
}
-const FormatEntity::Entry *Debugger::GetStopShowColumnAnsiPrefix() const {
+llvm::StringRef Debugger::GetStopShowColumnAnsiPrefix() const {
const uint32_t idx = ePropertyStopShowColumnAnsiPrefix;
- return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
+ return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
}
-const FormatEntity::Entry *Debugger::GetStopShowColumnAnsiSuffix() const {
+llvm::StringRef Debugger::GetStopShowColumnAnsiSuffix() const {
const uint32_t idx = ePropertyStopShowColumnAnsiSuffix;
- return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
+ return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
}
uint32_t Debugger::GetStopSourceLineCount(bool before) const {
@@ -600,16 +611,16 @@ bool Debugger::LoadPlugin(const FileSpec &spec, Status &error) {
return false;
}
-static FileSpec::EnumerateDirectoryResult
+static FileSystem::EnumerateDirectoryResult
LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
- const FileSpec &file_spec) {
+ llvm::StringRef path) {
Status error;
static ConstString g_dylibext(".dylib");
static ConstString g_solibext(".so");
if (!baton)
- return FileSpec::eEnumerateDirectoryResultQuit;
+ return FileSystem::eEnumerateDirectoryResultQuit;
Debugger *debugger = (Debugger *)baton;
@@ -620,18 +631,18 @@ LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
// file type information.
if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
ft == fs::file_type::type_unknown) {
- FileSpec plugin_file_spec(file_spec);
- plugin_file_spec.ResolvePath();
+ FileSpec plugin_file_spec(path);
+ FileSystem::Instance().Resolve(plugin_file_spec);
if (plugin_file_spec.GetFileNameExtension() != g_dylibext &&
plugin_file_spec.GetFileNameExtension() != g_solibext) {
- return FileSpec::eEnumerateDirectoryResultNext;
+ return FileSystem::eEnumerateDirectoryResultNext;
}
Status plugin_load_error;
debugger->LoadPlugin(plugin_file_spec, plugin_load_error);
- return FileSpec::eEnumerateDirectoryResultNext;
+ return FileSystem::eEnumerateDirectoryResultNext;
} else if (ft == fs::file_type::directory_file ||
ft == fs::file_type::symlink_file ||
ft == fs::file_type::type_unknown) {
@@ -639,10 +650,10 @@ LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
// also do this for unknown as sometimes the directory enumeration might be
// enumerating a file system that doesn't have correct file type
// information.
- return FileSpec::eEnumerateDirectoryResultEnter;
+ return FileSystem::eEnumerateDirectoryResultEnter;
}
- return FileSpec::eEnumerateDirectoryResultNext;
+ return FileSystem::eEnumerateDirectoryResultNext;
}
void Debugger::InstanceInitialize() {
@@ -651,16 +662,20 @@ void Debugger::InstanceInitialize() {
const bool find_other = true;
char dir_path[PATH_MAX];
if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
- if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
- FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
- find_other, LoadPluginCallback, this);
+ if (FileSystem::Instance().Exists(dir_spec) &&
+ dir_spec.GetPath(dir_path, sizeof(dir_path))) {
+ FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
+ find_files, find_other,
+ LoadPluginCallback, this);
}
}
if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
- if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
- FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
- find_other, LoadPluginCallback, this);
+ if (FileSystem::Instance().Exists(dir_spec) &&
+ dir_spec.GetPath(dir_path, sizeof(dir_path))) {
+ FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
+ find_files, find_other,
+ LoadPluginCallback, this);
}
}
@@ -795,6 +810,15 @@ Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton)
const char *term = getenv("TERM");
if (term && !strcmp(term, "dumb"))
SetUseColor(false);
+ // Turn off use-color if we don't write to a terminal with color support.
+ if (!m_output_file_sp->GetFile().GetIsTerminalWithColors())
+ SetUseColor(false);
+
+#if defined(_WIN32) && defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+ // Enabling use of ANSI color codes because LLDB is using them to highlight
+ // text.
+ llvm::sys::Process::UseANSIEscapeCodes(true);
+#endif
}
Debugger::~Debugger() { Clear(); }
@@ -1068,7 +1092,8 @@ void Debugger::AdoptTopIOHandlerFilesIfInvalid(StreamFileSP &in,
}
}
-void Debugger::PushIOHandler(const IOHandlerSP &reader_sp) {
+void Debugger::PushIOHandler(const IOHandlerSP &reader_sp,
+ bool cancel_top_handler) {
if (!reader_sp)
return;
@@ -1089,7 +1114,8 @@ void Debugger::PushIOHandler(const IOHandlerSP &reader_sp) {
// this new input reader take over
if (top_reader_sp) {
top_reader_sp->Deactivate();
- top_reader_sp->Cancel();
+ if (cancel_top_handler)
+ top_reader_sp->Cancel();
}
}
diff --git a/source/Core/Disassembler.cpp b/source/Core/Disassembler.cpp
index d41a19465280..a34b8038c589 100644
--- a/source/Core/Disassembler.cpp
+++ b/source/Core/Disassembler.cpp
@@ -9,14 +9,14 @@
#include "lldb/Core/Disassembler.h"
-#include "lldb/Core/AddressRange.h" // for AddressRange
+#include "lldb/Core/AddressRange.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/EmulateInstruction.h"
-#include "lldb/Core/Mangled.h" // for Mangled, Mangled...
+#include "lldb/Core/Mangled.h"
#include "lldb/Core/Module.h"
-#include "lldb/Core/ModuleList.h" // for ModuleList
+#include "lldb/Core/ModuleList.h"
#include "lldb/Core/PluginManager.h"
-#include "lldb/Core/SourceManager.h" // for SourceManager
+#include "lldb/Core/SourceManager.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Interpreter/OptionValue.h"
#include "lldb/Interpreter/OptionValueArray.h"
@@ -25,31 +25,31 @@
#include "lldb/Interpreter/OptionValueString.h"
#include "lldb/Interpreter/OptionValueUInt64.h"
#include "lldb/Symbol/Function.h"
-#include "lldb/Symbol/Symbol.h" // for Symbol
-#include "lldb/Symbol/SymbolContext.h" // for SymbolContext
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
-#include "lldb/Target/Thread.h" // for Thread
+#include "lldb/Target/Thread.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Status.h"
-#include "lldb/Utility/Stream.h" // for Stream
-#include "lldb/Utility/StreamString.h" // for StreamString
+#include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StreamString.h"
#include "lldb/Utility/Timer.h"
-#include "lldb/lldb-private-enumerations.h" // for InstructionType:...
-#include "lldb/lldb-private-interfaces.h" // for DisassemblerCrea...
-#include "lldb/lldb-private-types.h" // for RegisterInfo
-#include "llvm/ADT/Triple.h" // for Triple, Triple::...
-#include "llvm/Support/Compiler.h" // for LLVM_PRETTY_FUNC...
+#include "lldb/lldb-private-enumerations.h"
+#include "lldb/lldb-private-interfaces.h"
+#include "lldb/lldb-private-types.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Support/Compiler.h"
-#include <cstdint> // for uint32_t, UINT32...
+#include <cstdint>
#include <cstring>
-#include <utility> // for pair
+#include <utility>
-#include <assert.h> // for assert
+#include <assert.h>
#define DEFAULT_DISASM_BYTE_SIZE 32
@@ -429,9 +429,9 @@ bool Disassembler::PrintInstructions(Disassembler *disasm_ptr,
const Address &addr = inst->GetAddress();
ModuleSP module_sp(addr.GetModule());
if (module_sp) {
- const uint32_t resolve_mask = eSymbolContextFunction |
- eSymbolContextSymbol |
- eSymbolContextLineEntry;
+ const SymbolContextItem resolve_mask = eSymbolContextFunction |
+ eSymbolContextSymbol |
+ eSymbolContextLineEntry;
uint32_t resolved_mask =
module_sp->ResolveSymbolContextForAddress(addr, resolve_mask, sc);
if (resolved_mask) {
@@ -452,8 +452,7 @@ bool Disassembler::PrintInstructions(Disassembler *disasm_ptr,
if (mixed_source_and_assembly && sc.line_entry.IsValid()) {
if (sc.symbol != previous_symbol) {
SourceLine decl_line = GetFunctionDeclLineEntry(sc);
- if (ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, decl_line) ==
- false)
+ if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, decl_line))
AddLineToSourceLineTables(decl_line, source_lines_seen);
}
if (sc.line_entry.IsValid()) {
@@ -461,8 +460,7 @@ bool Disassembler::PrintInstructions(Disassembler *disasm_ptr,
this_line.file = sc.line_entry.file;
this_line.line = sc.line_entry.line;
this_line.column = sc.line_entry.column;
- if (ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, this_line) ==
- false)
+ if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, this_line))
AddLineToSourceLineTables(this_line, source_lines_seen);
}
}
@@ -506,8 +504,8 @@ bool Disassembler::PrintInstructions(Disassembler *disasm_ptr,
previous_symbol = sc.symbol;
if (sc.function && sc.line_entry.IsValid()) {
LineEntry prologue_end_line = sc.line_entry;
- if (ElideMixedSourceAndDisassemblyLine(
- exe_ctx, sc, prologue_end_line) == false) {
+ if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc,
+ prologue_end_line)) {
FileSpec func_decl_file;
uint32_t func_decl_line;
sc.function->GetStartLineSourceInfo(func_decl_file,
@@ -547,8 +545,8 @@ bool Disassembler::PrintInstructions(Disassembler *disasm_ptr,
this_line.file = sc.line_entry.file;
this_line.line = sc.line_entry.line;
- if (ElideMixedSourceAndDisassemblyLine(exe_ctx, sc,
- this_line) == false) {
+ if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc,
+ this_line)) {
// Only print this source line if it is different from the
// last source line we printed. There may have been inlined
// functions between these lines that we elided, resulting in
@@ -934,7 +932,7 @@ bool Instruction::TestEmulation(Stream *out_stream, const char *file_name) {
out_stream->Printf("Instruction::TestEmulation: Missing file_name.");
return false;
}
- FILE *test_file = FileSystem::Fopen(file_name, "r");
+ FILE *test_file = FileSystem::Instance().Fopen(file_name, "r");
if (!test_file) {
out_stream->Printf(
"Instruction::TestEmulation: Attempt to open test file failed.");
diff --git a/source/Core/DumpDataExtractor.cpp b/source/Core/DumpDataExtractor.cpp
index 049f4d3805a1..43a026d0dcb2 100644
--- a/source/Core/DumpDataExtractor.cpp
+++ b/source/Core/DumpDataExtractor.cpp
@@ -9,12 +9,12 @@
#include "lldb/Core/DumpDataExtractor.h"
-#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
-#include "lldb/lldb-forward.h" // for TargetSP, DisassemblerSP
+#include "lldb/lldb-defines.h"
+#include "lldb/lldb-forward.h"
-#include "lldb/Core/Address.h" // for Address
+#include "lldb/Core/Address.h"
#include "lldb/Core/Disassembler.h"
-#include "lldb/Core/ModuleList.h" // for ModuleList
+#include "lldb/Core/ModuleList.h"
#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/ExecutionContextScope.h"
@@ -23,22 +23,22 @@
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Stream.h"
-#include "clang/AST/ASTContext.h" // for ASTContext
-#include "clang/AST/CanonicalType.h" // for CanQualType
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/CanonicalType.h"
-#include "llvm/ADT/APFloat.h" // for APFloat, APFloatBase:...
-#include "llvm/ADT/APInt.h" // for APInt
-#include "llvm/ADT/ArrayRef.h" // for ArrayRef
-#include "llvm/ADT/SmallVector.h" // for SmallVector
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
-#include <limits> // for numeric_limits, numer...
-#include <memory> // for shared_ptr
-#include <string> // for string, basic_string
+#include <limits>
+#include <memory>
+#include <string>
-#include <assert.h> // for assert
-#include <ctype.h> // for isprint
-#include <inttypes.h> // for PRIu64, PRIx64, PRIX64
-#include <math.h> // for ldexpf
+#include <assert.h>
+#include <ctype.h>
+#include <inttypes.h>
+#include <math.h>
#include <bitset>
#include <sstream>
diff --git a/source/Core/DumpRegisterValue.cpp b/source/Core/DumpRegisterValue.cpp
index 99334ca78a6d..d7196a585667 100644
--- a/source/Core/DumpRegisterValue.cpp
+++ b/source/Core/DumpRegisterValue.cpp
@@ -9,8 +9,8 @@
#include "lldb/Core/DumpRegisterValue.h"
#include "lldb/Core/DumpDataExtractor.h"
-#include "lldb/Core/RegisterValue.h"
#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/RegisterValue.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-private-types.h"
diff --git a/source/Core/DynamicLoader.cpp b/source/Core/DynamicLoader.cpp
index 16f1ffca1a20..72ee3cfd6d5b 100644
--- a/source/Core/DynamicLoader.cpp
+++ b/source/Core/DynamicLoader.cpp
@@ -10,22 +10,22 @@
#include "lldb/Target/DynamicLoader.h"
#include "lldb/Core/Module.h"
-#include "lldb/Core/ModuleList.h" // for ModuleList
+#include "lldb/Core/ModuleList.h"
#include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/Section.h"
-#include "lldb/Symbol/ObjectFile.h" // for ObjectFile
+#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/lldb-private-interfaces.h" // for DynamicLoaderCreateInstance
+#include "lldb/Utility/ConstString.h"
+#include "lldb/lldb-private-interfaces.h"
-#include "llvm/ADT/StringRef.h" // for StringRef
+#include "llvm/ADT/StringRef.h"
-#include <memory> // for shared_ptr, unique_ptr
+#include <memory>
-#include <assert.h> // for assert
+#include <assert.h>
using namespace lldb;
using namespace lldb_private;
@@ -81,7 +81,7 @@ ModuleSP DynamicLoader::GetTargetExecutable() {
ModuleSP executable = target.GetExecutableModule();
if (executable) {
- if (executable->GetFileSpec().Exists()) {
+ if (FileSystem::Instance().Exists(executable->GetFileSpec())) {
ModuleSpec module_spec(executable->GetFileSpec(),
executable->GetArchitecture());
auto module_sp = std::make_shared<Module>(module_spec);
@@ -101,8 +101,7 @@ ModuleSP DynamicLoader::GetTargetExecutable() {
if (executable.get() != target.GetExecutableModulePointer()) {
// Don't load dependent images since we are in dyld where we will
// know and find out about all images that are loaded
- const bool get_dependent_images = false;
- target.SetExecutableModule(executable, get_dependent_images);
+ target.SetExecutableModule(executable, eLoadDependentsNo);
}
}
}
@@ -196,9 +195,8 @@ ModuleSP DynamicLoader::LoadModuleAtAddress(const FileSpec &file,
if (error.Success() && memory_info.GetMapped() &&
memory_info.GetRange().GetRangeBase() == base_addr &&
!(memory_info.GetName().IsEmpty())) {
- ModuleSpec new_module_spec(
- FileSpec(memory_info.GetName().AsCString(), false),
- target.GetArchitecture());
+ ModuleSpec new_module_spec(FileSpec(memory_info.GetName().AsCString()),
+ target.GetArchitecture());
if ((module_sp = modules.FindFirstModule(new_module_spec))) {
UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);
diff --git a/source/Core/EmulateInstruction.cpp b/source/Core/EmulateInstruction.cpp
index 469022119c9e..0fcb2eb7e8ce 100644
--- a/source/Core/EmulateInstruction.cpp
+++ b/source/Core/EmulateInstruction.cpp
@@ -12,27 +12,27 @@
#include "lldb/Core/Address.h"
#include "lldb/Core/DumpRegisterValue.h"
#include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegisterValue.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Symbol/UnwindPlan.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/StackFrame.h" // for StackFrame
-#include "lldb/Utility/ConstString.h" // for ConstString
+#include "lldb/Target/StackFrame.h"
+#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/RegisterValue.h"
#include "lldb/Utility/Status.h"
-#include "lldb/Utility/Stream.h" // for Stream, Stream::::eBinary
+#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
-#include "lldb/lldb-forward.h" // for ProcessSP
-#include "lldb/lldb-private-interfaces.h" // for EmulateInstructionCreateIn...
+#include "lldb/lldb-forward.h"
+#include "lldb/lldb-private-interfaces.h"
-#include "llvm/ADT/StringRef.h" // for StringRef
+#include "llvm/ADT/StringRef.h"
#include <cstring>
-#include <memory> // for shared_ptr
+#include <memory>
-#include <inttypes.h> // for PRIx64, PRId64, PRIu64
-#include <stdio.h> // for stdout
+#include <inttypes.h>
+#include <stdio.h>
namespace lldb_private {
class Target;
diff --git a/source/Core/Event.cpp b/source/Core/Event.cpp
deleted file mode 100644
index 3ebad7acdef7..000000000000
--- a/source/Core/Event.cpp
+++ /dev/null
@@ -1,301 +0,0 @@
-//===-- Event.cpp -----------------------------------------------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Core/Event.h"
-
-#include "lldb/Core/Broadcaster.h"
-#include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/Endian.h"
-#include "lldb/Utility/Stream.h"
-#include "lldb/Utility/StreamString.h" // for StreamString
-#include "lldb/lldb-enumerations.h" // for Format::eFormatBytes
-
-#include <algorithm>
-
-#include <ctype.h> // for isprint
-
-using namespace lldb;
-using namespace lldb_private;
-
-#pragma mark -
-#pragma mark Event
-
-//------------------------------------------------------------------
-// Event functions
-//------------------------------------------------------------------
-
-Event::Event(Broadcaster *broadcaster, uint32_t event_type, EventData *data)
- : m_broadcaster_wp(broadcaster->GetBroadcasterImpl()), m_type(event_type),
- m_data_sp(data) {}
-
-Event::Event(Broadcaster *broadcaster, uint32_t event_type,
- const EventDataSP &event_data_sp)
- : m_broadcaster_wp(broadcaster->GetBroadcasterImpl()), m_type(event_type),
- m_data_sp(event_data_sp) {}
-
-Event::Event(uint32_t event_type, EventData *data)
- : m_broadcaster_wp(), m_type(event_type), m_data_sp(data) {}
-
-Event::Event(uint32_t event_type, const EventDataSP &event_data_sp)
- : m_broadcaster_wp(), m_type(event_type), m_data_sp(event_data_sp) {}
-
-Event::~Event() = default;
-
-void Event::Dump(Stream *s) const {
- Broadcaster *broadcaster;
- Broadcaster::BroadcasterImplSP broadcaster_impl_sp(m_broadcaster_wp.lock());
- if (broadcaster_impl_sp)
- broadcaster = broadcaster_impl_sp->GetBroadcaster();
- else
- broadcaster = nullptr;
-
- if (broadcaster) {
- StreamString event_name;
- if (broadcaster->GetEventNames(event_name, m_type, false))
- s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x (%s), data = ",
- static_cast<const void *>(this),
- static_cast<void *>(broadcaster),
- broadcaster->GetBroadcasterName().GetCString(), m_type,
- event_name.GetData());
- else
- s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x, data = ",
- static_cast<const void *>(this),
- static_cast<void *>(broadcaster),
- broadcaster->GetBroadcasterName().GetCString(), m_type);
- } else
- s->Printf("%p Event: broadcaster = NULL, type = 0x%8.8x, data = ",
- static_cast<const void *>(this), m_type);
-
- if (m_data_sp) {
- s->PutChar('{');
- m_data_sp->Dump(s);
- s->PutChar('}');
- } else
- s->Printf("<NULL>");
-}
-
-void Event::DoOnRemoval() {
- if (m_data_sp)
- m_data_sp->DoOnRemoval(this);
-}
-
-#pragma mark -
-#pragma mark EventData
-
-//------------------------------------------------------------------
-// EventData functions
-//------------------------------------------------------------------
-
-EventData::EventData() = default;
-
-EventData::~EventData() = default;
-
-void EventData::Dump(Stream *s) const { s->PutCString("Generic Event Data"); }
-
-#pragma mark -
-#pragma mark EventDataBytes
-
-//------------------------------------------------------------------
-// EventDataBytes functions
-//------------------------------------------------------------------
-
-EventDataBytes::EventDataBytes() : m_bytes() {}
-
-EventDataBytes::EventDataBytes(const char *cstr) : m_bytes() {
- SetBytesFromCString(cstr);
-}
-
-EventDataBytes::EventDataBytes(llvm::StringRef str) : m_bytes() {
- SetBytes(str.data(), str.size());
-}
-
-EventDataBytes::EventDataBytes(const void *src, size_t src_len) : m_bytes() {
- SetBytes(src, src_len);
-}
-
-EventDataBytes::~EventDataBytes() = default;
-
-const ConstString &EventDataBytes::GetFlavorString() {
- static ConstString g_flavor("EventDataBytes");
- return g_flavor;
-}
-
-const ConstString &EventDataBytes::GetFlavor() const {
- return EventDataBytes::GetFlavorString();
-}
-
-void EventDataBytes::Dump(Stream *s) const {
- size_t num_printable_chars =
- std::count_if(m_bytes.begin(), m_bytes.end(), isprint);
- if (num_printable_chars == m_bytes.size())
- s->Format("\"{0}\"", m_bytes);
- else
- s->Format("{0:$[ ]@[x-2]}", llvm::make_range(
- reinterpret_cast<const uint8_t *>(m_bytes.data()),
- reinterpret_cast<const uint8_t *>(m_bytes.data() +
- m_bytes.size())));
-}
-
-const void *EventDataBytes::GetBytes() const {
- return (m_bytes.empty() ? nullptr : m_bytes.data());
-}
-
-size_t EventDataBytes::GetByteSize() const { return m_bytes.size(); }
-
-void EventDataBytes::SetBytes(const void *src, size_t src_len) {
- if (src != nullptr && src_len > 0)
- m_bytes.assign((const char *)src, src_len);
- else
- m_bytes.clear();
-}
-
-void EventDataBytes::SetBytesFromCString(const char *cstr) {
- if (cstr != nullptr && cstr[0])
- m_bytes.assign(cstr);
- else
- m_bytes.clear();
-}
-
-const void *EventDataBytes::GetBytesFromEvent(const Event *event_ptr) {
- const EventDataBytes *e = GetEventDataFromEvent(event_ptr);
- if (e != nullptr)
- return e->GetBytes();
- return nullptr;
-}
-
-size_t EventDataBytes::GetByteSizeFromEvent(const Event *event_ptr) {
- const EventDataBytes *e = GetEventDataFromEvent(event_ptr);
- if (e != nullptr)
- return e->GetByteSize();
- return 0;
-}
-
-const EventDataBytes *
-EventDataBytes::GetEventDataFromEvent(const Event *event_ptr) {
- if (event_ptr != nullptr) {
- const EventData *event_data = event_ptr->GetData();
- if (event_data &&
- event_data->GetFlavor() == EventDataBytes::GetFlavorString())
- return static_cast<const EventDataBytes *>(event_data);
- }
- return nullptr;
-}
-
-void EventDataBytes::SwapBytes(std::string &new_bytes) {
- m_bytes.swap(new_bytes);
-}
-
-#pragma mark -
-#pragma mark EventStructuredData
-
-//------------------------------------------------------------------
-// EventDataStructuredData definitions
-//------------------------------------------------------------------
-
-EventDataStructuredData::EventDataStructuredData()
- : EventData(), m_process_sp(), m_object_sp(), m_plugin_sp() {}
-
-EventDataStructuredData::EventDataStructuredData(
- const ProcessSP &process_sp, const StructuredData::ObjectSP &object_sp,
- const lldb::StructuredDataPluginSP &plugin_sp)
- : EventData(), m_process_sp(process_sp), m_object_sp(object_sp),
- m_plugin_sp(plugin_sp) {}
-
-EventDataStructuredData::~EventDataStructuredData() {}
-
-//------------------------------------------------------------------
-// EventDataStructuredData member functions
-//------------------------------------------------------------------
-
-const ConstString &EventDataStructuredData::GetFlavor() const {
- return EventDataStructuredData::GetFlavorString();
-}
-
-void EventDataStructuredData::Dump(Stream *s) const {
- if (!s)
- return;
-
- if (m_object_sp)
- m_object_sp->Dump(*s);
-}
-
-const ProcessSP &EventDataStructuredData::GetProcess() const {
- return m_process_sp;
-}
-
-const StructuredData::ObjectSP &EventDataStructuredData::GetObject() const {
- return m_object_sp;
-}
-
-const lldb::StructuredDataPluginSP &
-EventDataStructuredData::GetStructuredDataPlugin() const {
- return m_plugin_sp;
-}
-
-void EventDataStructuredData::SetProcess(const ProcessSP &process_sp) {
- m_process_sp = process_sp;
-}
-
-void EventDataStructuredData::SetObject(
- const StructuredData::ObjectSP &object_sp) {
- m_object_sp = object_sp;
-}
-
-void EventDataStructuredData::SetStructuredDataPlugin(
- const lldb::StructuredDataPluginSP &plugin_sp) {
- m_plugin_sp = plugin_sp;
-}
-
-//------------------------------------------------------------------
-// EventDataStructuredData static functions
-//------------------------------------------------------------------
-
-const EventDataStructuredData *
-EventDataStructuredData::GetEventDataFromEvent(const Event *event_ptr) {
- if (event_ptr == nullptr)
- return nullptr;
-
- const EventData *event_data = event_ptr->GetData();
- if (!event_data ||
- event_data->GetFlavor() != EventDataStructuredData::GetFlavorString())
- return nullptr;
-
- return static_cast<const EventDataStructuredData *>(event_data);
-}
-
-ProcessSP EventDataStructuredData::GetProcessFromEvent(const Event *event_ptr) {
- auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
- if (event_data)
- return event_data->GetProcess();
- else
- return ProcessSP();
-}
-
-StructuredData::ObjectSP
-EventDataStructuredData::GetObjectFromEvent(const Event *event_ptr) {
- auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
- if (event_data)
- return event_data->GetObject();
- else
- return StructuredData::ObjectSP();
-}
-
-lldb::StructuredDataPluginSP
-EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr) {
- auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
- if (event_data)
- return event_data->GetStructuredDataPlugin();
- else
- return StructuredDataPluginSP();
-}
-
-const ConstString &EventDataStructuredData::GetFlavorString() {
- static ConstString s_flavor("EventDataStructuredData");
- return s_flavor;
-}
diff --git a/source/Core/FileLineResolver.cpp b/source/Core/FileLineResolver.cpp
index 7f0f440252e7..0f4120711b24 100644
--- a/source/Core/FileLineResolver.cpp
+++ b/source/Core/FileLineResolver.cpp
@@ -9,14 +9,13 @@
#include "lldb/Core/FileLineResolver.h"
-// Project includes
-#include "lldb/Core/FileSpecList.h" // for FileSpecList
+#include "lldb/Core/FileSpecList.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/LineTable.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/Utility/Stream.h" // for Stream
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Stream.h"
-#include <string> // for string
+#include <string>
namespace lldb_private {
class Address;
@@ -68,8 +67,8 @@ FileLineResolver::SearchCallback(SearchFilter &filter, SymbolContext &context,
return Searcher::eCallbackReturnContinue;
}
-Searcher::Depth FileLineResolver::GetDepth() {
- return Searcher::eDepthCompUnit;
+lldb::SearchDepth FileLineResolver::GetDepth() {
+ return lldb::eSearchDepthCompUnit;
}
void FileLineResolver::GetDescription(Stream *s) {
diff --git a/source/Core/FileSpecList.cpp b/source/Core/FileSpecList.cpp
index 66e27b197447..ae4831b6efa6 100644
--- a/source/Core/FileSpecList.cpp
+++ b/source/Core/FileSpecList.cpp
@@ -9,12 +9,12 @@
#include "lldb/Core/FileSpecList.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
+#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
-#include <utility> // for find
+#include <utility>
-#include <stdint.h> // for UINT32_MAX
+#include <stdint.h>
using namespace lldb_private;
using namespace std;
diff --git a/source/Core/FormatEntity.cpp b/source/Core/FormatEntity.cpp
index 743c7c404994..200008dcff5f 100644
--- a/source/Core/FormatEntity.cpp
+++ b/source/Core/FormatEntity.cpp
@@ -10,29 +10,28 @@
#include "lldb/Core/FormatEntity.h"
#include "lldb/Core/Address.h"
-#include "lldb/Core/AddressRange.h" // for AddressRange
+#include "lldb/Core/AddressRange.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/DumpRegisterValue.h"
#include "lldb/Core/Module.h"
-#include "lldb/Core/RegisterValue.h" // for RegisterValue
#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectVariable.h"
#include "lldb/DataFormatters/DataVisualization.h"
-#include "lldb/DataFormatters/FormatClasses.h" // for TypeNameSpecifier...
+#include "lldb/DataFormatters/FormatClasses.h"
#include "lldb/DataFormatters/FormatManager.h"
-#include "lldb/DataFormatters/TypeSummary.h" // for TypeSummaryImpl::...
+#include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/Expression/ExpressionVariable.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/Block.h"
#include "lldb/Symbol/CompileUnit.h"
-#include "lldb/Symbol/CompilerType.h" // for CompilerType
+#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/LineEntry.h"
#include "lldb/Symbol/Symbol.h"
-#include "lldb/Symbol/SymbolContext.h" // for SymbolContext
+#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/ExecutionContextScope.h" // for ExecutionContextS...
+#include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/Language.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
@@ -42,31 +41,32 @@
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/AnsiTerminal.h"
-#include "lldb/Utility/ArchSpec.h" // for ArchSpec
-#include "lldb/Utility/ConstString.h" // for ConstString, oper...
+#include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/Log.h" // for Log
-#include "lldb/Utility/Logging.h" // for GetLogIfAllCatego...
-#include "lldb/Utility/SharingPtr.h" // for SharingPtr
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Logging.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/SharingPtr.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
-#include "lldb/Utility/StringList.h" // for StringList
-#include "lldb/Utility/StructuredData.h" // for StructuredData::O...
-#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
-#include "lldb/lldb-forward.h" // for ValueObjectSP
+#include "lldb/Utility/StringList.h"
+#include "lldb/Utility/StructuredData.h"
+#include "lldb/lldb-defines.h"
+#include "lldb/lldb-forward.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Triple.h" // for Triple, Triple::O...
-#include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH
-
-#include <ctype.h> // for isxdigit
-#include <inttypes.h> // for PRIu64, PRIx64
-#include <memory> // for shared_ptr, opera...
-#include <stdio.h> // for sprintf
-#include <stdlib.h> // for strtoul
-#include <string.h> // for size_t, strchr
-#include <type_traits> // for move
-#include <utility> // for pair
+#include "llvm/ADT/Triple.h"
+#include "llvm/Support/Compiler.h"
+
+#include <ctype.h>
+#include <inttypes.h>
+#include <memory>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <type_traits>
+#include <utility>
namespace lldb_private {
class ScriptInterpreter;
@@ -128,6 +128,7 @@ static FormatEntity::Entry::Definition g_frame_child_entries[] = {
ENTRY("flags", FrameRegisterFlags, UInt64),
ENTRY("no-debug", FrameNoDebug, None),
ENTRY_CHILDREN("reg", FrameRegisterByName, UInt64, g_string_entry),
+ ENTRY("is-artificial", FrameIsArtificial, UInt32),
};
static FormatEntity::Entry::Definition g_function_child_entries[] = {
@@ -146,6 +147,7 @@ static FormatEntity::Entry::Definition g_function_child_entries[] = {
static FormatEntity::Entry::Definition g_line_child_entries[] = {
ENTRY_CHILDREN("file", LineEntryFile, None, g_file_child_entries),
ENTRY("number", LineEntryLineNumber, UInt32),
+ ENTRY("column", LineEntryColumn, UInt32),
ENTRY("start-addr", LineEntryStartAddress, UInt64),
ENTRY("end-addr", LineEntryEndAddress, UInt64),
};
@@ -356,6 +358,7 @@ const char *FormatEntity::Entry::TypeToCString(Type t) {
ENUM_TO_CSTR(FrameRegisterFP);
ENUM_TO_CSTR(FrameRegisterFlags);
ENUM_TO_CSTR(FrameRegisterByName);
+ ENUM_TO_CSTR(FrameIsArtificial);
ENUM_TO_CSTR(ScriptFrame);
ENUM_TO_CSTR(FunctionID);
ENUM_TO_CSTR(FunctionDidChange);
@@ -372,6 +375,7 @@ const char *FormatEntity::Entry::TypeToCString(Type t) {
ENUM_TO_CSTR(FunctionIsOptimized);
ENUM_TO_CSTR(LineEntryFile);
ENUM_TO_CSTR(LineEntryLineNumber);
+ ENUM_TO_CSTR(LineEntryColumn);
ENUM_TO_CSTR(LineEntryStartAddress);
ENUM_TO_CSTR(LineEntryEndAddress);
ENUM_TO_CSTR(CurrentPCArrow);
@@ -1487,6 +1491,13 @@ bool FormatEntity::Format(const Entry &entry, Stream &s,
}
return false;
+ case Entry::Type::FrameIsArtificial: {
+ if (exe_ctx)
+ if (StackFrame *frame = exe_ctx->GetFramePtr())
+ return frame->IsArtificial();
+ return false;
+ }
+
case Entry::Type::ScriptFrame:
if (exe_ctx) {
StackFrame *frame = exe_ctx->GetFramePtr();
@@ -1814,6 +1825,16 @@ bool FormatEntity::Format(const Entry &entry, Stream &s,
}
return false;
+ case Entry::Type::LineEntryColumn:
+ if (sc && sc->line_entry.IsValid() && sc->line_entry.column) {
+ const char *format = "%" PRIu32;
+ if (!entry.printf_format.empty())
+ format = entry.printf_format.c_str();
+ s.Printf(format, sc->line_entry.column);
+ return true;
+ }
+ return false;
+
case Entry::Type::LineEntryStartAddress:
case Entry::Type::LineEntryEndAddress:
if (sc && sc->line_entry.range.GetBaseAddress().IsValid()) {
diff --git a/source/Core/Highlighter.cpp b/source/Core/Highlighter.cpp
new file mode 100644
index 000000000000..c7dd0db83645
--- /dev/null
+++ b/source/Core/Highlighter.cpp
@@ -0,0 +1,81 @@
+//===-- Highlighter.cpp -----------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/Highlighter.h"
+
+#include "lldb/Target/Language.h"
+#include "lldb/Utility/AnsiTerminal.h"
+#include "lldb/Utility/StreamString.h"
+
+using namespace lldb_private;
+
+void HighlightStyle::ColorStyle::Apply(Stream &s, llvm::StringRef value) const {
+ s << m_prefix << value << m_suffix;
+}
+
+void HighlightStyle::ColorStyle::Set(llvm::StringRef prefix,
+ llvm::StringRef suffix) {
+ m_prefix = lldb_utility::ansi::FormatAnsiTerminalCodes(prefix);
+ m_suffix = lldb_utility::ansi::FormatAnsiTerminalCodes(suffix);
+}
+
+void DefaultHighlighter::Highlight(const HighlightStyle &options,
+ llvm::StringRef line,
+ llvm::Optional<size_t> cursor_pos,
+ llvm::StringRef previous_lines,
+ Stream &s) const {
+ // If we don't have a valid cursor, then we just print the line as-is.
+ if (!cursor_pos || *cursor_pos >= line.size()) {
+ s << line;
+ return;
+ }
+
+ // If we have a valid cursor, we have to apply the 'selected' style around
+ // the character below the cursor.
+
+ // Split the line around the character which is below the cursor.
+ size_t column = *cursor_pos;
+ // Print the characters before the cursor.
+ s << line.substr(0, column);
+ // Print the selected character with the defined color codes.
+ options.selected.Apply(s, line.substr(column, 1));
+ // Print the rest of the line.
+ s << line.substr(column + 1U);
+}
+
+static HighlightStyle::ColorStyle GetColor(const char *c) {
+ return HighlightStyle::ColorStyle(c, "${ansi.normal}");
+}
+
+HighlightStyle HighlightStyle::MakeVimStyle() {
+ HighlightStyle result;
+ result.comment = GetColor("${ansi.fg.purple}");
+ result.scalar_literal = GetColor("${ansi.fg.red}");
+ result.keyword = GetColor("${ansi.fg.green}");
+ return result;
+}
+
+const Highlighter &
+HighlighterManager::getHighlighterFor(lldb::LanguageType language_type,
+ llvm::StringRef path) const {
+ Language *language = lldb_private::Language::FindPlugin(language_type, path);
+ if (language && language->GetHighlighter())
+ return *language->GetHighlighter();
+ return m_default;
+}
+
+std::string Highlighter::Highlight(const HighlightStyle &options,
+ llvm::StringRef line,
+ llvm::Optional<size_t> cursor_pos,
+ llvm::StringRef previous_lines) const {
+ StreamString s;
+ Highlight(options, line, cursor_pos, previous_lines, s);
+ s.Flush();
+ return s.GetString().str();
+}
diff --git a/source/Core/IOHandler.cpp b/source/Core/IOHandler.cpp
index e7ebeea1b88d..5c0eea5ea1a3 100644
--- a/source/Core/IOHandler.cpp
+++ b/source/Core/IOHandler.cpp
@@ -9,28 +9,24 @@
#include "lldb/Core/IOHandler.h"
-// C Includes
#ifndef LLDB_DISABLE_CURSES
#include <curses.h>
#include <panel.h>
#endif
-// C++ Includes
#if defined(__APPLE__)
#include <deque>
#endif
#include <string>
-// Other libraries and framework includes
-// Project includes
#include "lldb/Core/Debugger.h"
#include "lldb/Core/StreamFile.h"
-#include "lldb/Host/File.h" // for File
-#include "lldb/Host/Predicate.h" // for Predicate, ::eBroad...
-#include "lldb/Utility/Status.h" // for Status
-#include "lldb/Utility/StreamString.h" // for StreamString
-#include "lldb/Utility/StringList.h" // for StringList
-#include "lldb/lldb-forward.h" // for StreamFileSP
+#include "lldb/Host/File.h"
+#include "lldb/Utility/Predicate.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/StringList.h"
+#include "lldb/lldb-forward.h"
#ifndef LLDB_DISABLE_LIBEDIT
#include "lldb/Host/Editline.h"
@@ -40,7 +36,6 @@
#ifndef LLDB_DISABLE_CURSES
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Module.h"
-#include "lldb/Core/State.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectRegister.h"
#include "lldb/Symbol/Block.h"
@@ -53,25 +48,26 @@
#include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
+#include "lldb/Utility/State.h"
#endif
-#include "llvm/ADT/StringRef.h" // for StringRef
+#include "llvm/ADT/StringRef.h"
#ifdef _MSC_VER
#include "lldb/Host/windows/windows.h"
#endif
-#include <memory> // for shared_ptr
-#include <mutex> // for recursive_mutex
+#include <memory>
+#include <mutex>
-#include <assert.h> // for assert
-#include <ctype.h> // for isspace
-#include <errno.h> // for EINTR, errno
-#include <locale.h> // for setlocale
-#include <stdint.h> // for uint32_t, UINT32_MAX
-#include <stdio.h> // for size_t, fprintf, feof
-#include <string.h> // for strlen
-#include <type_traits> // for move
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <locale.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <type_traits>
using namespace lldb;
using namespace lldb_private;
@@ -172,12 +168,10 @@ IOHandlerConfirm::IOHandlerConfirm(Debugger &debugger, llvm::StringRef prompt,
IOHandlerConfirm::~IOHandlerConfirm() = default;
-int IOHandlerConfirm::IOHandlerComplete(IOHandler &io_handler,
- const char *current_line,
- const char *cursor,
- const char *last_char,
- int skip_first_n_matches,
- int max_matches, StringList &matches) {
+int IOHandlerConfirm::IOHandlerComplete(
+ IOHandler &io_handler, const char *current_line, const char *cursor,
+ const char *last_char, int skip_first_n_matches, int max_matches,
+ StringList &matches, StringList &descriptions) {
if (current_line == cursor) {
if (m_default_response) {
matches.AppendString("y");
@@ -223,12 +217,10 @@ void IOHandlerConfirm::IOHandlerInputComplete(IOHandler &io_handler,
}
}
-int IOHandlerDelegate::IOHandlerComplete(IOHandler &io_handler,
- const char *current_line,
- const char *cursor,
- const char *last_char,
- int skip_first_n_matches,
- int max_matches, StringList &matches) {
+int IOHandlerDelegate::IOHandlerComplete(
+ IOHandler &io_handler, const char *current_line, const char *cursor,
+ const char *last_char, int skip_first_n_matches, int max_matches,
+ StringList &matches, StringList &descriptions) {
switch (m_completion) {
case Completion::None:
break;
@@ -236,14 +228,16 @@ int IOHandlerDelegate::IOHandlerComplete(IOHandler &io_handler,
case Completion::LLDBCommand:
return io_handler.GetDebugger().GetCommandInterpreter().HandleCompletion(
current_line, cursor, last_char, skip_first_n_matches, max_matches,
- matches);
-
+ matches, descriptions);
case Completion::Expression: {
+ CompletionResult result;
CompletionRequest request(current_line, current_line - cursor,
- skip_first_n_matches, max_matches, matches);
+ skip_first_n_matches, max_matches, result);
CommandCompletions::InvokeCommonCompletionCallbacks(
io_handler.GetDebugger().GetCommandInterpreter(),
CommandCompletions::eVariablePathCompletion, request, nullptr);
+ result.GetMatches(matches);
+ result.GetDescriptions(descriptions);
size_t num_matches = request.GetNumberOfMatches();
if (num_matches > 0) {
@@ -432,17 +426,15 @@ int IOHandlerEditline::FixIndentationCallback(Editline *editline,
*editline_reader, lines, cursor_position);
}
-int IOHandlerEditline::AutoCompleteCallback(const char *current_line,
- const char *cursor,
- const char *last_char,
- int skip_first_n_matches,
- int max_matches,
- StringList &matches, void *baton) {
+int IOHandlerEditline::AutoCompleteCallback(
+ const char *current_line, const char *cursor, const char *last_char,
+ int skip_first_n_matches, int max_matches, StringList &matches,
+ StringList &descriptions, void *baton) {
IOHandlerEditline *editline_reader = (IOHandlerEditline *)baton;
if (editline_reader)
return editline_reader->m_delegate.IOHandlerComplete(
*editline_reader, current_line, cursor, last_char, skip_first_n_matches,
- max_matches, matches);
+ max_matches, matches, descriptions);
return 0;
}
#endif
@@ -1060,7 +1052,7 @@ public:
Windows::iterator pos, end = m_subwindows.end();
size_t i = 0;
for (pos = m_subwindows.begin(); pos != end; ++pos, ++i) {
- if ((*pos)->m_name.compare(name) == 0)
+ if ((*pos)->m_name == name)
return *pos;
}
return WindowSP();
@@ -1752,11 +1744,7 @@ public:
void Initialize() {
::setlocale(LC_ALL, "");
::setlocale(LC_CTYPE, "");
-#if 0
- ::initscr();
-#else
m_screen = ::newterm(nullptr, m_out, m_in);
-#endif
::start_color();
::curs_set(0);
::noecho();
@@ -4340,6 +4328,7 @@ public:
m_file_sp->GetFileSpec(), // Source file
m_selected_line +
1, // Source line number (m_selected_line is zero based)
+ 0, // Unspecified column.
0, // No offset
eLazyBoolCalculate, // Check inlines using global setting
eLazyBoolCalculate, // Skip prologue using global setting,
@@ -4379,6 +4368,7 @@ public:
m_file_sp->GetFileSpec(), // Source file
m_selected_line +
1, // Source line number (m_selected_line is zero based)
+ 0, // No column specified.
0, // No offset
eLazyBoolCalculate, // Check inlines using global setting
eLazyBoolCalculate, // Skip prologue using global setting,
diff --git a/source/Core/Listener.cpp b/source/Core/Listener.cpp
deleted file mode 100644
index a39ce6121b32..000000000000
--- a/source/Core/Listener.cpp
+++ /dev/null
@@ -1,470 +0,0 @@
-//===-- Listener.cpp --------------------------------------------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Core/Listener.h"
-
-#include "lldb/Core/Broadcaster.h"
-#include "lldb/Core/Event.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/Utility/Log.h"
-#include "lldb/Utility/Logging.h" // for GetLogIfAllCategoriesSet, LIBL...
-
-#include "llvm/ADT/Optional.h" // for Optional
-
-#include <algorithm>
-#include <memory> // for make_shared
-#include <utility> // for pair, make_pair
-
-using namespace lldb;
-using namespace lldb_private;
-
-namespace {
-class BroadcasterManagerWPMatcher {
-public:
- BroadcasterManagerWPMatcher(BroadcasterManagerSP manager_sp)
- : m_manager_sp(manager_sp) {}
- bool operator()(const BroadcasterManagerWP input_wp) const {
- BroadcasterManagerSP input_sp = input_wp.lock();
- return (input_sp && input_sp == m_manager_sp);
- }
-
- BroadcasterManagerSP m_manager_sp;
-};
-} // anonymous namespace
-
-Listener::Listener(const char *name)
- : m_name(name), m_broadcasters(), m_broadcasters_mutex(), m_events(),
- m_events_mutex() {
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
- if (log != nullptr)
- log->Printf("%p Listener::Listener('%s')", static_cast<void *>(this),
- m_name.c_str());
-}
-
-Listener::~Listener() {
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
-
- Clear();
-
- if (log)
- log->Printf("%p Listener::%s('%s')", static_cast<void *>(this),
- __FUNCTION__, m_name.c_str());
-}
-
-void Listener::Clear() {
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
- std::lock_guard<std::recursive_mutex> broadcasters_guard(
- m_broadcasters_mutex);
- broadcaster_collection::iterator pos, end = m_broadcasters.end();
- for (pos = m_broadcasters.begin(); pos != end; ++pos) {
- Broadcaster::BroadcasterImplSP broadcaster_sp(pos->first.lock());
- if (broadcaster_sp)
- broadcaster_sp->RemoveListener(this, pos->second.event_mask);
- }
- m_broadcasters.clear();
-
- std::lock_guard<std::mutex> events_guard(m_events_mutex);
- m_events.clear();
- size_t num_managers = m_broadcaster_managers.size();
-
- for (size_t i = 0; i < num_managers; i++) {
- BroadcasterManagerSP manager_sp(m_broadcaster_managers[i].lock());
- if (manager_sp)
- manager_sp->RemoveListener(this);
- }
-
- if (log)
- log->Printf("%p Listener::%s('%s')", static_cast<void *>(this),
- __FUNCTION__, m_name.c_str());
-}
-
-uint32_t Listener::StartListeningForEvents(Broadcaster *broadcaster,
- uint32_t event_mask) {
- if (broadcaster) {
- // Scope for "locker"
- // Tell the broadcaster to add this object as a listener
- {
- std::lock_guard<std::recursive_mutex> broadcasters_guard(
- m_broadcasters_mutex);
- Broadcaster::BroadcasterImplWP impl_wp(broadcaster->GetBroadcasterImpl());
- m_broadcasters.insert(
- std::make_pair(impl_wp, BroadcasterInfo(event_mask)));
- }
-
- uint32_t acquired_mask =
- broadcaster->AddListener(this->shared_from_this(), event_mask);
-
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
- if (log != nullptr)
- log->Printf("%p Listener::StartListeningForEvents (broadcaster = %p, "
- "mask = 0x%8.8x) acquired_mask = 0x%8.8x for %s",
- static_cast<void *>(this), static_cast<void *>(broadcaster),
- event_mask, acquired_mask, m_name.c_str());
-
- return acquired_mask;
- }
- return 0;
-}
-
-uint32_t Listener::StartListeningForEvents(Broadcaster *broadcaster,
- uint32_t event_mask,
- HandleBroadcastCallback callback,
- void *callback_user_data) {
- if (broadcaster) {
- // Scope for "locker"
- // Tell the broadcaster to add this object as a listener
- {
- std::lock_guard<std::recursive_mutex> broadcasters_guard(
- m_broadcasters_mutex);
- Broadcaster::BroadcasterImplWP impl_wp(broadcaster->GetBroadcasterImpl());
- m_broadcasters.insert(std::make_pair(
- impl_wp, BroadcasterInfo(event_mask, callback, callback_user_data)));
- }
-
- uint32_t acquired_mask =
- broadcaster->AddListener(this->shared_from_this(), event_mask);
-
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
- if (log != nullptr) {
- void **pointer = reinterpret_cast<void **>(&callback);
- log->Printf("%p Listener::StartListeningForEvents (broadcaster = %p, "
- "mask = 0x%8.8x, callback = %p, user_data = %p) "
- "acquired_mask = 0x%8.8x for %s",
- static_cast<void *>(this), static_cast<void *>(broadcaster),
- event_mask, *pointer, static_cast<void *>(callback_user_data),
- acquired_mask, m_name.c_str());
- }
-
- return acquired_mask;
- }
- return 0;
-}
-
-bool Listener::StopListeningForEvents(Broadcaster *broadcaster,
- uint32_t event_mask) {
- if (broadcaster) {
- // Scope for "locker"
- {
- std::lock_guard<std::recursive_mutex> broadcasters_guard(
- m_broadcasters_mutex);
- m_broadcasters.erase(broadcaster->GetBroadcasterImpl());
- }
- // Remove the broadcaster from our set of broadcasters
- return broadcaster->RemoveListener(this->shared_from_this(), event_mask);
- }
-
- return false;
-}
-
-// Called when a Broadcaster is in its destructor. We need to remove all
-// knowledge of this broadcaster and any events that it may have queued up
-void Listener::BroadcasterWillDestruct(Broadcaster *broadcaster) {
- // Scope for "broadcasters_locker"
- {
- std::lock_guard<std::recursive_mutex> broadcasters_guard(
- m_broadcasters_mutex);
- m_broadcasters.erase(broadcaster->GetBroadcasterImpl());
- }
-
- // Scope for "event_locker"
- {
- std::lock_guard<std::mutex> events_guard(m_events_mutex);
- // Remove all events for this broadcaster object.
- event_collection::iterator pos = m_events.begin();
- while (pos != m_events.end()) {
- if ((*pos)->GetBroadcaster() == broadcaster)
- pos = m_events.erase(pos);
- else
- ++pos;
- }
- }
-}
-
-void Listener::BroadcasterManagerWillDestruct(BroadcasterManagerSP manager_sp) {
- // Just need to remove this broadcast manager from the list of managers:
- broadcaster_manager_collection::iterator iter,
- end_iter = m_broadcaster_managers.end();
- BroadcasterManagerWP manager_wp;
-
- BroadcasterManagerWPMatcher matcher(manager_sp);
- iter = std::find_if<broadcaster_manager_collection::iterator,
- BroadcasterManagerWPMatcher>(
- m_broadcaster_managers.begin(), end_iter, matcher);
- if (iter != end_iter)
- m_broadcaster_managers.erase(iter);
-}
-
-void Listener::AddEvent(EventSP &event_sp) {
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
- if (log != nullptr)
- log->Printf("%p Listener('%s')::AddEvent (event_sp = {%p})",
- static_cast<void *>(this), m_name.c_str(),
- static_cast<void *>(event_sp.get()));
-
- std::lock_guard<std::mutex> guard(m_events_mutex);
- m_events.push_back(event_sp);
- m_events_condition.notify_all();
-}
-
-class EventBroadcasterMatches {
-public:
- EventBroadcasterMatches(Broadcaster *broadcaster)
- : m_broadcaster(broadcaster) {}
-
- bool operator()(const EventSP &event_sp) const {
- return event_sp->BroadcasterIs(m_broadcaster);
- }
-
-private:
- Broadcaster *m_broadcaster;
-};
-
-class EventMatcher {
-public:
- EventMatcher(Broadcaster *broadcaster, const ConstString *broadcaster_names,
- uint32_t num_broadcaster_names, uint32_t event_type_mask)
- : m_broadcaster(broadcaster), m_broadcaster_names(broadcaster_names),
- m_num_broadcaster_names(num_broadcaster_names),
- m_event_type_mask(event_type_mask) {}
-
- bool operator()(const EventSP &event_sp) const {
- if (m_broadcaster && !event_sp->BroadcasterIs(m_broadcaster))
- return false;
-
- if (m_broadcaster_names) {
- bool found_source = false;
- const ConstString &event_broadcaster_name =
- event_sp->GetBroadcaster()->GetBroadcasterName();
- for (uint32_t i = 0; i < m_num_broadcaster_names; ++i) {
- if (m_broadcaster_names[i] == event_broadcaster_name) {
- found_source = true;
- break;
- }
- }
- if (!found_source)
- return false;
- }
-
- if (m_event_type_mask == 0 || m_event_type_mask & event_sp->GetType())
- return true;
- return false;
- }
-
-private:
- Broadcaster *m_broadcaster;
- const ConstString *m_broadcaster_names;
- const uint32_t m_num_broadcaster_names;
- const uint32_t m_event_type_mask;
-};
-
-bool Listener::FindNextEventInternal(
- std::unique_lock<std::mutex> &lock,
- Broadcaster *broadcaster, // nullptr for any broadcaster
- const ConstString *broadcaster_names, // nullptr for any event
- uint32_t num_broadcaster_names, uint32_t event_type_mask, EventSP &event_sp,
- bool remove) {
- // NOTE: callers of this function must lock m_events_mutex using a
- // Mutex::Locker
- // and pass the locker as the first argument. m_events_mutex is no longer
- // recursive.
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
-
- if (m_events.empty())
- return false;
-
- Listener::event_collection::iterator pos = m_events.end();
-
- if (broadcaster == nullptr && broadcaster_names == nullptr &&
- event_type_mask == 0) {
- pos = m_events.begin();
- } else {
- pos = std::find_if(m_events.begin(), m_events.end(),
- EventMatcher(broadcaster, broadcaster_names,
- num_broadcaster_names, event_type_mask));
- }
-
- if (pos != m_events.end()) {
- event_sp = *pos;
-
- if (log != nullptr)
- log->Printf("%p '%s' Listener::FindNextEventInternal(broadcaster=%p, "
- "broadcaster_names=%p[%u], event_type_mask=0x%8.8x, "
- "remove=%i) event %p",
- static_cast<void *>(this), GetName(),
- static_cast<void *>(broadcaster),
- static_cast<const void *>(broadcaster_names),
- num_broadcaster_names, event_type_mask, remove,
- static_cast<void *>(event_sp.get()));
-
- if (remove) {
- m_events.erase(pos);
- // Unlock the event queue here. We've removed this event and are about
- // to return it so it should be okay to get the next event off the queue
- // here - and it might be useful to do that in the "DoOnRemoval".
- lock.unlock();
- event_sp->DoOnRemoval();
- }
- return true;
- }
-
- event_sp.reset();
- return false;
-}
-
-Event *Listener::PeekAtNextEvent() {
- std::unique_lock<std::mutex> guard(m_events_mutex);
- EventSP event_sp;
- if (FindNextEventInternal(guard, nullptr, nullptr, 0, 0, event_sp, false))
- return event_sp.get();
- return nullptr;
-}
-
-Event *Listener::PeekAtNextEventForBroadcaster(Broadcaster *broadcaster) {
- std::unique_lock<std::mutex> guard(m_events_mutex);
- EventSP event_sp;
- if (FindNextEventInternal(guard, broadcaster, nullptr, 0, 0, event_sp, false))
- return event_sp.get();
- return nullptr;
-}
-
-Event *
-Listener::PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster,
- uint32_t event_type_mask) {
- std::unique_lock<std::mutex> guard(m_events_mutex);
- EventSP event_sp;
- if (FindNextEventInternal(guard, broadcaster, nullptr, 0, event_type_mask,
- event_sp, false))
- return event_sp.get();
- return nullptr;
-}
-
-bool Listener::GetEventInternal(
- const Timeout<std::micro> &timeout,
- Broadcaster *broadcaster, // nullptr for any broadcaster
- const ConstString *broadcaster_names, // nullptr for any event
- uint32_t num_broadcaster_names, uint32_t event_type_mask,
- EventSP &event_sp) {
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
- LLDB_LOG(log, "this = {0}, timeout = {1} for {2}", this, timeout, m_name);
-
- std::unique_lock<std::mutex> lock(m_events_mutex);
-
- while (true) {
- if (FindNextEventInternal(lock, broadcaster, broadcaster_names,
- num_broadcaster_names, event_type_mask, event_sp,
- true)) {
- return true;
- } else {
- std::cv_status result = std::cv_status::no_timeout;
- if (!timeout)
- m_events_condition.wait(lock);
- else
- result = m_events_condition.wait_for(lock, *timeout);
-
- if (result == std::cv_status::timeout) {
- log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
- if (log)
- log->Printf("%p Listener::GetEventInternal() timed out for %s",
- static_cast<void *>(this), m_name.c_str());
- return false;
- } else if (result != std::cv_status::no_timeout) {
- log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
- if (log)
- log->Printf("%p Listener::GetEventInternal() unknown error for %s",
- static_cast<void *>(this), m_name.c_str());
- return false;
- }
- }
- }
-
- return false;
-}
-
-bool Listener::GetEventForBroadcasterWithType(
- Broadcaster *broadcaster, uint32_t event_type_mask, EventSP &event_sp,
- const Timeout<std::micro> &timeout) {
- return GetEventInternal(timeout, broadcaster, nullptr, 0, event_type_mask,
- event_sp);
-}
-
-bool Listener::GetEventForBroadcaster(Broadcaster *broadcaster,
- EventSP &event_sp,
- const Timeout<std::micro> &timeout) {
- return GetEventInternal(timeout, broadcaster, nullptr, 0, 0, event_sp);
-}
-
-bool Listener::GetEvent(EventSP &event_sp, const Timeout<std::micro> &timeout) {
- return GetEventInternal(timeout, nullptr, nullptr, 0, 0, event_sp);
-}
-
-size_t Listener::HandleBroadcastEvent(EventSP &event_sp) {
- size_t num_handled = 0;
- std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
- Broadcaster *broadcaster = event_sp->GetBroadcaster();
- if (!broadcaster)
- return 0;
- broadcaster_collection::iterator pos;
- broadcaster_collection::iterator end = m_broadcasters.end();
- Broadcaster::BroadcasterImplSP broadcaster_impl_sp(
- broadcaster->GetBroadcasterImpl());
- for (pos = m_broadcasters.find(broadcaster_impl_sp);
- pos != end && pos->first.lock() == broadcaster_impl_sp; ++pos) {
- BroadcasterInfo info = pos->second;
- if (event_sp->GetType() & info.event_mask) {
- if (info.callback != nullptr) {
- info.callback(event_sp, info.callback_user_data);
- ++num_handled;
- }
- }
- }
- return num_handled;
-}
-
-uint32_t
-Listener::StartListeningForEventSpec(BroadcasterManagerSP manager_sp,
- const BroadcastEventSpec &event_spec) {
- if (!manager_sp)
- return 0;
-
- // The BroadcasterManager mutex must be locked before m_broadcasters_mutex to
- // avoid violating the lock hierarchy (manager before broadcasters).
- std::lock_guard<std::recursive_mutex> manager_guard(
- manager_sp->m_manager_mutex);
- std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
-
- uint32_t bits_acquired = manager_sp->RegisterListenerForEvents(
- this->shared_from_this(), event_spec);
- if (bits_acquired) {
- broadcaster_manager_collection::iterator iter,
- end_iter = m_broadcaster_managers.end();
- BroadcasterManagerWP manager_wp(manager_sp);
- BroadcasterManagerWPMatcher matcher(manager_sp);
- iter = std::find_if<broadcaster_manager_collection::iterator,
- BroadcasterManagerWPMatcher>(
- m_broadcaster_managers.begin(), end_iter, matcher);
- if (iter == end_iter)
- m_broadcaster_managers.push_back(manager_wp);
- }
-
- return bits_acquired;
-}
-
-bool Listener::StopListeningForEventSpec(BroadcasterManagerSP manager_sp,
- const BroadcastEventSpec &event_spec) {
- if (!manager_sp)
- return false;
-
- std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
- return manager_sp->UnregisterListenerForEvents(this->shared_from_this(),
- event_spec);
-}
-
-ListenerSP Listener::MakeListener(const char *name) {
- return ListenerSP(new Listener(name));
-}
diff --git a/source/Core/Mangled.cpp b/source/Core/Mangled.cpp
index 545ac51c870f..943df008edad 100644
--- a/source/Core/Mangled.cpp
+++ b/source/Core/Mangled.cpp
@@ -16,6 +16,7 @@
#pragma comment(lib, "dbghelp.lib")
#endif
+#include "lldb/Core/RichManglingContext.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Logging.h"
@@ -195,7 +196,7 @@ void Mangled::Clear() {
int Mangled::Compare(const Mangled &a, const Mangled &b) {
return ConstString::Compare(
a.GetName(lldb::eLanguageTypeUnknown, ePreferMangled),
- a.GetName(lldb::eLanguageTypeUnknown, ePreferMangled));
+ b.GetName(lldb::eLanguageTypeUnknown, ePreferMangled));
}
//----------------------------------------------------------------------
@@ -233,6 +234,130 @@ void Mangled::SetValue(const ConstString &name) {
}
//----------------------------------------------------------------------
+// Local helpers for different demangling implementations.
+//----------------------------------------------------------------------
+static char *GetMSVCDemangledStr(const char *M) {
+#if defined(_MSC_VER)
+ const size_t demangled_length = 2048;
+ char *demangled_cstr = static_cast<char *>(::malloc(demangled_length));
+ ::ZeroMemory(demangled_cstr, demangled_length);
+ DWORD result = safeUndecorateName(M, demangled_cstr, demangled_length);
+
+ if (Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DEMANGLE)) {
+ if (demangled_cstr && demangled_cstr[0])
+ log->Printf("demangled msvc: %s -> \"%s\"", M, demangled_cstr);
+ else
+ log->Printf("demangled msvc: %s -> error: 0x%lu", M, result);
+ }
+
+ if (result != 0) {
+ return demangled_cstr;
+ } else {
+ ::free(demangled_cstr);
+ return nullptr;
+ }
+#else
+ return nullptr;
+#endif
+}
+
+static char *GetItaniumDemangledStr(const char *M) {
+ char *demangled_cstr = nullptr;
+
+ llvm::ItaniumPartialDemangler ipd;
+ bool err = ipd.partialDemangle(M);
+ if (!err) {
+ // Default buffer and size (will realloc in case it's too small).
+ size_t demangled_size = 80;
+ demangled_cstr = static_cast<char *>(std::malloc(demangled_size));
+ demangled_cstr = ipd.finishDemangle(demangled_cstr, &demangled_size);
+
+ assert(demangled_cstr &&
+ "finishDemangle must always succeed if partialDemangle did");
+ assert(demangled_cstr[demangled_size - 1] == '\0' &&
+ "Expected demangled_size to return length including trailing null");
+ }
+
+ if (Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DEMANGLE)) {
+ if (demangled_cstr)
+ log->Printf("demangled itanium: %s -> \"%s\"", M, demangled_cstr);
+ else
+ log->Printf("demangled itanium: %s -> error: failed to demangle", M);
+ }
+
+ return demangled_cstr;
+}
+
+//----------------------------------------------------------------------
+// Explicit demangling for scheduled requests during batch processing. This
+// makes use of ItaniumPartialDemangler's rich demangle info
+//----------------------------------------------------------------------
+bool Mangled::DemangleWithRichManglingInfo(
+ RichManglingContext &context, SkipMangledNameFn *skip_mangled_name) {
+ // We need to generate and cache the demangled name.
+ static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+ Timer scoped_timer(func_cat,
+ "Mangled::DemangleWithRichNameIndexInfo (m_mangled = %s)",
+ m_mangled.GetCString());
+
+ // Others are not meant to arrive here. ObjC names or C's main() for example
+ // have their names stored in m_demangled, while m_mangled is empty.
+ assert(m_mangled);
+
+ // Check whether or not we are interested in this name at all.
+ ManglingScheme scheme = cstring_mangling_scheme(m_mangled.GetCString());
+ if (skip_mangled_name && skip_mangled_name(m_mangled.GetStringRef(), scheme))
+ return false;
+
+ switch (scheme) {
+ case eManglingSchemeNone:
+ // The current mangled_name_filter would allow llvm_unreachable here.
+ return false;
+
+ case eManglingSchemeItanium:
+ // We want the rich mangling info here, so we don't care whether or not
+ // there is a demangled string in the pool already.
+ if (context.FromItaniumName(m_mangled)) {
+ // If we got an info, we have a name. Copy to string pool and connect the
+ // counterparts to accelerate later access in GetDemangledName().
+ context.ParseFullName();
+ m_demangled.SetStringWithMangledCounterpart(context.GetBufferRef(),
+ m_mangled);
+ return true;
+ } else {
+ m_demangled.SetCString("");
+ return false;
+ }
+
+ case eManglingSchemeMSVC: {
+ // We have no rich mangling for MSVC-mangled names yet, so first try to
+ // demangle it if necessary.
+ if (!m_demangled && !m_mangled.GetMangledCounterpart(m_demangled)) {
+ if (char *d = GetMSVCDemangledStr(m_mangled.GetCString())) {
+ // If we got an info, we have a name. Copy to string pool and connect
+ // the counterparts to accelerate later access in GetDemangledName().
+ m_demangled.SetStringWithMangledCounterpart(llvm::StringRef(d),
+ m_mangled);
+ ::free(d);
+ } else {
+ m_demangled.SetCString("");
+ }
+ }
+
+ if (m_demangled.IsEmpty()) {
+ // Cannot demangle it, so don't try parsing.
+ return false;
+ } else {
+ // Demangled successfully, we can try and parse it with
+ // CPlusPlusLanguage::MethodName.
+ return context.FromCxxMethodName(m_demangled);
+ }
+ }
+ }
+ llvm_unreachable("Fully covered switch above!");
+}
+
+//----------------------------------------------------------------------
// Generate the demangled name on demand using this accessor. Code in this
// class will need to use this accessor if it wishes to decode the demangled
// name. The result is cached and will be kept until a new string value is
@@ -242,14 +367,12 @@ const ConstString &
Mangled::GetDemangledName(lldb::LanguageType language) const {
// Check to make sure we have a valid mangled name and that we haven't
// already decoded our mangled name.
- if (m_mangled && !m_demangled) {
+ if (m_mangled && m_demangled.IsNull()) {
// We need to generate and cache the demangled name.
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, "Mangled::GetDemangledName (m_mangled = %s)",
m_mangled.GetCString());
- Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DEMANGLE);
-
// Don't bother running anything that isn't mangled
const char *mangled_name = m_mangled.GetCString();
ManglingScheme mangling_scheme{cstring_mangling_scheme(mangled_name)};
@@ -259,60 +382,23 @@ Mangled::GetDemangledName(lldb::LanguageType language) const {
// add it to our map.
char *demangled_name = nullptr;
switch (mangling_scheme) {
- case eManglingSchemeMSVC: {
-#if defined(_MSC_VER)
- if (log)
- log->Printf("demangle msvc: %s", mangled_name);
- const size_t demangled_length = 2048;
- demangled_name = static_cast<char *>(::malloc(demangled_length));
- ::ZeroMemory(demangled_name, demangled_length);
- DWORD result =
- safeUndecorateName(mangled_name, demangled_name, demangled_length);
- if (log) {
- if (demangled_name && demangled_name[0])
- log->Printf("demangled msvc: %s -> \"%s\"", mangled_name,
- demangled_name);
- else
- log->Printf("demangled msvc: %s -> error: 0x%lu", mangled_name,
- result);
- }
-
- if (result == 0) {
- free(demangled_name);
- demangled_name = nullptr;
- }
-#endif
+ case eManglingSchemeMSVC:
+ demangled_name = GetMSVCDemangledStr(mangled_name);
break;
- }
case eManglingSchemeItanium: {
- llvm::ItaniumPartialDemangler IPD;
- bool demangle_err = IPD.partialDemangle(mangled_name);
- if (!demangle_err) {
- // Default buffer and size (realloc is used in case it's too small).
- size_t demangled_size = 80;
- demangled_name = static_cast<char *>(::malloc(demangled_size));
- demangled_name = IPD.finishDemangle(demangled_name, &demangled_size);
- }
-
- if (log) {
- if (demangled_name)
- log->Printf("demangled itanium: %s -> \"%s\"", mangled_name,
- demangled_name);
- else
- log->Printf("demangled itanium: %s -> error: failed to demangle",
- mangled_name);
- }
+ demangled_name = GetItaniumDemangledStr(mangled_name);
break;
}
case eManglingSchemeNone:
- break;
+ llvm_unreachable("eManglingSchemeNone was handled already");
}
if (demangled_name) {
- m_demangled.SetCStringWithMangledCounterpart(demangled_name, m_mangled);
+ m_demangled.SetStringWithMangledCounterpart(
+ llvm::StringRef(demangled_name), m_mangled);
free(demangled_name);
}
}
- if (!m_demangled) {
+ if (m_demangled.IsNull()) {
// Set the demangled string to the empty string to indicate we tried to
// parse it once and failed.
m_demangled.SetCString("");
@@ -333,9 +419,7 @@ bool Mangled::NameMatches(const RegularExpression &regex,
return true;
ConstString demangled = GetDemangledName(language);
- if (demangled && regex.Execute(demangled.AsCString()))
- return true;
- return false;
+ return demangled && regex.Execute(demangled.AsCString());
}
//----------------------------------------------------------------------
diff --git a/source/Core/Module.cpp b/source/Core/Module.cpp
index 3b1a4fd7be0f..b48d3cca092b 100644
--- a/source/Core/Module.cpp
+++ b/source/Core/Module.cpp
@@ -9,65 +9,65 @@
#include "lldb/Core/Module.h"
-#include "lldb/Core/AddressRange.h" // for AddressRange
+#include "lldb/Core/AddressRange.h"
#include "lldb/Core/AddressResolverFileLine.h"
-#include "lldb/Core/Debugger.h" // for Debugger
-#include "lldb/Core/FileSpecList.h" // for FileSpecList
-#include "lldb/Core/Mangled.h" // for Mangled
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/FileSpecList.h"
+#include "lldb/Core/Mangled.h"
#include "lldb/Core/ModuleSpec.h"
-#include "lldb/Core/SearchFilter.h" // for SearchFilt...
+#include "lldb/Core/SearchFilter.h"
#include "lldb/Core/Section.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Host/Host.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Symbol/CompileUnit.h"
-#include "lldb/Symbol/Function.h" // for Function
+#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/ObjectFile.h"
-#include "lldb/Symbol/Symbol.h" // for Symbol
+#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/SymbolVendor.h"
-#include "lldb/Symbol/Symtab.h" // for Symtab
-#include "lldb/Symbol/Type.h" // for Type
-#include "lldb/Symbol/TypeList.h" // for TypeList
+#include "lldb/Symbol/Symtab.h"
+#include "lldb/Symbol/Type.h"
+#include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/TypeMap.h"
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Target/Language.h"
-#include "lldb/Target/Platform.h" // for Platform
+#include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/Log.h"
-#include "lldb/Utility/Logging.h" // for GetLogIfAn...
+#include "lldb/Utility/Logging.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Status.h"
-#include "lldb/Utility/Stream.h" // for Stream
+#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/Utility/Timer.h"
#if defined(_WIN32)
-#include "lldb/Host/windows/PosixApi.h" // for PATH_MAX
+#include "lldb/Host/windows/PosixApi.h"
#endif
#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
#include "Plugins/Language/ObjC/ObjCLanguage.h"
-#include "llvm/ADT/STLExtras.h" // for make_unique
-#include "llvm/Support/Compiler.h" // for LLVM_PRETT...
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Signals.h"
-#include "llvm/Support/raw_ostream.h" // for raw_string...
+#include "llvm/Support/raw_ostream.h"
-#include <assert.h> // for assert
-#include <cstdint> // for uint32_t
-#include <inttypes.h> // for PRIx64
-#include <map> // for map
-#include <stdarg.h> // for va_end
-#include <string.h> // for size_t
-#include <type_traits> // for move
-#include <utility> // for find, pair
+#include <assert.h>
+#include <cstdint>
+#include <inttypes.h>
+#include <map>
+#include <stdarg.h>
+#include <string.h>
+#include <type_traits>
+#include <utility>
namespace lldb_private {
class CompilerDeclContext;
@@ -162,15 +162,19 @@ Module::Module(const ModuleSpec &module_spec)
// fill any ivars in so we don't accidentally grab the wrong file later since
// they don't match...
ModuleSpec matching_module_spec;
- if (modules_specs.FindMatchingModuleSpec(module_spec, matching_module_spec) ==
- 0)
+ if (!modules_specs.FindMatchingModuleSpec(module_spec,
+ matching_module_spec)) {
+ if (log) {
+ log->Printf("Found local object file but the specs didn't match");
+ }
return;
+ }
if (module_spec.GetFileSpec())
- m_mod_time = FileSystem::GetModificationTime(module_spec.GetFileSpec());
+ m_mod_time = FileSystem::Instance().GetModificationTime(module_spec.GetFileSpec());
else if (matching_module_spec.GetFileSpec())
m_mod_time =
- FileSystem::GetModificationTime(matching_module_spec.GetFileSpec());
+ FileSystem::Instance().GetModificationTime(matching_module_spec.GetFileSpec());
// Copy the architecture from the actual spec if we got one back, else use
// the one that was specified
@@ -215,7 +219,7 @@ Module::Module(const ModuleSpec &module_spec)
Module::Module(const FileSpec &file_spec, const ArchSpec &arch,
const ConstString *object_name, lldb::offset_t object_offset,
const llvm::sys::TimePoint<> &object_mod_time)
- : m_mod_time(FileSystem::GetModificationTime(file_spec)), m_arch(arch),
+ : m_mod_time(FileSystem::Instance().GetModificationTime(file_spec)), m_arch(arch),
m_file(file_spec), m_object_offset(object_offset),
m_object_mod_time(object_mod_time), m_file_has_changed(false),
m_first_file_changed_log(false) {
@@ -305,7 +309,7 @@ ObjectFile *Module::GetMemoryObjectFile(const lldb::ProcessSP &process_sp,
// Once we get the object file, update our module with the object
// file's architecture since it might differ in vendor/os if some
// parts were unknown.
- m_objfile_sp->GetArchitecture(m_arch);
+ m_arch = m_objfile_sp->GetArchitecture();
} else {
error.SetErrorString("unable to find suitable object file plug-in");
}
@@ -361,26 +365,24 @@ void Module::ParseAllDebugSymbols() {
for (size_t cu_idx = 0; cu_idx < num_comp_units; cu_idx++) {
sc.comp_unit = symbols->GetCompileUnitAtIndex(cu_idx).get();
- if (sc.comp_unit) {
- sc.function = nullptr;
- symbols->ParseVariablesForContext(sc);
+ if (!sc.comp_unit)
+ continue;
- symbols->ParseCompileUnitFunctions(sc);
+ symbols->ParseVariablesForContext(sc);
- for (size_t func_idx = 0;
- (sc.function = sc.comp_unit->GetFunctionAtIndex(func_idx).get()) !=
- nullptr;
- ++func_idx) {
- symbols->ParseFunctionBlocks(sc);
+ symbols->ParseFunctions(*sc.comp_unit);
- // Parse the variables for this function and all its blocks
- symbols->ParseVariablesForContext(sc);
- }
+ sc.comp_unit->ForeachFunction([&sc, &symbols](const FunctionSP &f) {
+ symbols->ParseBlocksRecursive(*f);
- // Parse all types for this compile unit
- sc.function = nullptr;
- symbols->ParseTypes(sc);
- }
+ // Parse the variables for this function and all its blocks
+ sc.function = f.get();
+ symbols->ParseVariablesForContext(sc);
+ return false;
+ });
+
+ // Parse all types for this compile unit
+ symbols->ParseTypes(*sc.comp_unit);
}
}
@@ -431,8 +433,8 @@ bool Module::ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) {
}
uint32_t Module::ResolveSymbolContextForAddress(
- const Address &so_addr, uint32_t resolve_scope, SymbolContext &sc,
- bool resolve_tail_call_address) {
+ const Address &so_addr, lldb::SymbolContextItem resolve_scope,
+ SymbolContext &sc, bool resolve_tail_call_address) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
uint32_t resolved_flags = 0;
@@ -564,21 +566,17 @@ uint32_t Module::ResolveSymbolContextForAddress(
return resolved_flags;
}
-uint32_t Module::ResolveSymbolContextForFilePath(const char *file_path,
- uint32_t line,
- bool check_inlines,
- uint32_t resolve_scope,
- SymbolContextList &sc_list) {
- FileSpec file_spec(file_path, false);
+uint32_t Module::ResolveSymbolContextForFilePath(
+ const char *file_path, uint32_t line, bool check_inlines,
+ lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
+ FileSpec file_spec(file_path);
return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
resolve_scope, sc_list);
}
-uint32_t Module::ResolveSymbolContextsForFileSpec(const FileSpec &file_spec,
- uint32_t line,
- bool check_inlines,
- uint32_t resolve_scope,
- SymbolContextList &sc_list) {
+uint32_t Module::ResolveSymbolContextsForFileSpec(
+ const FileSpec &file_spec, uint32_t line, bool check_inlines,
+ lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat,
@@ -637,9 +635,11 @@ size_t Module::FindCompileUnits(const FileSpec &path, bool append,
return sc_list.GetSize() - start_size;
}
-Module::LookupInfo::LookupInfo(const ConstString &name, uint32_t name_type_mask,
- lldb::LanguageType language)
- : m_name(name), m_lookup_name(), m_language(language), m_name_type_mask(0),
+Module::LookupInfo::LookupInfo(const ConstString &name,
+ FunctionNameType name_type_mask,
+ LanguageType language)
+ : m_name(name), m_lookup_name(), m_language(language),
+ m_name_type_mask(eFunctionNameTypeNone),
m_match_name_after_lookup(false) {
const char *name_cstr = name.GetCString();
llvm::StringRef basename;
@@ -783,7 +783,7 @@ void Module::LookupInfo::Prune(SymbolContextList &sc_list,
qualified_name = cpp_method.GetBasename().str();
else
qualified_name = cpp_method.GetScopeQualifiedName();
- if (qualified_name.compare(m_name.GetCString()) != 0) {
+ if (qualified_name != m_name.GetCString()) {
sc_list.RemoveContextAtIndex(i);
continue;
}
@@ -797,9 +797,9 @@ void Module::LookupInfo::Prune(SymbolContextList &sc_list,
size_t Module::FindFunctions(const ConstString &name,
const CompilerDeclContext *parent_decl_ctx,
- uint32_t name_type_mask, bool include_symbols,
- bool include_inlines, bool append,
- SymbolContextList &sc_list) {
+ FunctionNameType name_type_mask,
+ bool include_symbols, bool include_inlines,
+ bool append, SymbolContextList &sc_list) {
if (!append)
sc_list.Clear();
@@ -943,33 +943,33 @@ void Module::FindAddressesForLine(const lldb::TargetSP target_sp,
}
size_t Module::FindTypes_Impl(
- const SymbolContext &sc, const ConstString &name,
- const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches,
+ const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ bool append, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
- if (!sc.module_sp || sc.module_sp.get() == this) {
- SymbolVendor *symbols = GetSymbolVendor();
- if (symbols)
- return symbols->FindTypes(sc, name, parent_decl_ctx, append, max_matches,
- searched_symbol_files, types);
- }
+ SymbolVendor *symbols = GetSymbolVendor();
+ if (symbols)
+ return symbols->FindTypes(name, parent_decl_ctx, append, max_matches,
+ searched_symbol_files, types);
return 0;
}
-size_t Module::FindTypesInNamespace(const SymbolContext &sc,
- const ConstString &type_name,
+size_t Module::FindTypesInNamespace(const ConstString &type_name,
const CompilerDeclContext *parent_decl_ctx,
size_t max_matches, TypeList &type_list) {
const bool append = true;
TypeMap types_map;
llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
size_t num_types =
- FindTypes_Impl(sc, type_name, parent_decl_ctx, append, max_matches,
+ FindTypes_Impl(type_name, parent_decl_ctx, append, max_matches,
searched_symbol_files, types_map);
- if (num_types > 0)
+ if (num_types > 0) {
+ SymbolContext sc;
+ sc.module_sp = shared_from_this();
sc.SortTypeList(types_map, type_list);
+ }
return num_types;
}
@@ -978,15 +978,14 @@ lldb::TypeSP Module::FindFirstType(const SymbolContext &sc,
TypeList type_list;
llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
const size_t num_matches =
- FindTypes(sc, name, exact_match, 1, searched_symbol_files, type_list);
+ FindTypes(name, exact_match, 1, searched_symbol_files, type_list);
if (num_matches)
return type_list.GetTypeAtIndex(0);
return TypeSP();
}
size_t Module::FindTypes(
- const SymbolContext &sc, const ConstString &name, bool exact_match,
- size_t max_matches,
+ const ConstString &name, bool exact_match, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeList &types) {
size_t num_matches = 0;
@@ -1006,8 +1005,8 @@ size_t Module::FindTypes(
exact_match = type_scope.consume_front("::");
ConstString type_basename_const_str(type_basename);
- if (FindTypes_Impl(sc, type_basename_const_str, nullptr, append,
- max_matches, searched_symbol_files, typesmap)) {
+ if (FindTypes_Impl(type_basename_const_str, nullptr, append, max_matches,
+ searched_symbol_files, typesmap)) {
typesmap.RemoveMismatchedTypes(type_scope, type_basename, type_class,
exact_match);
num_matches = typesmap.GetSize();
@@ -1018,13 +1017,13 @@ size_t Module::FindTypes(
if (type_class != eTypeClassAny && !type_basename.empty()) {
// The "type_name_cstr" will have been modified if we have a valid type
// class prefix (like "struct", "class", "union", "typedef" etc).
- FindTypes_Impl(sc, ConstString(type_basename), nullptr, append,
- UINT_MAX, searched_symbol_files, typesmap);
+ FindTypes_Impl(ConstString(type_basename), nullptr, append, UINT_MAX,
+ searched_symbol_files, typesmap);
typesmap.RemoveMismatchedTypes(type_scope, type_basename, type_class,
exact_match);
num_matches = typesmap.GetSize();
} else {
- num_matches = FindTypes_Impl(sc, name, nullptr, append, UINT_MAX,
+ num_matches = FindTypes_Impl(name, nullptr, append, UINT_MAX,
searched_symbol_files, typesmap);
if (exact_match) {
std::string name_str(name.AsCString(""));
@@ -1034,8 +1033,11 @@ size_t Module::FindTypes(
}
}
}
- if (num_matches > 0)
+ if (num_matches > 0) {
+ SymbolContext sc;
+ sc.module_sp = shared_from_this();
sc.SortTypeList(typesmap, types);
+ }
return num_matches;
}
@@ -1062,7 +1064,7 @@ void Module::SetFileSpecAndObjectName(const FileSpec &file,
// Container objects whose paths do not specify a file directly can call this
// function to correct the file and object names.
m_file = file;
- m_mod_time = FileSystem::GetModificationTime(file);
+ m_mod_time = FileSystem::Instance().GetModificationTime(file);
m_object_name = object_name;
}
@@ -1125,7 +1127,7 @@ void Module::ReportError(const char *format, ...) {
bool Module::FileHasChanged() const {
if (!m_file_has_changed)
m_file_has_changed =
- (FileSystem::GetModificationTime(m_file) != m_mod_time);
+ (FileSystem::Instance().GetModificationTime(m_file) != m_mod_time);
return m_file_has_changed;
}
@@ -1252,7 +1254,8 @@ ObjectFile *Module::GetObjectFile() {
GetFileSpec().GetFilename().AsCString(""));
DataBufferSP data_sp;
lldb::offset_t data_offset = 0;
- const lldb::offset_t file_size = m_file.GetByteSize();
+ const lldb::offset_t file_size =
+ FileSystem::Instance().GetByteSize(m_file);
if (file_size > m_object_offset) {
m_did_load_objfile = true;
m_objfile_sp = ObjectFile::FindPlugin(
@@ -1264,9 +1267,7 @@ ObjectFile *Module::GetObjectFile() {
// parts were unknown. But since the matching arch might already be
// more specific than the generic COFF architecture, only merge in
// those values that overwrite unspecified unknown values.
- ArchSpec new_arch;
- m_objfile_sp->GetArchitecture(new_arch);
- m_arch.MergeFrom(new_arch);
+ m_arch.MergeFrom(m_objfile_sp->GetArchitecture());
} else {
ReportError("failed to load objfile for %s",
GetFileSpec().GetPath().c_str());
@@ -1417,7 +1418,7 @@ void Module::PreloadSymbols() {
}
void Module::SetSymbolFileFileSpec(const FileSpec &file) {
- if (!file.Exists())
+ if (!FileSystem::Instance().Exists(file))
return;
if (m_symfile_ap) {
// Remove any sections in the unified section list that come from the
@@ -1447,7 +1448,7 @@ void Module::SetSymbolFileFileSpec(const FileSpec &file) {
// ("/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out"). So we need to
// check this
- if (llvm::sys::fs::is_directory(file.GetPath())) {
+ if (FileSystem::Instance().IsDirectory(file)) {
std::string new_path(file.GetPath());
std::string old_path(obj_file->GetFileSpec().GetPath());
if (old_path.find(new_path) == 0) {
@@ -1536,7 +1537,8 @@ bool Module::LoadScriptingResourceInTarget(Target *target, Status &error,
if (script_interpreter) {
for (uint32_t i = 0; i < num_specs; ++i) {
FileSpec scripting_fspec(file_specs.GetFileSpecAtIndex(i));
- if (scripting_fspec && scripting_fspec.Exists()) {
+ if (scripting_fspec &&
+ FileSystem::Instance().Exists(scripting_fspec)) {
if (should_load == eLoadScriptFromSymFileWarn) {
if (feedback_stream)
feedback_stream->Printf(
diff --git a/source/Core/ModuleList.cpp b/source/Core/ModuleList.cpp
index d2896da1adca..b8de86f4eadc 100644
--- a/source/Core/ModuleList.cpp
+++ b/source/Core/ModuleList.cpp
@@ -8,39 +8,39 @@
//===----------------------------------------------------------------------===//
#include "lldb/Core/ModuleList.h"
-#include "lldb/Core/FileSpecList.h" // for FileSpecList
+#include "lldb/Core/FileSpecList.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Host/Symbols.h"
-#include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Interpreter/OptionValueFileSpec.h"
+#include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Interpreter/Property.h"
#include "lldb/Symbol/ObjectFile.h"
-#include "lldb/Symbol/SymbolContext.h" // for SymbolContextList, SymbolCon...
+#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/VariableList.h"
-#include "lldb/Utility/ArchSpec.h" // for ArchSpec
-#include "lldb/Utility/ConstString.h" // for ConstString
+#include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Log.h"
-#include "lldb/Utility/Logging.h" // for GetLogIfAnyCategoriesSet
-#include "lldb/Utility/UUID.h" // for UUID, operator!=, operator==
-#include "lldb/lldb-defines.h" // for LLDB_INVALID_INDEX32
+#include "lldb/Utility/Logging.h"
+#include "lldb/Utility/UUID.h"
+#include "lldb/lldb-defines.h"
#if defined(_WIN32)
-#include "lldb/Host/windows/PosixApi.h" // for PATH_MAX
+#include "lldb/Host/windows/PosixApi.h"
#endif
-#include "llvm/ADT/StringRef.h" // for StringRef
+#include "clang/Driver/Driver.h"
+#include "llvm/ADT/StringRef.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Threading.h"
-#include "llvm/Support/raw_ostream.h" // for fs
-#include "clang/Driver/Driver.h"
+#include "llvm/Support/raw_ostream.h"
-#include <chrono> // for operator!=, time_point
-#include <memory> // for shared_ptr
+#include <chrono>
+#include <memory>
#include <mutex>
-#include <string> // for string
-#include <utility> // for distance
+#include <string>
+#include <utility>
namespace lldb_private {
class Function;
@@ -66,16 +66,22 @@ using namespace lldb_private;
namespace {
-PropertyDefinition g_properties[] = {
+static constexpr PropertyDefinition g_properties[] = {
{"enable-external-lookup", OptionValue::eTypeBoolean, true, true, nullptr,
- nullptr,
- "Control the use of external tools or libraries to locate symbol files. "
- "On macOS, Spotlight is used to locate a matching .dSYM bundle based on "
- "the UUID of the executable."},
+ {},
+ "Control the use of external tools and repositories to locate symbol "
+ "files. Directories listed in target.debug-file-search-paths and "
+ "directory of the executable are always checked first for separate debug "
+ "info files. Then depending on this setting: "
+ "On macOS, Spotlight would be also used to locate a matching .dSYM "
+ "bundle based on the UUID of the executable. "
+ "On NetBSD, directory /usr/libdata/debug would be also searched. "
+ "On platforms other than NetBSD directory /usr/lib/debug would be "
+ "also searched."
+ },
{"clang-modules-cache-path", OptionValue::eTypeFileSpec, true, 0, nullptr,
- nullptr,
- "The path to the clang modules cache directory (-fmodules-cache-path)."},
- {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, nullptr, nullptr}};
+ {},
+ "The path to the clang modules cache directory (-fmodules-cache-path)."}};
enum { ePropertyEnableExternalLookup, ePropertyClangModulesCachePath };
@@ -339,8 +345,9 @@ ModuleSP ModuleList::GetModuleAtIndexUnlocked(size_t idx) const {
}
size_t ModuleList::FindFunctions(const ConstString &name,
- uint32_t name_type_mask, bool include_symbols,
- bool include_inlines, bool append,
+ FunctionNameType name_type_mask,
+ bool include_symbols, bool include_inlines,
+ bool append,
SymbolContextList &sc_list) const {
if (!append)
sc_list.Clear();
@@ -374,7 +381,7 @@ size_t ModuleList::FindFunctions(const ConstString &name,
}
size_t ModuleList::FindFunctionSymbols(const ConstString &name,
- uint32_t name_type_mask,
+ lldb::FunctionNameType name_type_mask,
SymbolContextList &sc_list) {
const size_t old_size = sc_list.GetSize();
@@ -535,7 +542,7 @@ ModuleSP ModuleList::FindModule(const UUID &uuid) const {
}
size_t
-ModuleList::FindTypes(const SymbolContext &sc, const ConstString &name,
+ModuleList::FindTypes(Module *search_first, const ConstString &name,
bool name_is_fully_qualified, size_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files,
TypeList &types) const {
@@ -543,14 +550,12 @@ ModuleList::FindTypes(const SymbolContext &sc, const ConstString &name,
size_t total_matches = 0;
collection::const_iterator pos, end = m_modules.end();
- if (sc.module_sp) {
- // The symbol context "sc" contains a module so we want to search that one
- // first if it is in our list...
+ if (search_first) {
for (pos = m_modules.begin(); pos != end; ++pos) {
- if (sc.module_sp.get() == (*pos).get()) {
+ if (search_first == pos->get()) {
total_matches +=
- (*pos)->FindTypes(sc, name, name_is_fully_qualified, max_matches,
- searched_symbol_files, types);
+ search_first->FindTypes(name, name_is_fully_qualified, max_matches,
+ searched_symbol_files, types);
if (total_matches >= max_matches)
break;
@@ -559,15 +564,14 @@ ModuleList::FindTypes(const SymbolContext &sc, const ConstString &name,
}
if (total_matches < max_matches) {
- SymbolContext world_sc;
for (pos = m_modules.begin(); pos != end; ++pos) {
// Search the module if the module is not equal to the one in the symbol
// context "sc". If "sc" contains a empty module shared pointer, then the
// comparison will always be true (valid_module_ptr != nullptr).
- if (sc.module_sp.get() != (*pos).get())
+ if (search_first != pos->get())
total_matches +=
- (*pos)->FindTypes(world_sc, name, name_is_fully_qualified,
- max_matches, searched_symbol_files, types);
+ (*pos)->FindTypes(name, name_is_fully_qualified, max_matches,
+ searched_symbol_files, types);
if (total_matches >= max_matches)
break;
@@ -663,9 +667,10 @@ bool ModuleList::ResolveFileAddress(lldb::addr_t vm_addr,
return false;
}
-uint32_t ModuleList::ResolveSymbolContextForAddress(const Address &so_addr,
- uint32_t resolve_scope,
- SymbolContext &sc) const {
+uint32_t
+ModuleList::ResolveSymbolContextForAddress(const Address &so_addr,
+ SymbolContextItem resolve_scope,
+ SymbolContext &sc) const {
// The address is already section offset so it has a module
uint32_t resolved_flags = 0;
ModuleSP module_sp(so_addr.GetModule());
@@ -688,15 +693,15 @@ uint32_t ModuleList::ResolveSymbolContextForAddress(const Address &so_addr,
uint32_t ModuleList::ResolveSymbolContextForFilePath(
const char *file_path, uint32_t line, bool check_inlines,
- uint32_t resolve_scope, SymbolContextList &sc_list) const {
- FileSpec file_spec(file_path, false);
+ SymbolContextItem resolve_scope, SymbolContextList &sc_list) const {
+ FileSpec file_spec(file_path);
return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
resolve_scope, sc_list);
}
uint32_t ModuleList::ResolveSymbolContextsForFileSpec(
const FileSpec &file_spec, uint32_t line, bool check_inlines,
- uint32_t resolve_scope, SymbolContextList &sc_list) const {
+ SymbolContextItem resolve_scope, SymbolContextList &sc_list) const {
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos) {
@@ -856,14 +861,13 @@ Status ModuleList::GetSharedModule(const ModuleSpec &module_spec,
const auto num_directories = module_search_paths_ptr->GetSize();
for (size_t idx = 0; idx < num_directories; ++idx) {
auto search_path_spec = module_search_paths_ptr->GetFileSpecAtIndex(idx);
- if (!search_path_spec.ResolvePath())
- continue;
+ FileSystem::Instance().Resolve(search_path_spec);
namespace fs = llvm::sys::fs;
- if (!fs::is_directory(search_path_spec.GetPath()))
+ if (!FileSystem::Instance().IsDirectory(search_path_spec))
continue;
search_path_spec.AppendPathComponent(
module_spec.GetFileSpec().GetFilename().AsCString());
- if (!search_path_spec.Exists())
+ if (!FileSystem::Instance().Exists(search_path_spec))
continue;
auto resolved_module_spec(module_spec);
@@ -904,13 +908,15 @@ Status ModuleList::GetSharedModule(const ModuleSpec &module_spec,
// Don't look for the file if it appears to be the same one we already
// checked for above...
if (located_binary_modulespec.GetFileSpec() != module_file_spec) {
- if (!located_binary_modulespec.GetFileSpec().Exists()) {
+ if (!FileSystem::Instance().Exists(
+ located_binary_modulespec.GetFileSpec())) {
located_binary_modulespec.GetFileSpec().GetPath(path, sizeof(path));
if (path[0] == '\0')
module_file_spec.GetPath(path, sizeof(path));
// How can this check ever be true? This branch it is false, and we
// haven't modified file_spec.
- if (located_binary_modulespec.GetFileSpec().Exists()) {
+ if (FileSystem::Instance().Exists(
+ located_binary_modulespec.GetFileSpec())) {
std::string uuid_str;
if (uuid_ptr && uuid_ptr->IsValid())
uuid_str = uuid_ptr->GetAsString();
@@ -951,7 +957,7 @@ Status ModuleList::GetSharedModule(const ModuleSpec &module_spec,
// If we didn't have a UUID in mind when looking for the object file,
// then we should make sure the modification time hasn't changed!
if (platform_module_spec.GetUUIDPtr() == nullptr) {
- auto file_spec_mod_time = FileSystem::GetModificationTime(
+ auto file_spec_mod_time = FileSystem::Instance().GetModificationTime(
located_binary_modulespec.GetFileSpec());
if (file_spec_mod_time != llvm::sys::TimePoint<>()) {
if (file_spec_mod_time != module_sp->GetModificationTime()) {
diff --git a/source/Core/Opcode.cpp b/source/Core/Opcode.cpp
index d15fdb3b17be..ed8be78a6d67 100644
--- a/source/Core/Opcode.cpp
+++ b/source/Core/Opcode.cpp
@@ -13,50 +13,51 @@
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Endian.h"
#include "lldb/Utility/Stream.h"
-#include "lldb/lldb-forward.h" // for DataBufferSP
+#include "lldb/lldb-forward.h"
-#include <memory> // for make_shared
+#include <memory>
-#include <inttypes.h> // for PRIx64
+#include <inttypes.h>
using namespace lldb;
using namespace lldb_private;
int Opcode::Dump(Stream *s, uint32_t min_byte_width) {
- int bytes_written = 0;
+ const uint32_t previous_bytes = s->GetWrittenBytes();
switch (m_type) {
case Opcode::eTypeInvalid:
- bytes_written = s->PutCString("<invalid>");
+ s->PutCString("<invalid>");
break;
case Opcode::eType8:
- bytes_written = s->Printf("0x%2.2x", m_data.inst8);
+ s->Printf("0x%2.2x", m_data.inst8);
break;
case Opcode::eType16:
- bytes_written = s->Printf("0x%4.4x", m_data.inst16);
+ s->Printf("0x%4.4x", m_data.inst16);
break;
case Opcode::eType16_2:
case Opcode::eType32:
- bytes_written = s->Printf("0x%8.8x", m_data.inst32);
+ s->Printf("0x%8.8x", m_data.inst32);
break;
case Opcode::eType64:
- bytes_written = s->Printf("0x%16.16" PRIx64, m_data.inst64);
+ s->Printf("0x%16.16" PRIx64, m_data.inst64);
break;
case Opcode::eTypeBytes:
for (uint32_t i = 0; i < m_data.inst.length; ++i) {
if (i > 0)
- bytes_written += s->PutChar(' ');
- bytes_written += s->Printf("%2.2x", m_data.inst.bytes[i]);
+ s->PutChar(' ');
+ s->Printf("%2.2x", m_data.inst.bytes[i]);
}
break;
}
- // Add spaces to make sure bytes dispay comes out even in case opcodes aren't
- // all the same size
- if (static_cast<uint32_t>(bytes_written) < min_byte_width)
- bytes_written = s->Printf("%*s", min_byte_width - bytes_written, "");
- return bytes_written;
+ uint32_t bytes_written_so_far = s->GetWrittenBytes() - previous_bytes;
+ // Add spaces to make sure bytes display comes out even in case opcodes aren't
+ // all the same size.
+ if (bytes_written_so_far < min_byte_width)
+ s->Printf("%*s", min_byte_width - bytes_written_so_far, "");
+ return s->GetWrittenBytes() - previous_bytes;
}
lldb::ByteOrder Opcode::GetDataByteOrder() const {
diff --git a/source/Core/PluginManager.cpp b/source/Core/PluginManager.cpp
index 55affb6a1030..fbb258039882 100644
--- a/source/Core/PluginManager.cpp
+++ b/source/Core/PluginManager.cpp
@@ -10,30 +10,31 @@
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/Debugger.h"
+#include "lldb/Host/FileSystem.h"
#include "lldb/Host/HostInfo.h"
#include "lldb/Interpreter/OptionValueProperties.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
+#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h"
-#include "lldb/Utility/StringList.h" // for StringList
+#include "lldb/Utility/StringList.h"
#if defined(_WIN32)
-#include "lldb/Host/windows/PosixApi.h" // for PATH_MAX
+#include "lldb/Host/windows/PosixApi.h"
#endif
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/DynamicLibrary.h"
-#include "llvm/Support/FileSystem.h" // for file_type, file_...
-#include "llvm/Support/raw_ostream.h" // for fs
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/raw_ostream.h"
-#include <map> // for map<>::const_ite...
-#include <memory> // for shared_ptr
+#include <map>
+#include <memory>
#include <mutex>
#include <string>
-#include <utility> // for pair
+#include <utility>
#include <vector>
-#include <assert.h> // for assert
+#include <assert.h>
namespace lldb_private {
class CommandInterpreter;
@@ -89,9 +90,9 @@ template <typename FPtrTy> static FPtrTy CastToFPtr(void *VPtr) {
return reinterpret_cast<FPtrTy>(reinterpret_cast<intptr_t>(VPtr));
}
-static FileSpec::EnumerateDirectoryResult
+static FileSystem::EnumerateDirectoryResult
LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
- const FileSpec &file_spec) {
+ llvm::StringRef path) {
// PluginManager *plugin_manager = (PluginManager *)baton;
Status error;
@@ -102,11 +103,11 @@ LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
// file type information.
if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
ft == fs::file_type::type_unknown) {
- FileSpec plugin_file_spec(file_spec);
- plugin_file_spec.ResolvePath();
+ FileSpec plugin_file_spec(path);
+ FileSystem::Instance().Resolve(plugin_file_spec);
if (PluginIsLoaded(plugin_file_spec))
- return FileSpec::eEnumerateDirectoryResultNext;
+ return FileSystem::eEnumerateDirectoryResultNext;
else {
PluginInfo plugin_info;
@@ -138,7 +139,7 @@ LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
// plug-in info so we don't try to load it again and again.
SetPluginInfo(plugin_file_spec, plugin_info);
- return FileSpec::eEnumerateDirectoryResultNext;
+ return FileSystem::eEnumerateDirectoryResultNext;
}
}
}
@@ -149,10 +150,10 @@ LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
// also do this for unknown as sometimes the directory enumeration might be
// enumerating a file system that doesn't have correct file type
// information.
- return FileSpec::eEnumerateDirectoryResultEnter;
+ return FileSystem::eEnumerateDirectoryResultEnter;
}
- return FileSpec::eEnumerateDirectoryResultNext;
+ return FileSystem::eEnumerateDirectoryResultNext;
}
void PluginManager::Initialize() {
@@ -162,16 +163,20 @@ void PluginManager::Initialize() {
const bool find_other = true;
char dir_path[PATH_MAX];
if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
- if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
- FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
- find_other, LoadPluginCallback, nullptr);
+ if (FileSystem::Instance().Exists(dir_spec) &&
+ dir_spec.GetPath(dir_path, sizeof(dir_path))) {
+ FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
+ find_files, find_other,
+ LoadPluginCallback, nullptr);
}
}
if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
- if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
- FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
- find_other, LoadPluginCallback, nullptr);
+ if (FileSystem::Instance().Exists(dir_spec) &&
+ dir_spec.GetPath(dir_path, sizeof(dir_path))) {
+ FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
+ find_files, find_other,
+ LoadPluginCallback, nullptr);
}
}
#endif
@@ -281,7 +286,10 @@ struct ArchitectureInstance {
typedef std::vector<ArchitectureInstance> ArchitectureInstances;
-static std::mutex g_architecture_mutex;
+static std::mutex &GetArchitectureMutex() {
+ static std::mutex g_architecture_mutex;
+ return g_architecture_mutex;
+}
static ArchitectureInstances &GetArchitectureInstances() {
static ArchitectureInstances g_instances;
@@ -291,13 +299,13 @@ static ArchitectureInstances &GetArchitectureInstances() {
void PluginManager::RegisterPlugin(const ConstString &name,
llvm::StringRef description,
ArchitectureCreateInstance create_callback) {
- std::lock_guard<std::mutex> guard(g_architecture_mutex);
+ std::lock_guard<std::mutex> guard(GetArchitectureMutex());
GetArchitectureInstances().push_back({name, description, create_callback});
}
void PluginManager::UnregisterPlugin(
ArchitectureCreateInstance create_callback) {
- std::lock_guard<std::mutex> guard(g_architecture_mutex);
+ std::lock_guard<std::mutex> guard(GetArchitectureMutex());
auto &instances = GetArchitectureInstances();
for (auto pos = instances.begin(), end = instances.end(); pos != end; ++pos) {
@@ -311,7 +319,7 @@ void PluginManager::UnregisterPlugin(
std::unique_ptr<Architecture>
PluginManager::CreateArchitectureInstance(const ArchSpec &arch) {
- std::lock_guard<std::mutex> guard(g_architecture_mutex);
+ std::lock_guard<std::mutex> guard(GetArchitectureMutex());
for (const auto &instances : GetArchitectureInstances()) {
if (auto plugin_up = instances.create_callback(arch))
return plugin_up;
diff --git a/source/Core/RegisterValue.cpp b/source/Core/RegisterValue.cpp
deleted file mode 100644
index 4f908609dde9..000000000000
--- a/source/Core/RegisterValue.cpp
+++ /dev/null
@@ -1,905 +0,0 @@
-//===-- RegisterValue.cpp ---------------------------------------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Core/RegisterValue.h"
-
-#include "lldb/Core/Scalar.h"
-#include "lldb/Utility/Args.h"
-#include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/Status.h"
-#include "lldb/Utility/Stream.h"
-#include "lldb/Utility/StreamString.h"
-#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
-#include "lldb/lldb-private-types.h" // for RegisterInfo, type128
-
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringRef.h"
-
-#include <cstdint> // for uint8_t, uint32_t, uint64_t
-#include <string> // for string
-#include <tuple> // for tie, tuple
-#include <vector>
-
-#include <assert.h> // for assert
-#include <inttypes.h> // for PRIx64
-#include <stdio.h> // for sscanf
-
-using namespace lldb;
-using namespace lldb_private;
-
-bool RegisterValue::GetData(DataExtractor &data) const {
- return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
-}
-
-uint32_t RegisterValue::GetAsMemoryData(const RegisterInfo *reg_info, void *dst,
- uint32_t dst_len,
- lldb::ByteOrder dst_byte_order,
- Status &error) const {
- if (reg_info == nullptr) {
- error.SetErrorString("invalid register info argument.");
- return 0;
- }
-
- // ReadRegister should have already been called on this object prior to
- // calling this.
- if (GetType() == eTypeInvalid) {
- // No value has been read into this object...
- error.SetErrorStringWithFormat(
- "invalid register value type for register %s", reg_info->name);
- return 0;
- }
-
- if (dst_len > kMaxRegisterByteSize) {
- error.SetErrorString("destination is too big");
- return 0;
- }
-
- const uint32_t src_len = reg_info->byte_size;
-
- // Extract the register data into a data extractor
- DataExtractor reg_data;
- if (!GetData(reg_data)) {
- error.SetErrorString("invalid register value to copy into");
- return 0;
- }
-
- // Prepare a memory buffer that contains some or all of the register value
- const uint32_t bytes_copied =
- reg_data.CopyByteOrderedData(0, // src offset
- src_len, // src length
- dst, // dst buffer
- dst_len, // dst length
- dst_byte_order); // dst byte order
- if (bytes_copied == 0)
- error.SetErrorStringWithFormat(
- "failed to copy data for register write of %s", reg_info->name);
-
- return bytes_copied;
-}
-
-uint32_t RegisterValue::SetFromMemoryData(const RegisterInfo *reg_info,
- const void *src, uint32_t src_len,
- lldb::ByteOrder src_byte_order,
- Status &error) {
- if (reg_info == nullptr) {
- error.SetErrorString("invalid register info argument.");
- return 0;
- }
-
- // Moving from addr into a register
- //
- // Case 1: src_len == dst_len
- //
- // |AABBCCDD| Address contents
- // |AABBCCDD| Register contents
- //
- // Case 2: src_len > dst_len
- //
- // Status! (The register should always be big enough to hold the data)
- //
- // Case 3: src_len < dst_len
- //
- // |AABB| Address contents
- // |AABB0000| Register contents [on little-endian hardware]
- // |0000AABB| Register contents [on big-endian hardware]
- if (src_len > kMaxRegisterByteSize) {
- error.SetErrorStringWithFormat(
- "register buffer is too small to receive %u bytes of data.", src_len);
- return 0;
- }
-
- const uint32_t dst_len = reg_info->byte_size;
-
- if (src_len > dst_len) {
- error.SetErrorStringWithFormat(
- "%u bytes is too big to store in register %s (%u bytes)", src_len,
- reg_info->name, dst_len);
- return 0;
- }
-
- // Use a data extractor to correctly copy and pad the bytes read into the
- // register value
- DataExtractor src_data(src, src_len, src_byte_order, 4);
-
- error = SetValueFromData(reg_info, src_data, 0, true);
- if (error.Fail())
- return 0;
-
- // If SetValueFromData succeeded, we must have copied all of src_len
- return src_len;
-}
-
-bool RegisterValue::GetScalarValue(Scalar &scalar) const {
- switch (m_type) {
- case eTypeInvalid:
- break;
- case eTypeBytes: {
- switch (buffer.length) {
- default:
- break;
- case 1:
- scalar = *(const uint8_t *)buffer.bytes;
- return true;
- case 2:
- scalar = *(const uint16_t *)buffer.bytes;
- return true;
- case 4:
- scalar = *(const uint32_t *)buffer.bytes;
- return true;
- case 8:
- scalar = *(const uint64_t *)buffer.bytes;
- return true;
- case 16:
- case 32:
- if (buffer.length % sizeof(uint64_t) == 0) {
- const auto length_in_bits = buffer.length * 8;
- const auto length_in_uint64 = buffer.length / sizeof(uint64_t);
- scalar =
- llvm::APInt(length_in_bits,
- llvm::ArrayRef<uint64_t>((const uint64_t *)buffer.bytes,
- length_in_uint64));
- return true;
- }
- break;
- }
- } break;
- case eTypeUInt8:
- case eTypeUInt16:
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- scalar = m_scalar;
- return true;
- }
- return false;
-}
-
-void RegisterValue::Clear() { m_type = eTypeInvalid; }
-
-RegisterValue::Type RegisterValue::SetType(const RegisterInfo *reg_info) {
- // To change the type, we simply copy the data in again, using the new format
- RegisterValue copy;
- DataExtractor copy_data;
- if (copy.CopyValue(*this) && copy.GetData(copy_data))
- SetValueFromData(reg_info, copy_data, 0, true);
-
- return m_type;
-}
-
-Status RegisterValue::SetValueFromData(const RegisterInfo *reg_info,
- DataExtractor &src,
- lldb::offset_t src_offset,
- bool partial_data_ok) {
- Status error;
-
- if (src.GetByteSize() == 0) {
- error.SetErrorString("empty data.");
- return error;
- }
-
- if (reg_info->byte_size == 0) {
- error.SetErrorString("invalid register info.");
- return error;
- }
-
- uint32_t src_len = src.GetByteSize() - src_offset;
-
- if (!partial_data_ok && (src_len < reg_info->byte_size)) {
- error.SetErrorString("not enough data.");
- return error;
- }
-
- // Cap the data length if there is more than enough bytes for this register
- // value
- if (src_len > reg_info->byte_size)
- src_len = reg_info->byte_size;
-
- // Zero out the value in case we get partial data...
- memset(buffer.bytes, 0, sizeof(buffer.bytes));
-
- type128 int128;
-
- m_type = eTypeInvalid;
- switch (reg_info->encoding) {
- case eEncodingInvalid:
- break;
- case eEncodingUint:
- case eEncodingSint:
- if (reg_info->byte_size == 1)
- SetUInt8(src.GetMaxU32(&src_offset, src_len));
- else if (reg_info->byte_size <= 2)
- SetUInt16(src.GetMaxU32(&src_offset, src_len));
- else if (reg_info->byte_size <= 4)
- SetUInt32(src.GetMaxU32(&src_offset, src_len));
- else if (reg_info->byte_size <= 8)
- SetUInt64(src.GetMaxU64(&src_offset, src_len));
- else if (reg_info->byte_size <= 16) {
- uint64_t data1 = src.GetU64(&src_offset);
- uint64_t data2 = src.GetU64(&src_offset);
- if (src.GetByteSize() == eByteOrderBig) {
- int128.x[0] = data1;
- int128.x[1] = data2;
- } else {
- int128.x[0] = data2;
- int128.x[1] = data1;
- }
- SetUInt128(llvm::APInt(128, 2, int128.x));
- }
- break;
- case eEncodingIEEE754:
- if (reg_info->byte_size == sizeof(float))
- SetFloat(src.GetFloat(&src_offset));
- else if (reg_info->byte_size == sizeof(double))
- SetDouble(src.GetDouble(&src_offset));
- else if (reg_info->byte_size == sizeof(long double))
- SetLongDouble(src.GetLongDouble(&src_offset));
- break;
- case eEncodingVector: {
- m_type = eTypeBytes;
- buffer.length = reg_info->byte_size;
- buffer.byte_order = src.GetByteOrder();
- assert(buffer.length <= kMaxRegisterByteSize);
- if (buffer.length > kMaxRegisterByteSize)
- buffer.length = kMaxRegisterByteSize;
- if (src.CopyByteOrderedData(
- src_offset, // offset within "src" to start extracting data
- src_len, // src length
- buffer.bytes, // dst buffer
- buffer.length, // dst length
- buffer.byte_order) == 0) // dst byte order
- {
- error.SetErrorStringWithFormat(
- "failed to copy data for register write of %s", reg_info->name);
- return error;
- }
- }
- }
-
- if (m_type == eTypeInvalid)
- error.SetErrorStringWithFormat(
- "invalid register value type for register %s", reg_info->name);
- return error;
-}
-
-// Helper function for RegisterValue::SetValueFromString()
-static bool ParseVectorEncoding(const RegisterInfo *reg_info,
- llvm::StringRef vector_str,
- const uint32_t byte_size,
- RegisterValue *reg_value) {
- // Example: vector_str = "{0x2c 0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a
- // 0x2a 0x3e 0x84 0x4f 0x2a 0x3e}".
- vector_str = vector_str.trim();
- vector_str.consume_front("{");
- vector_str.consume_back("}");
- vector_str = vector_str.trim();
-
- char Sep = ' ';
-
- // The first split should give us:
- // ('0x2c', '0x4b 0x2a 0x3e 0xd0 0x4f 0x2a 0x3e 0xac 0x4a 0x2a 0x3e 0x84 0x4f
- // 0x2a 0x3e').
- llvm::StringRef car;
- llvm::StringRef cdr = vector_str;
- std::tie(car, cdr) = vector_str.split(Sep);
- std::vector<uint8_t> bytes;
- unsigned byte = 0;
-
- // Using radix auto-sensing by passing 0 as the radix. Keep on processing the
- // vector elements as long as the parsing succeeds and the vector size is <
- // byte_size.
- while (!car.getAsInteger(0, byte) && bytes.size() < byte_size) {
- bytes.push_back(byte);
- std::tie(car, cdr) = cdr.split(Sep);
- }
-
- // Check for vector of exact byte_size elements.
- if (bytes.size() != byte_size)
- return false;
-
- reg_value->SetBytes(&(bytes.front()), byte_size, eByteOrderLittle);
- return true;
-}
-
-Status RegisterValue::SetValueFromString(const RegisterInfo *reg_info,
- llvm::StringRef value_str) {
- Status error;
- if (reg_info == nullptr) {
- error.SetErrorString("Invalid register info argument.");
- return error;
- }
-
- m_type = eTypeInvalid;
- if (value_str.empty()) {
- error.SetErrorString("Invalid c-string value string.");
- return error;
- }
- const uint32_t byte_size = reg_info->byte_size;
-
- uint64_t uval64;
- int64_t ival64;
- float flt_val;
- double dbl_val;
- long double ldbl_val;
- switch (reg_info->encoding) {
- case eEncodingInvalid:
- error.SetErrorString("Invalid encoding.");
- break;
-
- case eEncodingUint:
- if (byte_size > sizeof(uint64_t)) {
- error.SetErrorStringWithFormat(
- "unsupported unsigned integer byte size: %u", byte_size);
- break;
- }
- if (value_str.getAsInteger(0, uval64)) {
- error.SetErrorStringWithFormat(
- "'%s' is not a valid unsigned integer string value",
- value_str.str().c_str());
- break;
- }
-
- if (!Args::UInt64ValueIsValidForByteSize(uval64, byte_size)) {
- error.SetErrorStringWithFormat(
- "value 0x%" PRIx64
- " is too large to fit in a %u byte unsigned integer value",
- uval64, byte_size);
- break;
- }
-
- if (!SetUInt(uval64, reg_info->byte_size)) {
- error.SetErrorStringWithFormat(
- "unsupported unsigned integer byte size: %u", byte_size);
- break;
- }
- // TODO: Shouldn't we be setting m_type here?
- break;
-
- case eEncodingSint:
- if (byte_size > sizeof(long long)) {
- error.SetErrorStringWithFormat("unsupported signed integer byte size: %u",
- byte_size);
- break;
- }
-
- if (value_str.getAsInteger(0, ival64)) {
- error.SetErrorStringWithFormat(
- "'%s' is not a valid signed integer string value",
- value_str.str().c_str());
- break;
- }
-
- if (!Args::SInt64ValueIsValidForByteSize(ival64, byte_size)) {
- error.SetErrorStringWithFormat(
- "value 0x%" PRIx64
- " is too large to fit in a %u byte signed integer value",
- ival64, byte_size);
- break;
- }
-
- if (!SetUInt(ival64, reg_info->byte_size)) {
- error.SetErrorStringWithFormat("unsupported signed integer byte size: %u",
- byte_size);
- break;
- }
-
- // TODO: Shouldn't we be setting m_type here?
- break;
-
- case eEncodingIEEE754: {
- std::string value_string = value_str;
- if (byte_size == sizeof(float)) {
- if (::sscanf(value_string.c_str(), "%f", &flt_val) != 1) {
- error.SetErrorStringWithFormat("'%s' is not a valid float string value",
- value_string.c_str());
- break;
- }
- m_scalar = flt_val;
- m_type = eTypeFloat;
- } else if (byte_size == sizeof(double)) {
- if (::sscanf(value_string.c_str(), "%lf", &dbl_val) != 1) {
- error.SetErrorStringWithFormat("'%s' is not a valid float string value",
- value_string.c_str());
- break;
- }
- m_scalar = dbl_val;
- m_type = eTypeDouble;
- } else if (byte_size == sizeof(long double)) {
- if (::sscanf(value_string.c_str(), "%Lf", &ldbl_val) != 1) {
- error.SetErrorStringWithFormat("'%s' is not a valid float string value",
- value_string.c_str());
- break;
- }
- m_scalar = ldbl_val;
- m_type = eTypeLongDouble;
- } else {
- error.SetErrorStringWithFormat("unsupported float byte size: %u",
- byte_size);
- return error;
- }
- break;
- }
- case eEncodingVector:
- if (!ParseVectorEncoding(reg_info, value_str, byte_size, this))
- error.SetErrorString("unrecognized vector encoding string value.");
- break;
- }
-
- return error;
-}
-
-bool RegisterValue::SignExtend(uint32_t sign_bitpos) {
- switch (m_type) {
- case eTypeInvalid:
- break;
-
- case eTypeUInt8:
- case eTypeUInt16:
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- return m_scalar.SignExtend(sign_bitpos);
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- case eTypeBytes:
- break;
- }
- return false;
-}
-
-bool RegisterValue::CopyValue(const RegisterValue &rhs) {
- if (this == &rhs)
- return rhs.m_type == eTypeInvalid ? false : true;
-
- m_type = rhs.m_type;
- switch (m_type) {
- case eTypeInvalid:
- return false;
- case eTypeUInt8:
- case eTypeUInt16:
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- m_scalar = rhs.m_scalar;
- break;
- case eTypeBytes:
- assert(rhs.buffer.length <= kMaxRegisterByteSize);
- ::memcpy(buffer.bytes, rhs.buffer.bytes, kMaxRegisterByteSize);
- buffer.length = rhs.buffer.length;
- buffer.byte_order = rhs.buffer.byte_order;
- break;
- }
- return true;
-}
-
-uint16_t RegisterValue::GetAsUInt16(uint16_t fail_value,
- bool *success_ptr) const {
- if (success_ptr)
- *success_ptr = true;
-
- switch (m_type) {
- default:
- break;
- case eTypeUInt8:
- case eTypeUInt16:
- return m_scalar.UShort(fail_value);
- case eTypeBytes: {
- switch (buffer.length) {
- default:
- break;
- case 1:
- case 2:
- return *(const uint16_t *)buffer.bytes;
- }
- } break;
- }
- if (success_ptr)
- *success_ptr = false;
- return fail_value;
-}
-
-uint32_t RegisterValue::GetAsUInt32(uint32_t fail_value,
- bool *success_ptr) const {
- if (success_ptr)
- *success_ptr = true;
- switch (m_type) {
- default:
- break;
- case eTypeUInt8:
- case eTypeUInt16:
- case eTypeUInt32:
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- return m_scalar.UInt(fail_value);
- case eTypeBytes: {
- switch (buffer.length) {
- default:
- break;
- case 1:
- case 2:
- case 4:
- return *(const uint32_t *)buffer.bytes;
- }
- } break;
- }
- if (success_ptr)
- *success_ptr = false;
- return fail_value;
-}
-
-uint64_t RegisterValue::GetAsUInt64(uint64_t fail_value,
- bool *success_ptr) const {
- if (success_ptr)
- *success_ptr = true;
- switch (m_type) {
- default:
- break;
- case eTypeUInt8:
- case eTypeUInt16:
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- return m_scalar.ULongLong(fail_value);
- case eTypeBytes: {
- switch (buffer.length) {
- default:
- break;
- case 1:
- return *(const uint8_t *)buffer.bytes;
- case 2:
- return *(const uint16_t *)buffer.bytes;
- case 4:
- return *(const uint32_t *)buffer.bytes;
- case 8:
- return *(const uint64_t *)buffer.bytes;
- }
- } break;
- }
- if (success_ptr)
- *success_ptr = false;
- return fail_value;
-}
-
-llvm::APInt RegisterValue::GetAsUInt128(const llvm::APInt &fail_value,
- bool *success_ptr) const {
- if (success_ptr)
- *success_ptr = true;
- switch (m_type) {
- default:
- break;
- case eTypeUInt8:
- case eTypeUInt16:
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- return m_scalar.UInt128(fail_value);
- case eTypeBytes: {
- switch (buffer.length) {
- default:
- break;
- case 1:
- case 2:
- case 4:
- case 8:
- case 16:
- return llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
- ((const type128 *)buffer.bytes)->x);
- }
- } break;
- }
- if (success_ptr)
- *success_ptr = false;
- return fail_value;
-}
-
-float RegisterValue::GetAsFloat(float fail_value, bool *success_ptr) const {
- if (success_ptr)
- *success_ptr = true;
- switch (m_type) {
- default:
- break;
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- return m_scalar.Float(fail_value);
- }
- if (success_ptr)
- *success_ptr = false;
- return fail_value;
-}
-
-double RegisterValue::GetAsDouble(double fail_value, bool *success_ptr) const {
- if (success_ptr)
- *success_ptr = true;
- switch (m_type) {
- default:
- break;
-
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- return m_scalar.Double(fail_value);
- }
- if (success_ptr)
- *success_ptr = false;
- return fail_value;
-}
-
-long double RegisterValue::GetAsLongDouble(long double fail_value,
- bool *success_ptr) const {
- if (success_ptr)
- *success_ptr = true;
- switch (m_type) {
- default:
- break;
-
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- return m_scalar.LongDouble();
- }
- if (success_ptr)
- *success_ptr = false;
- return fail_value;
-}
-
-const void *RegisterValue::GetBytes() const {
- switch (m_type) {
- case eTypeInvalid:
- break;
- case eTypeUInt8:
- case eTypeUInt16:
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- return m_scalar.GetBytes();
- case eTypeBytes:
- return buffer.bytes;
- }
- return nullptr;
-}
-
-uint32_t RegisterValue::GetByteSize() const {
- switch (m_type) {
- case eTypeInvalid:
- break;
- case eTypeUInt8:
- return 1;
- case eTypeUInt16:
- return 2;
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- return m_scalar.GetByteSize();
- case eTypeBytes:
- return buffer.length;
- }
- return 0;
-}
-
-bool RegisterValue::SetUInt(uint64_t uint, uint32_t byte_size) {
- if (byte_size == 0) {
- SetUInt64(uint);
- } else if (byte_size == 1) {
- SetUInt8(uint);
- } else if (byte_size <= 2) {
- SetUInt16(uint);
- } else if (byte_size <= 4) {
- SetUInt32(uint);
- } else if (byte_size <= 8) {
- SetUInt64(uint);
- } else if (byte_size <= 16) {
- SetUInt128(llvm::APInt(128, uint));
- } else
- return false;
- return true;
-}
-
-void RegisterValue::SetBytes(const void *bytes, size_t length,
- lldb::ByteOrder byte_order) {
- // If this assertion fires off we need to increase the size of buffer.bytes,
- // or make it something that is allocated on the heap. Since the data buffer
- // is in a union, we can't make it a collection class like SmallVector...
- if (bytes && length > 0) {
- assert(length <= sizeof(buffer.bytes) &&
- "Storing too many bytes in a RegisterValue.");
- m_type = eTypeBytes;
- buffer.length = length;
- memcpy(buffer.bytes, bytes, length);
- buffer.byte_order = byte_order;
- } else {
- m_type = eTypeInvalid;
- buffer.length = 0;
- }
-}
-
-bool RegisterValue::operator==(const RegisterValue &rhs) const {
- if (m_type == rhs.m_type) {
- switch (m_type) {
- case eTypeInvalid:
- return true;
- case eTypeUInt8:
- case eTypeUInt16:
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- return m_scalar == rhs.m_scalar;
- case eTypeBytes:
- if (buffer.length != rhs.buffer.length)
- return false;
- else {
- uint8_t length = buffer.length;
- if (length > kMaxRegisterByteSize)
- length = kMaxRegisterByteSize;
- return memcmp(buffer.bytes, rhs.buffer.bytes, length) == 0;
- }
- break;
- }
- }
- return false;
-}
-
-bool RegisterValue::operator!=(const RegisterValue &rhs) const {
- if (m_type != rhs.m_type)
- return true;
- switch (m_type) {
- case eTypeInvalid:
- return false;
- case eTypeUInt8:
- case eTypeUInt16:
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- return m_scalar != rhs.m_scalar;
- case eTypeBytes:
- if (buffer.length != rhs.buffer.length) {
- return true;
- } else {
- uint8_t length = buffer.length;
- if (length > kMaxRegisterByteSize)
- length = kMaxRegisterByteSize;
- return memcmp(buffer.bytes, rhs.buffer.bytes, length) != 0;
- }
- break;
- }
- return true;
-}
-
-bool RegisterValue::ClearBit(uint32_t bit) {
- switch (m_type) {
- case eTypeInvalid:
- break;
-
- case eTypeUInt8:
- case eTypeUInt16:
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- if (bit < (GetByteSize() * 8)) {
- return m_scalar.ClearBit(bit);
- }
- break;
-
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- break;
-
- case eTypeBytes:
- if (buffer.byte_order == eByteOrderBig ||
- buffer.byte_order == eByteOrderLittle) {
- uint32_t byte_idx;
- if (buffer.byte_order == eByteOrderBig)
- byte_idx = buffer.length - (bit / 8) - 1;
- else
- byte_idx = bit / 8;
-
- const uint32_t byte_bit = bit % 8;
- if (byte_idx < buffer.length) {
- buffer.bytes[byte_idx] &= ~(1u << byte_bit);
- return true;
- }
- }
- break;
- }
- return false;
-}
-
-bool RegisterValue::SetBit(uint32_t bit) {
- switch (m_type) {
- case eTypeInvalid:
- break;
-
- case eTypeUInt8:
- case eTypeUInt16:
- case eTypeUInt32:
- case eTypeUInt64:
- case eTypeUInt128:
- if (bit < (GetByteSize() * 8)) {
- return m_scalar.SetBit(bit);
- }
- break;
-
- case eTypeFloat:
- case eTypeDouble:
- case eTypeLongDouble:
- break;
-
- case eTypeBytes:
- if (buffer.byte_order == eByteOrderBig ||
- buffer.byte_order == eByteOrderLittle) {
- uint32_t byte_idx;
- if (buffer.byte_order == eByteOrderBig)
- byte_idx = buffer.length - (bit / 8) - 1;
- else
- byte_idx = bit / 8;
-
- const uint32_t byte_bit = bit % 8;
- if (byte_idx < buffer.length) {
- buffer.bytes[byte_idx] |= (1u << byte_bit);
- return true;
- }
- }
- break;
- }
- return false;
-}
diff --git a/source/Core/RichManglingContext.cpp b/source/Core/RichManglingContext.cpp
new file mode 100644
index 000000000000..f5fbe38a49fb
--- /dev/null
+++ b/source/Core/RichManglingContext.cpp
@@ -0,0 +1,175 @@
+//===-- RichManglingContext.cpp ---------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/RichManglingContext.h"
+
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Logging.h"
+
+#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
+
+#include "llvm/ADT/StringRef.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+//----------------------------------------------------------------------
+// RichManglingContext
+//----------------------------------------------------------------------
+void RichManglingContext::ResetProvider(InfoProvider new_provider) {
+ // If we want to support parsers for other languages some day, we need a
+ // switch here to delete the correct parser type.
+ if (m_cxx_method_parser.hasValue()) {
+ assert(m_provider == PluginCxxLanguage);
+ delete get<CPlusPlusLanguage::MethodName>(m_cxx_method_parser);
+ m_cxx_method_parser.reset();
+ }
+
+ assert(new_provider != None && "Only reset to a valid provider");
+ m_provider = new_provider;
+}
+
+bool RichManglingContext::FromItaniumName(const ConstString &mangled) {
+ bool err = m_ipd.partialDemangle(mangled.GetCString());
+ if (!err) {
+ ResetProvider(ItaniumPartialDemangler);
+ }
+
+ if (Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DEMANGLE)) {
+ if (!err) {
+ ParseFullName();
+ LLDB_LOG(log, "demangled itanium: {0} -> \"{1}\"", mangled, m_ipd_buf);
+ } else {
+ LLDB_LOG(log, "demangled itanium: {0} -> error: failed to demangle",
+ mangled);
+ }
+ }
+
+ return !err; // true == success
+}
+
+bool RichManglingContext::FromCxxMethodName(const ConstString &demangled) {
+ ResetProvider(PluginCxxLanguage);
+ m_cxx_method_parser = new CPlusPlusLanguage::MethodName(demangled);
+ return true;
+}
+
+bool RichManglingContext::IsCtorOrDtor() const {
+ assert(m_provider != None && "Initialize a provider first");
+ switch (m_provider) {
+ case ItaniumPartialDemangler:
+ return m_ipd.isCtorOrDtor();
+ case PluginCxxLanguage: {
+ // We can only check for destructors here.
+ auto base_name =
+ get<CPlusPlusLanguage::MethodName>(m_cxx_method_parser)->GetBasename();
+ return base_name.startswith("~");
+ }
+ case None:
+ return false;
+ }
+ llvm_unreachable("Fully covered switch above!");
+}
+
+bool RichManglingContext::IsFunction() const {
+ assert(m_provider != None && "Initialize a provider first");
+ switch (m_provider) {
+ case ItaniumPartialDemangler:
+ return m_ipd.isFunction();
+ case PluginCxxLanguage:
+ return get<CPlusPlusLanguage::MethodName>(m_cxx_method_parser)->IsValid();
+ case None:
+ return false;
+ }
+ llvm_unreachable("Fully covered switch above!");
+}
+
+void RichManglingContext::processIPDStrResult(char *ipd_res, size_t res_size) {
+ // Error case: Clear the buffer.
+ if (LLVM_UNLIKELY(ipd_res == nullptr)) {
+ assert(res_size == m_ipd_buf_size &&
+ "Failed IPD queries keep the original size in the N parameter");
+
+ m_ipd_buf[0] = '\0';
+ m_buffer = llvm::StringRef(m_ipd_buf, 0);
+ return;
+ }
+
+ // IPD's res_size includes null terminator.
+ assert(ipd_res[res_size - 1] == '\0' &&
+ "IPD returns null-terminated strings and we rely on that");
+
+ // Update buffer/size on realloc.
+ if (LLVM_UNLIKELY(ipd_res != m_ipd_buf || res_size > m_ipd_buf_size)) {
+ m_ipd_buf = ipd_res; // std::realloc freed or reused the old buffer.
+ m_ipd_buf_size = res_size; // May actually be bigger, but we can't know.
+
+ if (Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DEMANGLE))
+ LLDB_LOG(log, "ItaniumPartialDemangler Realloc: new buffer size is {0}",
+ m_ipd_buf_size);
+ }
+
+ // 99% case: Just remember the string length.
+ m_buffer = llvm::StringRef(m_ipd_buf, res_size - 1);
+}
+
+void RichManglingContext::ParseFunctionBaseName() {
+ assert(m_provider != None && "Initialize a provider first");
+ switch (m_provider) {
+ case ItaniumPartialDemangler: {
+ auto n = m_ipd_buf_size;
+ auto buf = m_ipd.getFunctionBaseName(m_ipd_buf, &n);
+ processIPDStrResult(buf, n);
+ return;
+ }
+ case PluginCxxLanguage:
+ m_buffer =
+ get<CPlusPlusLanguage::MethodName>(m_cxx_method_parser)->GetBasename();
+ return;
+ case None:
+ return;
+ }
+}
+
+void RichManglingContext::ParseFunctionDeclContextName() {
+ assert(m_provider != None && "Initialize a provider first");
+ switch (m_provider) {
+ case ItaniumPartialDemangler: {
+ auto n = m_ipd_buf_size;
+ auto buf = m_ipd.getFunctionDeclContextName(m_ipd_buf, &n);
+ processIPDStrResult(buf, n);
+ return;
+ }
+ case PluginCxxLanguage:
+ m_buffer =
+ get<CPlusPlusLanguage::MethodName>(m_cxx_method_parser)->GetContext();
+ return;
+ case None:
+ return;
+ }
+}
+
+void RichManglingContext::ParseFullName() {
+ assert(m_provider != None && "Initialize a provider first");
+ switch (m_provider) {
+ case ItaniumPartialDemangler: {
+ auto n = m_ipd_buf_size;
+ auto buf = m_ipd.finishDemangle(m_ipd_buf, &n);
+ processIPDStrResult(buf, n);
+ return;
+ }
+ case PluginCxxLanguage:
+ m_buffer = get<CPlusPlusLanguage::MethodName>(m_cxx_method_parser)
+ ->GetFullName()
+ .GetStringRef();
+ return;
+ case None:
+ return;
+ }
+}
diff --git a/source/Core/Scalar.cpp b/source/Core/Scalar.cpp
deleted file mode 100644
index 6a7186969ef2..000000000000
--- a/source/Core/Scalar.cpp
+++ /dev/null
@@ -1,2852 +0,0 @@
-//===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Core/Scalar.h"
-
-#include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/Endian.h"
-#include "lldb/Utility/Status.h"
-#include "lldb/Utility/Stream.h"
-#include "lldb/lldb-types.h" // for offset_t
-
-#include "llvm/ADT/SmallString.h"
-
-#include <cinttypes>
-#include <cstdio>
-
-using namespace lldb;
-using namespace lldb_private;
-
-//----------------------------------------------------------------------
-// Promote to max type currently follows the ANSI C rule for type promotion in
-// expressions.
-//----------------------------------------------------------------------
-static Scalar::Type PromoteToMaxType(
- const Scalar &lhs, // The const left hand side object
- const Scalar &rhs, // The const right hand side object
- Scalar &temp_value, // A modifiable temp value than can be used to hold
- // either the promoted lhs or rhs object
- const Scalar *&promoted_lhs_ptr, // Pointer to the resulting possibly
- // promoted value of lhs (at most one of
- // lhs/rhs will get promoted)
- const Scalar *&promoted_rhs_ptr // Pointer to the resulting possibly
- // promoted value of rhs (at most one of
- // lhs/rhs will get promoted)
- ) {
- Scalar result;
- // Initialize the promoted values for both the right and left hand side
- // values to be the objects themselves. If no promotion is needed (both right
- // and left have the same type), then the temp_value will not get used.
- promoted_lhs_ptr = &lhs;
- promoted_rhs_ptr = &rhs;
- // Extract the types of both the right and left hand side values
- Scalar::Type lhs_type = lhs.GetType();
- Scalar::Type rhs_type = rhs.GetType();
-
- if (lhs_type > rhs_type) {
- // Right hand side need to be promoted
- temp_value = rhs; // Copy right hand side into the temp value
- if (temp_value.Promote(lhs_type)) // Promote it
- promoted_rhs_ptr =
- &temp_value; // Update the pointer for the promoted right hand side
- } else if (lhs_type < rhs_type) {
- // Left hand side need to be promoted
- temp_value = lhs; // Copy left hand side value into the temp value
- if (temp_value.Promote(rhs_type)) // Promote it
- promoted_lhs_ptr =
- &temp_value; // Update the pointer for the promoted left hand side
- }
-
- // Make sure our type promotion worked as expected
- if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
- return promoted_lhs_ptr->GetType(); // Return the resulting max type
-
- // Return the void type (zero) if we fail to promote either of the values.
- return Scalar::e_void;
-}
-
-Scalar::Scalar() : m_type(e_void), m_float((float)0) {}
-
-Scalar::Scalar(const Scalar &rhs)
- : m_type(rhs.m_type), m_integer(rhs.m_integer), m_float(rhs.m_float) {}
-
-// Scalar::Scalar(const RegisterValue& reg) :
-// m_type(e_void),
-// m_data()
-//{
-// switch (reg.info.encoding)
-// {
-// case eEncodingUint: // unsigned integer
-// switch (reg.info.byte_size)
-// {
-// case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
-// case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
-// case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
-// case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64;
-// break;
-// break;
-// }
-// break;
-//
-// case eEncodingSint: // signed integer
-// switch (reg.info.byte_size)
-// {
-// case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
-// case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
-// case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
-// case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64;
-// break;
-// break;
-// }
-// break;
-//
-// case eEncodingIEEE754: // float
-// switch (reg.info.byte_size)
-// {
-// case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
-// case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
-// break;
-// }
-// break;
-// case eEncodingVector: // vector registers
-// break;
-// }
-//}
-
-bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
- size_t byte_size = GetByteSize();
- if (byte_size > 0) {
- const uint8_t *bytes = reinterpret_cast<const uint8_t *>(GetBytes());
-
- if (limit_byte_size < byte_size) {
- if (endian::InlHostByteOrder() == eByteOrderLittle) {
- // On little endian systems if we want fewer bytes from the current
- // type we just specify fewer bytes since the LSByte is first...
- byte_size = limit_byte_size;
- } else if (endian::InlHostByteOrder() == eByteOrderBig) {
- // On big endian systems if we want fewer bytes from the current type
- // have to advance our initial byte pointer and trim down the number of
- // bytes since the MSByte is first
- bytes += byte_size - limit_byte_size;
- byte_size = limit_byte_size;
- }
- }
-
- data.SetData(bytes, byte_size, endian::InlHostByteOrder());
- return true;
- }
- data.Clear();
- return false;
-}
-
-const void *Scalar::GetBytes() const {
- const uint64_t *apint_words;
- const uint8_t *bytes;
- static float_t flt_val;
- static double_t dbl_val;
- static uint64_t swapped_words[4];
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- bytes = reinterpret_cast<const uint8_t *>(m_integer.getRawData());
- // getRawData always returns a pointer to an uint64_t. If we have a
- // smaller type, we need to update the pointer on big-endian systems.
- if (endian::InlHostByteOrder() == eByteOrderBig) {
- size_t byte_size = m_integer.getBitWidth() / 8;
- if (byte_size < 8)
- bytes += 8 - byte_size;
- }
- return bytes;
- case e_sint128:
- case e_uint128:
- apint_words = m_integer.getRawData();
- // getRawData always returns a pointer to an array of two uint64_t values,
- // where the least-significant word always comes first. On big-endian
- // systems we need to swap the two words.
- if (endian::InlHostByteOrder() == eByteOrderBig) {
- swapped_words[0] = apint_words[1];
- swapped_words[1] = apint_words[0];
- apint_words = swapped_words;
- }
- return reinterpret_cast<const void *>(apint_words);
- case e_sint256:
- case e_uint256:
- apint_words = m_integer.getRawData();
- // getRawData always returns a pointer to an array of four uint64_t values,
- // where the least-significant word always comes first. On big-endian
- // systems we need to swap the four words.
- if (endian::InlHostByteOrder() == eByteOrderBig) {
- swapped_words[0] = apint_words[3];
- swapped_words[1] = apint_words[2];
- swapped_words[2] = apint_words[1];
- swapped_words[3] = apint_words[0];
- apint_words = swapped_words;
- }
- return reinterpret_cast<const void *>(apint_words);
- case e_float:
- flt_val = m_float.convertToFloat();
- return reinterpret_cast<const void *>(&flt_val);
- case e_double:
- dbl_val = m_float.convertToDouble();
- return reinterpret_cast<const void *>(&dbl_val);
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- apint_words = ldbl_val.getRawData();
- // getRawData always returns a pointer to an array of two uint64_t values,
- // where the least-significant word always comes first. On big-endian
- // systems we need to swap the two words.
- if (endian::InlHostByteOrder() == eByteOrderBig) {
- swapped_words[0] = apint_words[1];
- swapped_words[1] = apint_words[0];
- apint_words = swapped_words;
- }
- return reinterpret_cast<const void *>(apint_words);
- }
- return nullptr;
-}
-
-size_t Scalar::GetByteSize() const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return (m_integer.getBitWidth() / 8);
- case e_float:
- return sizeof(float_t);
- case e_double:
- return sizeof(double_t);
- case e_long_double:
- return sizeof(long_double_t);
- }
- return 0;
-}
-
-bool Scalar::IsZero() const {
- llvm::APInt zero_int = llvm::APInt::getNullValue(m_integer.getBitWidth() / 8);
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return llvm::APInt::isSameValue(zero_int, m_integer);
- case e_float:
- case e_double:
- case e_long_double:
- return m_float.isZero();
- }
- return false;
-}
-
-void Scalar::GetValue(Stream *s, bool show_type) const {
- if (show_type)
- s->Printf("(%s) ", GetTypeAsCString());
-
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_slong:
- case e_slonglong:
- case e_sint128:
- case e_sint256:
- s->PutCString(m_integer.toString(10, true));
- break;
- case e_uint:
- case e_ulong:
- case e_ulonglong:
- case e_uint128:
- case e_uint256:
- s->PutCString(m_integer.toString(10, false));
- break;
- case e_float:
- case e_double:
- case e_long_double:
- llvm::SmallString<24> string;
- m_float.toString(string);
- s->Printf("%s", string.c_str());
- break;
- }
-}
-
-const char *Scalar::GetTypeAsCString() const {
- switch (m_type) {
- case e_void:
- return "void";
- case e_sint:
- return "int";
- case e_uint:
- return "unsigned int";
- case e_slong:
- return "long";
- case e_ulong:
- return "unsigned long";
- case e_slonglong:
- return "long long";
- case e_ulonglong:
- return "unsigned long long";
- case e_sint128:
- return "int128_t";
- case e_uint128:
- return "unsigned int128_t";
- case e_sint256:
- return "int256_t";
- case e_uint256:
- return "unsigned int256_t";
- case e_float:
- return "float";
- case e_double:
- return "double";
- case e_long_double:
- return "long double";
- }
- return "<invalid Scalar type>";
-}
-
-Scalar &Scalar::operator=(const Scalar &rhs) {
- if (this != &rhs) {
- m_type = rhs.m_type;
- m_integer = llvm::APInt(rhs.m_integer);
- m_float = rhs.m_float;
- }
- return *this;
-}
-
-Scalar &Scalar::operator=(const int v) {
- m_type = e_sint;
- m_integer = llvm::APInt(sizeof(int) * 8, v, true);
- return *this;
-}
-
-Scalar &Scalar::operator=(unsigned int v) {
- m_type = e_uint;
- m_integer = llvm::APInt(sizeof(int) * 8, v);
- return *this;
-}
-
-Scalar &Scalar::operator=(long v) {
- m_type = e_slong;
- m_integer = llvm::APInt(sizeof(long) * 8, v, true);
- return *this;
-}
-
-Scalar &Scalar::operator=(unsigned long v) {
- m_type = e_ulong;
- m_integer = llvm::APInt(sizeof(long) * 8, v);
- return *this;
-}
-
-Scalar &Scalar::operator=(long long v) {
- m_type = e_slonglong;
- m_integer = llvm::APInt(sizeof(long) * 8, v, true);
- return *this;
-}
-
-Scalar &Scalar::operator=(unsigned long long v) {
- m_type = e_ulonglong;
- m_integer = llvm::APInt(sizeof(long long) * 8, v);
- return *this;
-}
-
-Scalar &Scalar::operator=(float v) {
- m_type = e_float;
- m_float = llvm::APFloat(v);
- return *this;
-}
-
-Scalar &Scalar::operator=(double v) {
- m_type = e_double;
- m_float = llvm::APFloat(v);
- return *this;
-}
-
-Scalar &Scalar::operator=(long double v) {
- m_type = e_long_double;
- if (m_ieee_quad)
- m_float = llvm::APFloat(
- llvm::APFloat::IEEEquad(),
- llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
- else
- m_float = llvm::APFloat(
- llvm::APFloat::x87DoubleExtended(),
- llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, ((type128 *)&v)->x));
- return *this;
-}
-
-Scalar &Scalar::operator=(llvm::APInt rhs) {
- m_integer = llvm::APInt(rhs);
- switch (m_integer.getBitWidth()) {
- case 8:
- case 16:
- case 32:
- if (m_integer.isSignedIntN(sizeof(sint_t) * 8))
- m_type = e_sint;
- else
- m_type = e_uint;
- break;
- case 64:
- if (m_integer.isSignedIntN(sizeof(slonglong_t) * 8))
- m_type = e_slonglong;
- else
- m_type = e_ulonglong;
- break;
- case 128:
- if (m_integer.isSignedIntN(BITWIDTH_INT128))
- m_type = e_sint128;
- else
- m_type = e_uint128;
- break;
- case 256:
- if (m_integer.isSignedIntN(BITWIDTH_INT256))
- m_type = e_sint256;
- else
- m_type = e_uint256;
- break;
- }
- return *this;
-}
-
-Scalar::~Scalar() = default;
-
-bool Scalar::Promote(Scalar::Type type) {
- bool success = false;
- switch (m_type) {
- case e_void:
- break;
-
- case e_sint:
- switch (type) {
- case e_void:
- break;
- case e_sint:
- success = true;
- break;
- case e_uint:
- m_integer = m_integer.sextOrTrunc(sizeof(uint_t) * 8);
- success = true;
- break;
-
- case e_slong:
- m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
- success = true;
- break;
-
- case e_ulong:
- m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
- success = true;
- break;
-
- case e_slonglong:
- m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
- success = true;
- break;
-
- case e_ulonglong:
- m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
- success = true;
- break;
-
- case e_sint128:
- case e_uint128:
- m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
- success = true;
- break;
-
- case e_sint256:
- case e_uint256:
- m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
- success = true;
- break;
-
- case e_float:
- m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_double:
- m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_long_double:
- m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
- : llvm::APFloat::x87DoubleExtended());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
- }
- break;
-
- case e_uint:
- switch (type) {
- case e_void:
- case e_sint:
- break;
- case e_uint:
- success = true;
- break;
- case e_slong:
- m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
- success = true;
- break;
-
- case e_ulong:
- m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
- success = true;
- break;
-
- case e_slonglong:
- m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
- success = true;
- break;
-
- case e_ulonglong:
- m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
- success = true;
- break;
-
- case e_sint128:
- case e_uint128:
- m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
- success = true;
- break;
-
- case e_sint256:
- case e_uint256:
- m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
- success = true;
- break;
-
- case e_float:
- m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_double:
- m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_long_double:
- m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
- : llvm::APFloat::x87DoubleExtended());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
- }
- break;
-
- case e_slong:
- switch (type) {
- case e_void:
- case e_sint:
- case e_uint:
- break;
- case e_slong:
- success = true;
- break;
- case e_ulong:
- m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
- success = true;
- break;
-
- case e_slonglong:
- m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
- success = true;
- break;
-
- case e_ulonglong:
- m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
- success = true;
- break;
-
- case e_sint128:
- case e_uint128:
- m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
- success = true;
- break;
-
- case e_sint256:
- case e_uint256:
- m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
- success = true;
- break;
-
- case e_float:
- m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_double:
- m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_long_double:
- m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
- : llvm::APFloat::x87DoubleExtended());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
- }
- break;
-
- case e_ulong:
- switch (type) {
- case e_void:
- case e_sint:
- case e_uint:
- case e_slong:
- break;
- case e_ulong:
- success = true;
- break;
- case e_slonglong:
- m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
- success = true;
- break;
-
- case e_ulonglong:
- m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
- success = true;
- break;
-
- case e_sint128:
- case e_uint128:
- m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
- success = true;
- break;
-
- case e_sint256:
- case e_uint256:
- m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
- success = true;
- break;
-
- case e_float:
- m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_double:
- m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_long_double:
- m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
- : llvm::APFloat::x87DoubleExtended());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
- }
- break;
-
- case e_slonglong:
- switch (type) {
- case e_void:
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- break;
- case e_slonglong:
- success = true;
- break;
- case e_ulonglong:
- m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
- success = true;
- break;
-
- case e_sint128:
- case e_uint128:
- m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
- success = true;
- break;
-
- case e_sint256:
- case e_uint256:
- m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
- success = true;
- break;
-
- case e_float:
- m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_double:
- m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_long_double:
- m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
- : llvm::APFloat::x87DoubleExtended());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
- }
- break;
-
- case e_ulonglong:
- switch (type) {
- case e_void:
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- break;
- case e_ulonglong:
- success = true;
- break;
- case e_sint128:
- case e_uint128:
- m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
- success = true;
- break;
-
- case e_sint256:
- case e_uint256:
- m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
- success = true;
- break;
-
- case e_float:
- m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_double:
- m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_long_double:
- m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
- : llvm::APFloat::x87DoubleExtended());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
- }
- break;
-
- case e_sint128:
- switch (type) {
- case e_void:
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- break;
- case e_sint128:
- success = true;
- break;
- case e_uint128:
- m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
- success = true;
- break;
-
- case e_sint256:
- case e_uint256:
- m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
- success = true;
- break;
-
- case e_float:
- m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_double:
- m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_long_double:
- m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
- : llvm::APFloat::x87DoubleExtended());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
- }
- break;
-
- case e_uint128:
- switch (type) {
- case e_void:
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- break;
- case e_uint128:
- success = true;
- break;
- case e_sint256:
- case e_uint256:
- m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
- success = true;
- break;
-
- case e_float:
- m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_double:
- m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_long_double:
- m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
- : llvm::APFloat::x87DoubleExtended());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
- }
- break;
-
- case e_sint256:
- switch (type) {
- case e_void:
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- break;
- case e_sint256:
- success = true;
- break;
- case e_uint256:
- m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
- success = true;
- break;
-
- case e_float:
- m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_double:
- m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_long_double:
- m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
- : llvm::APFloat::x87DoubleExtended());
- m_float.convertFromAPInt(m_integer, true,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
- }
- break;
-
- case e_uint256:
- switch (type) {
- case e_void:
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- break;
- case e_uint256:
- success = true;
- break;
- case e_float:
- m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_double:
- m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
-
- case e_long_double:
- m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad()
- : llvm::APFloat::x87DoubleExtended());
- m_float.convertFromAPInt(m_integer, false,
- llvm::APFloat::rmNearestTiesToEven);
- success = true;
- break;
- }
- break;
-
- case e_float:
- switch (type) {
- case e_void:
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- break;
- case e_float:
- success = true;
- break;
- case e_double:
- m_float = llvm::APFloat((double_t)m_float.convertToFloat());
- success = true;
- break;
-
- case e_long_double: {
- bool ignore;
- m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
- : llvm::APFloat::x87DoubleExtended(),
- llvm::APFloat::rmNearestTiesToEven, &ignore);
- success = true;
- break;
- }
- }
- break;
-
- case e_double:
- switch (type) {
- case e_void:
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_float:
- break;
- case e_double:
- success = true;
- break;
- case e_long_double: {
- bool ignore;
- m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad()
- : llvm::APFloat::x87DoubleExtended(),
- llvm::APFloat::rmNearestTiesToEven, &ignore);
- success = true;
- break;
- }
- }
- break;
-
- case e_long_double:
- switch (type) {
- case e_void:
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- case e_float:
- case e_double:
- break;
- case e_long_double:
- success = true;
- break;
- }
- break;
- }
-
- if (success)
- m_type = type;
- return success;
-}
-
-const char *Scalar::GetValueTypeAsCString(Scalar::Type type) {
- switch (type) {
- case e_void:
- return "void";
- case e_sint:
- return "int";
- case e_uint:
- return "unsigned int";
- case e_slong:
- return "long";
- case e_ulong:
- return "unsigned long";
- case e_slonglong:
- return "long long";
- case e_ulonglong:
- return "unsigned long long";
- case e_float:
- return "float";
- case e_double:
- return "double";
- case e_long_double:
- return "long double";
- case e_sint128:
- return "int128_t";
- case e_uint128:
- return "uint128_t";
- case e_sint256:
- return "int256_t";
- case e_uint256:
- return "uint256_t";
- }
- return "???";
-}
-
-Scalar::Type
-Scalar::GetValueTypeForSignedIntegerWithByteSize(size_t byte_size) {
- if (byte_size <= sizeof(sint_t))
- return e_sint;
- if (byte_size <= sizeof(slong_t))
- return e_slong;
- if (byte_size <= sizeof(slonglong_t))
- return e_slonglong;
- return e_void;
-}
-
-Scalar::Type
-Scalar::GetValueTypeForUnsignedIntegerWithByteSize(size_t byte_size) {
- if (byte_size <= sizeof(uint_t))
- return e_uint;
- if (byte_size <= sizeof(ulong_t))
- return e_ulong;
- if (byte_size <= sizeof(ulonglong_t))
- return e_ulonglong;
- return e_void;
-}
-
-Scalar::Type Scalar::GetValueTypeForFloatWithByteSize(size_t byte_size) {
- if (byte_size == sizeof(float_t))
- return e_float;
- if (byte_size == sizeof(double_t))
- return e_double;
- if (byte_size == sizeof(long_double_t))
- return e_long_double;
- return e_void;
-}
-
-bool Scalar::MakeSigned() {
- bool success = false;
-
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- success = true;
- break;
- case e_uint:
- m_type = e_sint;
- success = true;
- break;
- case e_slong:
- success = true;
- break;
- case e_ulong:
- m_type = e_slong;
- success = true;
- break;
- case e_slonglong:
- success = true;
- break;
- case e_ulonglong:
- m_type = e_slonglong;
- success = true;
- break;
- case e_sint128:
- success = true;
- break;
- case e_uint128:
- m_type = e_sint128;
- success = true;
- break;
- case e_sint256:
- success = true;
- break;
- case e_uint256:
- m_type = e_sint256;
- success = true;
- break;
- case e_float:
- success = true;
- break;
- case e_double:
- success = true;
- break;
- case e_long_double:
- success = true;
- break;
- }
-
- return success;
-}
-
-bool Scalar::MakeUnsigned() {
- bool success = false;
-
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- m_type = e_uint;
- success = true;
- break;
- case e_uint:
- success = true;
- break;
- case e_slong:
- m_type = e_ulong;
- success = true;
- break;
- case e_ulong:
- success = true;
- break;
- case e_slonglong:
- m_type = e_ulonglong;
- success = true;
- break;
- case e_ulonglong:
- success = true;
- break;
- case e_sint128:
- m_type = e_uint128;
- success = true;
- break;
- case e_uint128:
- success = true;
- break;
- case e_sint256:
- m_type = e_uint256;
- success = true;
- break;
- case e_uint256:
- success = true;
- break;
- case e_float:
- success = true;
- break;
- case e_double:
- success = true;
- break;
- case e_long_double:
- success = true;
- break;
- }
-
- return success;
-}
-
-signed char Scalar::SChar(char fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return (schar_t)(m_integer.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
- case e_float:
- return (schar_t)m_float.convertToFloat();
- case e_double:
- return (schar_t)m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return (schar_t)(ldbl_val.sextOrTrunc(sizeof(schar_t) * 8)).getSExtValue();
- }
- return fail_value;
-}
-
-unsigned char Scalar::UChar(unsigned char fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return (uchar_t)(m_integer.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
- case e_float:
- return (uchar_t)m_float.convertToFloat();
- case e_double:
- return (uchar_t)m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return (uchar_t)(ldbl_val.zextOrTrunc(sizeof(uchar_t) * 8)).getZExtValue();
- }
- return fail_value;
-}
-
-short Scalar::SShort(short fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return (sshort_t)(m_integer.sextOrTrunc(sizeof(sshort_t) * 8))
- .getSExtValue();
- case e_float:
- return (sshort_t)m_float.convertToFloat();
- case e_double:
- return (sshort_t)m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return (sshort_t)(ldbl_val.sextOrTrunc(sizeof(sshort_t) * 8))
- .getSExtValue();
- }
- return fail_value;
-}
-
-unsigned short Scalar::UShort(unsigned short fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return (ushort_t)(m_integer.zextOrTrunc(sizeof(ushort_t) * 8))
- .getZExtValue();
- case e_float:
- return (ushort_t)m_float.convertToFloat();
- case e_double:
- return (ushort_t)m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return (ushort_t)(ldbl_val.zextOrTrunc(sizeof(ushort_t) * 8))
- .getZExtValue();
- }
- return fail_value;
-}
-
-int Scalar::SInt(int fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return (sint_t)(m_integer.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
- case e_float:
- return (sint_t)m_float.convertToFloat();
- case e_double:
- return (sint_t)m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return (sint_t)(ldbl_val.sextOrTrunc(sizeof(sint_t) * 8)).getSExtValue();
- }
- return fail_value;
-}
-
-unsigned int Scalar::UInt(unsigned int fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return (uint_t)(m_integer.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
- case e_float:
- return (uint_t)m_float.convertToFloat();
- case e_double:
- return (uint_t)m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return (uint_t)(ldbl_val.zextOrTrunc(sizeof(uint_t) * 8)).getZExtValue();
- }
- return fail_value;
-}
-
-long Scalar::SLong(long fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return (slong_t)(m_integer.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
- case e_float:
- return (slong_t)m_float.convertToFloat();
- case e_double:
- return (slong_t)m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return (slong_t)(ldbl_val.sextOrTrunc(sizeof(slong_t) * 8)).getSExtValue();
- }
- return fail_value;
-}
-
-unsigned long Scalar::ULong(unsigned long fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return (ulong_t)(m_integer.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
- case e_float:
- return (ulong_t)m_float.convertToFloat();
- case e_double:
- return (ulong_t)m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return (ulong_t)(ldbl_val.zextOrTrunc(sizeof(ulong_t) * 8)).getZExtValue();
- }
- return fail_value;
-}
-
-long long Scalar::SLongLong(long long fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return (slonglong_t)(m_integer.sextOrTrunc(sizeof(slonglong_t) * 8))
- .getSExtValue();
- case e_float:
- return (slonglong_t)m_float.convertToFloat();
- case e_double:
- return (slonglong_t)m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return (slonglong_t)(ldbl_val.sextOrTrunc(sizeof(slonglong_t) * 8))
- .getSExtValue();
- }
- return fail_value;
-}
-
-unsigned long long Scalar::ULongLong(unsigned long long fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return (ulonglong_t)(m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8))
- .getZExtValue();
- case e_float:
- return (ulonglong_t)m_float.convertToFloat();
- case e_double:
- return (ulonglong_t)m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return (ulonglong_t)(ldbl_val.zextOrTrunc(sizeof(ulonglong_t) * 8))
- .getZExtValue();
- }
- return fail_value;
-}
-
-llvm::APInt Scalar::SInt128(llvm::APInt &fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return m_integer;
- case e_float:
- case e_double:
- case e_long_double:
- return m_float.bitcastToAPInt();
- }
- return fail_value;
-}
-
-llvm::APInt Scalar::UInt128(const llvm::APInt &fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return m_integer;
- case e_float:
- case e_double:
- case e_long_double:
- return m_float.bitcastToAPInt();
- }
- return fail_value;
-}
-
-llvm::APInt Scalar::SInt256(llvm::APInt &fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return m_integer;
- case e_float:
- case e_double:
- case e_long_double:
- return m_float.bitcastToAPInt();
- }
- return fail_value;
-}
-
-llvm::APInt Scalar::UInt256(const llvm::APInt &fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return m_integer;
- case e_float:
- case e_double:
- case e_long_double:
- return m_float.bitcastToAPInt();
- }
- return fail_value;
-}
-
-float Scalar::Float(float fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return llvm::APIntOps::RoundAPIntToFloat(m_integer);
- case e_float:
- return m_float.convertToFloat();
- case e_double:
- return (float_t)m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return ldbl_val.bitsToFloat();
- }
- return fail_value;
-}
-
-double Scalar::Double(double fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return llvm::APIntOps::RoundAPIntToDouble(m_integer);
- case e_float:
- return (double_t)m_float.convertToFloat();
- case e_double:
- return m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return ldbl_val.bitsToFloat();
- }
- return fail_value;
-}
-
-long double Scalar::LongDouble(long double fail_value) const {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- return (long_double_t)llvm::APIntOps::RoundAPIntToDouble(m_integer);
- case e_float:
- return (long_double_t)m_float.convertToFloat();
- case e_double:
- return (long_double_t)m_float.convertToDouble();
- case e_long_double:
- llvm::APInt ldbl_val = m_float.bitcastToAPInt();
- return (long_double_t)ldbl_val.bitsToDouble();
- }
- return fail_value;
-}
-
-Scalar &Scalar::operator+=(const Scalar &rhs) {
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) !=
- Scalar::e_void) {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- m_integer = a->m_integer + b->m_integer;
- break;
-
- case e_float:
- case e_double:
- case e_long_double:
- m_float = a->m_float + b->m_float;
- break;
- }
- }
- return *this;
-}
-
-Scalar &Scalar::operator<<=(const Scalar &rhs) {
- switch (m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
-
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- switch (rhs.m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- m_integer = m_integer << rhs.m_integer;
- break;
- }
- break;
- }
- return *this;
-}
-
-bool Scalar::ShiftRightLogical(const Scalar &rhs) {
- switch (m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
-
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- switch (rhs.m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- m_integer = m_integer.lshr(rhs.m_integer);
- break;
- }
- break;
- }
- return m_type != e_void;
-}
-
-Scalar &Scalar::operator>>=(const Scalar &rhs) {
- switch (m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
-
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- switch (rhs.m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- m_integer = m_integer.ashr(rhs.m_integer);
- break;
- }
- break;
- }
- return *this;
-}
-
-Scalar &Scalar::operator&=(const Scalar &rhs) {
- switch (m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
-
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- switch (rhs.m_type) {
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- m_type = e_void;
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- m_integer &= rhs.m_integer;
- break;
- }
- break;
- }
- return *this;
-}
-
-bool Scalar::AbsoluteValue() {
- switch (m_type) {
- case e_void:
- break;
-
- case e_sint:
- case e_slong:
- case e_slonglong:
- case e_sint128:
- case e_sint256:
- if (m_integer.isNegative())
- m_integer = -m_integer;
- return true;
-
- case e_uint:
- case e_ulong:
- case e_ulonglong:
- return true;
- case e_uint128:
- case e_uint256:
- case e_float:
- case e_double:
- case e_long_double:
- m_float.clearSign();
- return true;
- }
- return false;
-}
-
-bool Scalar::UnaryNegate() {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- m_integer = -m_integer;
- return true;
- case e_float:
- case e_double:
- case e_long_double:
- m_float.changeSign();
- return true;
- }
- return false;
-}
-
-bool Scalar::OnesComplement() {
- switch (m_type) {
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- m_integer = ~m_integer;
- return true;
-
- case e_void:
- case e_float:
- case e_double:
- case e_long_double:
- break;
- }
- return false;
-}
-
-const Scalar lldb_private::operator+(const Scalar &lhs, const Scalar &rhs) {
- Scalar result;
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
- Scalar::e_void) {
- switch (result.m_type) {
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- result.m_integer = a->m_integer + b->m_integer;
- break;
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- result.m_float = a->m_float + b->m_float;
- break;
- }
- }
- return result;
-}
-
-const Scalar lldb_private::operator-(const Scalar &lhs, const Scalar &rhs) {
- Scalar result;
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
- Scalar::e_void) {
- switch (result.m_type) {
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- result.m_integer = a->m_integer - b->m_integer;
- break;
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- result.m_float = a->m_float - b->m_float;
- break;
- }
- }
- return result;
-}
-
-const Scalar lldb_private::operator/(const Scalar &lhs, const Scalar &rhs) {
- Scalar result;
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
- Scalar::e_void) {
- switch (result.m_type) {
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_slong:
- case Scalar::e_slonglong:
- case Scalar::e_sint128:
- case Scalar::e_sint256:
- if (b->m_integer != 0) {
- result.m_integer = a->m_integer.sdiv(b->m_integer);
- return result;
- }
- break;
- case Scalar::e_uint:
- case Scalar::e_ulong:
- case Scalar::e_ulonglong:
- case Scalar::e_uint128:
- case Scalar::e_uint256:
- if (b->m_integer != 0) {
- result.m_integer = a->m_integer.udiv(b->m_integer);
- return result;
- }
- break;
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- if (!b->m_float.isZero()) {
- result.m_float = a->m_float / b->m_float;
- return result;
- }
- break;
- }
- }
- // For division only, the only way it should make it here is if a promotion
- // failed, or if we are trying to do a divide by zero.
- result.m_type = Scalar::e_void;
- return result;
-}
-
-const Scalar lldb_private::operator*(const Scalar &lhs, const Scalar &rhs) {
- Scalar result;
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
- Scalar::e_void) {
- switch (result.m_type) {
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- result.m_integer = a->m_integer * b->m_integer;
- break;
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- result.m_float = a->m_float * b->m_float;
- break;
- }
- }
- return result;
-}
-
-const Scalar lldb_private::operator&(const Scalar &lhs, const Scalar &rhs) {
- Scalar result;
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
- Scalar::e_void) {
- switch (result.m_type) {
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- result.m_integer = a->m_integer & b->m_integer;
- break;
- case Scalar::e_void:
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- // No bitwise AND on floats, doubles of long doubles
- result.m_type = Scalar::e_void;
- break;
- }
- }
- return result;
-}
-
-const Scalar lldb_private::operator|(const Scalar &lhs, const Scalar &rhs) {
- Scalar result;
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
- Scalar::e_void) {
- switch (result.m_type) {
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- result.m_integer = a->m_integer | b->m_integer;
- break;
-
- case Scalar::e_void:
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- // No bitwise AND on floats, doubles of long doubles
- result.m_type = Scalar::e_void;
- break;
- }
- }
- return result;
-}
-
-const Scalar lldb_private::operator%(const Scalar &lhs, const Scalar &rhs) {
- Scalar result;
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
- Scalar::e_void) {
- switch (result.m_type) {
- default:
- break;
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_slong:
- case Scalar::e_slonglong:
- case Scalar::e_sint128:
- case Scalar::e_sint256:
- if (b->m_integer != 0) {
- result.m_integer = a->m_integer.srem(b->m_integer);
- return result;
- }
- break;
- case Scalar::e_uint:
- case Scalar::e_ulong:
- case Scalar::e_ulonglong:
- case Scalar::e_uint128:
- case Scalar::e_uint256:
- if (b->m_integer != 0) {
- result.m_integer = a->m_integer.urem(b->m_integer);
- return result;
- }
- break;
- }
- }
- result.m_type = Scalar::e_void;
- return result;
-}
-
-const Scalar lldb_private::operator^(const Scalar &lhs, const Scalar &rhs) {
- Scalar result;
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) !=
- Scalar::e_void) {
- switch (result.m_type) {
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- result.m_integer = a->m_integer ^ b->m_integer;
- break;
-
- case Scalar::e_void:
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- // No bitwise AND on floats, doubles of long doubles
- result.m_type = Scalar::e_void;
- break;
- }
- }
- return result;
-}
-
-const Scalar lldb_private::operator<<(const Scalar &lhs, const Scalar &rhs) {
- Scalar result = lhs;
- result <<= rhs;
- return result;
-}
-
-const Scalar lldb_private::operator>>(const Scalar &lhs, const Scalar &rhs) {
- Scalar result = lhs;
- result >>= rhs;
- return result;
-}
-
-Status Scalar::SetValueFromCString(const char *value_str, Encoding encoding,
- size_t byte_size) {
- Status error;
- if (value_str == nullptr || value_str[0] == '\0') {
- error.SetErrorString("Invalid c-string value string.");
- return error;
- }
- switch (encoding) {
- case eEncodingInvalid:
- error.SetErrorString("Invalid encoding.");
- break;
-
- case eEncodingUint:
- if (byte_size <= sizeof(uint64_t)) {
- uint64_t uval64;
- if (!llvm::to_integer(value_str, uval64))
- error.SetErrorStringWithFormat(
- "'%s' is not a valid unsigned integer string value", value_str);
- else if (!UIntValueIsValidForSize(uval64, byte_size))
- error.SetErrorStringWithFormat("value 0x%" PRIx64
- " is too large to fit in a %" PRIu64
- " byte unsigned integer value",
- uval64, (uint64_t)byte_size);
- else {
- m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize(byte_size);
- switch (m_type) {
- case e_uint:
- m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false);
- break;
- case e_ulong:
- m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false);
- break;
- case e_ulonglong:
- m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false);
- break;
- default:
- error.SetErrorStringWithFormat(
- "unsupported unsigned integer byte size: %" PRIu64 "",
- (uint64_t)byte_size);
- break;
- }
- }
- } else {
- error.SetErrorStringWithFormat(
- "unsupported unsigned integer byte size: %" PRIu64 "",
- (uint64_t)byte_size);
- return error;
- }
- break;
-
- case eEncodingSint:
- if (byte_size <= sizeof(int64_t)) {
- int64_t sval64;
- if (!llvm::to_integer(value_str, sval64))
- error.SetErrorStringWithFormat(
- "'%s' is not a valid signed integer string value", value_str);
- else if (!SIntValueIsValidForSize(sval64, byte_size))
- error.SetErrorStringWithFormat("value 0x%" PRIx64
- " is too large to fit in a %" PRIu64
- " byte signed integer value",
- sval64, (uint64_t)byte_size);
- else {
- m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize(byte_size);
- switch (m_type) {
- case e_sint:
- m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true);
- break;
- case e_slong:
- m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true);
- break;
- case e_slonglong:
- m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true);
- break;
- default:
- error.SetErrorStringWithFormat(
- "unsupported signed integer byte size: %" PRIu64 "",
- (uint64_t)byte_size);
- break;
- }
- }
- } else {
- error.SetErrorStringWithFormat(
- "unsupported signed integer byte size: %" PRIu64 "",
- (uint64_t)byte_size);
- return error;
- }
- break;
-
- case eEncodingIEEE754:
- static float f_val;
- static double d_val;
- static long double l_val;
- if (byte_size == sizeof(float)) {
- if (::sscanf(value_str, "%f", &f_val) == 1) {
- m_float = llvm::APFloat(f_val);
- m_type = e_float;
- } else
- error.SetErrorStringWithFormat("'%s' is not a valid float string value",
- value_str);
- } else if (byte_size == sizeof(double)) {
- if (::sscanf(value_str, "%lf", &d_val) == 1) {
- m_float = llvm::APFloat(d_val);
- m_type = e_double;
- } else
- error.SetErrorStringWithFormat("'%s' is not a valid float string value",
- value_str);
- } else if (byte_size == sizeof(long double)) {
- if (::sscanf(value_str, "%Lf", &l_val) == 1) {
- m_float =
- llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
- llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128,
- ((type128 *)&l_val)->x));
- m_type = e_long_double;
- } else
- error.SetErrorStringWithFormat("'%s' is not a valid float string value",
- value_str);
- } else {
- error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
- (uint64_t)byte_size);
- return error;
- }
- break;
-
- case eEncodingVector:
- error.SetErrorString("vector encoding unsupported.");
- break;
- }
- if (error.Fail())
- m_type = e_void;
-
- return error;
-}
-
-Status Scalar::SetValueFromData(DataExtractor &data, lldb::Encoding encoding,
- size_t byte_size) {
- Status error;
-
- type128 int128;
- type256 int256;
- switch (encoding) {
- case lldb::eEncodingInvalid:
- error.SetErrorString("invalid encoding");
- break;
- case lldb::eEncodingVector:
- error.SetErrorString("vector encoding unsupported");
- break;
- case lldb::eEncodingUint: {
- lldb::offset_t offset = 0;
-
- switch (byte_size) {
- case 1:
- operator=((uint8_t)data.GetU8(&offset));
- break;
- case 2:
- operator=((uint16_t)data.GetU16(&offset));
- break;
- case 4:
- operator=((uint32_t)data.GetU32(&offset));
- break;
- case 8:
- operator=((uint64_t)data.GetU64(&offset));
- break;
- case 16:
- if (data.GetByteOrder() == eByteOrderBig) {
- int128.x[1] = (uint64_t)data.GetU64(&offset);
- int128.x[0] = (uint64_t)data.GetU64(&offset);
- } else {
- int128.x[0] = (uint64_t)data.GetU64(&offset);
- int128.x[1] = (uint64_t)data.GetU64(&offset);
- }
- operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
- break;
- case 32:
- if (data.GetByteOrder() == eByteOrderBig) {
- int256.x[3] = (uint64_t)data.GetU64(&offset);
- int256.x[2] = (uint64_t)data.GetU64(&offset);
- int256.x[1] = (uint64_t)data.GetU64(&offset);
- int256.x[0] = (uint64_t)data.GetU64(&offset);
- } else {
- int256.x[0] = (uint64_t)data.GetU64(&offset);
- int256.x[1] = (uint64_t)data.GetU64(&offset);
- int256.x[2] = (uint64_t)data.GetU64(&offset);
- int256.x[3] = (uint64_t)data.GetU64(&offset);
- }
- operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
- break;
- default:
- error.SetErrorStringWithFormat(
- "unsupported unsigned integer byte size: %" PRIu64 "",
- (uint64_t)byte_size);
- break;
- }
- } break;
- case lldb::eEncodingSint: {
- lldb::offset_t offset = 0;
-
- switch (byte_size) {
- case 1:
- operator=((int8_t)data.GetU8(&offset));
- break;
- case 2:
- operator=((int16_t)data.GetU16(&offset));
- break;
- case 4:
- operator=((int32_t)data.GetU32(&offset));
- break;
- case 8:
- operator=((int64_t)data.GetU64(&offset));
- break;
- case 16:
- if (data.GetByteOrder() == eByteOrderBig) {
- int128.x[1] = (uint64_t)data.GetU64(&offset);
- int128.x[0] = (uint64_t)data.GetU64(&offset);
- } else {
- int128.x[0] = (uint64_t)data.GetU64(&offset);
- int128.x[1] = (uint64_t)data.GetU64(&offset);
- }
- operator=(llvm::APInt(BITWIDTH_INT128, NUM_OF_WORDS_INT128, int128.x));
- break;
- case 32:
- if (data.GetByteOrder() == eByteOrderBig) {
- int256.x[3] = (uint64_t)data.GetU64(&offset);
- int256.x[2] = (uint64_t)data.GetU64(&offset);
- int256.x[1] = (uint64_t)data.GetU64(&offset);
- int256.x[0] = (uint64_t)data.GetU64(&offset);
- } else {
- int256.x[0] = (uint64_t)data.GetU64(&offset);
- int256.x[1] = (uint64_t)data.GetU64(&offset);
- int256.x[2] = (uint64_t)data.GetU64(&offset);
- int256.x[3] = (uint64_t)data.GetU64(&offset);
- }
- operator=(llvm::APInt(BITWIDTH_INT256, NUM_OF_WORDS_INT256, int256.x));
- break;
- default:
- error.SetErrorStringWithFormat(
- "unsupported signed integer byte size: %" PRIu64 "",
- (uint64_t)byte_size);
- break;
- }
- } break;
- case lldb::eEncodingIEEE754: {
- lldb::offset_t offset = 0;
-
- if (byte_size == sizeof(float))
- operator=((float)data.GetFloat(&offset));
- else if (byte_size == sizeof(double))
- operator=((double)data.GetDouble(&offset));
- else if (byte_size == sizeof(long double))
- operator=((long double)data.GetLongDouble(&offset));
- else
- error.SetErrorStringWithFormat("unsupported float byte size: %" PRIu64 "",
- (uint64_t)byte_size);
- } break;
- }
-
- return error;
-}
-
-bool Scalar::SignExtend(uint32_t sign_bit_pos) {
- const uint32_t max_bit_pos = GetByteSize() * 8;
-
- if (sign_bit_pos < max_bit_pos) {
- switch (m_type) {
- case Scalar::e_void:
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- return false;
-
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- if (max_bit_pos == sign_bit_pos)
- return true;
- else if (sign_bit_pos < (max_bit_pos - 1)) {
- llvm::APInt sign_bit = llvm::APInt::getSignMask(sign_bit_pos + 1);
- llvm::APInt bitwize_and = m_integer & sign_bit;
- if (bitwize_and.getBoolValue()) {
- const llvm::APInt mask =
- ~(sign_bit) + llvm::APInt(m_integer.getBitWidth(), 1);
- m_integer |= mask;
- }
- return true;
- }
- break;
- }
- }
- return false;
-}
-
-size_t Scalar::GetAsMemoryData(void *dst, size_t dst_len,
- lldb::ByteOrder dst_byte_order,
- Status &error) const {
- // Get a data extractor that points to the native scalar data
- DataExtractor data;
- if (!GetData(data)) {
- error.SetErrorString("invalid scalar value");
- return 0;
- }
-
- const size_t src_len = data.GetByteSize();
-
- // Prepare a memory buffer that contains some or all of the register value
- const size_t bytes_copied =
- data.CopyByteOrderedData(0, // src offset
- src_len, // src length
- dst, // dst buffer
- dst_len, // dst length
- dst_byte_order); // dst byte order
- if (bytes_copied == 0)
- error.SetErrorString("failed to copy data");
-
- return bytes_copied;
-}
-
-bool Scalar::ExtractBitfield(uint32_t bit_size, uint32_t bit_offset) {
- if (bit_size == 0)
- return true;
-
- switch (m_type) {
- case Scalar::e_void:
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- break;
-
- case Scalar::e_sint:
- case Scalar::e_slong:
- case Scalar::e_slonglong:
- case Scalar::e_sint128:
- case Scalar::e_sint256:
- m_integer = m_integer.ashr(bit_offset)
- .sextOrTrunc(bit_size)
- .sextOrSelf(8 * GetByteSize());
- return true;
-
- case Scalar::e_uint:
- case Scalar::e_ulong:
- case Scalar::e_ulonglong:
- case Scalar::e_uint128:
- case Scalar::e_uint256:
- m_integer = m_integer.lshr(bit_offset)
- .zextOrTrunc(bit_size)
- .zextOrSelf(8 * GetByteSize());
- return true;
- }
- return false;
-}
-
-bool lldb_private::operator==(const Scalar &lhs, const Scalar &rhs) {
- // If either entry is void then we can just compare the types
- if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
- return lhs.m_type == rhs.m_type;
-
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- llvm::APFloat::cmpResult result;
- switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- return a->m_integer == b->m_integer;
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- result = a->m_float.compare(b->m_float);
- if (result == llvm::APFloat::cmpEqual)
- return true;
- }
- return false;
-}
-
-bool lldb_private::operator!=(const Scalar &lhs, const Scalar &rhs) {
- // If either entry is void then we can just compare the types
- if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
- return lhs.m_type != rhs.m_type;
-
- Scalar
- temp_value; // A temp value that might get a copy of either promoted value
- const Scalar *a;
- const Scalar *b;
- llvm::APFloat::cmpResult result;
- switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_uint:
- case Scalar::e_slong:
- case Scalar::e_ulong:
- case Scalar::e_slonglong:
- case Scalar::e_ulonglong:
- case Scalar::e_sint128:
- case Scalar::e_uint128:
- case Scalar::e_sint256:
- case Scalar::e_uint256:
- return a->m_integer != b->m_integer;
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- result = a->m_float.compare(b->m_float);
- if (result != llvm::APFloat::cmpEqual)
- return true;
- }
- return true;
-}
-
-bool lldb_private::operator<(const Scalar &lhs, const Scalar &rhs) {
- if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
- return false;
-
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- llvm::APFloat::cmpResult result;
- switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_slong:
- case Scalar::e_slonglong:
- case Scalar::e_sint128:
- case Scalar::e_sint256:
- return a->m_integer.slt(b->m_integer);
- case Scalar::e_uint:
- case Scalar::e_ulong:
- case Scalar::e_ulonglong:
- case Scalar::e_uint128:
- case Scalar::e_uint256:
- return a->m_integer.ult(b->m_integer);
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- result = a->m_float.compare(b->m_float);
- if (result == llvm::APFloat::cmpLessThan)
- return true;
- }
- return false;
-}
-
-bool lldb_private::operator<=(const Scalar &lhs, const Scalar &rhs) {
- if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
- return false;
-
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- llvm::APFloat::cmpResult result;
- switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_slong:
- case Scalar::e_slonglong:
- case Scalar::e_sint128:
- case Scalar::e_sint256:
- return a->m_integer.sle(b->m_integer);
- case Scalar::e_uint:
- case Scalar::e_ulong:
- case Scalar::e_ulonglong:
- case Scalar::e_uint128:
- case Scalar::e_uint256:
- return a->m_integer.ule(b->m_integer);
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- result = a->m_float.compare(b->m_float);
- if (result == llvm::APFloat::cmpLessThan ||
- result == llvm::APFloat::cmpEqual)
- return true;
- }
- return false;
-}
-
-bool lldb_private::operator>(const Scalar &lhs, const Scalar &rhs) {
- if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
- return false;
-
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- llvm::APFloat::cmpResult result;
- switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_slong:
- case Scalar::e_slonglong:
- case Scalar::e_sint128:
- case Scalar::e_sint256:
- return a->m_integer.sgt(b->m_integer);
- case Scalar::e_uint:
- case Scalar::e_ulong:
- case Scalar::e_ulonglong:
- case Scalar::e_uint128:
- case Scalar::e_uint256:
- return a->m_integer.ugt(b->m_integer);
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- result = a->m_float.compare(b->m_float);
- if (result == llvm::APFloat::cmpGreaterThan)
- return true;
- }
- return false;
-}
-
-bool lldb_private::operator>=(const Scalar &lhs, const Scalar &rhs) {
- if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
- return false;
-
- Scalar temp_value;
- const Scalar *a;
- const Scalar *b;
- llvm::APFloat::cmpResult result;
- switch (PromoteToMaxType(lhs, rhs, temp_value, a, b)) {
- case Scalar::e_void:
- break;
- case Scalar::e_sint:
- case Scalar::e_slong:
- case Scalar::e_slonglong:
- case Scalar::e_sint128:
- case Scalar::e_sint256:
- return a->m_integer.sge(b->m_integer);
- case Scalar::e_uint:
- case Scalar::e_ulong:
- case Scalar::e_ulonglong:
- case Scalar::e_uint128:
- case Scalar::e_uint256:
- return a->m_integer.uge(b->m_integer);
- case Scalar::e_float:
- case Scalar::e_double:
- case Scalar::e_long_double:
- result = a->m_float.compare(b->m_float);
- if (result == llvm::APFloat::cmpGreaterThan ||
- result == llvm::APFloat::cmpEqual)
- return true;
- }
- return false;
-}
-
-bool Scalar::ClearBit(uint32_t bit) {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- m_integer.clearBit(bit);
- return true;
- case e_float:
- case e_double:
- case e_long_double:
- break;
- }
- return false;
-}
-
-bool Scalar::SetBit(uint32_t bit) {
- switch (m_type) {
- case e_void:
- break;
- case e_sint:
- case e_uint:
- case e_slong:
- case e_ulong:
- case e_slonglong:
- case e_ulonglong:
- case e_sint128:
- case e_uint128:
- case e_sint256:
- case e_uint256:
- m_integer.setBit(bit);
- return true;
- case e_float:
- case e_double:
- case e_long_double:
- break;
- }
- return false;
-}
diff --git a/source/Core/SearchFilter.cpp b/source/Core/SearchFilter.cpp
index 0701955233a1..5d26c715bec6 100644
--- a/source/Core/SearchFilter.cpp
+++ b/source/Core/SearchFilter.cpp
@@ -9,26 +9,27 @@
#include "lldb/Core/SearchFilter.h"
-#include "lldb/Breakpoint/Breakpoint.h" // for Breakpoint
+#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/Module.h"
-#include "lldb/Core/ModuleList.h" // for ModuleList
+#include "lldb/Core/ModuleList.h"
#include "lldb/Symbol/CompileUnit.h"
-#include "lldb/Symbol/SymbolContext.h" // for SymbolContext
+#include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Target/Target.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/Utility/Status.h" // for Status
-#include "lldb/Utility/Stream.h" // for Stream
-#include "lldb/lldb-enumerations.h" // for SymbolContextItem::eSymbolCo...
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/Utility/Stream.h"
+#include "lldb/lldb-enumerations.h"
-#include "llvm/ADT/StringRef.h" // for StringRef
-#include "llvm/Support/ErrorHandling.h" // for llvm_unreachable
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorHandling.h"
-#include <memory> // for shared_ptr
-#include <mutex> // for recursive_mutex, lock_guard
-#include <string> // for string
+#include <memory>
+#include <mutex>
+#include <string>
-#include <inttypes.h> // for PRIu64
-#include <string.h> // for size_t, strcmp
+#include <inttypes.h>
+#include <string.h>
namespace lldb_private {
class Address;
@@ -147,6 +148,15 @@ bool SearchFilter::CompUnitPasses(FileSpec &fileSpec) { return true; }
bool SearchFilter::CompUnitPasses(CompileUnit &compUnit) { return true; }
+bool SearchFilter::FunctionPasses(Function &function) {
+ // This is a slightly cheesy job, but since we don't have finer grained
+ // filters yet, just checking that the start address passes is probably
+ // good enough for the base class behavior.
+ Address addr = function.GetAddressRange().GetBaseAddress();
+ return AddressPasses(addr);
+}
+
+
uint32_t SearchFilter::GetFilterRequiredItems() {
return (lldb::SymbolContextItem)0;
}
@@ -207,7 +217,7 @@ void SearchFilter::Search(Searcher &searcher) {
return;
empty_sc.target_sp = m_target_sp;
- if (searcher.GetDepth() == Searcher::eDepthTarget)
+ if (searcher.GetDepth() == lldb::eSearchDepthTarget)
searcher.SearchCallback(*this, empty_sc, nullptr, false);
else
DoModuleIteration(empty_sc, searcher);
@@ -220,7 +230,7 @@ void SearchFilter::SearchInModuleList(Searcher &searcher, ModuleList &modules) {
return;
empty_sc.target_sp = m_target_sp;
- if (searcher.GetDepth() == Searcher::eDepthTarget)
+ if (searcher.GetDepth() == lldb::eSearchDepthTarget)
searcher.SearchCallback(*this, empty_sc, nullptr, false);
else {
std::lock_guard<std::recursive_mutex> guard(modules.GetMutex());
@@ -247,9 +257,9 @@ SearchFilter::DoModuleIteration(const lldb::ModuleSP &module_sp,
Searcher::CallbackReturn
SearchFilter::DoModuleIteration(const SymbolContext &context,
Searcher &searcher) {
- if (searcher.GetDepth() >= Searcher::eDepthModule) {
+ if (searcher.GetDepth() >= lldb::eSearchDepthModule) {
if (context.module_sp) {
- if (searcher.GetDepth() == Searcher::eDepthModule) {
+ if (searcher.GetDepth() == lldb::eSearchDepthModule) {
SymbolContext matchingContext(context.module_sp.get());
searcher.SearchCallback(*this, matchingContext, nullptr, false);
} else {
@@ -267,7 +277,7 @@ SearchFilter::DoModuleIteration(const SymbolContext &context,
if (!ModulePasses(module_sp))
continue;
- if (searcher.GetDepth() == Searcher::eDepthModule) {
+ if (searcher.GetDepth() == lldb::eSearchDepthModule) {
SymbolContext matchingContext(m_target_sp, module_sp);
Searcher::CallbackReturn shouldContinue =
@@ -301,7 +311,7 @@ SearchFilter::DoCUIteration(const ModuleSP &module_sp,
if (!CompUnitPasses(*(cu_sp.get())))
continue;
- if (searcher.GetDepth() == Searcher::eDepthCompUnit) {
+ if (searcher.GetDepth() == lldb::eSearchDepthCompUnit) {
SymbolContext matchingContext(m_target_sp, module_sp, cu_sp.get());
shouldContinue =
@@ -312,7 +322,30 @@ SearchFilter::DoCUIteration(const ModuleSP &module_sp,
else if (shouldContinue == Searcher::eCallbackReturnStop)
return shouldContinue;
} else {
- // FIXME Descend to block.
+ // First make sure this compile unit's functions are parsed
+ // since CompUnit::ForeachFunction only iterates over already
+ // parsed functions.
+ SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
+ if (!sym_vendor)
+ continue;
+ if (!sym_vendor->ParseFunctions(*cu_sp))
+ continue;
+ // If we got any functions, use ForeachFunction to do the iteration.
+ cu_sp->ForeachFunction([&](const FunctionSP &func_sp) {
+ if (!FunctionPasses(*func_sp.get()))
+ return false; // Didn't pass the filter, just keep going.
+ if (searcher.GetDepth() == lldb::eSearchDepthFunction) {
+ SymbolContext matchingContext(m_target_sp, module_sp,
+ cu_sp.get(), func_sp.get());
+ shouldContinue = searcher.SearchCallback(*this,
+ matchingContext,
+ nullptr, false);
+ } else {
+ shouldContinue = DoFunctionIteration(func_sp.get(), context,
+ searcher);
+ }
+ return shouldContinue != Searcher::eCallbackReturnContinue;
+ });
}
}
}
@@ -353,10 +386,7 @@ SearchFilterForUnconstrainedSearches::SerializeToStructuredData() {
bool SearchFilterForUnconstrainedSearches::ModulePasses(
const FileSpec &module_spec) {
- if (m_target_sp->ModuleIsExcludedForUnconstrainedSearches(module_spec))
- return false;
- else
- return true;
+ return !m_target_sp->ModuleIsExcludedForUnconstrainedSearches(module_spec);
}
bool SearchFilterForUnconstrainedSearches::ModulePasses(
@@ -421,7 +451,7 @@ void SearchFilterByModule::Search(Searcher &searcher) {
if (!m_target_sp)
return;
- if (searcher.GetDepth() == Searcher::eDepthTarget) {
+ if (searcher.GetDepth() == lldb::eSearchDepthTarget) {
SymbolContext empty_sc;
empty_sc.target_sp = m_target_sp;
searcher.SearchCallback(*this, empty_sc, nullptr, false);
@@ -489,7 +519,7 @@ SearchFilterSP SearchFilterByModule::CreateFromStructuredData(
error.SetErrorString("SFBM::CFSD: filter module item not a string.");
return nullptr;
}
- FileSpec module_spec(module, false);
+ FileSpec module_spec(module);
return std::make_shared<SearchFilterByModule>(target.shared_from_this(),
module_spec);
@@ -535,22 +565,15 @@ bool SearchFilterByModuleList::ModulePasses(const ModuleSP &module_sp) {
if (m_module_spec_list.GetSize() == 0)
return true;
- if (module_sp &&
- m_module_spec_list.FindFileIndex(0, module_sp->GetFileSpec(), false) !=
- UINT32_MAX)
- return true;
- else
- return false;
+ return module_sp && m_module_spec_list.FindFileIndex(
+ 0, module_sp->GetFileSpec(), false) != UINT32_MAX;
}
bool SearchFilterByModuleList::ModulePasses(const FileSpec &spec) {
if (m_module_spec_list.GetSize() == 0)
return true;
- if (m_module_spec_list.FindFileIndex(0, spec, true) != UINT32_MAX)
- return true;
- else
- return false;
+ return m_module_spec_list.FindFileIndex(0, spec, true) != UINT32_MAX;
}
bool SearchFilterByModuleList::AddressPasses(Address &address) {
@@ -570,7 +593,7 @@ void SearchFilterByModuleList::Search(Searcher &searcher) {
if (!m_target_sp)
return;
- if (searcher.GetDepth() == Searcher::eDepthTarget) {
+ if (searcher.GetDepth() == lldb::eSearchDepthTarget) {
SymbolContext empty_sc;
empty_sc.target_sp = m_target_sp;
searcher.SearchCallback(*this, empty_sc, nullptr, false);
@@ -645,7 +668,7 @@ SearchFilterSP SearchFilterByModuleList::CreateFromStructuredData(
"SFBM::CFSD: filter module item %zu not a string.", i);
return nullptr;
}
- modules.Append(FileSpec(module, false));
+ modules.Append(FileSpec(module));
}
}
@@ -710,7 +733,7 @@ lldb::SearchFilterSP SearchFilterByModuleListAndCU::CreateFromStructuredData(
"SFBM::CFSD: filter module item %zu not a string.", i);
return result_sp;
}
- modules.Append(FileSpec(module, false));
+ modules.Append(FileSpec(module));
}
}
@@ -732,7 +755,7 @@ lldb::SearchFilterSP SearchFilterByModuleListAndCU::CreateFromStructuredData(
"SFBM::CFSD: filter cu item %zu not a string.", i);
return nullptr;
}
- cus.Append(FileSpec(cu, false));
+ cus.Append(FileSpec(cu));
}
return std::make_shared<SearchFilterByModuleListAndCU>(
@@ -748,7 +771,15 @@ SearchFilterByModuleListAndCU::SerializeToStructuredData() {
}
bool SearchFilterByModuleListAndCU::AddressPasses(Address &address) {
- return true;
+ SymbolContext sym_ctx;
+ address.CalculateSymbolContext(&sym_ctx, eSymbolContextEverything);
+ if (!sym_ctx.comp_unit) {
+ if (m_cu_spec_list.GetSize() != 0)
+ return false; // Has no comp_unit so can't pass the file check.
+ }
+ if (m_cu_spec_list.FindFileIndex(0, sym_ctx.comp_unit, false) == UINT32_MAX)
+ return false; // Fails the file check
+ return SearchFilterByModuleList::ModulePasses(sym_ctx.module_sp);
}
bool SearchFilterByModuleListAndCU::CompUnitPasses(FileSpec &fileSpec) {
@@ -773,7 +804,7 @@ void SearchFilterByModuleListAndCU::Search(Searcher &searcher) {
if (!m_target_sp)
return;
- if (searcher.GetDepth() == Searcher::eDepthTarget) {
+ if (searcher.GetDepth() == lldb::eSearchDepthTarget) {
SymbolContext empty_sc;
empty_sc.target_sp = m_target_sp;
searcher.SearchCallback(*this, empty_sc, nullptr, false);
@@ -797,7 +828,7 @@ void SearchFilterByModuleListAndCU::Search(Searcher &searcher) {
SymbolContext matchingContext(m_target_sp, module_sp);
Searcher::CallbackReturn shouldContinue;
- if (searcher.GetDepth() == Searcher::eDepthModule) {
+ if (searcher.GetDepth() == lldb::eSearchDepthModule) {
shouldContinue = DoModuleIteration(matchingContext, searcher);
if (shouldContinue == Searcher::eCallbackReturnStop)
return;
diff --git a/source/Core/Section.cpp b/source/Core/Section.cpp
index d9c5d32ee13c..87f75e1f50ac 100644
--- a/source/Core/Section.cpp
+++ b/source/Core/Section.cpp
@@ -8,18 +8,18 @@
//===----------------------------------------------------------------------===//
#include "lldb/Core/Section.h"
-#include "lldb/Core/Address.h" // for Address
+#include "lldb/Core/Address.h"
#include "lldb/Core/Module.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h"
-#include "lldb/Utility/FileSpec.h" // for FileSpec
-#include "lldb/Utility/Stream.h" // for Stream
-#include "lldb/Utility/VMRange.h" // for VMRange
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Stream.h"
+#include "lldb/Utility/VMRange.h"
-#include <inttypes.h> // for PRIx64
-#include <limits> // for numeric_limits
-#include <utility> // for distance
+#include <inttypes.h>
+#include <limits>
+#include <utility>
namespace lldb_private {
class DataExtractor;
@@ -61,6 +61,8 @@ const char *Section::GetTypeAsCString() const {
return "objc-cfstrings";
case eSectionTypeDWARFDebugAbbrev:
return "dwarf-abbrev";
+ case eSectionTypeDWARFDebugAbbrevDwo:
+ return "dwarf-abbrev-dwo";
case eSectionTypeDWARFDebugAddr:
return "dwarf-addr";
case eSectionTypeDWARFDebugAranges:
@@ -71,10 +73,16 @@ const char *Section::GetTypeAsCString() const {
return "dwarf-frame";
case eSectionTypeDWARFDebugInfo:
return "dwarf-info";
+ case eSectionTypeDWARFDebugInfoDwo:
+ return "dwarf-info-dwo";
case eSectionTypeDWARFDebugLine:
return "dwarf-line";
+ case eSectionTypeDWARFDebugLineStr:
+ return "dwarf-line-str";
case eSectionTypeDWARFDebugLoc:
return "dwarf-loc";
+ case eSectionTypeDWARFDebugLocLists:
+ return "dwarf-loclists";
case eSectionTypeDWARFDebugMacInfo:
return "dwarf-macinfo";
case eSectionTypeDWARFDebugMacro:
@@ -85,10 +93,16 @@ const char *Section::GetTypeAsCString() const {
return "dwarf-pubtypes";
case eSectionTypeDWARFDebugRanges:
return "dwarf-ranges";
+ case eSectionTypeDWARFDebugRngLists:
+ return "dwarf-rnglists";
case eSectionTypeDWARFDebugStr:
return "dwarf-str";
+ case eSectionTypeDWARFDebugStrDwo:
+ return "dwarf-str-dwo";
case eSectionTypeDWARFDebugStrOffsets:
return "dwarf-str-offsets";
+ case eSectionTypeDWARFDebugStrOffsetsDwo:
+ return "dwarf-str-offsets-dwo";
case eSectionTypeDWARFDebugTypes:
return "dwarf-types";
case eSectionTypeDWARFDebugNames:
diff --git a/source/Core/SourceManager.cpp b/source/Core/SourceManager.cpp
index a6afd64f3054..fe603c5a44e6 100644
--- a/source/Core/SourceManager.cpp
+++ b/source/Core/SourceManager.cpp
@@ -9,33 +9,34 @@
#include "lldb/Core/SourceManager.h"
-#include "lldb/Core/Address.h" // for Address
-#include "lldb/Core/AddressRange.h" // for AddressRange
+#include "lldb/Core/Address.h"
+#include "lldb/Core/AddressRange.h"
#include "lldb/Core/Debugger.h"
-#include "lldb/Core/FormatEntity.h" // for FormatEntity
+#include "lldb/Core/FormatEntity.h"
+#include "lldb/Core/Highlighter.h"
#include "lldb/Core/Module.h"
-#include "lldb/Core/ModuleList.h" // for ModuleList
+#include "lldb/Core/ModuleList.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/Function.h"
-#include "lldb/Symbol/LineEntry.h" // for LineEntry
+#include "lldb/Symbol/LineEntry.h"
#include "lldb/Symbol/SymbolContext.h"
-#include "lldb/Target/PathMappingList.h" // for PathMappingList
+#include "lldb/Target/PathMappingList.h"
#include "lldb/Target/Target.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
+#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/DataBuffer.h"
#include "lldb/Utility/DataBufferLLVM.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
-#include "lldb/lldb-enumerations.h" // for StopShowColumn::eStopSho...
+#include "lldb/lldb-enumerations.h"
-#include "llvm/ADT/Twine.h" // for Twine
+#include "llvm/ADT/Twine.h"
#include <memory>
-#include <utility> // for pair
+#include <utility>
-#include <assert.h> // for assert
-#include <stdio.h> // for size_t, NULL, snprintf
+#include <assert.h>
+#include <stdio.h>
namespace lldb_private {
class ExecutionContext;
@@ -91,7 +92,7 @@ SourceManager::FileSP SourceManager::GetFile(const FileSpec &file_spec) {
file_sp->UpdateIfNeeded();
// If file_sp is no good or it points to a non-existent file, reset it.
- if (!file_sp || !file_sp->GetFileSpec().Exists()) {
+ if (!file_sp || !FileSystem::Instance().Exists(file_sp->GetFileSpec())) {
if (target_sp)
file_sp = std::make_shared<File>(file_spec, target_sp.get());
else
@@ -103,6 +104,18 @@ SourceManager::FileSP SourceManager::GetFile(const FileSpec &file_spec) {
return file_sp;
}
+static bool should_highlight_source(DebuggerSP debugger_sp) {
+ if (!debugger_sp)
+ return false;
+
+ // We don't use ANSI stop column formatting if the debugger doesn't think it
+ // should be using color.
+ if (!debugger_sp->GetUseColor())
+ return false;
+
+ return debugger_sp->GetHighlightSource();
+}
+
static bool should_show_stop_column_with_ansi(DebuggerSP debugger_sp) {
// We don't use ANSI stop column formatting if we can't lookup values from
// the debugger.
@@ -145,7 +158,9 @@ size_t SourceManager::DisplaySourceLinesWithLineNumbersUsingLastFile(
const SymbolContextList *bp_locs) {
if (count == 0)
return 0;
- size_t return_value = 0;
+
+ Stream::ByteDelta delta(*s);
+
if (start_line == 0) {
if (m_last_line != 0 && m_last_line != UINT32_MAX)
start_line = m_last_line + m_last_count;
@@ -180,31 +195,37 @@ size_t SourceManager::DisplaySourceLinesWithLineNumbersUsingLastFile(
::snprintf(prefix, sizeof(prefix), " ");
}
- return_value +=
- s->Printf("%s%2.2s %-4u\t", prefix,
- line == curr_line ? current_line_cstr : "", line);
- size_t this_line_size = m_last_file_sp->DisplaySourceLines(
- line, line == curr_line ? column : 0, 0, 0, s);
+ s->Printf("%s%2.2s %-4u\t", prefix,
+ line == curr_line ? current_line_cstr : "", line);
+
+ // So far we treated column 0 as a special 'no column value', but
+ // DisplaySourceLines starts counting columns from 0 (and no column is
+ // expressed by passing an empty optional).
+ llvm::Optional<size_t> columnToHighlight;
+ if (line == curr_line && column)
+ columnToHighlight = column - 1;
+
+ size_t this_line_size =
+ m_last_file_sp->DisplaySourceLines(line, columnToHighlight, 0, 0, s);
if (column != 0 && line == curr_line &&
should_show_stop_column_with_caret(m_debugger_wp.lock())) {
// Display caret cursor.
std::string src_line;
m_last_file_sp->GetLine(line, src_line);
- return_value += s->Printf(" \t");
+ s->Printf(" \t");
// Insert a space for every non-tab character in the source line.
for (size_t i = 0; i + 1 < column && i < src_line.length(); ++i)
- return_value += s->PutChar(src_line[i] == '\t' ? '\t' : ' ');
+ s->PutChar(src_line[i] == '\t' ? '\t' : ' ');
// Now add the caret.
- return_value += s->Printf("^\n");
+ s->Printf("^\n");
}
if (this_line_size == 0) {
m_last_line = UINT32_MAX;
break;
- } else
- return_value += this_line_size;
+ }
}
}
- return return_value;
+ return *delta;
}
size_t SourceManager::DisplaySourceLinesWithLineNumbers(
@@ -349,14 +370,14 @@ void SourceManager::FindLinesMatchingRegex(FileSpec &file_spec,
SourceManager::File::File(const FileSpec &file_spec,
lldb::DebuggerSP debugger_sp)
: m_file_spec_orig(file_spec), m_file_spec(file_spec),
- m_mod_time(FileSystem::GetModificationTime(file_spec)),
+ m_mod_time(FileSystem::Instance().GetModificationTime(file_spec)),
m_debugger_wp(debugger_sp) {
CommonInitializer(file_spec, nullptr);
}
SourceManager::File::File(const FileSpec &file_spec, Target *target)
: m_file_spec_orig(file_spec), m_file_spec(file_spec),
- m_mod_time(FileSystem::GetModificationTime(file_spec)),
+ m_mod_time(FileSystem::Instance().GetModificationTime(file_spec)),
m_debugger_wp(target ? target->GetDebugger().shared_from_this()
: DebuggerSP()) {
CommonInitializer(file_spec, target);
@@ -376,7 +397,8 @@ void SourceManager::File::CommonInitializer(const FileSpec &file_spec,
size_t num_matches =
target->GetImages().ResolveSymbolContextForFilePath(
file_spec.GetFilename().AsCString(), 0, check_inlines,
- lldb::eSymbolContextModule | lldb::eSymbolContextCompUnit,
+ SymbolContextItem(eSymbolContextModule |
+ eSymbolContextCompUnit),
sc_list);
bool got_multiple = false;
if (num_matches != 0) {
@@ -400,12 +422,12 @@ void SourceManager::File::CommonInitializer(const FileSpec &file_spec,
SymbolContext sc;
sc_list.GetContextAtIndex(0, sc);
m_file_spec = sc.comp_unit;
- m_mod_time = FileSystem::GetModificationTime(m_file_spec);
+ m_mod_time = FileSystem::Instance().GetModificationTime(m_file_spec);
}
}
}
// Try remapping if m_file_spec does not correspond to an existing file.
- if (!m_file_spec.Exists()) {
+ if (!FileSystem::Instance().Exists(m_file_spec)) {
FileSpec new_file_spec;
// Check target specific source remappings first, then fall back to
// modules objects can have individual path remappings that were
@@ -413,14 +435,14 @@ void SourceManager::File::CommonInitializer(const FileSpec &file_spec,
if (target->GetSourcePathMap().FindFile(m_file_spec, new_file_spec) ||
target->GetImages().FindSourceFile(m_file_spec, new_file_spec)) {
m_file_spec = new_file_spec;
- m_mod_time = FileSystem::GetModificationTime(m_file_spec);
+ m_mod_time = FileSystem::Instance().GetModificationTime(m_file_spec);
}
}
}
}
if (m_mod_time != llvm::sys::TimePoint<>())
- m_data_sp = DataBufferLLVM::CreateFromPath(m_file_spec.GetPath());
+ m_data_sp = FileSystem::Instance().CreateDataBuffer(m_file_spec);
}
uint32_t SourceManager::File::GetLineOffset(uint32_t line) {
@@ -464,7 +486,7 @@ uint32_t SourceManager::File::GetLineLength(uint32_t line,
if (end_offset > start_offset) {
uint32_t length = end_offset - start_offset;
- if (include_newline_chars == false) {
+ if (!include_newline_chars) {
const char *line_start =
(const char *)m_data_sp->GetBytes() + start_offset;
while (length > 0) {
@@ -493,17 +515,18 @@ void SourceManager::File::UpdateIfNeeded() {
// TODO: use host API to sign up for file modifications to anything in our
// source cache and only update when we determine a file has been updated.
// For now we check each time we want to display info for the file.
- auto curr_mod_time = FileSystem::GetModificationTime(m_file_spec);
+ auto curr_mod_time = FileSystem::Instance().GetModificationTime(m_file_spec);
if (curr_mod_time != llvm::sys::TimePoint<>() &&
m_mod_time != curr_mod_time) {
m_mod_time = curr_mod_time;
- m_data_sp = DataBufferLLVM::CreateFromPath(m_file_spec.GetPath());
+ m_data_sp = FileSystem::Instance().CreateDataBuffer(m_file_spec);
m_offsets.clear();
}
}
-size_t SourceManager::File::DisplaySourceLines(uint32_t line, uint32_t column,
+size_t SourceManager::File::DisplaySourceLines(uint32_t line,
+ llvm::Optional<size_t> column,
uint32_t context_before,
uint32_t context_after,
Stream *s) {
@@ -515,6 +538,27 @@ size_t SourceManager::File::DisplaySourceLines(uint32_t line, uint32_t column,
if (!m_data_sp)
return 0;
+ size_t bytes_written = s->GetWrittenBytes();
+
+ auto debugger_sp = m_debugger_wp.lock();
+
+ HighlightStyle style;
+ // Use the default Vim style if source highlighting is enabled.
+ if (should_highlight_source(debugger_sp))
+ style = HighlightStyle::MakeVimStyle();
+
+ // If we should mark the stop column with color codes, then copy the prefix
+ // and suffix to our color style.
+ if (should_show_stop_column_with_ansi(debugger_sp))
+ style.selected.Set(debugger_sp->GetStopShowColumnAnsiPrefix(),
+ debugger_sp->GetStopShowColumnAnsiSuffix());
+
+ HighlighterManager mgr;
+ std::string path = GetFileSpec().GetPath(/*denormalize*/ false);
+ // FIXME: Find a way to get the definitive language this file was written in
+ // and pass it to the highlighter.
+ const auto &h = mgr.getHighlighterFor(lldb::eLanguageTypeUnknown, path);
+
const uint32_t start_line =
line <= context_before ? 1 : line - context_before;
const uint32_t start_line_offset = GetLineOffset(start_line);
@@ -525,71 +569,20 @@ size_t SourceManager::File::DisplaySourceLines(uint32_t line, uint32_t column,
end_line_offset = m_data_sp->GetByteSize();
assert(start_line_offset <= end_line_offset);
- size_t bytes_written = 0;
if (start_line_offset < end_line_offset) {
size_t count = end_line_offset - start_line_offset;
const uint8_t *cstr = m_data_sp->GetBytes() + start_line_offset;
- bool displayed_line = false;
-
- if (column && (column < count)) {
- auto debugger_sp = m_debugger_wp.lock();
- if (should_show_stop_column_with_ansi(debugger_sp) && debugger_sp) {
- // Check if we have any ANSI codes with which to mark this column. If
- // not, no need to do this work.
- auto ansi_prefix_entry = debugger_sp->GetStopShowColumnAnsiPrefix();
- auto ansi_suffix_entry = debugger_sp->GetStopShowColumnAnsiSuffix();
-
- // We only bother breaking up the line to format the marked column if
- // there is any marking specified on both sides of the marked column.
- // In ANSI-terminal-sequence land, there must be a post if there is a
- // pre format, and vice versa.
- if (ansi_prefix_entry && ansi_suffix_entry) {
- // Mark the current column with the desired escape sequence for
- // formatting the column (e.g. underline, inverse, etc.)
-
- // First print the part before the column to mark.
- bytes_written = s->Write(cstr, column - 1);
-
- // Write the pre escape sequence.
- const SymbolContext *sc = nullptr;
- const ExecutionContext *exe_ctx = nullptr;
- const Address addr = LLDB_INVALID_ADDRESS;
- ValueObject *valobj = nullptr;
- const bool function_changed = false;
- const bool initial_function = false;
-
- FormatEntity::Format(*ansi_prefix_entry, *s, sc, exe_ctx, &addr,
- valobj, function_changed, initial_function);
-
- // Write the marked column.
- bytes_written += s->Write(cstr + column - 1, 1);
-
- // Write the post escape sequence.
- FormatEntity::Format(*ansi_suffix_entry, *s, sc, exe_ctx, &addr,
- valobj, function_changed, initial_function);
-
- // And finish up with the rest of the line.
- bytes_written += s->Write(cstr + column, count - column);
-
- // Keep track of the fact that we just wrote the line.
- displayed_line = true;
- }
- }
- }
+ auto ref = llvm::StringRef(reinterpret_cast<const char *>(cstr), count);
- // If we didn't end up displaying the line with ANSI codes for whatever
- // reason, display it now sans codes.
- if (!displayed_line)
- bytes_written = s->Write(cstr, count);
+ h.Highlight(style, ref, column, "", *s);
// Ensure we get an end of line character one way or another.
- if (!is_newline_char(cstr[count - 1]))
- bytes_written += s->EOL();
+ if (!is_newline_char(ref.back()))
+ s->EOL();
}
- return bytes_written;
}
- return 0;
+ return s->GetWrittenBytes() - bytes_written;
}
void SourceManager::File::FindLinesMatchingRegex(
diff --git a/source/Core/State.cpp b/source/Core/State.cpp
deleted file mode 100644
index 4697ca4b5f17..000000000000
--- a/source/Core/State.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-//===-- State.cpp -----------------------------------------------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
-#include "lldb/Core/State.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-const char *lldb_private::StateAsCString(StateType state) {
- switch (state) {
- case eStateInvalid:
- return "invalid";
- case eStateUnloaded:
- return "unloaded";
- case eStateConnected:
- return "connected";
- case eStateAttaching:
- return "attaching";
- case eStateLaunching:
- return "launching";
- case eStateStopped:
- return "stopped";
- case eStateRunning:
- return "running";
- case eStateStepping:
- return "stepping";
- case eStateCrashed:
- return "crashed";
- case eStateDetached:
- return "detached";
- case eStateExited:
- return "exited";
- case eStateSuspended:
- return "suspended";
- }
- return "unknown";
-}
-
-const char *lldb_private::GetPermissionsAsCString(uint32_t permissions) {
- switch (permissions) {
- case 0:
- return "---";
- case ePermissionsWritable:
- return "-w-";
- case ePermissionsReadable:
- return "r--";
- case ePermissionsExecutable:
- return "--x";
- case ePermissionsReadable | ePermissionsWritable:
- return "rw-";
- case ePermissionsReadable | ePermissionsExecutable:
- return "r-x";
- case ePermissionsWritable | ePermissionsExecutable:
- return "-wx";
- case ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable:
- return "rwx";
- default:
- break;
- }
- return "???";
-}
-
-bool lldb_private::StateIsRunningState(StateType state) {
- switch (state) {
- case eStateAttaching:
- case eStateLaunching:
- case eStateRunning:
- case eStateStepping:
- return true;
-
- case eStateConnected:
- case eStateDetached:
- case eStateInvalid:
- case eStateUnloaded:
- case eStateStopped:
- case eStateCrashed:
- case eStateExited:
- case eStateSuspended:
- break;
- }
- return false;
-}
-
-bool lldb_private::StateIsStoppedState(StateType state, bool must_exist) {
- switch (state) {
- case eStateInvalid:
- case eStateConnected:
- case eStateAttaching:
- case eStateLaunching:
- case eStateRunning:
- case eStateStepping:
- case eStateDetached:
- break;
-
- case eStateUnloaded:
- case eStateExited:
- return !must_exist;
-
- case eStateStopped:
- case eStateCrashed:
- case eStateSuspended:
- return true;
- }
- return false;
-}
diff --git a/source/Core/StreamAsynchronousIO.cpp b/source/Core/StreamAsynchronousIO.cpp
index aae8636bff09..b8938bd3fc4e 100644
--- a/source/Core/StreamAsynchronousIO.cpp
+++ b/source/Core/StreamAsynchronousIO.cpp
@@ -10,7 +10,7 @@
#include "lldb/Core/StreamAsynchronousIO.h"
#include "lldb/Core/Debugger.h"
-#include "lldb/lldb-enumerations.h" // for ByteOrder::eByteOrderBig
+#include "lldb/lldb-enumerations.h"
using namespace lldb;
using namespace lldb_private;
@@ -31,7 +31,7 @@ void StreamAsynchronousIO::Flush() {
}
}
-size_t StreamAsynchronousIO::Write(const void *s, size_t length) {
+size_t StreamAsynchronousIO::WriteImpl(const void *s, size_t length) {
m_data.append((const char *)s, length);
return length;
}
diff --git a/source/Core/StreamFile.cpp b/source/Core/StreamFile.cpp
index f59415485021..d24634598c36 100644
--- a/source/Core/StreamFile.cpp
+++ b/source/Core/StreamFile.cpp
@@ -8,6 +8,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/Core/StreamFile.h"
+#include "lldb/Host/FileSystem.h"
#include <stdio.h>
@@ -28,20 +29,24 @@ StreamFile::StreamFile(int fd, bool transfer_ownership)
StreamFile::StreamFile(FILE *fh, bool transfer_ownership)
: Stream(), m_file(fh, transfer_ownership) {}
-StreamFile::StreamFile(const char *path)
- : Stream(),
- m_file(path, File::eOpenOptionWrite | File::eOpenOptionCanCreate |
- File::eOpenOptionCloseOnExec,
- lldb::eFilePermissionsFileDefault) {}
+StreamFile::StreamFile(const char *path) : Stream(), m_file() {
+ FileSystem::Instance().Open(m_file, FileSpec(path),
+ File::eOpenOptionWrite |
+ File::eOpenOptionCanCreate |
+ File::eOpenOptionCloseOnExec);
+}
StreamFile::StreamFile(const char *path, uint32_t options, uint32_t permissions)
- : Stream(), m_file(path, options, permissions) {}
+ : Stream(), m_file() {
+
+ FileSystem::Instance().Open(m_file, FileSpec(path), options, permissions);
+}
StreamFile::~StreamFile() {}
void StreamFile::Flush() { m_file.Flush(); }
-size_t StreamFile::Write(const void *s, size_t length) {
+size_t StreamFile::WriteImpl(const void *s, size_t length) {
m_file.Write(s, length);
return length;
}
diff --git a/source/Core/UserSettingsController.cpp b/source/Core/UserSettingsController.cpp
index a4661a6c9e8c..4406057ca6b9 100644
--- a/source/Core/UserSettingsController.cpp
+++ b/source/Core/UserSettingsController.cpp
@@ -13,7 +13,7 @@
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"
-#include <memory> // for shared_ptr
+#include <memory>
namespace lldb_private {
class CommandInterpreter;
diff --git a/source/Core/Value.cpp b/source/Core/Value.cpp
index 254c9008babb..8e18458b90c2 100644
--- a/source/Core/Value.cpp
+++ b/source/Core/Value.cpp
@@ -9,9 +9,8 @@
#include "lldb/Core/Value.h"
-#include "lldb/Core/Address.h" // for Address
+#include "lldb/Core/Address.h"
#include "lldb/Core/Module.h"
-#include "lldb/Core/State.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolContext.h"
@@ -21,20 +20,21 @@
#include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h"
-#include "lldb/Utility/ConstString.h" // for ConstString
+#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/Endian.h" // for InlHostByteOrder
-#include "lldb/Utility/FileSpec.h" // for FileSpec
+#include "lldb/Utility/Endian.h"
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/State.h"
#include "lldb/Utility/Stream.h"
-#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
-#include "lldb/lldb-forward.h" // for DataBufferSP, ModuleSP
-#include "lldb/lldb-types.h" // for addr_t
+#include "lldb/lldb-defines.h"
+#include "lldb/lldb-forward.h"
+#include "lldb/lldb-types.h"
-#include <memory> // for make_shared
-#include <string> // for string
+#include <memory>
+#include <string>
-#include <inttypes.h> // for PRIx64
+#include <inttypes.h>
using namespace lldb;
using namespace lldb_private;
@@ -210,34 +210,31 @@ bool Value::ValueOf(ExecutionContext *exe_ctx) {
}
uint64_t Value::GetValueByteSize(Status *error_ptr, ExecutionContext *exe_ctx) {
- uint64_t byte_size = 0;
-
switch (m_context_type) {
case eContextTypeRegisterInfo: // RegisterInfo *
- if (GetRegisterInfo())
- byte_size = GetRegisterInfo()->byte_size;
+ if (GetRegisterInfo()) {
+ if (error_ptr)
+ error_ptr->Clear();
+ return GetRegisterInfo()->byte_size;
+ }
break;
case eContextTypeInvalid:
case eContextTypeLLDBType: // Type *
case eContextTypeVariable: // Variable *
{
- const CompilerType &ast_type = GetCompilerType();
- if (ast_type.IsValid())
- byte_size = ast_type.GetByteSize(
- exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr);
- } break;
- }
-
- if (error_ptr) {
- if (byte_size == 0) {
- if (error_ptr->Success())
- error_ptr->SetErrorString("Unable to determine byte size.");
- } else {
- error_ptr->Clear();
+ auto *scope = exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr;
+ if (llvm::Optional<uint64_t> size = GetCompilerType().GetByteSize(scope)) {
+ if (error_ptr)
+ error_ptr->Clear();
+ return *size;
}
+ break;
}
- return byte_size;
+ }
+ if (error_ptr && error_ptr->Success())
+ error_ptr->SetErrorString("Unable to determine byte size.");
+ return 0;
}
const CompilerType &Value::GetCompilerType() {
@@ -344,10 +341,9 @@ Status Value::GetValueAsData(ExecutionContext *exe_ctx, DataExtractor &data,
uint32_t limit_byte_size = UINT32_MAX;
- if (ast_type.IsValid()) {
- limit_byte_size = ast_type.GetByteSize(
- exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr);
- }
+ if (llvm::Optional<uint64_t> size = ast_type.GetByteSize(
+ exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr))
+ limit_byte_size = *size;
if (limit_byte_size <= m_value.GetByteSize()) {
if (m_value.GetData(data, limit_byte_size))
diff --git a/source/Core/ValueObject.cpp b/source/Core/ValueObject.cpp
index 244ea2936fb4..95e944b22b87 100644
--- a/source/Core/ValueObject.cpp
+++ b/source/Core/ValueObject.cpp
@@ -9,9 +9,8 @@
#include "lldb/Core/ValueObject.h"
-#include "lldb/Core/Address.h" // for Address
+#include "lldb/Core/Address.h"
#include "lldb/Core/Module.h"
-#include "lldb/Core/Scalar.h" // for Scalar
#include "lldb/Core/ValueObjectCast.h"
#include "lldb/Core/ValueObjectChild.h"
#include "lldb/Core/ValueObjectConstResult.h"
@@ -19,51 +18,52 @@
#include "lldb/Core/ValueObjectMemory.h"
#include "lldb/Core/ValueObjectSyntheticFilter.h"
#include "lldb/DataFormatters/DataVisualization.h"
-#include "lldb/DataFormatters/DumpValueObjectOptions.h" // for DumpValueObj...
-#include "lldb/DataFormatters/FormatManager.h" // for FormatManager
+#include "lldb/DataFormatters/DumpValueObjectOptions.h"
+#include "lldb/DataFormatters/FormatManager.h"
#include "lldb/DataFormatters/StringPrinter.h"
-#include "lldb/DataFormatters/TypeFormat.h" // for TypeFormatImpl_F...
-#include "lldb/DataFormatters/TypeSummary.h" // for TypeSummaryOptions
-#include "lldb/DataFormatters/TypeValidator.h" // for TypeValidatorImp...
+#include "lldb/DataFormatters/TypeFormat.h"
+#include "lldb/DataFormatters/TypeSummary.h"
+#include "lldb/DataFormatters/TypeValidator.h"
#include "lldb/DataFormatters/ValueObjectPrinter.h"
-#include "lldb/Expression/ExpressionVariable.h" // for ExpressionVariable
+#include "lldb/Expression/ExpressionVariable.h"
#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/CompilerType.h"
-#include "lldb/Symbol/Declaration.h" // for Declaration
-#include "lldb/Symbol/SymbolContext.h" // for SymbolContext
+#include "lldb/Symbol/Declaration.h"
+#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Language.h"
#include "lldb/Target/LanguageRuntime.h"
#include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Process.h"
-#include "lldb/Target/StackFrame.h" // for StackFrame
+#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
-#include "lldb/Target/ThreadList.h" // for ThreadList
-#include "lldb/Utility/DataBuffer.h" // for DataBuffer
+#include "lldb/Target/ThreadList.h"
+#include "lldb/Utility/DataBuffer.h"
#include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/Flags.h" // for Flags
+#include "lldb/Utility/Flags.h"
#include "lldb/Utility/Log.h"
-#include "lldb/Utility/Logging.h" // for GetLogIfAllCateg...
-#include "lldb/Utility/SharingPtr.h" // for SharingPtr
-#include "lldb/Utility/Stream.h" // for Stream
+#include "lldb/Utility/Logging.h"
+#include "lldb/Utility/Scalar.h"
+#include "lldb/Utility/SharingPtr.h"
+#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
-#include "lldb/lldb-private-types.h" // for RegisterInfo
+#include "lldb/lldb-private-types.h"
-#include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH
+#include "llvm/Support/Compiler.h"
-#include <algorithm> // for min
-#include <cstdint> // for uint32_t, uint64_t
-#include <cstdlib> // for size_t, NULL
-#include <memory> // for shared_ptr, oper...
-#include <tuple> // for tie, tuple
+#include <algorithm>
+#include <cstdint>
+#include <cstdlib>
+#include <memory>
+#include <tuple>
-#include <assert.h> // for assert
-#include <inttypes.h> // for PRIu64, PRIx64
-#include <stdio.h> // for snprintf
-#include <string.h> // for memcpy, memcmp
+#include <assert.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
namespace lldb_private {
class ExecutionContextScope;
@@ -214,7 +214,7 @@ bool ValueObject::UpdateValueIfNeeded(bool update_format) {
if (first_update)
SetValueDidChange(false);
- else if (!m_value_did_change && success == false) {
+ else if (!m_value_did_change && !success) {
// The value wasn't gotten successfully, so we mark this as changed if
// the value used to be valid and now isn't
SetValueDidChange(value_was_valid);
@@ -442,10 +442,7 @@ bool ValueObject::IsLogicalTrue(Status &error) {
}
bool ret;
- if (scalar_value.ULongLong(1) == 0)
- ret = false;
- else
- ret = true;
+ ret = scalar_value.ULongLong(1) != 0;
error.Clear();
return ret;
}
@@ -639,7 +636,7 @@ ValueObject *ValueObject::CreateChildAtIndex(size_t idx,
bool child_is_deref_of_parent = false;
uint64_t language_flags = 0;
- const bool transparent_pointers = synthetic_array_member == false;
+ const bool transparent_pointers = !synthetic_array_member;
CompilerType child_compiler_type;
ExecutionContext exe_ctx(GetExecutionContextRef());
@@ -662,8 +659,6 @@ ValueObject *ValueObject::CreateChildAtIndex(size_t idx,
child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
child_is_base_class, child_is_deref_of_parent, eAddressTypeInvalid,
language_flags);
- // if (valobj)
- // valobj->SetAddressTypeOfChildren(eAddressTypeInvalid);
}
return valobj;
@@ -761,10 +756,13 @@ size_t ValueObject::GetPointeeData(DataExtractor &data, uint32_t item_idx,
ExecutionContext exe_ctx(GetExecutionContextRef());
- const uint64_t item_type_size = pointee_or_element_compiler_type.GetByteSize(
- exe_ctx.GetBestExecutionContextScope());
- const uint64_t bytes = item_count * item_type_size;
- const uint64_t offset = item_idx * item_type_size;
+ llvm::Optional<uint64_t> item_type_size =
+ pointee_or_element_compiler_type.GetByteSize(
+ exe_ctx.GetBestExecutionContextScope());
+ if (!item_type_size)
+ return 0;
+ const uint64_t bytes = item_count * *item_type_size;
+ const uint64_t offset = item_idx * *item_type_size;
if (item_idx == 0 && item_count == 1) // simply a deref
{
@@ -827,10 +825,10 @@ size_t ValueObject::GetPointeeData(DataExtractor &data, uint32_t item_idx,
}
} break;
case eAddressTypeHost: {
- const uint64_t max_bytes =
+ auto max_bytes =
GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope());
- if (max_bytes > offset) {
- size_t bytes_read = std::min<uint64_t>(max_bytes - offset, bytes);
+ if (max_bytes && *max_bytes > offset) {
+ size_t bytes_read = std::min<uint64_t>(*max_bytes - offset, bytes);
addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
if (addr == 0 || addr == LLDB_INVALID_ADDRESS)
break;
@@ -1823,14 +1821,16 @@ ValueObjectSP ValueObject::GetSyntheticChildAtOffset(
return synthetic_child_sp;
if (!can_create)
- return ValueObjectSP();
+ return {};
ExecutionContext exe_ctx(GetExecutionContextRef());
-
- ValueObjectChild *synthetic_child = new ValueObjectChild(
- *this, type, name_const_str,
- type.GetByteSize(exe_ctx.GetBestExecutionContextScope()), offset, 0, 0,
- false, false, eAddressTypeInvalid, 0);
+ llvm::Optional<uint64_t> size =
+ type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
+ if (!size)
+ return {};
+ ValueObjectChild *synthetic_child =
+ new ValueObjectChild(*this, type, name_const_str, *size, offset, 0, 0,
+ false, false, eAddressTypeInvalid, 0);
if (synthetic_child) {
AddSyntheticChild(name_const_str, synthetic_child);
synthetic_child_sp = synthetic_child->GetSP();
@@ -1861,16 +1861,18 @@ ValueObjectSP ValueObject::GetSyntheticBase(uint32_t offset,
return synthetic_child_sp;
if (!can_create)
- return ValueObjectSP();
+ return {};
const bool is_base_class = true;
ExecutionContext exe_ctx(GetExecutionContextRef());
-
- ValueObjectChild *synthetic_child = new ValueObjectChild(
- *this, type, name_const_str,
- type.GetByteSize(exe_ctx.GetBestExecutionContextScope()), offset, 0, 0,
- is_base_class, false, eAddressTypeInvalid, 0);
+ llvm::Optional<uint64_t> size =
+ type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
+ if (!size)
+ return {};
+ ValueObjectChild *synthetic_child =
+ new ValueObjectChild(*this, type, name_const_str, *size, offset, 0, 0,
+ is_base_class, false, eAddressTypeInvalid, 0);
if (synthetic_child) {
AddSyntheticChild(name_const_str, synthetic_child);
synthetic_child_sp = synthetic_child->GetSP();
@@ -1923,11 +1925,11 @@ ValueObject::GetSyntheticExpressionPathChild(const char *expression,
}
void ValueObject::CalculateSyntheticValue(bool use_synthetic) {
- if (use_synthetic == false)
+ if (!use_synthetic)
return;
TargetSP target_sp(GetTargetSP());
- if (target_sp && target_sp->GetEnableSyntheticValue() == false) {
+ if (target_sp && !target_sp->GetEnableSyntheticValue()) {
m_synthetic_value = NULL;
return;
}
@@ -1978,7 +1980,7 @@ ValueObjectSP ValueObject::GetStaticValue() { return GetSP(); }
lldb::ValueObjectSP ValueObject::GetNonSyntheticValue() { return GetSP(); }
ValueObjectSP ValueObject::GetSyntheticValue(bool use_synthetic) {
- if (use_synthetic == false)
+ if (!use_synthetic)
return ValueObjectSP();
CalculateSyntheticValue(use_synthetic);
@@ -1997,10 +1999,7 @@ bool ValueObject::HasSyntheticValue() {
CalculateSyntheticValue(true);
- if (m_synthetic_value)
- return true;
- else
- return false;
+ return m_synthetic_value != nullptr;
}
bool ValueObject::GetBaseClassPath(Stream &s) {
@@ -2806,31 +2805,6 @@ ValueObjectSP ValueObject::GetQualifiedRepresentationIfAvailable(
return result_sp;
}
-lldb::addr_t ValueObject::GetCPPVTableAddress(AddressType &address_type) {
- CompilerType pointee_type;
- CompilerType this_type(GetCompilerType());
- uint32_t type_info = this_type.GetTypeInfo(&pointee_type);
- if (type_info) {
- bool ptr_or_ref = false;
- if (type_info & (eTypeIsPointer | eTypeIsReference)) {
- ptr_or_ref = true;
- type_info = pointee_type.GetTypeInfo();
- }
-
- const uint32_t cpp_class = eTypeIsClass | eTypeIsCPlusPlus;
- if ((type_info & cpp_class) == cpp_class) {
- if (ptr_or_ref) {
- address_type = GetAddressTypeOfChildren();
- return GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
- } else
- return GetAddressOf(false, &address_type);
- }
- }
-
- address_type = eAddressTypeInvalid;
- return LLDB_INVALID_ADDRESS;
-}
-
ValueObjectSP ValueObject::Dereference(Status &error) {
if (m_deref_valobj)
return m_deref_valobj->GetSP();
@@ -3222,7 +3196,7 @@ ValueObject *
ValueObject::FollowParentChain(std::function<bool(ValueObject *)> f) {
ValueObject *vo = this;
while (vo) {
- if (f(vo) == false)
+ if (!f(vo))
break;
vo = vo->m_parent;
}
@@ -3291,8 +3265,7 @@ bool ValueObject::CanProvideValue() {
// board debugging scenarios have no notion of types, but still manage to
// have raw numeric values for things like registers. sigh.
const CompilerType &type(GetCompilerType());
- return (false == type.IsValid()) ||
- (0 != (type.GetTypeInfo() & eTypeHasValue));
+ return (!type.IsValid()) || (0 != (type.GetTypeInfo() & eTypeHasValue));
}
bool ValueObject::IsChecksumEmpty() { return m_value_checksum.empty(); }
diff --git a/source/Core/ValueObjectCast.cpp b/source/Core/ValueObjectCast.cpp
index e0978f692bc5..fb0b55b6efdf 100644
--- a/source/Core/ValueObjectCast.cpp
+++ b/source/Core/ValueObjectCast.cpp
@@ -9,12 +9,12 @@
#include "lldb/Core/ValueObjectCast.h"
-#include "lldb/Core/Scalar.h" // for operator!=, Scalar
#include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/ExecutionContext.h"
-#include "lldb/Utility/Status.h" // for Status
+#include "lldb/Utility/Scalar.h"
+#include "lldb/Utility/Status.h"
namespace lldb_private {
class ConstString;
@@ -44,7 +44,9 @@ ValueObjectCast::~ValueObjectCast() {}
CompilerType ValueObjectCast::GetCompilerTypeImpl() { return m_cast_type; }
size_t ValueObjectCast::CalculateNumChildren(uint32_t max) {
- auto children_count = GetCompilerType().GetNumChildren(true);
+ ExecutionContext exe_ctx(GetExecutionContextRef());
+ auto children_count = GetCompilerType().GetNumChildren(
+ true, &exe_ctx);
return children_count <= max ? children_count : max;
}
diff --git a/source/Core/ValueObjectChild.cpp b/source/Core/ValueObjectChild.cpp
index 019daa2fd3d2..0f7be8317dec 100644
--- a/source/Core/ValueObjectChild.cpp
+++ b/source/Core/ValueObjectChild.cpp
@@ -9,21 +9,21 @@
#include "lldb/Core/ValueObjectChild.h"
-#include "lldb/Core/Scalar.h" // for Scalar
-#include "lldb/Core/Value.h" // for Value, Value::ValueType::e...
+#include "lldb/Core/Value.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
-#include "lldb/Utility/Flags.h" // for Flags
-#include "lldb/Utility/Status.h" // for Status
-#include "lldb/lldb-forward.h" // for ProcessSP, ModuleSP
+#include "lldb/Utility/Flags.h"
+#include "lldb/Utility/Scalar.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/lldb-forward.h"
-#include <functional> // for _Func_impl<>::_Mybase
-#include <memory> // for shared_ptr
-#include <vector> // for vector
+#include <functional>
+#include <memory>
+#include <vector>
-#include <stdio.h> // for snprintf, size_t
-#include <string.h> // for strlen
+#include <stdio.h>
+#include <string.h>
using namespace lldb_private;
@@ -51,7 +51,8 @@ lldb::ValueType ValueObjectChild::GetValueType() const {
}
size_t ValueObjectChild::CalculateNumChildren(uint32_t max) {
- auto children_count = GetCompilerType().GetNumChildren(true);
+ ExecutionContext exe_ctx(GetExecutionContextRef());
+ auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);
return children_count <= max ? children_count : max;
}
@@ -123,7 +124,7 @@ bool ValueObjectChild::UpdateValue() {
Flags parent_type_flags(parent_type.GetTypeInfo());
const bool is_instance_ptr_base =
- ((m_is_base_class == true) &&
+ ((m_is_base_class) &&
(parent_type_flags.AnySet(lldb::eTypeInstanceIsPointer)));
if (parent->GetCompilerType().ShouldTreatScalarValueAsAddress()) {
@@ -141,7 +142,7 @@ bool ValueObjectChild::UpdateValue() {
switch (addr_type) {
case eAddressTypeFile: {
lldb::ProcessSP process_sp(GetProcessSP());
- if (process_sp && process_sp->IsAlive() == true)
+ if (process_sp && process_sp->IsAlive())
m_value.SetValueType(Value::eValueTypeLoadAddress);
else
m_value.SetValueType(Value::eValueTypeFileAddress);
@@ -201,12 +202,9 @@ bool ValueObjectChild::UpdateValue() {
ExecutionContext exe_ctx(
GetExecutionContextRef().Lock(thread_and_frame_only_if_stopped));
if (GetCompilerType().GetTypeInfo() & lldb::eTypeHasValue) {
- if (!is_instance_ptr_base)
- m_error =
- m_value.GetValueAsData(&exe_ctx, m_data, 0, GetModule().get());
- else
- m_error = m_parent->GetValue().GetValueAsData(&exe_ctx, m_data, 0,
- GetModule().get());
+ Value &value = is_instance_ptr_base ? m_parent->GetValue() : m_value;
+ m_error =
+ value.GetValueAsData(&exe_ctx, m_data, 0, GetModule().get());
} else {
m_error.Clear(); // No value so nothing to read...
}
diff --git a/source/Core/ValueObjectConstResult.cpp b/source/Core/ValueObjectConstResult.cpp
index 1023696c35a7..f6e32c03b0eb 100644
--- a/source/Core/ValueObjectConstResult.cpp
+++ b/source/Core/ValueObjectConstResult.cpp
@@ -9,15 +9,15 @@
#include "lldb/Core/ValueObjectConstResult.h"
-#include "lldb/Core/Scalar.h" // for Scalar
#include "lldb/Core/ValueObjectDynamicValue.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/ExecutionContextScope.h" // for ExecutionContextScope
+#include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/Process.h"
-#include "lldb/Utility/DataBuffer.h" // for DataBuffer
-#include "lldb/Utility/DataBufferHeap.h" // for DataBufferHeap
+#include "lldb/Utility/DataBuffer.h"
+#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Scalar.h"
namespace lldb_private {
class Module;
@@ -198,17 +198,19 @@ lldb::ValueType ValueObjectConstResult::GetValueType() const {
uint64_t ValueObjectConstResult::GetByteSize() {
ExecutionContext exe_ctx(GetExecutionContextRef());
-
- if (m_byte_size == 0)
- SetByteSize(
- GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope()));
+ if (m_byte_size == 0) {
+ if (auto size =
+ GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope()))
+ SetByteSize(*size);
+ }
return m_byte_size;
}
void ValueObjectConstResult::SetByteSize(size_t size) { m_byte_size = size; }
size_t ValueObjectConstResult::CalculateNumChildren(uint32_t max) {
- auto children_count = GetCompilerType().GetNumChildren(true);
+ ExecutionContext exe_ctx(GetExecutionContextRef());
+ auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);
return children_count <= max ? children_count : max;
}
diff --git a/source/Core/ValueObjectConstResultChild.cpp b/source/Core/ValueObjectConstResultChild.cpp
index 3e9f87684162..441c16479f2c 100644
--- a/source/Core/ValueObjectConstResultChild.cpp
+++ b/source/Core/ValueObjectConstResultChild.cpp
@@ -9,7 +9,7 @@
#include "lldb/Core/ValueObjectConstResultChild.h"
-#include "lldb/lldb-private-enumerations.h" // for AddressType::eAddressType
+#include "lldb/lldb-private-enumerations.h"
namespace lldb_private {
class DataExtractor;
}
@@ -52,6 +52,11 @@ lldb::ValueObjectSP ValueObjectConstResultChild::AddressOf(Status &error) {
return m_impl.AddressOf(error);
}
+lldb::addr_t ValueObjectConstResultChild::GetAddressOf(
+ bool scalar_is_load_address, AddressType* address_type) {
+ return m_impl.GetAddressOf(scalar_is_load_address, address_type);
+}
+
ValueObject *ValueObjectConstResultChild::CreateChildAtIndex(
size_t idx, bool synthetic_array_member, int32_t synthetic_index) {
return m_impl.CreateChildAtIndex(idx, synthetic_array_member,
diff --git a/source/Core/ValueObjectConstResultImpl.cpp b/source/Core/ValueObjectConstResultImpl.cpp
index 714634ed56e3..6bf8e62db067 100644
--- a/source/Core/ValueObjectConstResultImpl.cpp
+++ b/source/Core/ValueObjectConstResultImpl.cpp
@@ -9,19 +9,19 @@
#include "lldb/Core/ValueObjectConstResultImpl.h"
-#include "lldb/Core/Scalar.h" // for Scalar
-#include "lldb/Core/Value.h" // for Value, Value::Val...
-#include "lldb/Core/ValueObject.h" // for ValueObject
+#include "lldb/Core/Value.h"
+#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectConstResultCast.h"
#include "lldb/Core/ValueObjectConstResultChild.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/ExecutionContext.h"
-#include "lldb/Utility/DataBufferHeap.h" // for DataBufferHeap
-#include "lldb/Utility/Endian.h" // for InlHostByteOrder
-#include "lldb/Utility/SharingPtr.h" // for SharingPtr
+#include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/Endian.h"
+#include "lldb/Utility/Scalar.h"
+#include "lldb/Utility/SharingPtr.h"
-#include <string> // for string
+#include <string>
namespace lldb_private {
class DataExtractor;
@@ -66,7 +66,7 @@ ValueObject *ValueObjectConstResultImpl::CreateChildAtIndex(
bool child_is_deref_of_parent = false;
uint64_t language_flags;
- const bool transparent_pointers = synthetic_array_member == false;
+ const bool transparent_pointers = !synthetic_array_member;
CompilerType compiler_type = m_impl_backend->GetCompilerType();
CompilerType child_compiler_type;
@@ -77,7 +77,13 @@ ValueObject *ValueObjectConstResultImpl::CreateChildAtIndex(
ignore_array_bounds, child_name_str, child_byte_size, child_byte_offset,
child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
child_is_deref_of_parent, m_impl_backend, language_flags);
- if (child_compiler_type && child_byte_size) {
+
+ // One might think we should check that the size of the children
+ // is always strictly positive, hence we could avoid creating a
+ // ValueObject if that's not the case, but it turns out there
+ // are languages out there which allow zero-size types with
+ // children (e.g. Swift).
+ if (child_compiler_type) {
if (synthetic_index)
child_byte_offset += child_byte_size * synthetic_index;
diff --git a/source/Core/ValueObjectDynamicValue.cpp b/source/Core/ValueObjectDynamicValue.cpp
index e9b48310b0c6..161b6e49e0dd 100644
--- a/source/Core/ValueObjectDynamicValue.cpp
+++ b/source/Core/ValueObjectDynamicValue.cpp
@@ -8,7 +8,6 @@
//===----------------------------------------------------------------------===//
#include "lldb/Core/ValueObjectDynamicValue.h"
-#include "lldb/Core/Scalar.h" // for Scalar, operator!=
#include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Symbol/CompilerType.h"
@@ -17,13 +16,14 @@
#include "lldb/Target/LanguageRuntime.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
-#include "lldb/Utility/DataExtractor.h" // for DataExtractor
+#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Log.h"
-#include "lldb/Utility/Logging.h" // for GetLogIfAllCategoriesSet
-#include "lldb/Utility/Status.h" // for Status
-#include "lldb/lldb-types.h" // for addr_t, offset_t
+#include "lldb/Utility/Logging.h"
+#include "lldb/Utility/Scalar.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/lldb-types.h"
-#include <string.h> // for strcmp, size_t
+#include <string.h>
namespace lldb_private {
class Declaration;
}
@@ -92,7 +92,8 @@ ConstString ValueObjectDynamicValue::GetDisplayTypeName() {
size_t ValueObjectDynamicValue::CalculateNumChildren(uint32_t max) {
const bool success = UpdateValueIfNeeded(false);
if (success && m_dynamic_type_info.HasType()) {
- auto children_count = GetCompilerType().GetNumChildren(true);
+ ExecutionContext exe_ctx(GetExecutionContextRef());
+ auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);
return children_count <= max ? children_count : max;
} else
return m_parent->GetNumChildren(max);
diff --git a/source/Core/ValueObjectList.cpp b/source/Core/ValueObjectList.cpp
index 0dd07252888f..7a7e0d8417b7 100644
--- a/source/Core/ValueObjectList.cpp
+++ b/source/Core/ValueObjectList.cpp
@@ -9,11 +9,11 @@
#include "lldb/Core/ValueObjectList.h"
-#include "lldb/Core/ValueObject.h" // for ValueObject
-#include "lldb/Utility/ConstString.h" // for ConstString
-#include "lldb/Utility/SharingPtr.h" // for SharingPtr
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/SharingPtr.h"
-#include <utility> // for back_insert_iterator, back_ins...
+#include <utility>
using namespace lldb;
using namespace lldb_private;
diff --git a/source/Core/ValueObjectMemory.cpp b/source/Core/ValueObjectMemory.cpp
index 3e71fea6bb35..24103204ee47 100644
--- a/source/Core/ValueObjectMemory.cpp
+++ b/source/Core/ValueObjectMemory.cpp
@@ -8,19 +8,19 @@
//===----------------------------------------------------------------------===//
#include "lldb/Core/ValueObjectMemory.h"
-#include "lldb/Core/Scalar.h" // for Scalar, operator!=
#include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Target.h"
-#include "lldb/Utility/DataExtractor.h" // for DataExtractor
-#include "lldb/Utility/Status.h" // for Status
-#include "lldb/lldb-types.h" // for addr_t
-#include "llvm/Support/ErrorHandling.h" // for llvm_unreachable
+#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Scalar.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/lldb-types.h"
+#include "llvm/Support/ErrorHandling.h"
-#include <assert.h> // for assert
-#include <memory> // for shared_ptr
+#include <assert.h>
+#include <memory>
namespace lldb_private {
class ExecutionContextScope;
@@ -128,15 +128,19 @@ size_t ValueObjectMemory::CalculateNumChildren(uint32_t max) {
return child_count <= max ? child_count : max;
}
+ ExecutionContext exe_ctx(GetExecutionContextRef());
const bool omit_empty_base_classes = true;
- auto child_count = m_compiler_type.GetNumChildren(omit_empty_base_classes);
+ auto child_count =
+ m_compiler_type.GetNumChildren(omit_empty_base_classes, &exe_ctx);
return child_count <= max ? child_count : max;
}
uint64_t ValueObjectMemory::GetByteSize() {
if (m_type_sp)
return m_type_sp->GetByteSize();
- return m_compiler_type.GetByteSize(nullptr);
+ if (llvm::Optional<uint64_t> size = m_compiler_type.GetByteSize(nullptr))
+ return *size;
+ return 0;
}
lldb::ValueType ValueObjectMemory::GetValueType() const {
diff --git a/source/Core/ValueObjectRegister.cpp b/source/Core/ValueObjectRegister.cpp
index 05022d3ed10a..41d1c27f7361 100644
--- a/source/Core/ValueObjectRegister.cpp
+++ b/source/Core/ValueObjectRegister.cpp
@@ -10,23 +10,23 @@
#include "lldb/Core/ValueObjectRegister.h"
#include "lldb/Core/Module.h"
-#include "lldb/Core/Scalar.h" // for Scalar
-#include "lldb/Core/Value.h" // for Value, Value::ContextType:...
+#include "lldb/Core/Value.h"
#include "lldb/Symbol/CompilerType.h"
-#include "lldb/Symbol/TypeSystem.h" // for TypeSystem
+#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/StackFrame.h" // for StackFrame
+#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
-#include "lldb/Utility/DataExtractor.h" // for DataExtractor
-#include "lldb/Utility/Status.h" // for Status
-#include "lldb/Utility/Stream.h" // for Stream
+#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Scalar.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/Utility/Stream.h"
-#include "llvm/ADT/StringRef.h" // for StringRef
+#include "llvm/ADT/StringRef.h"
-#include <assert.h> // for assert
-#include <memory> // for shared_ptr
+#include <assert.h>
+#include <memory>
namespace lldb_private {
class ExecutionContextScope;
@@ -279,7 +279,8 @@ ConstString ValueObjectRegister::GetTypeName() {
}
size_t ValueObjectRegister::CalculateNumChildren(uint32_t max) {
- auto children_count = GetCompilerType().GetNumChildren(true);
+ ExecutionContext exe_ctx(GetExecutionContextRef());
+ auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);
return children_count <= max ? children_count : max;
}
diff --git a/source/Core/ValueObjectSyntheticFilter.cpp b/source/Core/ValueObjectSyntheticFilter.cpp
index 044387a4ae12..d22b1dc1c57d 100644
--- a/source/Core/ValueObjectSyntheticFilter.cpp
+++ b/source/Core/ValueObjectSyntheticFilter.cpp
@@ -9,14 +9,14 @@
#include "lldb/Core/ValueObjectSyntheticFilter.h"
-#include "lldb/Core/Value.h" // for Value
+#include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/DataFormatters/TypeSynthetic.h"
-#include "lldb/Target/ExecutionContext.h" // for ExecutionContext
+#include "lldb/Target/ExecutionContext.h"
#include "lldb/Utility/Log.h"
-#include "lldb/Utility/Logging.h" // for GetLogIfAllCategoriesSet
-#include "lldb/Utility/SharingPtr.h" // for SharingPtr
-#include "lldb/Utility/Status.h" // for Status
+#include "lldb/Utility/Logging.h"
+#include "lldb/Utility/SharingPtr.h"
+#include "lldb/Utility/Status.h"
#include "llvm/ADT/STLExtras.h"
@@ -119,7 +119,7 @@ bool ValueObjectSynthetic::MightHaveChildren() {
if (m_might_have_children == eLazyBoolCalculate)
m_might_have_children =
(m_synth_filter_ap->MightHaveChildren() ? eLazyBoolYes : eLazyBoolNo);
- return (m_might_have_children == eLazyBoolNo ? false : true);
+ return (m_might_have_children != eLazyBoolNo);
}
uint64_t ValueObjectSynthetic::GetByteSize() { return m_parent->GetByteSize(); }
@@ -174,7 +174,7 @@ bool ValueObjectSynthetic::UpdateValue() {
}
// let our backend do its update
- if (m_synth_filter_ap->Update() == false) {
+ if (!m_synth_filter_ap->Update()) {
if (log)
log->Printf("[ValueObjectSynthetic::UpdateValue] name=%s, synthetic "
"filter said caches are stale - clearing",
@@ -235,7 +235,7 @@ lldb::ValueObjectSP ValueObjectSynthetic::GetChildAtIndex(size_t idx,
UpdateValueIfNeeded();
ValueObject *valobj;
- if (m_children_byindex.GetValueForKey(idx, valobj) == false) {
+ if (!m_children_byindex.GetValueForKey(idx, valobj)) {
if (can_create && m_synth_filter_ap.get() != nullptr) {
if (log)
log->Printf("[ValueObjectSynthetic::GetChildAtIndex] name=%s, child at "
diff --git a/source/Core/ValueObjectVariable.cpp b/source/Core/ValueObjectVariable.cpp
index bfe5c3de7fbf..4d401c56249c 100644
--- a/source/Core/ValueObjectVariable.cpp
+++ b/source/Core/ValueObjectVariable.cpp
@@ -9,14 +9,12 @@
#include "lldb/Core/ValueObjectVariable.h"
-#include "lldb/Core/Address.h" // for Address
-#include "lldb/Core/AddressRange.h" // for AddressRange
+#include "lldb/Core/Address.h"
+#include "lldb/Core/AddressRange.h"
#include "lldb/Core/Module.h"
-#include "lldb/Core/RegisterValue.h"
-#include "lldb/Core/Scalar.h" // for Scalar, operator!=
#include "lldb/Core/Value.h"
-#include "lldb/Expression/DWARFExpression.h" // for DWARFExpression
-#include "lldb/Symbol/Declaration.h" // for Declaration
+#include "lldb/Expression/DWARFExpression.h"
+#include "lldb/Symbol/Declaration.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolContext.h"
@@ -27,15 +25,17 @@
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h"
-#include "lldb/Utility/DataExtractor.h" // for DataExtractor
-#include "lldb/Utility/Status.h" // for Status
-#include "lldb/lldb-private-enumerations.h" // for AddressType::eAddressTy...
-#include "lldb/lldb-types.h" // for addr_t
+#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/lldb-private-enumerations.h"
+#include "lldb/lldb-types.h"
-#include "llvm/ADT/StringRef.h" // for StringRef
+#include "llvm/ADT/StringRef.h"
-#include <assert.h> // for assert
-#include <memory> // for shared_ptr
+#include <assert.h>
+#include <memory>
namespace lldb_private {
class ExecutionContextScope;
@@ -98,8 +98,9 @@ size_t ValueObjectVariable::CalculateNumChildren(uint32_t max) {
if (!type.IsValid())
return 0;
+ ExecutionContext exe_ctx(GetExecutionContextRef());
const bool omit_empty_base_classes = true;
- auto child_count = type.GetNumChildren(omit_empty_base_classes);
+ auto child_count = type.GetNumChildren(omit_empty_base_classes, &exe_ctx);
return child_count <= max ? child_count : max;
}
@@ -111,7 +112,7 @@ uint64_t ValueObjectVariable::GetByteSize() {
if (!type.IsValid())
return 0;
- return type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
+ return type.GetByteSize(exe_ctx.GetBestExecutionContextScope()).getValueOr(0);
}
lldb::ValueType ValueObjectVariable::GetValueType() const {