cpp_reference/lldb-forward_8h_source.html

//===-- lldb-forward.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_LLDB_FORWARD_H

#define LLDB_LLDB_FORWARD_H


#include <memory>


// lldb forward declarations

namespace lldb_private {


class ABI;

class ASTResultSynthesizer;

class ASTStructExtractor;

class Address;

class AddressRange;

class AddressRanges;

class AddressRangeList;

class AddressResolver;

class ArchSpec;

class Architecture;

class Args;

class ArmUnwindInfo;

class Baton;

class Block;

class Breakpoint;

class BreakpointID;

class BreakpointIDList;

class BreakpointList;

class BreakpointLocation;

class BreakpointLocationCollection;

class BreakpointLocationList;

class BreakpointName;

class BreakpointOptionGroup;

class BreakpointOptions;

class BreakpointPrecondition;

class BreakpointResolver;

class BreakpointSite;

class BroadcastEventSpec;

class Broadcaster;

class BroadcasterManager;

class CXXSyntheticChildren;

struct CacheSignature;

class CallFrameInfo;

class CommandInterpreter;

class CommandInterpreterRunOptions;

class CommandObject;

class CommandObjectMultiword;

class CommandReturnObject;

class Communication;

class CompactUnwindInfo;

class CompileUnit;

class CompilerDecl;

class CompilerDeclContext;

class CompilerType;

class Connection;

class ConnectionFileDescriptor;

class ConstString;

class ConstStringTable;

class DWARFCallFrameInfo;

class DWARFDataExtractor;

class DWARFExpression;

class DWARFExpressionList;

class DataBuffer;

class WritableDataBuffer;

class DataBufferHeap;

class DataEncoder;

class DataExtractor;

class DataFileCache;

class Debugger;

class Declaration;

class DiagnosticManager;

class Disassembler;

class DumpValueObjectOptions;

class DynamicCheckerFunctions;

class DynamicLoader;

class Editline;

class EmulateInstruction;

class Environment;

class EvaluateExpressionOptions;

class Event;

class EventData;

class EventDataStructuredData;

class ExecutionContext;

class ExecutionContextRef;

class ExecutionContextScope;

class Expression;

class ExpressionTypeSystemHelper;

class ExpressionVariable;

class ExpressionVariableList;

class File;

class FileSpec;

class FileSpecList;

class Flags;

namespace FormatEntity {

struct Entry;

} // namespace FormatEntity

class FormatManager;

class FormattersMatchCandidate;

class FuncUnwinders;

class Function;

class FunctionCaller;

class FunctionInfo;

class IOHandler;

class IOObject;

class IRExecutionUnit;

class InlineFunctionInfo;

class Instruction;

class InstructionList;

class InstrumentationRuntime;

class JITLoader;

class JITLoaderList;

class Language;

class LanguageCategory;

class LanguageRuntime;

class LineTable;

class Listener;

class Log;

class Mangled;

class Materializer;

class MemoryHistory;

class MemoryRegionInfo;

class MemoryRegionInfos;

class Module;

class ModuleList;

class ModuleSpec;

class ModuleSpecList;

class ObjectContainer;

class ObjectFile;

class ObjectFileJITDelegate;

class OperatingSystem;

class OperatingSystemInterface;

class OptionGroup;

class OptionGroupOptions;

class OptionGroupPlatform;

class OptionValue;

class OptionValueArch;

class OptionValueArgs;

class OptionValueArray;

class OptionValueBoolean;

class OptionValueChar;

class OptionValueDictionary;

class OptionValueEnumeration;

class OptionValueFileSpec;

class OptionValueFileSpecList;

class OptionValueFormat;

class OptionValueFormatEntity;

class OptionValueLanguage;

class OptionValuePathMappings;

class OptionValueProperties;

class OptionValueRegex;

class OptionValueSInt64;

class OptionValueString;

class OptionValueUInt64;

class OptionValueUUID;

class Options;

class PathMappingList;

class PersistentExpressionState;

class Platform;

class Process;

class ProcessAttachInfo;

class ProcessLaunchInfo;

class ProcessInfo;

class ProcessInstanceInfo;

class ProcessInstanceInfoMatch;

class ProcessLaunchInfo;

class ProcessModID;

class Property;

class Queue;

class QueueImpl;

class QueueItem;

class REPL;

class RecognizedStackFrame;

class RegisterCheckpoint;

class RegisterContext;

class RegisterTypeBuilder;

class RegisterValue;

class RegularExpression;

class RichManglingContext;

class SaveCoreOptions;

class Scalar;

class ScriptInterpreter;

class ScriptInterpreterLocker;

class ScriptedMetadata;

class ScriptedPlatformInterface;

class ScriptedProcessInterface;

class ScriptedThreadInterface;

class ScriptedThreadPlanInterface;

class ScriptedSyntheticChildren;

class SearchFilter;

class Section;

class SectionList;

class SectionLoadHistory;

class SectionLoadList;

class Settings;

class SourceManager;

class SourceManagerImpl;

class StackFrame;

class StackFrameList;

class StackFrameRecognizer;

class StackFrameRecognizerManager;

class StackID;

class Status;

class StopInfo;

class Stoppoint;

class StoppointCallbackContext;

class Stream;

class StreamFile;

class StreamString;

class StringList;

class StringTableReader;

class StructuredDataImpl;

class StructuredDataPlugin;

class SupportFile;

class Symbol;

class SymbolContext;

class SymbolContextList;

class SymbolContextScope;

class SymbolContextSpecifier;

class SymbolFile;

class SymbolFileType;

class SymbolLocator;

class SymbolVendor;

class Symtab;

class SyntheticChildren;

class SyntheticChildrenFrontEnd;

class SystemRuntime;

class Target;

class TargetList;

class TargetProperties;

class Thread;

class ThreadCollection;

class ThreadList;

class ThreadPlan;

class ThreadPlanBase;

class ThreadPlanRunToAddress;

class ThreadPlanStepInstruction;

class ThreadPlanStepOut;

class ThreadPlanStepOverBreakpoint;

class ThreadPlanStepRange;

class ThreadPlanStepThrough;

class ThreadPlanTracer;

class ThreadSpec;

class ThreadPostMortemTrace;

class ThreadedCommunication;

class Trace;

class TraceCursor;

class TraceExporter;

class Type;

class TypeAndOrName;

class TypeCategoryImpl;

class TypeCategoryMap;

class TypeEnumMemberImpl;

class TypeEnumMemberListImpl;

class TypeFilterImpl;

class TypeFormatImpl;

class TypeImpl;

class TypeList;

class TypeListImpl;

class TypeMap;

class TypeQuery;

class TypeMemberFunctionImpl;

class TypeMemberImpl;

class TypeNameSpecifierImpl;

class TypeResults;

class TypeSummaryImpl;

class TypeSummaryOptions;

class TypeSystem;

class TypeSystemClang;

class UUID;

class UnixSignals;

class Unwind;

class UnwindAssembly;

class UnwindPlan;

class UnwindTable;

class UserExpression;

class UtilityFunction;

class VMRange;

class Value;

class ValueList;

class ValueObject;

class ValueObjectChild;

class ValueObjectConstResult;

class ValueObjectConstResultChild;

class ValueObjectConstResultImpl;

class ValueObjectList;

class ValueObjectPrinter;

class Variable;

class VariableList;

class Watchpoint;

class WatchpointList;

class WatchpointOptions;

class WatchpointResource;

class WatchpointResourceCollection;

class WatchpointSetOptions;

struct CompilerContext;

struct LineEntry;

struct PropertyDefinition;

struct ScriptSummaryFormat;

struct StatisticsOptions;

struct StringSummaryFormat;

template <unsigned N> class StreamBuffer;


} // namespace lldb_private


// lldb forward declarations

namespace lldb {


typedef std::shared_ptr<lldb_private::ABI> ABISP;

typedef std::unique_ptr<lldb_private::AddressRange> AddressRangeUP;

typedef std::shared_ptr<lldb_private::Baton> BatonSP;

typedef std::shared_ptr<lldb_private::Block> BlockSP;

typedef std::shared_ptr<lldb_private::Breakpoint> BreakpointSP;

typedef std::weak_ptr<lldb_private::Breakpoint> BreakpointWP;

typedef std::shared_ptr<lldb_private::BreakpointSite> BreakpointSiteSP;

typedef std::shared_ptr<lldb_private::BreakpointLocation> BreakpointLocationSP;

typedef std::weak_ptr<lldb_private::BreakpointLocation> BreakpointLocationWP;

typedef std::shared_ptr<lldb_private::BreakpointPrecondition>

    BreakpointPreconditionSP;

typedef std::shared_ptr<lldb_private::BreakpointResolver> BreakpointResolverSP;

typedef std::shared_ptr<lldb_private::Broadcaster> BroadcasterSP;

typedef std::shared_ptr<lldb_private::BroadcasterManager> BroadcasterManagerSP;

typedef std::weak_ptr<lldb_private::BroadcasterManager> BroadcasterManagerWP;

typedef std::shared_ptr<lldb_private::UserExpression> UserExpressionSP;

typedef std::shared_ptr<lldb_private::CommandObject> CommandObjectSP;

typedef std::shared_ptr<lldb_private::Connection> ConnectionSP;

typedef std::shared_ptr<lldb_private::CompileUnit> CompUnitSP;

typedef std::shared_ptr<lldb_private::DataBuffer> DataBufferSP;

typedef std::shared_ptr<lldb_private::WritableDataBuffer> WritableDataBufferSP;

typedef std::shared_ptr<lldb_private::DataExtractor> DataExtractorSP;

typedef std::shared_ptr<lldb_private::Debugger> DebuggerSP;

typedef std::weak_ptr<lldb_private::Debugger> DebuggerWP;

typedef std::shared_ptr<lldb_private::Disassembler> DisassemblerSP;

typedef std::unique_ptr<lldb_private::DynamicCheckerFunctions>

    DynamicCheckerFunctionsUP;

typedef std::unique_ptr<lldb_private::DynamicLoader> DynamicLoaderUP;

typedef std::shared_ptr<lldb_private::Event> EventSP;

typedef std::shared_ptr<lldb_private::EventData> EventDataSP;

typedef std::shared_ptr<lldb_private::EventDataStructuredData>

    EventDataStructuredDataSP;

typedef std::shared_ptr<lldb_private::ExecutionContextRef>

    ExecutionContextRefSP;

typedef std::shared_ptr<lldb_private::ExpressionVariable> ExpressionVariableSP;

typedef std::unique_ptr<lldb_private::File> FileUP;

typedef std::shared_ptr<lldb_private::File> FileSP;

typedef std::shared_ptr<lldb_private::FormatEntity::Entry> FormatEntrySP;

typedef std::shared_ptr<lldb_private::Function> FunctionSP;

typedef std::shared_ptr<lldb_private::FuncUnwinders> FuncUnwindersSP;

typedef std::shared_ptr<lldb_private::InlineFunctionInfo> InlineFunctionInfoSP;

typedef std::shared_ptr<lldb_private::Instruction> InstructionSP;

typedef std::shared_ptr<lldb_private::InstrumentationRuntime>

    InstrumentationRuntimeSP;

typedef std::shared_ptr<lldb_private::IOHandler> IOHandlerSP;

typedef std::shared_ptr<lldb_private::IOObject> IOObjectSP;

typedef std::shared_ptr<lldb_private::IRExecutionUnit> IRExecutionUnitSP;

typedef std::shared_ptr<lldb_private::JITLoader> JITLoaderSP;

typedef std::unique_ptr<lldb_private::JITLoaderList> JITLoaderListUP;

typedef std::shared_ptr<lldb_private::LanguageRuntime> LanguageRuntimeSP;

typedef std::unique_ptr<lldb_private::SystemRuntime> SystemRuntimeUP;

typedef std::shared_ptr<lldb_private::Listener> ListenerSP;

typedef std::weak_ptr<lldb_private::Listener> ListenerWP;

typedef std::shared_ptr<lldb_private::MemoryHistory> MemoryHistorySP;

typedef std::unique_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoUP;

typedef std::shared_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoSP;

typedef std::shared_ptr<lldb_private::Module> ModuleSP;

typedef std::weak_ptr<lldb_private::Module> ModuleWP;

typedef std::shared_ptr<lldb_private::ObjectFile> ObjectFileSP;

typedef std::shared_ptr<lldb_private::ObjectContainer> ObjectContainerSP;

typedef std::shared_ptr<lldb_private::ObjectFileJITDelegate>

    ObjectFileJITDelegateSP;

typedef std::weak_ptr<lldb_private::ObjectFileJITDelegate>

    ObjectFileJITDelegateWP;

typedef std::unique_ptr<lldb_private::OperatingSystem> OperatingSystemUP;

typedef std::shared_ptr<lldb_private::OperatingSystemInterface>

    OperatingSystemInterfaceSP;

typedef std::shared_ptr<lldb_private::OptionValue> OptionValueSP;

typedef std::weak_ptr<lldb_private::OptionValue> OptionValueWP;

typedef std::shared_ptr<lldb_private::OptionValueProperties>

    OptionValuePropertiesSP;

typedef std::shared_ptr<lldb_private::Platform> PlatformSP;

typedef std::shared_ptr<lldb_private::Process> ProcessSP;

typedef std::shared_ptr<lldb_private::ProcessAttachInfo> ProcessAttachInfoSP;

typedef std::shared_ptr<lldb_private::ProcessLaunchInfo> ProcessLaunchInfoSP;

typedef std::weak_ptr<lldb_private::Process> ProcessWP;

typedef std::shared_ptr<lldb_private::RegisterCheckpoint> RegisterCheckpointSP;

typedef std::shared_ptr<lldb_private::RegisterContext> RegisterContextSP;

typedef std::shared_ptr<lldb_private::RegisterTypeBuilder>

    RegisterTypeBuilderSP;

typedef std::shared_ptr<lldb_private::RegularExpression> RegularExpressionSP;

typedef std::shared_ptr<lldb_private::Queue> QueueSP;

typedef std::weak_ptr<lldb_private::Queue> QueueWP;

typedef std::shared_ptr<lldb_private::QueueItem> QueueItemSP;

typedef std::shared_ptr<lldb_private::REPL> REPLSP;

typedef std::shared_ptr<lldb_private::RecognizedStackFrame>

    RecognizedStackFrameSP;

typedef std::shared_ptr<lldb_private::ScriptSummaryFormat>

    ScriptSummaryFormatSP;

typedef std::shared_ptr<lldb_private::ScriptInterpreter> ScriptInterpreterSP;

typedef std::shared_ptr<lldb_private::ScriptedMetadata> ScriptedMetadataSP;

typedef std::unique_ptr<lldb_private::ScriptedPlatformInterface>

    ScriptedPlatformInterfaceUP;

typedef std::unique_ptr<lldb_private::ScriptedProcessInterface>

    ScriptedProcessInterfaceUP;

typedef std::shared_ptr<lldb_private::ScriptedThreadInterface>

    ScriptedThreadInterfaceSP;

typedef std::shared_ptr<lldb_private::ScriptedThreadPlanInterface>

    ScriptedThreadPlanInterfaceSP;

typedef std::shared_ptr<lldb_private::Section> SectionSP;

typedef std::unique_ptr<lldb_private::SectionList> SectionListUP;

typedef std::weak_ptr<lldb_private::Section> SectionWP;

typedef std::shared_ptr<lldb_private::SectionLoadList> SectionLoadListSP;

typedef std::shared_ptr<lldb_private::SearchFilter> SearchFilterSP;

typedef std::unique_ptr<lldb_private::SourceManager> SourceManagerUP;

typedef std::shared_ptr<lldb_private::StackFrame> StackFrameSP;

typedef std::weak_ptr<lldb_private::StackFrame> StackFrameWP;

typedef std::shared_ptr<lldb_private::StackFrameList> StackFrameListSP;

typedef std::shared_ptr<lldb_private::StackFrameRecognizer>

    StackFrameRecognizerSP;

typedef std::unique_ptr<lldb_private::StackFrameRecognizerManager>

    StackFrameRecognizerManagerUP;

typedef std::shared_ptr<lldb_private::StopInfo> StopInfoSP;

typedef std::shared_ptr<lldb_private::Stream> StreamSP;

typedef std::shared_ptr<lldb_private::StreamFile> StreamFileSP;

typedef std::shared_ptr<lldb_private::StringSummaryFormat>

    StringTypeSummaryImplSP;

typedef std::unique_ptr<lldb_private::StructuredDataImpl> StructuredDataImplUP;

typedef std::shared_ptr<lldb_private::StructuredDataPlugin>

    StructuredDataPluginSP;

typedef std::weak_ptr<lldb_private::StructuredDataPlugin>

    StructuredDataPluginWP;

typedef std::shared_ptr<lldb_private::SymbolFileType> SymbolFileTypeSP;

typedef std::shared_ptr<lldb_private::SymbolContextSpecifier>

    SymbolContextSpecifierSP;

typedef std::unique_ptr<lldb_private::SymbolVendor> SymbolVendorUP;

typedef std::shared_ptr<lldb_private::SyntheticChildren> SyntheticChildrenSP;

typedef std::shared_ptr<lldb_private::SyntheticChildrenFrontEnd>

    SyntheticChildrenFrontEndSP;

typedef std::shared_ptr<lldb_private::Target> TargetSP;

typedef std::weak_ptr<lldb_private::Target> TargetWP;

typedef std::shared_ptr<lldb_private::Thread> ThreadSP;

typedef std::weak_ptr<lldb_private::Thread> ThreadWP;

typedef std::shared_ptr<lldb_private::ThreadCollection> ThreadCollectionSP;

typedef std::shared_ptr<lldb_private::ThreadPlan> ThreadPlanSP;

typedef std::shared_ptr<lldb_private::ThreadPostMortemTrace>

    ThreadPostMortemTraceSP;

typedef std::weak_ptr<lldb_private::ThreadPlan> ThreadPlanWP;

typedef std::shared_ptr<lldb_private::ThreadPlanTracer> ThreadPlanTracerSP;

typedef std::shared_ptr<lldb_private::Trace> TraceSP;

typedef std::unique_ptr<lldb_private::TraceExporter> TraceExporterUP;

typedef std::shared_ptr<lldb_private::TraceCursor> TraceCursorSP;

typedef std::shared_ptr<lldb_private::Type> TypeSP;

typedef std::weak_ptr<lldb_private::Type> TypeWP;

typedef std::shared_ptr<lldb_private::TypeCategoryImpl> TypeCategoryImplSP;

typedef std::shared_ptr<lldb_private::TypeImpl> TypeImplSP;

typedef std::shared_ptr<lldb_private::TypeMemberFunctionImpl>

    TypeMemberFunctionImplSP;

typedef std::shared_ptr<lldb_private::TypeEnumMemberImpl> TypeEnumMemberImplSP;

typedef std::shared_ptr<lldb_private::TypeFilterImpl> TypeFilterImplSP;

typedef std::shared_ptr<lldb_private::TypeSystem> TypeSystemSP;

typedef std::shared_ptr<lldb_private::TypeSystemClang> TypeSystemClangSP;

typedef std::weak_ptr<lldb_private::TypeSystem> TypeSystemWP;

typedef std::shared_ptr<lldb_private::TypeFormatImpl> TypeFormatImplSP;

typedef std::shared_ptr<lldb_private::TypeNameSpecifierImpl>

    TypeNameSpecifierImplSP;

typedef std::shared_ptr<lldb_private::TypeSummaryImpl> TypeSummaryImplSP;

typedef std::shared_ptr<lldb_private::TypeSummaryOptions> TypeSummaryOptionsSP;

typedef std::shared_ptr<lldb_private::ScriptedSyntheticChildren>

    ScriptedSyntheticChildrenSP;

typedef std::shared_ptr<lldb_private::SupportFile> SupportFileSP;

typedef std::shared_ptr<lldb_private::UnixSignals> UnixSignalsSP;

typedef std::weak_ptr<lldb_private::UnixSignals> UnixSignalsWP;

typedef std::shared_ptr<lldb_private::UnwindAssembly> UnwindAssemblySP;

typedef std::shared_ptr<lldb_private::UnwindPlan> UnwindPlanSP;

typedef std::shared_ptr<lldb_private::ValueObject> ValueObjectSP;

typedef std::shared_ptr<lldb_private::Value> ValueSP;

typedef std::shared_ptr<lldb_private::Variable> VariableSP;

typedef std::shared_ptr<lldb_private::VariableList> VariableListSP;

typedef std::shared_ptr<lldb_private::ValueObjectList> ValueObjectListSP;

typedef std::shared_ptr<lldb_private::Watchpoint> WatchpointSP;

typedef std::shared_ptr<lldb_private::WatchpointResource> WatchpointResourceSP;


} // namespace lldb


#endif // LLDB_LLDB_FORWARD_H

lldb_private::npdb::PdbSymUidKind::Type
@ Type

lldb_private
A class that represents a running process on the host machine.
Definition: SBAddressRange.h:14

lldb_private::CompilerContextKind::Variable
@ Variable

lldb_private::CompilerContextKind::Function
@ Function

lldb_private::CompilerContextKind::Module
@ Module

lldb_private::LineStatus::Status
@ Status

lldb_private::NameMatch::RegularExpression
@ RegularExpression

lldb_private::LLDBLog::Communication
@ Communication

lldb_private::LLDBLog::Platform
@ Platform

lldb_private::LLDBLog::Language
@ Language

lldb_private::LLDBLog::Unwind
@ Unwind

lldb_private::LLDBLog::JITLoader
@ JITLoader

lldb_private::LLDBLog::Process
@ Process

lldb_private::LLDBLog::SystemRuntime
@ SystemRuntime

lldb_private::LLDBLog::DynamicLoader
@ DynamicLoader

lldb_private::LLDBLog::Connection
@ Connection

lldb_private::LLDBLog::Target
@ Target

lldb_private::LLDBLog::Thread
@ Thread

lldb_private::WindowsLog::Event
@ Event

lldb_private::POSIXLog::Trace
@ Trace

lldb
Definition: SBAddress.h:15

lldb::FunctionSP
std::shared_ptr< lldb_private::Function > FunctionSP
Definition: lldb-forward.h:352

lldb::IOObjectSP
std::shared_ptr< lldb_private::IOObject > IOObjectSP
Definition: lldb-forward.h:359

lldb::InlineFunctionInfoSP
std::shared_ptr< lldb_private::InlineFunctionInfo > InlineFunctionInfoSP
Definition: lldb-forward.h:354

lldb::BreakpointWP
std::weak_ptr< lldb_private::Breakpoint > BreakpointWP
Definition: lldb-forward.h:319

lldb::EventDataStructuredDataSP
std::shared_ptr< lldb_private::EventDataStructuredData > EventDataStructuredDataSP
Definition: lldb-forward.h:345

lldb::MemoryRegionInfoUP
std::unique_ptr< lldb_private::MemoryRegionInfo > MemoryRegionInfoUP
Definition: lldb-forward.h:368

lldb::ScriptedPlatformInterfaceUP
std::unique_ptr< lldb_private::ScriptedPlatformInterface > ScriptedPlatformInterfaceUP
Definition: lldb-forward.h:406

lldb::ScriptSummaryFormatSP
std::shared_ptr< lldb_private::ScriptSummaryFormat > ScriptSummaryFormatSP
Definition: lldb-forward.h:402

lldb::StackFrameWP
std::weak_ptr< lldb_private::StackFrame > StackFrameWP
Definition: lldb-forward.h:420

lldb::OptionValuePropertiesSP
std::shared_ptr< lldb_private::OptionValueProperties > OptionValuePropertiesSP
Definition: lldb-forward.h:384

lldb::TraceSP
std::shared_ptr< lldb_private::Trace > TraceSP
Definition: lldb-forward.h:453

lldb::BroadcasterSP
std::shared_ptr< lldb_private::Broadcaster > BroadcasterSP
Definition: lldb-forward.h:326

lldb::TypeSystemSP
std::shared_ptr< lldb_private::TypeSystem > TypeSystemSP
Definition: lldb-forward.h:464

lldb::BreakpointLocationWP
std::weak_ptr< lldb_private::BreakpointLocation > BreakpointLocationWP
Definition: lldb-forward.h:322

lldb::ThreadPlanSP
std::shared_ptr< lldb_private::ThreadPlan > ThreadPlanSP
Definition: lldb-forward.h:448

lldb::QueueSP
std::shared_ptr< lldb_private::Queue > QueueSP
Definition: lldb-forward.h:395

lldb::ABISP
std::shared_ptr< lldb_private::ABI > ABISP
Definition: lldb-forward.h:314

lldb::IRExecutionUnitSP
std::shared_ptr< lldb_private::IRExecutionUnit > IRExecutionUnitSP
Definition: lldb-forward.h:360

lldb::StackFrameSP
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
Definition: lldb-forward.h:419

lldb::SystemRuntimeUP
std::unique_ptr< lldb_private::SystemRuntime > SystemRuntimeUP
Definition: lldb-forward.h:364

lldb::BroadcasterManagerSP
std::shared_ptr< lldb_private::BroadcasterManager > BroadcasterManagerSP
Definition: lldb-forward.h:327

lldb::ThreadPostMortemTraceSP
std::shared_ptr< lldb_private::ThreadPostMortemTrace > ThreadPostMortemTraceSP
Definition: lldb-forward.h:450

lldb::ConnectionSP
std::shared_ptr< lldb_private::Connection > ConnectionSP
Definition: lldb-forward.h:331

lldb::RecognizedStackFrameSP
std::shared_ptr< lldb_private::RecognizedStackFrame > RecognizedStackFrameSP
Definition: lldb-forward.h:400

lldb::BreakpointSiteSP
std::shared_ptr< lldb_private::BreakpointSite > BreakpointSiteSP
Definition: lldb-forward.h:320

lldb::SearchFilterSP
std::shared_ptr< lldb_private::SearchFilter > SearchFilterSP
Definition: lldb-forward.h:417

lldb::BreakpointResolverSP
std::shared_ptr< lldb_private::BreakpointResolver > BreakpointResolverSP
Definition: lldb-forward.h:325

lldb::TypeSummaryImplSP
std::shared_ptr< lldb_private::TypeSummaryImpl > TypeSummaryImplSP
Definition: lldb-forward.h:470

lldb::BreakpointLocationSP
std::shared_ptr< lldb_private::BreakpointLocation > BreakpointLocationSP
Definition: lldb-forward.h:321

lldb::BlockSP
std::shared_ptr< lldb_private::Block > BlockSP
Definition: lldb-forward.h:317

lldb::StackFrameRecognizerManagerUP
std::unique_ptr< lldb_private::StackFrameRecognizerManager > StackFrameRecognizerManagerUP
Definition: lldb-forward.h:425

lldb::ModuleWP
std::weak_ptr< lldb_private::Module > ModuleWP
Definition: lldb-forward.h:371

lldb::ObjectContainerSP
std::shared_ptr< lldb_private::ObjectContainer > ObjectContainerSP
Definition: lldb-forward.h:373

lldb::IOHandlerSP
std::shared_ptr< lldb_private::IOHandler > IOHandlerSP
Definition: lldb-forward.h:358

lldb::OperatingSystemUP
std::unique_ptr< lldb_private::OperatingSystem > OperatingSystemUP
Definition: lldb-forward.h:378

lldb::ThreadPlanWP
std::weak_ptr< lldb_private::ThreadPlan > ThreadPlanWP
Definition: lldb-forward.h:451

lldb::AddressRangeUP
std::unique_ptr< lldb_private::AddressRange > AddressRangeUP
Definition: lldb-forward.h:315

lldb::ScriptInterpreterSP
std::shared_ptr< lldb_private::ScriptInterpreter > ScriptInterpreterSP
Definition: lldb-forward.h:403

lldb::ThreadSP
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:445

lldb::ScriptedMetadataSP
std::shared_ptr< lldb_private::ScriptedMetadata > ScriptedMetadataSP
Definition: lldb-forward.h:404

lldb::ScriptedThreadPlanInterfaceSP
std::shared_ptr< lldb_private::ScriptedThreadPlanInterface > ScriptedThreadPlanInterfaceSP
Definition: lldb-forward.h:412

lldb::CommandObjectSP
std::shared_ptr< lldb_private::CommandObject > CommandObjectSP
Definition: lldb-forward.h:330

lldb::TypeFormatImplSP
std::shared_ptr< lldb_private::TypeFormatImpl > TypeFormatImplSP
Definition: lldb-forward.h:467

lldb::ValueObjectSP
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:479

lldb::FileUP
std::unique_ptr< lldb_private::File > FileUP
Definition: lldb-forward.h:349

lldb::TypeNameSpecifierImplSP
std::shared_ptr< lldb_private::TypeNameSpecifierImpl > TypeNameSpecifierImplSP
Definition: lldb-forward.h:469

lldb::SupportFileSP
std::shared_ptr< lldb_private::SupportFile > SupportFileSP
Definition: lldb-forward.h:474

lldb::ExpressionVariableSP
std::shared_ptr< lldb_private::ExpressionVariable > ExpressionVariableSP
Definition: lldb-forward.h:348

lldb::UnixSignalsSP
std::shared_ptr< lldb_private::UnixSignals > UnixSignalsSP
Definition: lldb-forward.h:475

lldb::TypeEnumMemberImplSP
std::shared_ptr< lldb_private::TypeEnumMemberImpl > TypeEnumMemberImplSP
Definition: lldb-forward.h:462

lldb::PlatformSP
std::shared_ptr< lldb_private::Platform > PlatformSP
Definition: lldb-forward.h:385

lldb::ListenerWP
std::weak_ptr< lldb_private::Listener > ListenerWP
Definition: lldb-forward.h:366

lldb::ProcessAttachInfoSP
std::shared_ptr< lldb_private::ProcessAttachInfo > ProcessAttachInfoSP
Definition: lldb-forward.h:387

lldb::DynamicCheckerFunctionsUP
std::unique_ptr< lldb_private::DynamicCheckerFunctions > DynamicCheckerFunctionsUP
Definition: lldb-forward.h:340

lldb::StructuredDataPluginWP
std::weak_ptr< lldb_private::StructuredDataPlugin > StructuredDataPluginWP
Definition: lldb-forward.h:435

lldb::RegularExpressionSP
std::shared_ptr< lldb_private::RegularExpression > RegularExpressionSP
Definition: lldb-forward.h:394

lldb::TypeSummaryOptionsSP
std::shared_ptr< lldb_private::TypeSummaryOptions > TypeSummaryOptionsSP
Definition: lldb-forward.h:471

lldb::OperatingSystemInterfaceSP
std::shared_ptr< lldb_private::OperatingSystemInterface > OperatingSystemInterfaceSP
Definition: lldb-forward.h:380

lldb::FormatEntrySP
std::shared_ptr< lldb_private::FormatEntity::Entry > FormatEntrySP
Definition: lldb-forward.h:351

lldb::TypeMemberFunctionImplSP
std::shared_ptr< lldb_private::TypeMemberFunctionImpl > TypeMemberFunctionImplSP
Definition: lldb-forward.h:461

lldb::ObjectFileSP
std::shared_ptr< lldb_private::ObjectFile > ObjectFileSP
Definition: lldb-forward.h:372

lldb::RegisterTypeBuilderSP
std::shared_ptr< lldb_private::RegisterTypeBuilder > RegisterTypeBuilderSP
Definition: lldb-forward.h:393

lldb::MemoryHistorySP
std::shared_ptr< lldb_private::MemoryHistory > MemoryHistorySP
Definition: lldb-forward.h:367

lldb::StreamSP
std::shared_ptr< lldb_private::Stream > StreamSP
Definition: lldb-forward.h:427

lldb::SectionLoadListSP
std::shared_ptr< lldb_private::SectionLoadList > SectionLoadListSP
Definition: lldb-forward.h:416

lldb::BreakpointSP
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
Definition: lldb-forward.h:318

lldb::UserExpressionSP
std::shared_ptr< lldb_private::UserExpression > UserExpressionSP
Definition: lldb-forward.h:329

lldb::MemoryRegionInfoSP
std::shared_ptr< lldb_private::MemoryRegionInfo > MemoryRegionInfoSP
Definition: lldb-forward.h:369

lldb::InstructionSP
std::shared_ptr< lldb_private::Instruction > InstructionSP
Definition: lldb-forward.h:355

lldb::FuncUnwindersSP
std::shared_ptr< lldb_private::FuncUnwinders > FuncUnwindersSP
Definition: lldb-forward.h:353

lldb::TypeSP
std::shared_ptr< lldb_private::Type > TypeSP
Definition: lldb-forward.h:456

lldb::StructuredDataPluginSP
std::shared_ptr< lldb_private::StructuredDataPlugin > StructuredDataPluginSP
Definition: lldb-forward.h:433

lldb::DebuggerWP
std::weak_ptr< lldb_private::Debugger > DebuggerWP
Definition: lldb-forward.h:337

lldb::SourceManagerUP
std::unique_ptr< lldb_private::SourceManager > SourceManagerUP
Definition: lldb-forward.h:418

lldb::ProcessSP
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:386

lldb::BatonSP
std::shared_ptr< lldb_private::Baton > BatonSP
Definition: lldb-forward.h:316

lldb::BreakpointPreconditionSP
std::shared_ptr< lldb_private::BreakpointPrecondition > BreakpointPreconditionSP
Definition: lldb-forward.h:324

lldb::ScriptedThreadInterfaceSP
std::shared_ptr< lldb_private::ScriptedThreadInterface > ScriptedThreadInterfaceSP
Definition: lldb-forward.h:410

lldb::ValueObjectListSP
std::shared_ptr< lldb_private::ValueObjectList > ValueObjectListSP
Definition: lldb-forward.h:483

lldb::UnixSignalsWP
std::weak_ptr< lldb_private::UnixSignals > UnixSignalsWP
Definition: lldb-forward.h:476

lldb::DebuggerSP
std::shared_ptr< lldb_private::Debugger > DebuggerSP
Definition: lldb-forward.h:336

lldb::SymbolVendorUP
std::unique_ptr< lldb_private::SymbolVendor > SymbolVendorUP
Definition: lldb-forward.h:439

lldb::DisassemblerSP
std::shared_ptr< lldb_private::Disassembler > DisassemblerSP
Definition: lldb-forward.h:338

lldb::LanguageRuntimeSP
std::shared_ptr< lldb_private::LanguageRuntime > LanguageRuntimeSP
Definition: lldb-forward.h:363

lldb::EventSP
std::shared_ptr< lldb_private::Event > EventSP
Definition: lldb-forward.h:342

lldb::DynamicLoaderUP
std::unique_ptr< lldb_private::DynamicLoader > DynamicLoaderUP
Definition: lldb-forward.h:341

lldb::JITLoaderListUP
std::unique_ptr< lldb_private::JITLoaderList > JITLoaderListUP
Definition: lldb-forward.h:362

lldb::SymbolContextSpecifierSP
std::shared_ptr< lldb_private::SymbolContextSpecifier > SymbolContextSpecifierSP
Definition: lldb-forward.h:438

lldb::VariableListSP
std::shared_ptr< lldb_private::VariableList > VariableListSP
Definition: lldb-forward.h:482

lldb::SymbolFileTypeSP
std::shared_ptr< lldb_private::SymbolFileType > SymbolFileTypeSP
Definition: lldb-forward.h:436

lldb::WatchpointSP
std::shared_ptr< lldb_private::Watchpoint > WatchpointSP
Definition: lldb-forward.h:484

lldb::ProcessWP
std::weak_ptr< lldb_private::Process > ProcessWP
Definition: lldb-forward.h:389

lldb::ListenerSP
std::shared_ptr< lldb_private::Listener > ListenerSP
Definition: lldb-forward.h:365

lldb::UnwindPlanSP
std::shared_ptr< lldb_private::UnwindPlan > UnwindPlanSP
Definition: lldb-forward.h:478

lldb::StreamFileSP
std::shared_ptr< lldb_private::StreamFile > StreamFileSP
Definition: lldb-forward.h:428

lldb::VariableSP
std::shared_ptr< lldb_private::Variable > VariableSP
Definition: lldb-forward.h:481

lldb::TraceCursorSP
std::shared_ptr< lldb_private::TraceCursor > TraceCursorSP
Definition: lldb-forward.h:455

lldb::WatchpointResourceSP
std::shared_ptr< lldb_private::WatchpointResource > WatchpointResourceSP
Definition: lldb-forward.h:485

lldb::TypeSystemClangSP
std::shared_ptr< lldb_private::TypeSystemClang > TypeSystemClangSP
Definition: lldb-forward.h:465

lldb::SyntheticChildrenSP
std::shared_ptr< lldb_private::SyntheticChildren > SyntheticChildrenSP
Definition: lldb-forward.h:440

lldb::TypeCategoryImplSP
std::shared_ptr< lldb_private::TypeCategoryImpl > TypeCategoryImplSP
Definition: lldb-forward.h:458

lldb::DataBufferSP
std::shared_ptr< lldb_private::DataBuffer > DataBufferSP
Definition: lldb-forward.h:333

lldb::StackFrameRecognizerSP
std::shared_ptr< lldb_private::StackFrameRecognizer > StackFrameRecognizerSP
Definition: lldb-forward.h:423

lldb::SectionListUP
std::unique_ptr< lldb_private::SectionList > SectionListUP
Definition: lldb-forward.h:414

lldb::TypeWP
std::weak_ptr< lldb_private::Type > TypeWP
Definition: lldb-forward.h:457

lldb::StructuredDataImplUP
std::unique_ptr< lldb_private::StructuredDataImpl > StructuredDataImplUP
Definition: lldb-forward.h:431

lldb::SyntheticChildrenFrontEndSP
std::shared_ptr< lldb_private::SyntheticChildrenFrontEnd > SyntheticChildrenFrontEndSP
Definition: lldb-forward.h:442

lldb::StopInfoSP
std::shared_ptr< lldb_private::StopInfo > StopInfoSP
Definition: lldb-forward.h:426

lldb::SectionSP
std::shared_ptr< lldb_private::Section > SectionSP
Definition: lldb-forward.h:413

lldb::WritableDataBufferSP
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
Definition: lldb-forward.h:334

lldb::ScriptedSyntheticChildrenSP
std::shared_ptr< lldb_private::ScriptedSyntheticChildren > ScriptedSyntheticChildrenSP
Definition: lldb-forward.h:473

lldb::TypeFilterImplSP
std::shared_ptr< lldb_private::TypeFilterImpl > TypeFilterImplSP
Definition: lldb-forward.h:463

lldb::TraceExporterUP
std::unique_ptr< lldb_private::TraceExporter > TraceExporterUP
Definition: lldb-forward.h:454

lldb::QueueWP
std::weak_ptr< lldb_private::Queue > QueueWP
Definition: lldb-forward.h:396

lldb::ObjectFileJITDelegateSP
std::shared_ptr< lldb_private::ObjectFileJITDelegate > ObjectFileJITDelegateSP
Definition: lldb-forward.h:375

lldb::TargetWP
std::weak_ptr< lldb_private::Target > TargetWP
Definition: lldb-forward.h:444

lldb::TypeImplSP
std::shared_ptr< lldb_private::TypeImpl > TypeImplSP
Definition: lldb-forward.h:459

lldb::JITLoaderSP
std::shared_ptr< lldb_private::JITLoader > JITLoaderSP
Definition: lldb-forward.h:361

lldb::TargetSP
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:443

lldb::OptionValueWP
std::weak_ptr< lldb_private::OptionValue > OptionValueWP
Definition: lldb-forward.h:382

lldb::ThreadWP
std::weak_ptr< lldb_private::Thread > ThreadWP
Definition: lldb-forward.h:446

lldb::FileSP
std::shared_ptr< lldb_private::File > FileSP
Definition: lldb-forward.h:350

lldb::RegisterContextSP
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
Definition: lldb-forward.h:391

lldb::TypeSystemWP
std::weak_ptr< lldb_private::TypeSystem > TypeSystemWP
Definition: lldb-forward.h:466

lldb::DataExtractorSP
std::shared_ptr< lldb_private::DataExtractor > DataExtractorSP
Definition: lldb-forward.h:335

lldb::ScriptedProcessInterfaceUP
std::unique_ptr< lldb_private::ScriptedProcessInterface > ScriptedProcessInterfaceUP
Definition: lldb-forward.h:408

lldb::ProcessLaunchInfoSP
std::shared_ptr< lldb_private::ProcessLaunchInfo > ProcessLaunchInfoSP
Definition: lldb-forward.h:388

lldb::InstrumentationRuntimeSP
std::shared_ptr< lldb_private::InstrumentationRuntime > InstrumentationRuntimeSP
Definition: lldb-forward.h:357

lldb::ValueSP
std::shared_ptr< lldb_private::Value > ValueSP
Definition: lldb-forward.h:480

lldb::ModuleSP
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:370

lldb::OptionValueSP
std::shared_ptr< lldb_private::OptionValue > OptionValueSP
Definition: lldb-forward.h:381

lldb::ThreadCollectionSP
std::shared_ptr< lldb_private::ThreadCollection > ThreadCollectionSP
Definition: lldb-forward.h:447

lldb::CompUnitSP
std::shared_ptr< lldb_private::CompileUnit > CompUnitSP
Definition: lldb-forward.h:332

lldb::RegisterCheckpointSP
std::shared_ptr< lldb_private::RegisterCheckpoint > RegisterCheckpointSP
Definition: lldb-forward.h:390

lldb::ThreadPlanTracerSP
std::shared_ptr< lldb_private::ThreadPlanTracer > ThreadPlanTracerSP
Definition: lldb-forward.h:452

lldb::StackFrameListSP
std::shared_ptr< lldb_private::StackFrameList > StackFrameListSP
Definition: lldb-forward.h:421

lldb::EventDataSP
std::shared_ptr< lldb_private::EventData > EventDataSP
Definition: lldb-forward.h:343

lldb::ObjectFileJITDelegateWP
std::weak_ptr< lldb_private::ObjectFileJITDelegate > ObjectFileJITDelegateWP
Definition: lldb-forward.h:377

lldb::StringTypeSummaryImplSP
std::shared_ptr< lldb_private::StringSummaryFormat > StringTypeSummaryImplSP
Definition: lldb-forward.h:430

lldb::REPLSP
std::shared_ptr< lldb_private::REPL > REPLSP
Definition: lldb-forward.h:398

lldb::QueueItemSP
std::shared_ptr< lldb_private::QueueItem > QueueItemSP
Definition: lldb-forward.h:397

lldb::UnwindAssemblySP
std::shared_ptr< lldb_private::UnwindAssembly > UnwindAssemblySP
Definition: lldb-forward.h:477

lldb::BroadcasterManagerWP
std::weak_ptr< lldb_private::BroadcasterManager > BroadcasterManagerWP
Definition: lldb-forward.h:328

lldb::ExecutionContextRefSP
std::shared_ptr< lldb_private::ExecutionContextRef > ExecutionContextRefSP
Definition: lldb-forward.h:347

lldb::SectionWP
std::weak_ptr< lldb_private::Section > SectionWP
Definition: lldb-forward.h:415

lldb_private::FormatEntity::Entry
Definition: FormatEntity.h:39