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

class ProcessInstanceInfo;

class ProcessInstanceInfoMatch;

class ProcessLaunchInfo;

class ProcessModID;

class Property;

class ProtocolServer;

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

class ScriptedMetadata;

class ScriptedBreakpointInterface;

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

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<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::unique_ptr<lldb_private::ProtocolServer> ProtocolServerUP;

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

    ScriptedFrameInterfaceSP;

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

    ScriptedStopHookInterfaceSP;

typedef std::shared_ptr<lldb_private::ScriptedThreadInterface>

    ScriptedThreadInterfaceSP;

typedef std::shared_ptr<lldb_private::ScriptedThreadPlanInterface>

    ScriptedThreadPlanInterfaceSP;

typedef std::shared_ptr<lldb_private::ScriptedBreakpointInterface>

    ScriptedBreakpointInterfaceSP;

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::unique_ptr<lldb_private::Stream> StreamUP;

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

typedef std::shared_ptr<lldb_private::LockableStreamFile> LockableStreamFileSP;

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::ABI
Definition ABI.h:28

lldb_private::ASTResultSynthesizer
"lldb/Expression/ASTResultSynthesizer.h" Adds a result variable declaration to the ASTs for an expres...
Definition ASTResultSynthesizer.h:37

lldb_private::ASTStructExtractor
"lldb/Expression/ASTStructExtractor.h" Extracts and describes the argument structure for a wrapped fu...
Definition ASTStructExtractor.h:33

lldb_private::AddressRange
A section + offset based address range class.
Definition AddressRange.h:25

lldb_private::AddressRanges
Definition AddressRange.h:254

lldb_private::AddressResolver
General Outline: The AddressResolver is a Searcher.
Definition AddressResolver.h:33

lldb_private::Address
A section + offset based address class.
Definition Address.h:62

lldb_private::ArchSpec
An architecture specification class.
Definition ArchSpec.h:31

lldb_private::Architecture
Definition Architecture.h:19

lldb_private::Args
A command line argument class.
Definition Args.h:33

lldb_private::ArmUnwindInfo
Definition ArmUnwindInfo.h:30

lldb_private::Baton
A class designed to wrap callback batons so they can cleanup any acquired resources.
Definition Baton.h:35

lldb_private::Block
A class that describes a single lexical block.
Definition Block.h:41

lldb_private::BreakpointIDList
Definition BreakpointIDList.h:26

lldb_private::BreakpointID
Definition BreakpointID.h:22

lldb_private::BreakpointList
General Outline: Allows adding and removing breakpoints and find by ID and index.
Definition BreakpointList.h:25

lldb_private::BreakpointLocationCollection
Definition BreakpointLocationCollection.h:20

lldb_private::BreakpointLocationList
"lldb/Breakpoint/BreakpointLocationList.h" This class is used by Breakpoint to manage a list of break...
Definition BreakpointLocationList.h:26

lldb_private::BreakpointLocation
General Outline: A breakpoint location is defined by the breakpoint that produces it,...
Definition BreakpointLocation.h:40

lldb_private::BreakpointName
Definition BreakpointName.h:30

lldb_private::BreakpointOptionGroup
Definition CommandObjectBreakpoint.cpp:53

lldb_private::BreakpointOptions
"lldb/Breakpoint/BreakpointOptions.h" Class that manages the options on a breakpoint or breakpoint lo...
Definition BreakpointOptions.h:28

lldb_private::BreakpointPrecondition
Definition BreakpointPrecondition.h:21

lldb_private::BreakpointResolver
General Outline: The BreakpointResolver is a Searcher.
Definition BreakpointResolver.h:36

lldb_private::BreakpointSite
Class that manages the actual breakpoint that will be inserted into the running program.
Definition BreakpointSite.h:36

lldb_private::Breakpoint
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition Breakpoint.h:81

lldb_private::BroadcastEventSpec
lldb::BroadcastEventSpec
Definition Broadcaster.h:40

lldb_private::BroadcasterManager
Definition Broadcaster.h:75

lldb_private::Broadcaster
An event broadcasting class.
Definition Broadcaster.h:146

lldb_private::CXXSyntheticChildren
Definition TypeSynthetic.h:375

lldb_private::CallFrameInfo
Definition CallFrameInfo.h:16

lldb_private::CommandInterpreterRunOptions
Definition CommandInterpreter.h:63

lldb_private::CommandInterpreter
Definition CommandInterpreter.h:231

lldb_private::CommandObjectMultiword
Definition CommandObjectMultiword.h:20

lldb_private::CommandObject
Definition CommandObject.h:70

lldb_private::CommandReturnObject
Definition CommandReturnObject.h:29

lldb_private::Communication
An abstract communications class.
Definition Communication.h:39

lldb_private::CompactUnwindInfo
Definition CompactUnwindInfo.h:36

lldb_private::CompileUnit
A class that describes a compilation unit.
Definition CompileUnit.h:43

lldb_private::CompilerDeclContext
Represents a generic declaration context in a program.
Definition CompilerDeclContext.h:31

lldb_private::CompilerDecl
Represents a generic declaration such as a function declaration.
Definition CompilerDecl.h:28

lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition CompilerType.h:37

lldb_private::ConnectionFileDescriptor
Definition ConnectionFileDescriptorPosix.h:26

lldb_private::Connection
A communication connection class.
Definition Connection.h:41

lldb_private::ConstStringTable
Many cache files require string tables to store data efficiently.
Definition DataFileCache.h:181

lldb_private::ConstString
A uniqued constant string class.
Definition ConstString.h:40

lldb_private::DWARFCallFrameInfo
Definition DWARFCallFrameInfo.h:34

lldb_private::DWARFDataExtractor
Definition DWARFDataExtractor.h:17

lldb_private::DWARFExpressionList
"lldb/Expression/DWARFExpressionList.h" Encapsulates a range map from file address range to a single ...
Definition DWARFExpressionList.h:23

lldb_private::DWARFExpression
"lldb/Expression/DWARFExpression.h" Encapsulates a DWARF location expression and interprets it.
Definition DWARFExpression.h:36

lldb_private::DataBufferHeap
A subclass of DataBuffer that stores a data buffer on the heap.
Definition DataBufferHeap.h:30

lldb_private::DataBuffer
A pure virtual protocol class for abstracted read only data buffers.
Definition DataBuffer.h:42

lldb_private::DataEncoder
An binary data encoding class.
Definition DataEncoder.h:42

lldb_private::DataExtractor
An data extractor class.
Definition DataExtractor.h:48

lldb_private::DataFileCache
This class enables data to be cached into a directory using the llvm caching code.
Definition DataFileCache.h:45

lldb_private::Debugger
A class to manage flag bits.
Definition Debugger.h:80

lldb_private::Declaration
A class that describes the declaration location of a lldb object.
Definition Declaration.h:24

lldb_private::DiagnosticManager
Definition DiagnosticManager.h:103

lldb_private::Disassembler
Definition Disassembler.h:390

lldb_private::DumpValueObjectOptions
Definition DumpValueObjectOptions.h:22

lldb_private::DynamicCheckerFunctions
Encapsulates dynamic check functions used by expressions.
Definition DynamicCheckerFunctions.h:32

lldb_private::DynamicLoader
A plug-in interface definition class for dynamic loaders.
Definition DynamicLoader.h:54

lldb_private::Editline
Instances of Editline provide an abstraction over libedit's EditLine facility.
Definition Editline.h:155

lldb_private::EmulateInstruction
"lldb/Core/EmulateInstruction.h" A class that allows emulation of CPU opcodes.
Definition EmulateInstruction.h:128

lldb_private::Environment
Definition Environment.h:18

lldb_private::EvaluateExpressionOptions
Definition Target.h:307

lldb_private::EventDataStructuredData
This class handles one or more StructuredData::Dictionary entries that are raised for structured data...
Definition Event.h:127

lldb_private::EventData
Definition Event.h:35

lldb_private::Event
Definition Event.h:179

lldb_private::ExecutionContextRef
Execution context objects refer to objects in the execution of the program that is being debugged.
Definition ExecutionContext.h:73

lldb_private::ExecutionContextScope
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
Definition ExecutionContextScope.h:32

lldb_private::ExecutionContext
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
Definition ExecutionContext.h:293

lldb_private::ExpressionTypeSystemHelper
"lldb/Expression/ExpressionTypeSystemHelper.h" A helper object that the Expression can pass to its Ex...
Definition ExpressionTypeSystemHelper.h:27

lldb_private::ExpressionVariableList
"lldb/Expression/ExpressionVariable.h" A list of variable references.
Definition ExpressionVariable.h:129

lldb_private::ExpressionVariable
Definition ExpressionVariable.h:27

lldb_private::Expression
Encapsulates a single expression for use in lldb.
Definition Expression.h:32

lldb_private::FileSpecList
A file collection class.
Definition FileSpecList.h:91

lldb_private::FileSpec
A file utility class.
Definition FileSpec.h:57

lldb_private::File
An abstract base class for files.
Definition File.h:36

lldb_private::Flags
A class to manage flags.
Definition Flags.h:22

lldb_private::FormatManager
Definition FormatManager.h:36

lldb_private::FormattersMatchCandidate
Definition FormatClasses.h:45

lldb_private::FuncUnwinders
Definition FuncUnwinders.h:13

lldb_private::FunctionCaller
Encapsulates a function that can be called.
Definition FunctionCaller.h:56

lldb_private::FunctionInfo
A class that contains generic function information.
Definition Function.h:32

lldb_private::Function
A class that describes a function.
Definition Function.h:400

lldb_private::IOHandler
Definition IOHandler.h:37

lldb_private::IOObject
Definition IOObject.h:21

lldb_private::IRExecutionUnit
"lldb/Expression/IRExecutionUnit.h" Contains the IR and, optionally, JIT- compiled code for a module.
Definition IRExecutionUnit.h:59

lldb_private::InlineFunctionInfo
A class that describes information for an inlined function.
Definition Function.h:126

lldb_private::InstructionList
Definition Disassembler.h:287

lldb_private::Instruction
Definition Disassembler.h:58

lldb_private::InstrumentationRuntime
Definition InstrumentationRuntime.h:29

lldb_private::JITLoaderList
Class used by the Process to hold a list of its JITLoaders.
Definition JITLoaderList.h:22

lldb_private::JITLoader
A plug-in interface definition class for JIT loaders.
Definition JITLoader.h:27

lldb_private::LanguageCategory
Definition LanguageCategory.h:21

lldb_private::LanguageRuntime
Definition LanguageRuntime.h:61

lldb_private::Language
Definition Language.h:39

lldb_private::LineTable
A line table class.
Definition LineTable.h:25

lldb_private::Listener
Definition Listener.h:35

lldb_private::LockableStreamFile
Definition StreamFile.h:75

lldb_private::Log
Definition Log.h:132

lldb_private::Mangled
A class that handles mangled names.
Definition Mangled.h:34

lldb_private::Materializer
Definition Materializer.h:23

lldb_private::MemoryHistory
Definition MemoryHistory.h:23

lldb_private::MemoryRegionInfo
Definition MemoryRegionInfo.h:21

lldb_private::MemoryRegionInfos
Definition MemoryRegionInfo.h:178

lldb_private::ModuleList
A collection class for Module objects.
Definition ModuleList.h:104

lldb_private::ModuleSpecList
Definition ModuleSpec.h:275

lldb_private::ModuleSpec
Definition ModuleSpec.h:27

lldb_private::Module
A class that describes an executable image and its associated object and symbol files.
Definition Module.h:90

lldb_private::ObjectContainer
A plug-in interface definition class for object containers.
Definition ObjectContainer.h:30

lldb_private::ObjectFileJITDelegate
Definition ObjectFileJIT.h:20

lldb_private::ObjectFile
A plug-in interface definition class for object file parsers.
Definition ObjectFile.h:45

lldb_private::OperatingSystemInterface
Definition OperatingSystemInterface.h:18

lldb_private::OperatingSystem
A plug-in interface definition class for halted OS helpers.
Definition OperatingSystem.h:27

lldb_private::OptionGroupOptions
Definition Options.h:256

lldb_private::OptionGroupPlatform
Definition OptionGroupPlatform.h:21

lldb_private::OptionGroup
Definition Options.h:234

lldb_private::OptionValueArch
Definition OptionValueArch.h:18

lldb_private::OptionValueArgs
Definition OptionValueArgs.h:16

lldb_private::OptionValueArray
Definition OptionValueArray.h:18

lldb_private::OptionValueBoolean
Definition OptionValueBoolean.h:16

lldb_private::OptionValueChar
Definition OptionValueChar.h:16

lldb_private::OptionValueDictionary
Definition OptionValueDictionary.h:20

lldb_private::OptionValueEnumeration
Definition OptionValueEnumeration.h:23

lldb_private::OptionValueFileSpecList
Definition OptionValueFileSpecList.h:20

lldb_private::OptionValueFileSpec
Definition OptionValueFileSpec.h:20

lldb_private::OptionValueFormatEntity
Definition OptionValueFormatEntity.h:18

lldb_private::OptionValueFormat
Definition OptionValueFormat.h:17

lldb_private::OptionValueLanguage
Definition OptionValueLanguage.h:18

lldb_private::OptionValuePathMappings
Definition OptionValuePathMappings.h:18

lldb_private::OptionValueProperties
Definition OptionValueProperties.h:24

lldb_private::OptionValueRegex
Definition OptionValueRegex.h:17

lldb_private::OptionValueSInt64
Definition OptionValueSInt64.h:17

lldb_private::OptionValueString
Definition OptionValueString.h:20

lldb_private::OptionValueUInt64
Definition OptionValueUInt64.h:17

lldb_private::OptionValueUUID
Definition OptionValueUUID.h:17

lldb_private::OptionValue
Definition OptionValue.h:32

lldb_private::Options
A command line option parsing protocol class.
Definition Options.h:58

lldb_private::PathMappingList
Definition PathMappingList.h:23

lldb_private::PersistentExpressionState
Definition ExpressionVariable.h:214

lldb_private::Platform
A plug-in interface definition class for debug platform that includes many platform abilities such as...
Definition Platform.h:77

lldb_private::ProcessAttachInfo
Definition Process.h:126

lldb_private::ProcessInfo
Definition ProcessInfo.h:31

lldb_private::ProcessInstanceInfoMatch
Definition ProcessInfo.h:303

lldb_private::ProcessInstanceInfo
Definition ProcessInfo.h:141

lldb_private::ProcessLaunchInfo
Definition ProcessLaunchInfo.h:30

lldb_private::ProcessModID
Definition Process.h:215

lldb_private::Process
A plug-in interface definition class for debugging a process.
Definition Process.h:357

lldb_private::Progress
A Progress indicator helper class.
Definition Progress.h:60

lldb_private::Property
Definition Property.h:35

lldb_private::ProtocolServer
Definition ProtocolServer.h:18

lldb_private::QueueImpl
Definition SBQueue.cpp:28

lldb_private::QueueItem
Definition QueueItem.h:32

lldb_private::Queue
Definition Queue.h:32

lldb_private::REPL
Definition REPL.h:23

lldb_private::RealpathPrefixes
Definition RealpathPrefixes.h:22

lldb_private::RecognizedStackFrame
This class provides extra information about a stack frame that was provided by a specific stack frame...
Definition StackFrameRecognizer.h:33

lldb_private::RegisterCheckpoint
Definition RegisterCheckpoint.h:21

lldb_private::RegisterContext
Definition RegisterContext.h:18

lldb_private::RegisterTypeBuilder
Definition RegisterTypeBuilder.h:17

lldb_private::RegisterValue
Definition RegisterValue.h:29

lldb_private::RegularExpression
Definition RegularExpression.h:18

lldb_private::RichManglingContext
Uniform wrapper for access to rich mangling information from different providers.
Definition RichManglingContext.h:26

lldb_private::SaveCoreOptions
Definition SaveCoreOptions.h:25

lldb_private::Scalar
Definition Scalar.h:34

lldb_private::ScriptInterpreterLocker
Definition ScriptInterpreter.h:43

lldb_private::ScriptInterpreter
Definition ScriptInterpreter.h:145

lldb_private::ScriptedBreakpointInterface
Definition ScriptedBreakpointInterface.h:17

lldb_private::ScriptedFrameInterface
Definition ScriptedFrameInterface.h:20

lldb_private::ScriptedMetadata
Definition ScriptedMetadata.h:16

lldb_private::ScriptedPlatformInterface
Definition ScriptedPlatformInterface.h:20

lldb_private::ScriptedProcessInterface
Definition ScriptedProcessInterface.h:22

lldb_private::ScriptedStopHookInterface
Definition ScriptedStopHookInterface.h:17

lldb_private::ScriptedSyntheticChildren
Definition TypeSynthetic.h:404

lldb_private::ScriptedThreadInterface
Definition ScriptedThreadInterface.h:21

lldb_private::ScriptedThreadPlanInterface
Definition ScriptedThreadPlanInterface.h:17

lldb_private::SearchFilter
General Outline: Provides the callback and search depth for the SearchFilter search.
Definition SearchFilter.h:83

lldb_private::SectionList
Definition Section.h:35

lldb_private::SectionLoadHistory
Definition SectionLoadHistory.h:19

lldb_private::SectionLoadList
Definition SectionLoadList.h:22

lldb_private::Section
Definition Section.h:129

lldb_private::SourceManagerImpl
Definition SBSourceManager.cpp:23

lldb_private::SourceManager
Definition SourceManager.h:34

lldb_private::StackFrameList
Definition StackFrameList.h:23

lldb_private::StackFrameRecognizerManager
Class that provides a registry of known stack frame recognizers.
Definition StackFrameRecognizer.h:106

lldb_private::StackFrameRecognizer
A base class for frame recognizers.
Definition StackFrameRecognizer.h:61

lldb_private::StackFrame
This base class provides an interface to stack frames.
Definition StackFrame.h:44

lldb_private::StackID
Definition StackID.h:18

lldb_private::Status
An error handling class.
Definition Status.h:118

lldb_private::StopInfo
Definition StopInfo.h:20

lldb_private::StoppointCallbackContext
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
Definition StoppointCallbackContext.h:26

lldb_private::Stoppoint
Definition Stoppoint.h:17

lldb_private::StreamBuffer
Definition StreamBuffer.h:19

lldb_private::StreamFile
Definition StreamFile.h:25

lldb_private::StreamString
Definition StreamString.h:25

lldb_private::Stream
A stream class that can stream formatted output to a file.
Definition Stream.h:28

lldb_private::StringList
Definition StringList.h:26

lldb_private::StringTableReader
Many cache files require string tables to store data efficiently.
Definition DataFileCache.h:213

lldb_private::StructuredDataImpl
Definition StructuredDataImpl.h:26

lldb_private::StructuredDataPlugin
Plugin that supports process-related structured data sent asynchronously from the debug monitor (e....
Definition StructuredDataPlugin.h:42

lldb_private::SupportFile
Wraps a FileSpec and an optional Checksum.
Definition SupportFile.h:21

lldb_private::SymbolContextList
Defines a list of symbol context objects.
Definition SymbolContext.h:379

lldb_private::SymbolContextScope
"lldb/Symbol/SymbolContextScope.h" Inherit from this if your object is part of a symbol context and c...
Definition SymbolContextScope.h:64

lldb_private::SymbolContextSpecifier
Definition SymbolContext.h:328

lldb_private::SymbolContext
Defines a symbol context baton that can be handed other debug core functions.
Definition SymbolContext.h:34

lldb_private::SymbolFileType
Definition Type.h:398

lldb_private::SymbolFile
Provides public interface for all SymbolFiles.
Definition SymbolFile.h:51

lldb_private::SymbolLocator
Definition SymbolLocator.h:17

lldb_private::SymbolVendor
Definition SymbolVendor.h:31

lldb_private::Symbol
Definition Symbol.h:33

lldb_private::Symtab
Definition Symtab.h:22

lldb_private::SyntheticChildrenFrontEnd
Definition TypeSynthetic.h:27

lldb_private::SyntheticChildren
Definition TypeSynthetic.h:140

lldb_private::SystemRuntime
A plug-in interface definition class for system runtimes.
Definition SystemRuntime.h:43

lldb_private::TargetList
Definition TargetList.h:21

lldb_private::TargetProperties
Definition Target.h:84

lldb_private::Target
Definition Target.h:527

lldb_private::ThreadCollection
Definition ThreadCollection.h:20

lldb_private::ThreadList
Definition ThreadList.h:26

lldb_private::ThreadPlanBase
Definition ThreadPlanBase.h:23

lldb_private::ThreadPlanRunToAddress
Definition ThreadPlanRunToAddress.h:19

lldb_private::ThreadPlanStepInstruction
Definition ThreadPlanStepInstruction.h:18

lldb_private::ThreadPlanStepOut
Definition ThreadPlanStepOut.h:18

lldb_private::ThreadPlanStepOverBreakpoint
Definition ThreadPlanStepOverBreakpoint.h:17

lldb_private::ThreadPlanStepRange
Definition ThreadPlanStepRange.h:20

lldb_private::ThreadPlanStepThrough
Definition ThreadPlanStepThrough.h:17

lldb_private::ThreadPlanTracer
Definition ThreadPlanTracer.h:20

lldb_private::ThreadPlan
Definition ThreadPlan.h:297

lldb_private::ThreadPostMortemTrace
Thread implementation used for representing threads gotten from trace session files,...
Definition ThreadPostMortemTrace.h:22

lldb_private::ThreadSpec
Definition ThreadSpec.h:33

lldb_private::Thread
Definition Thread.h:69

lldb_private::ThreadedCommunication
"lldb/Core/ThreadedCommunication.h" Variation of Communication that supports threaded reads.
Definition ThreadedCommunication.h:61

lldb_private::TraceCursor
Class used for iterating over the instructions of a thread's trace, among other kinds of information.
Definition TraceCursor.h:94

lldb_private::TraceExporter
A plug-in interface definition class for trace exporters.
Definition TraceExporter.h:28

lldb_private::Trace
A plug-in interface definition class for trace information.
Definition Trace.h:48

lldb_private::TypeAndOrName
Sometimes you can find the name of the type corresponding to an object, but we don't have debug infor...
Definition Type.h:779

lldb_private::TypeCategoryImpl
Definition TypeCategory.h:167

lldb_private::TypeCategoryMap
Definition TypeCategoryMap.h:25

lldb_private::TypeEnumMemberImpl
Definition Type.h:859

lldb_private::TypeEnumMemberListImpl
Definition Type.h:887

lldb_private::TypeFilterImpl
Definition TypeSynthetic.h:290

lldb_private::TypeFormatImpl
Definition TypeFormat.h:24

lldb_private::TypeImpl
Definition Type.h:624

lldb_private::TypeListImpl
Definition Type.h:697

lldb_private::TypeList
Definition TypeList.h:20

lldb_private::TypeMap
Definition TypeMap.h:20

lldb_private::TypeMemberFunctionImpl
Definition Type.h:822

lldb_private::TypeMemberImpl
Definition Type.h:728

lldb_private::TypeNameSpecifierImpl
Definition FormatClasses.h:152

lldb_private::TypeQuery
A class that contains all state required for type lookups.
Definition Type.h:104

lldb_private::TypeResults
This class tracks the state and results of a TypeQuery.
Definition Type.h:344

lldb_private::TypeSummaryImpl
Definition TypeSummary.h:49

lldb_private::TypeSummaryOptions
Definition TypeSummary.h:30

lldb_private::TypeSystemClang
A TypeSystem implementation based on Clang.
Definition TypeSystemClang.h:111

lldb_private::TypeSystem
Interface for representing a type system.
Definition TypeSystem.h:70

lldb_private::Type
Definition Type.h:417

lldb_private::UUID
Represents UUID's of various sizes.
Definition UUID.h:27

lldb_private::UnixSignals
Definition UnixSignals.h:22

lldb_private::UnwindAssembly
Definition UnwindAssembly.h:19

lldb_private::UnwindPlan
Definition UnwindPlan.h:53

lldb_private::UnwindTable
Definition UnwindTable.h:24

lldb_private::Unwind
Definition Unwind.h:18

lldb_private::UserExpression
Encapsulates a one-time expression for use in lldb.
Definition UserExpression.h:35

lldb_private::UtilityFunction
"lldb/Expression/UtilityFunction.h" Encapsulates a bit of source code that provides a function that i...
Definition UtilityFunction.h:30

lldb_private::VMRange
Definition VMRange.h:23

lldb_private::ValueList
Definition Value.h:187

lldb_private::ValueObjectChild
A child of another ValueObject.
Definition ValueObjectChild.h:28

lldb_private::ValueObjectConstResultChild
Definition ValueObjectConstResultChild.h:29

lldb_private::ValueObjectConstResultImpl
A class wrapping common implementation details for operations in ValueObjectConstResult ( & Child ) t...
Definition ValueObjectConstResultImpl.h:32

lldb_private::ValueObjectConstResult
A frozen ValueObject copied into host memory.
Definition ValueObjectConstResult.h:34

lldb_private::ValueObjectList
A collection of ValueObject values that.
Definition ValueObjectList.h:23

lldb_private::ValueObjectPrinter
Definition ValueObjectPrinter.h:22

lldb_private::ValueObject
ValueObject:
Definition ValueObject.h:105

lldb_private::Value
Definition Value.h:38

lldb_private::VariableList
Definition VariableList.h:18

lldb_private::Variable
Definition Variable.h:25

lldb_private::WatchpointList
This class is used by Watchpoint to manage a list of watchpoints,.
Definition WatchpointList.h:27

lldb_private::WatchpointOptions
"lldb/Breakpoint/WatchpointOptions.h" Class that manages the options on a watchpoint.
Definition WatchpointOptions.h:25

lldb_private::WatchpointResource
Definition WatchpointResource.h:21

lldb_private::Watchpoint
Definition Watchpoint.h:25

lldb_private::WritableDataBuffer
Definition DataBuffer.h:90

lldb_private::FormatEntity
Definition FormatEntity.h:38

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

lldb
Definition SBAddress.h:15

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

lldb::ProtocolServerUP
std::unique_ptr< lldb_private::ProtocolServer > ProtocolServerUP
Definition lldb-forward.h:396

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

lldb::ScriptedBreakpointInterfaceSP
std::shared_ptr< lldb_private::ScriptedBreakpointInterface > ScriptedBreakpointInterfaceSP
Definition lldb-forward.h:426

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

lldb::LockableStreamFileSP
std::shared_ptr< lldb_private::LockableStreamFile > LockableStreamFileSP
Definition lldb-forward.h:444

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

lldb::StreamUP
std::unique_ptr< lldb_private::Stream > StreamUP
Definition lldb-forward.h:442

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

lldb::ScriptedFrameInterfaceSP
std::shared_ptr< lldb_private::ScriptedFrameInterface > ScriptedFrameInterfaceSP
Definition lldb-forward.h:413

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

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

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

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

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

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

lldb_private::CacheSignature
A signature for a given file on disk.
Definition DataFileCache.h:109

lldb_private::CompilerContext
CompilerContext allows an array of these items to be passed to perform detailed lookups in SymbolVend...
Definition Type.h:52

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

lldb_private::LineEntry
A line table entry class.
Definition LineEntry.h:21

lldb_private::PropertyDefinition
Definition Property.h:23

lldb_private::ScriptSummaryFormat
Definition TypeSummary.h:376

lldb_private::StatisticsOptions
Definition Statistics.h:183

lldb_private::StringSummaryFormat
Definition TypeSummary.h:296