File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/lldb/include/lldb/Target

usr / src / contrib / llvm-project / lldb / include / lldb / Target /

📁 ..
📄 ABI.h(7 KB)
📄 AssertFrameRecognizer.h(1.79 KB)
📄 DynamicLoader.h(12.8 KB)
📄 ExecutionContext.h(23.91 KB)
📄 ExecutionContextScope.h(2.07 KB)
📄 InstrumentationRuntime.h(3.06 KB)
📄 InstrumentationRuntimeStopInfo.h(1.3 KB)
📄 JITLoader.h(2.15 KB)
📄 JITLoaderList.h(1.17 KB)
📄 Language.h(9.42 KB)
📄 LanguageRuntime.h(6.71 KB)
📄 Memory.h(4.66 KB)
📄 MemoryHistory.h(998 B)
📄 MemoryRegionInfo.h(4.76 KB)
📄 ModuleCache.h(2.42 KB)
📄 OperatingSystem.h(2.66 KB)
📄 PathMappingList.h(4.09 KB)
📄 Platform.h(42.4 KB)
📄 Process.h(110.8 KB)
📄 ProcessStructReader.h(3.27 KB)
📄 Queue.h(5.04 KB)
📄 QueueItem.h(5.24 KB)
📄 QueueList.h(3.32 KB)
📄 RegisterCheckpoint.h(1.89 KB)
📄 RegisterContext.h(7.73 KB)
📄 RegisterContextUnwind.h(9.73 KB)
📄 RegisterNumber.h(1.71 KB)
📄 RemoteAwarePlatform.h(3.76 KB)
📄 SectionLoadHistory.h(2.79 KB)
📄 SectionLoadList.h(2.36 KB)
📄 StackFrame.h(20.05 KB)
📄 StackFrameList.h(5.83 KB)
📄 StackFrameRecognizer.h(5.65 KB)
📄 StackID.h(3.16 KB)
📄 StopInfo.h(6.92 KB)
📄 StructuredDataPlugin.h(7.14 KB)
📄 SystemRuntime.h(11.83 KB)
📄 Target.h(49.2 KB)
📄 TargetList.h(7.75 KB)
📄 Thread.h(49.21 KB)
📄 ThreadCollection.h(1.63 KB)
📄 ThreadList.h(4.65 KB)
📄 ThreadPlan.h(24.41 KB)
📄 ThreadPlanBase.h(1.79 KB)
📄 ThreadPlanCallFunction.h(5.55 KB)
📄 ThreadPlanCallFunctionUsingABI.h(1.98 KB)
📄 ThreadPlanCallOnFunctionExit.h(1.56 KB)
📄 ThreadPlanCallUserExpression.h(2.21 KB)
📄 ThreadPlanPython.h(2.11 KB)
📄 ThreadPlanRunToAddress.h(2.04 KB)
📄 ThreadPlanShouldStopHere.h(5.02 KB)
📄 ThreadPlanStack.h(5.48 KB)
📄 ThreadPlanStepInRange.h(4.66 KB)
📄 ThreadPlanStepInstruction.h(1.86 KB)
📄 ThreadPlanStepOut.h(3.67 KB)
📄 ThreadPlanStepOverBreakpoint.h(1.84 KB)
📄 ThreadPlanStepOverRange.h(1.83 KB)
📄 ThreadPlanStepRange.h(3.69 KB)
📄 ThreadPlanStepThrough.h(1.97 KB)
📄 ThreadPlanStepUntil.h(2.12 KB)
📄 ThreadPlanTracer.h(2.32 KB)
📄 ThreadSpec.h(3.35 KB)
📄 UnixSignals.h(4.25 KB)
📄 Unwind.h(2.4 KB)
📄 UnwindAssembly.h(1.81 KB)
📄 UnwindLLDB.h(5.69 KB)

Editing: LanguageRuntime.h

//===-- LanguageRuntime.h ---------------------------------------------------*-
// C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//

#ifndef LLDB_TARGET_LANGUAGERUNTIME_H
#define LLDB_TARGET_LANGUAGERUNTIME_H

#include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Breakpoint/BreakpointResolverName.h"
#include "lldb/Core/PluginInterface.h"
#include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Expression/LLVMUserExpression.h"
#include "lldb/Symbol/DeclVendor.h"
#include "lldb/Target/ExecutionContextScope.h"
#include "lldb/lldb-private.h"
#include "lldb/lldb-public.h"

namespace lldb_private {

class ExceptionSearchFilter : public SearchFilter {
public:
  ExceptionSearchFilter(const lldb::TargetSP &target_sp,
                        lldb::LanguageType language,
                        bool update_module_list = true);

~ExceptionSearchFilter() override = default;

bool ModulePasses(const lldb::ModuleSP &module_sp) override;

bool ModulePasses(const FileSpec &spec) override;

void Search(Searcher &searcher) override;

void GetDescription(Stream *s) override;

static SearchFilter *
  CreateFromStructuredData(Target &target,
                           const StructuredData::Dictionary &data_dict,
                           Status &error);

StructuredData::ObjectSP SerializeToStructuredData() override;

protected:
  lldb::LanguageType m_language;
  LanguageRuntime *m_language_runtime;
  lldb::SearchFilterSP m_filter_sp;

lldb::SearchFilterSP DoCreateCopy() override;

void UpdateModuleListIfNeeded();
};

class LanguageRuntime : public PluginInterface {
public:
  ~LanguageRuntime() override;

static LanguageRuntime *FindPlugin(Process *process,
                                     lldb::LanguageType language);

static void InitializeCommands(CommandObject *parent);

virtual lldb::LanguageType GetLanguageType() const = 0;

virtual bool GetObjectDescription(Stream &str, ValueObject &object) = 0;

virtual bool GetObjectDescription(Stream &str, Value &value,
                                    ExecutionContextScope *exe_scope) = 0;

// this call should return true if it could set the name and/or the type
  virtual bool GetDynamicTypeAndAddress(ValueObject &in_value,
                                        lldb::DynamicValueType use_dynamic,
                                        TypeAndOrName &class_type_or_name,
                                        Address &address,
                                        Value::ValueType &value_type) = 0;

// This call should return a CompilerType given a generic type name and an
  // ExecutionContextScope in which one can actually fetch any specialization
  // information required.
  virtual CompilerType GetConcreteType(ExecutionContextScope *exe_scope,
                                       ConstString abstract_type_name) {
    return CompilerType();
  }

// This should be a fast test to determine whether it is likely that this
  // value would have a dynamic type.
  virtual bool CouldHaveDynamicValue(ValueObject &in_value) = 0;

// The contract for GetDynamicTypeAndAddress() is to return a "bare-bones"
  // dynamic type For instance, given a Base* pointer,
  // GetDynamicTypeAndAddress() will return the type of Derived, not Derived*.
  // The job of this API is to correct this misalignment between the static
  // type and the discovered dynamic type
  virtual TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name,
                                         ValueObject &static_value) = 0;

virtual void SetExceptionBreakpoints() {}

virtual void ClearExceptionBreakpoints() {}

virtual bool ExceptionBreakpointsAreSet() { return false; }

virtual bool ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason) {
    return false;
  }

static lldb::BreakpointSP
  CreateExceptionBreakpoint(Target &target, lldb::LanguageType language,
                            bool catch_bp, bool throw_bp,
                            bool is_internal = false);

static lldb::BreakpointPreconditionSP
  GetExceptionPrecondition(lldb::LanguageType language, bool throw_bp);

virtual lldb::ValueObjectSP GetExceptionObjectForThread(
      lldb::ThreadSP thread_sp) {
    return lldb::ValueObjectSP();
  }

virtual lldb::ThreadSP GetBacktraceThreadFromException(
      lldb::ValueObjectSP thread_sp) {
    return lldb::ThreadSP();
  }

Process *GetProcess() { return m_process; }

Target &GetTargetRef() { return m_process->GetTarget(); }

virtual DeclVendor *GetDeclVendor() { return nullptr; }

virtual lldb::BreakpointResolverSP
  CreateExceptionResolver(const lldb::BreakpointSP &bkpt,
                          bool catch_bp, bool throw_bp) = 0;

virtual lldb::SearchFilterSP CreateExceptionSearchFilter() {
    return m_process->GetTarget().GetSearchFilterForModule(nullptr);
  }

virtual bool GetTypeBitSize(const CompilerType &compiler_type,
                              uint64_t &size) {
    return false;
  }

virtual void SymbolsDidLoad(const ModuleList &module_list) { return; }

virtual lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
                                                          bool stop_others) = 0;

/// Identify whether a name is a runtime value that should not be hidden by
  /// from the user interface.
  virtual bool IsAllowedRuntimeValue(ConstString name) { return false; }

virtual llvm::Optional<CompilerType> GetRuntimeType(CompilerType base_type) {
    return llvm::None;
  }

virtual void ModulesDidLoad(const ModuleList &module_list) {}

// Called by ClangExpressionParser::PrepareForExecution to query for any
  // custom LLVM IR passes that need to be run before an expression is
  // assembled and run.
  virtual bool GetIRPasses(LLVMUserExpression::IRPasses &custom_passes) {
    return false;
  }

// Given the name of a runtime symbol (e.g. in Objective-C, an ivar offset
  // symbol), try to determine from the runtime what the value of that symbol
  // would be. Useful when the underlying binary is stripped.
  virtual lldb::addr_t LookupRuntimeSymbol(ConstString name) {
    return LLDB_INVALID_ADDRESS;
  }

virtual bool isA(const void *ClassID) const { return ClassID == &ID; }
  static char ID;

protected:
  // Classes that inherit from LanguageRuntime can see and modify these

LanguageRuntime(Process *process);
  Process *m_process;

private:
  LanguageRuntime(const LanguageRuntime &) = delete;
  const LanguageRuntime &operator=(const LanguageRuntime &) = delete;
};

} // namespace lldb_private

#endif // LLDB_TARGET_LANGUAGERUNTIME_H

003 File Manager

Editing: LanguageRuntime.h

Upload File

Create Folder