lldb.llvm.org/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


// 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 RealpathPrefixes;

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 ScriptedStopHookInterface;

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 SaveCoreOptions;

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 Progress;

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 ABISP;

typedef std::unique_ptr AddressRangeUP;

typedef std::shared_ptr BatonSP;

typedef std::shared_ptr BlockSP;

typedef std::shared_ptr BreakpointSP;

typedef std::weak_ptr BreakpointWP;

typedef std::shared_ptr BreakpointSiteSP;

typedef std::shared_ptr BreakpointLocationSP;

typedef std::weak_ptr BreakpointLocationWP;

typedef std::shared_ptr

    BreakpointPreconditionSP;

typedef std::shared_ptr BreakpointResolverSP;

typedef std::shared_ptr BroadcasterSP;

typedef std::shared_ptr BroadcasterManagerSP;

typedef std::weak_ptr BroadcasterManagerWP;

typedef std::shared_ptr UserExpressionSP;

typedef std::shared_ptr CommandObjectSP;

typedef std::shared_ptr ConnectionSP;

typedef std::shared_ptr CompUnitSP;

typedef std::shared_ptr DataBufferSP;

typedef std::shared_ptr WritableDataBufferSP;

typedef std::shared_ptr DataExtractorSP;

typedef std::shared_ptr DebuggerSP;

typedef std::weak_ptr DebuggerWP;

typedef std::shared_ptr DisassemblerSP;

typedef std::unique_ptr

    DynamicCheckerFunctionsUP;

typedef std::unique_ptr DynamicLoaderUP;

typedef std::shared_ptr EventSP;

typedef std::shared_ptr EventDataSP;

typedef std::shared_ptr

    EventDataStructuredDataSP;

typedef std::shared_ptr

    ExecutionContextRefSP;

typedef std::shared_ptr ExpressionVariableSP;

typedef std::unique_ptr FileUP;

typedef std::shared_ptr FileSP;

typedef std::shared_ptr FormatEntrySP;

typedef std::shared_ptr FunctionSP;

typedef std::shared_ptr FuncUnwindersSP;

typedef std::shared_ptr InlineFunctionInfoSP;

typedef std::shared_ptr InstructionSP;

typedef std::shared_ptr

    InstrumentationRuntimeSP;

typedef std::shared_ptr IOHandlerSP;

typedef std::shared_ptr IOObjectSP;

typedef std::shared_ptr IRExecutionUnitSP;

typedef std::shared_ptr JITLoaderSP;

typedef std::unique_ptr JITLoaderListUP;

typedef std::shared_ptr LanguageRuntimeSP;

typedef std::unique_ptr SystemRuntimeUP;

typedef std::shared_ptr ListenerSP;

typedef std::weak_ptr ListenerWP;

typedef std::shared_ptr MemoryHistorySP;

typedef std::unique_ptr MemoryRegionInfoUP;

typedef std::shared_ptr MemoryRegionInfoSP;

typedef std::shared_ptr ModuleSP;

typedef std::weak_ptr ModuleWP;

typedef std::shared_ptr ObjectFileSP;

typedef std::shared_ptr ObjectContainerSP;

typedef std::shared_ptr

    ObjectFileJITDelegateSP;

typedef std::weak_ptr

    ObjectFileJITDelegateWP;

typedef std::unique_ptr OperatingSystemUP;

typedef std::shared_ptr

    OperatingSystemInterfaceSP;

typedef std::shared_ptr OptionValueSP;

typedef std::weak_ptr OptionValueWP;

typedef std::shared_ptr

    OptionValuePropertiesSP;

typedef std::shared_ptr PlatformSP;

typedef std::shared_ptr ProcessSP;

typedef std::shared_ptr ProcessAttachInfoSP;

typedef std::shared_ptr ProcessLaunchInfoSP;

typedef std::weak_ptr ProcessWP;

typedef std::shared_ptr RegisterCheckpointSP;

typedef std::shared_ptr RegisterContextSP;

typedef std::shared_ptr

    RegisterTypeBuilderSP;

typedef std::shared_ptr RegularExpressionSP;

typedef std::shared_ptr QueueSP;

typedef std::weak_ptr QueueWP;

typedef std::shared_ptr QueueItemSP;

typedef std::shared_ptr REPLSP;

typedef std::shared_ptr

    RecognizedStackFrameSP;

typedef std::shared_ptr

    ScriptSummaryFormatSP;

typedef std::shared_ptr ScriptInterpreterSP;

typedef std::shared_ptr ScriptedMetadataSP;

typedef std::unique_ptr

    ScriptedPlatformInterfaceUP;

typedef std::unique_ptr

    ScriptedProcessInterfaceUP;

typedef std::shared_ptr

    ScriptedStopHookInterfaceSP;

typedef std::shared_ptr

    ScriptedThreadInterfaceSP;

typedef std::shared_ptr

    ScriptedThreadPlanInterfaceSP;

typedef std::shared_ptr SectionSP;

typedef std::unique_ptr SectionListUP;

typedef std::weak_ptr SectionWP;

typedef std::shared_ptr SectionLoadListSP;

typedef std::shared_ptr SearchFilterSP;

typedef std::unique_ptr SourceManagerUP;

typedef std::shared_ptr StackFrameSP;

typedef std::weak_ptr StackFrameWP;

typedef std::shared_ptr StackFrameListSP;

typedef std::shared_ptr

    StackFrameRecognizerSP;

typedef std::unique_ptr

    StackFrameRecognizerManagerUP;

typedef std::shared_ptr StopInfoSP;

typedef std::shared_ptr StreamSP;

typedef std::shared_ptr StreamFileSP;

typedef std::shared_ptr

    StringTypeSummaryImplSP;

typedef std::unique_ptr StructuredDataImplUP;

typedef std::shared_ptr

    StructuredDataPluginSP;

typedef std::weak_ptr

    StructuredDataPluginWP;

typedef std::shared_ptr SymbolFileTypeSP;

typedef std::shared_ptr

    SymbolContextSpecifierSP;

typedef std::unique_ptr SymbolVendorUP;

typedef std::shared_ptr SyntheticChildrenSP;

typedef std::shared_ptr

    SyntheticChildrenFrontEndSP;

typedef std::shared_ptr TargetSP;

typedef std::weak_ptr TargetWP;

typedef std::shared_ptr ThreadSP;

typedef std::weak_ptr ThreadWP;

typedef std::shared_ptr ThreadCollectionSP;

typedef std::shared_ptr ThreadPlanSP;

typedef std::shared_ptr

    ThreadPostMortemTraceSP;

typedef std::weak_ptr ThreadPlanWP;

typedef std::shared_ptr ThreadPlanTracerSP;

typedef std::shared_ptr TraceSP;

typedef std::unique_ptr TraceExporterUP;

typedef std::shared_ptr TraceCursorSP;

typedef std::shared_ptr TypeSP;

typedef std::weak_ptr TypeWP;

typedef std::shared_ptr TypeCategoryImplSP;

typedef std::shared_ptr TypeImplSP;

typedef std::shared_ptr

    TypeMemberFunctionImplSP;

typedef std::shared_ptr TypeEnumMemberImplSP;

typedef std::shared_ptr TypeFilterImplSP;

typedef std::shared_ptr TypeSystemSP;

typedef std::shared_ptr TypeSystemClangSP;

typedef std::weak_ptr TypeSystemWP;

typedef std::shared_ptr TypeFormatImplSP;

typedef std::shared_ptr

    TypeNameSpecifierImplSP;

typedef std::shared_ptr TypeSummaryImplSP;

typedef std::shared_ptr TypeSummaryOptionsSP;

typedef std::shared_ptr

    ScriptedSyntheticChildrenSP;

typedef std::shared_ptr SupportFileSP;

typedef std::shared_ptr UnixSignalsSP;

typedef std::weak_ptr UnixSignalsWP;

typedef std::shared_ptr UnwindAssemblySP;

typedef std::shared_ptr UnwindPlanSP;

typedef std::shared_ptr ValueObjectSP;

typedef std::shared_ptr ValueSP;

typedef std::shared_ptr VariableSP;

typedef std::shared_ptr VariableListSP;

typedef std::shared_ptr ValueObjectListSP;

typedef std::shared_ptr WatchpointSP;

typedef std::shared_ptr WatchpointResourceSP;


} // namespace lldb


#endif // LLDB_LLDB_FORWARD_H

lldb_private::FormatterBytecode::Type
@ Type
Definition: FormatterBytecode.h:16

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:356

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

lldb::ScriptedStopHookInterfaceSP
std::shared_ptr< lldb_private::ScriptedStopHookInterface > ScriptedStopHookInterfaceSP
Definition: lldb-forward.h:414

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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