| //===----------------------------------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "ScriptedFrameProvider.h" |
| #include "Plugins/Process/scripted/ScriptedFrame.h" |
| #include "lldb/Core/Debugger.h" |
| #include "lldb/Core/PluginManager.h" |
| #include "lldb/Interpreter/Interfaces/ScriptedFrameProviderInterface.h" |
| #include "lldb/Interpreter/ScriptInterpreter.h" |
| #include "lldb/Target/BorrowedStackFrame.h" |
| #include "lldb/Target/Process.h" |
| #include "lldb/Target/StackFrame.h" |
| #include "lldb/Target/Thread.h" |
| #include "lldb/Utility/ScriptedMetadata.h" |
| #include "lldb/Utility/Status.h" |
| #include "llvm/Support/Error.h" |
| #include <cstdint> |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| void ScriptedFrameProvider::Initialize() { |
| PluginManager::RegisterPlugin(GetPluginNameStatic(), |
| "Provides synthetic frames via scripting", |
| nullptr, ScriptedFrameProvider::CreateInstance); |
| } |
| |
| void ScriptedFrameProvider::Terminate() { |
| PluginManager::UnregisterPlugin(ScriptedFrameProvider::CreateInstance); |
| } |
| |
| llvm::Expected<lldb::SyntheticFrameProviderSP> |
| ScriptedFrameProvider::CreateInstance( |
| lldb::StackFrameListSP input_frames, |
| const ScriptedFrameProviderDescriptor &descriptor) { |
| if (!input_frames) |
| return llvm::createStringError( |
| "failed to create scripted frame provider: invalid input frames"); |
| |
| Thread &thread = input_frames->GetThread(); |
| ProcessSP process_sp = thread.GetProcess(); |
| if (!process_sp) |
| return nullptr; |
| |
| if (!descriptor.IsValid()) |
| return llvm::createStringError( |
| "failed to create scripted frame provider: invalid scripted metadata"); |
| |
| if (!descriptor.AppliesToThread(thread)) |
| return nullptr; |
| |
| ScriptInterpreter *script_interp = |
| process_sp->GetTarget().GetDebugger().GetScriptInterpreter(); |
| if (!script_interp) |
| return llvm::createStringError("cannot create scripted frame provider: No " |
| "script interpreter installed"); |
| |
| ScriptedFrameProviderInterfaceSP interface_sp = |
| script_interp->CreateScriptedFrameProviderInterface(); |
| if (!interface_sp) |
| return llvm::createStringError( |
| "cannot create scripted frame provider: script interpreter couldn't " |
| "create Scripted Frame Provider Interface"); |
| |
| const ScriptedMetadataSP scripted_metadata = descriptor.scripted_metadata_sp; |
| |
| // If we shouldn't attach a frame provider to this thread, just exit early. |
| if (!interface_sp->AppliesToThread(scripted_metadata->GetClassName(), |
| thread.shared_from_this())) |
| return nullptr; |
| |
| auto obj_or_err = interface_sp->CreatePluginObject( |
| scripted_metadata->GetClassName(), input_frames, |
| scripted_metadata->GetArgsSP()); |
| if (!obj_or_err) |
| return obj_or_err.takeError(); |
| |
| StructuredData::ObjectSP object_sp = *obj_or_err; |
| if (!object_sp || !object_sp->IsValid()) |
| return llvm::createStringError( |
| "cannot create scripted frame provider: failed to create valid scripted" |
| "frame provider object"); |
| |
| return std::make_shared<ScriptedFrameProvider>(input_frames, interface_sp, |
| descriptor); |
| } |
| |
| ScriptedFrameProvider::ScriptedFrameProvider( |
| StackFrameListSP input_frames, |
| lldb::ScriptedFrameProviderInterfaceSP interface_sp, |
| const ScriptedFrameProviderDescriptor &descriptor) |
| : SyntheticFrameProvider(input_frames), m_interface_sp(interface_sp), |
| m_descriptor(descriptor) {} |
| |
| ScriptedFrameProvider::~ScriptedFrameProvider() = default; |
| |
| std::string ScriptedFrameProvider::GetDescription() const { |
| if (!m_interface_sp) |
| return {}; |
| |
| return m_interface_sp->GetDescription(m_descriptor.GetName()); |
| } |
| |
| std::optional<uint32_t> ScriptedFrameProvider::GetPriority() const { |
| if (!m_interface_sp) |
| return std::nullopt; |
| |
| return m_interface_sp->GetPriority(m_descriptor.GetName()); |
| } |
| |
| llvm::Expected<StackFrameSP> |
| ScriptedFrameProvider::GetFrameAtIndex(uint32_t idx) { |
| if (!m_interface_sp) |
| return llvm::createStringError( |
| "cannot get stack frame: scripted frame provider not initialized"); |
| |
| auto create_frame_from_dict = |
| [this](StructuredData::Dictionary *dict, |
| uint32_t index) -> llvm::Expected<StackFrameSP> { |
| lldb::addr_t pc; |
| if (!dict->GetValueForKeyAsInteger("pc", pc)) |
| return llvm::createStringError( |
| "missing 'pc' key from scripted frame dictionary"); |
| |
| Address symbol_addr; |
| symbol_addr.SetLoadAddress(pc, &GetThread().GetProcess()->GetTarget()); |
| |
| const lldb::addr_t cfa = LLDB_INVALID_ADDRESS; |
| const bool cfa_is_valid = false; |
| const bool artificial = false; |
| const bool behaves_like_zeroth_frame = false; |
| SymbolContext sc; |
| symbol_addr.CalculateSymbolContext(&sc); |
| |
| ThreadSP thread_sp = GetThread().shared_from_this(); |
| return std::make_shared<StackFrame>(thread_sp, index, index, cfa, |
| cfa_is_valid, pc, |
| StackFrame::Kind::Synthetic, artificial, |
| behaves_like_zeroth_frame, &sc); |
| }; |
| |
| auto create_frame_from_script_object = |
| [this]( |
| StructuredData::ObjectSP object_sp) -> llvm::Expected<StackFrameSP> { |
| Status error; |
| if (!object_sp || !object_sp->GetAsGeneric()) |
| return llvm::createStringError("invalid script object"); |
| |
| ThreadSP thread_sp = GetThread().shared_from_this(); |
| auto frame_or_error = ScriptedFrame::Create(thread_sp, nullptr, nullptr, |
| object_sp->GetAsGeneric()); |
| |
| if (!frame_or_error) { |
| ScriptedInterface::ErrorWithMessage<bool>( |
| LLVM_PRETTY_FUNCTION, toString(frame_or_error.takeError()), error); |
| return error.ToError(); |
| } |
| |
| return *frame_or_error; |
| }; |
| |
| StructuredData::ObjectSP obj_sp = m_interface_sp->GetFrameAtIndex(idx); |
| |
| // None/null means no more frames or error. |
| if (!obj_sp || !obj_sp->IsValid()) |
| return llvm::createStringError("invalid script object returned for frame " + |
| llvm::Twine(idx)); |
| |
| StackFrameSP synth_frame_sp = nullptr; |
| if (StructuredData::UnsignedInteger *int_obj = |
| obj_sp->GetAsUnsignedInteger()) { |
| uint32_t real_frame_index = int_obj->GetValue(); |
| if (real_frame_index < m_input_frames->GetNumFrames()) { |
| StackFrameSP real_frame_sp = |
| m_input_frames->GetFrameAtIndex(real_frame_index); |
| synth_frame_sp = |
| (real_frame_index == idx) |
| ? real_frame_sp |
| : std::make_shared<BorrowedStackFrame>(real_frame_sp, idx); |
| } |
| } else if (StructuredData::Dictionary *dict = obj_sp->GetAsDictionary()) { |
| // Check if it's a dictionary describing a frame. |
| auto frame_from_dict_or_err = create_frame_from_dict(dict, idx); |
| if (!frame_from_dict_or_err) { |
| return llvm::createStringError(llvm::Twine( |
| "couldn't create frame from dictionary at index " + llvm::Twine(idx) + |
| ": " + toString(frame_from_dict_or_err.takeError()))); |
| } |
| synth_frame_sp = *frame_from_dict_or_err; |
| } else if (obj_sp->GetAsGeneric()) { |
| // It's a ScriptedFrame object. |
| auto frame_from_script_obj_or_err = create_frame_from_script_object(obj_sp); |
| if (!frame_from_script_obj_or_err) { |
| return llvm::createStringError( |
| llvm::Twine("couldn't create frame from script object at index " + |
| llvm::Twine(idx) + ": " + |
| toString(frame_from_script_obj_or_err.takeError()))); |
| } |
| synth_frame_sp = *frame_from_script_obj_or_err; |
| } else { |
| return llvm::createStringError( |
| llvm::Twine("invalid return type from get_frame_at_index at index " + |
| llvm::Twine(idx))); |
| } |
| |
| if (!synth_frame_sp) |
| return llvm::createStringError( |
| llvm::Twine("failed to create frame at index " + llvm::Twine(idx))); |
| |
| synth_frame_sp->SetFrameIndex(idx); |
| |
| return synth_frame_sp; |
| } |
| |
| namespace lldb_private { |
| void lldb_initialize_ScriptedFrameProvider() { |
| ScriptedFrameProvider::Initialize(); |
| } |
| |
| void lldb_terminate_ScriptedFrameProvider() { |
| ScriptedFrameProvider::Terminate(); |
| } |
| } // namespace lldb_private |
