This is an archive of the discontinued LLVM Phabricator instance.

This patch makes me a little sad because it breaks the "Jump to Definition" chain in Xcode (and I bet it does in other IDE's that support this.) You used to be able to do "Jump to Definition" on ProcessSP, then jump to definition on the class name in the shared pointer definition to jump to the class. Now the first jump takes you to:

LLDB_FORWARD_CLASS(Process)

in the lldb-forward.def file, and you can't go any further because the IDE can't tell what to do with the contents of the .def file (it has no way to know how it was imported to create real definitions). These .def insertions almost always make things harder to find in the actual code, so they aren't free.

mib added a comment.Sep 14 2022, 5:36 PM

This comment was removed by mib.

In D133906#3791153, @jingham wrote:

This patch makes me a little sad because it breaks the "Jump to Definition" chain in Xcode (and I bet it does in other IDE's that support this.) You used to be able to do "Jump to Definition" on ProcessSP, then jump to definition on the class name in the shared pointer definition to jump to the class. Now the first jump takes you to:

LLDB_FORWARD_CLASS(Process)

in the lldb-forward.def file, and you can't go any further because the IDE can't tell what to do with the contents of the .def file (it has no way to know how it was imported to create real definitions). These .def insertions almost always make things harder to find in the actual code, so they aren't free.

@jingham to be honest, as a fellow Xcode user, this indirection annoyed me more than I found it convenient. May be we should have Xcode go directly to the template argument class when jumping to definition on smart pointers.

@JDevlieghere LGTM! Thanks!

In D133906#3791153, @jingham wrote:

This patch makes me a little sad because it breaks the "Jump to Definition" chain in Xcode (and I bet it does in other IDE's that support this.) You used to be able to do "Jump to Definition" on ProcessSP, then jump to definition on the class name in the shared pointer definition to jump to the class. Now the first jump takes you to:

LLDB_FORWARD_CLASS(Process)

in the lldb-forward.def file, and you can't go any further because the IDE can't tell what to do with the contents of the .def file (it has no way to know how it was imported to create real definitions). These .def insertions almost always make things harder to find in the actual code, so they aren't free.

The alternative would be to have tablegen generate the header, but I think that's overkill, and I'm not even sure Xcode would pick the generated header.

In D133906#3791352, @JDevlieghere wrote:

In D133906#3791153, @jingham wrote:

This patch makes me a little sad because it breaks the "Jump to Definition" chain in Xcode (and I bet it does in other IDE's that support this.) You used to be able to do "Jump to Definition" on ProcessSP, then jump to definition on the class name in the shared pointer definition to jump to the class. Now the first jump takes you to:

LLDB_FORWARD_CLASS(Process)

in the lldb-forward.def file, and you can't go any further because the IDE can't tell what to do with the contents of the .def file (it has no way to know how it was imported to create real definitions). These .def insertions almost always make things harder to find in the actual code, so they aren't free.

The alternative would be to have tablegen generate the header, but I think that's overkill, and I'm not even sure Xcode would pick the generated header.

I have a feeling that the code would be simpler if you reversed the "iteration order", and it might even make the go-to definition command more useful. I'm thinking of something like

// no .def file
#define LLDB_FORWARD_CLASS(cls) \
  namespace lldb_private { class cls; } \
  namespace lldb {  using cls##SP = std::shared_ptr<lldb_private::cls>; } \
  ...

LLDB_FORWARD_CLASS(Foo)
LLDB_FORWARD_CLASS(Bar)
...

That said, my preferred solution would be something like template<typename T> using SP = std::shared_ptr<T>, and then replacing all XyzSP with SP<Xyz>. The two main benefits (besides simplifying the forward file) I see are:

being able to write SP<const Xyz>. With the current pattern, you'd have to introduce a whole new class of typedefs, or live with the fact that shared_ptr<const xyz> looks very different from XyzSP
being compatible with the llvm naming scheme. XyzSP and xyz_sp would collide if they both used camel case. With this, they won't because one of them will not exist.

In D133906#3792230, @labath wrote:
In D133906#3791352, @JDevlieghere wrote:

In D133906#3791153, @jingham wrote:

This patch makes me a little sad because it breaks the "Jump to Definition" chain in Xcode (and I bet it does in other IDE's that support this.) You used to be able to do "Jump to Definition" on ProcessSP, then jump to definition on the class name in the shared pointer definition to jump to the class. Now the first jump takes you to:

LLDB_FORWARD_CLASS(Process)

in the lldb-forward.def file, and you can't go any further because the IDE can't tell what to do with the contents of the .def file (it has no way to know how it was imported to create real definitions). These .def insertions almost always make things harder to find in the actual code, so they aren't free.

The alternative would be to have tablegen generate the header, but I think that's overkill, and I'm not even sure Xcode would pick the generated header.

I have a feeling that the code would be simpler if you reversed the "iteration order", and it might even make the go-to definition command more useful. I'm thinking of something like
// no .def file
#define LLDB_FORWARD_CLASS(cls) \
  namespace lldb_private { class cls; } \
  namespace lldb {  using cls##SP = std::shared_ptr<lldb_private::cls>; } \
  ...

LLDB_FORWARD_CLASS(Foo)
LLDB_FORWARD_CLASS(Bar)
...

Works for me, but I don't see how that would help with go-to definition. Xcode still won't show you the macro expansion so there's nothing to click through, which was Jim's complaint.

That said, my preferred solution would be something like template<typename T> using SP = std::shared_ptr<T>, and then replacing all XyzSP with SP<Xyz>. The two main benefits (besides simplifying the forward file) I see are:

being able to write SP<const Xyz>. With the current pattern, you'd have to introduce a whole new class of typedefs, or live with the fact that shared_ptr<const xyz> looks very different from XyzSP

being compatible with the llvm naming scheme. XyzSP and xyz_sp would collide if they both used camel case. With this, they won't because one of them will not exist.

This would address Jim's concern, but it's more churn. If everyone's okay with this approach I'm happy to do the mechanical find-and-replace.

JDevlieghere added reviewers: clayborg, DavidSpickett.Sep 15 2022, 9:31 AM

SP and UP templates seems fine to me.

To some extent, the fact that we define an XxxSP for a class is saying "This is a thing we mostly pass around as a shared pointer" which would be lost if every time we make an SP or UP we use the same syntax. But I'm not sure that that's a terribly strong objection.

I really wish the .def files would actually generate a header file in the output directory. I am not a fan of using code navigation when saying "take me to the definition of "class Block;" and it shows:

#define LLDB_FORWARD_CLASS(Name) class Name;
#include "lldb-forward.def"
#undef LLDB_FORWARD_CLASS

Also as Jim pointed out, we now will generate shared, unique, and weak pointers for everything, even if those classes are never used that way.

I am not a fan of this. Wouldn't this also slow down compilation a bit? Each file that #include "lldb-forward.h" will not do a large amount of preprocessor stuff for each and every file that is compiled that includes this?

In D133906#3792666, @JDevlieghere wrote:
In D133906#3792230, @labath wrote:
// no .def file
#define LLDB_FORWARD_CLASS(cls) \
  namespace lldb_private { class cls; } \
  namespace lldb {  using cls##SP = std::shared_ptr<lldb_private::cls>; } \
  ...

LLDB_FORWARD_CLASS(Foo)
LLDB_FORWARD_CLASS(Bar)
...
Works for me, but I don't see how that would help with go-to definition. Xcode still won't show you the macro expansion so there's nothing to click through, which was Jim's complaint.

Right, I see. I misunderstood the problem somehow. That said, I can imagine Xcode offering a (clickable) tooltip showin the macro expansion in this case. I know of an IDE that does that, and it's pretty cool.

In D133906#3793505, @clayborg wrote:

Wouldn't this also slow down compilation a bit? Each file that #include "lldb-forward.h" will not do a large amount of preprocessor stuff for each and every file that is compiled that includes this?

Technically yes, but I very much doubt the difference will be measurable. The slowness of compiling c++ comes from instantiating templates and other fancy stuff. The preprocessor step is ridiculously fast.

Revision Contents

Path

Size

lldb/

include/

lldb/

lldb-forward.h

466 lines

lldb-forward.def

291 lines

Diff 460262

lldb/include/lldb/lldb-forward.h

	Show All 10 Lines

	#if defined(__cplusplus)			#if defined(__cplusplus)

	#include <memory>			#include <memory>

	// lldb forward declarations			// lldb forward declarations
	namespace lldb_private {			namespace lldb_private {

	class ABI;			#define LLDB_FORWARD_CLASS(Name) class Name;
	class ASTResultSynthesizer;			#include "lldb-forward.def"
	class ASTStructExtractor;			#undef LLDB_FORWARD_CLASS
	class Address;
	class AddressRange;			#define LLDB_FORWARD_STRUCT(Name) struct Name;
	class AddressResolver;			#include "lldb-forward.def"
	class ArchSpec;			#undef LLDB_FORWARD_STRUCT
	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 BreakpointSiteList;
	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;
	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 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 Queue;
	class QueueImpl;
	class QueueItem;
	class REPL;
	class RecognizedStackFrame;
	class RegisterCheckpoint;
	class RegisterContext;
	class RegisterValue;
	class RegularExpression;
	class RichManglingContext;
	class Scalar;
	class ScriptInterpreter;
	class ScriptInterpreterLocker;
	class ScriptedProcessInterface;
	class ScriptedThreadInterface;
	class ScriptedSyntheticChildren;
	class SearchFilter;
	class Section;
	class SectionList;
	class SectionLoadHistory;
	class SectionLoadList;
	class Settings;
	class SourceManager;
	class SourceManagerImpl;
	class StackFrame;
	class StackFrameList;
	class StackFrameRecognizer;
	class StackFrameRecognizerManager;
	class StackID;
	class Status;
	class StopInfo;
	class Stoppoint;
	class StoppointCallbackContext;
	class Stream;
	class StreamFile;
	class StreamString;
	class StringList;
	class StringTableReader;
	class StructuredDataImpl;
	class StructuredDataPlugin;
	class Symbol;
	class SymbolContext;
	class SymbolContextList;
	class SymbolContextScope;
	class SymbolContextSpecifier;
	class SymbolFile;
	class SymbolFileType;
	class SymbolVendor;
	class Symtab;
	class SyntheticChildren;
	class SyntheticChildrenFrontEnd;
	class SystemRuntime;
	class Target;
	class TargetList;
	class TargetProperties;
	class Thread;
	class ThreadCollection;
	class ThreadList;
	class ThreadPlan;
	class ThreadPlanBase;
	class ThreadPlanRunToAddress;
	class ThreadPlanStepInstruction;
	class ThreadPlanStepOut;
	class ThreadPlanStepOverBreakpoint;
	class ThreadPlanStepRange;
	class ThreadPlanStepThrough;
	class ThreadPlanTracer;
	class ThreadSpec;
	class ThreadPostMortemTrace;
	class ThreadedCommunication;
	class Trace;
	class TraceCursor;
	class TraceExporter;
	class Type;
	class TypeAndOrName;
	class TypeCategoryImpl;
	class TypeCategoryMap;
	class TypeEnumMemberImpl;
	class TypeEnumMemberListImpl;
	class TypeFilterImpl;
	class TypeFormatImpl;
	class TypeImpl;
	class TypeList;
	class TypeListImpl;
	class TypeMap;
	class TypeMemberFunctionImpl;
	class TypeMemberImpl;
	class TypeNameSpecifierImpl;
	class TypeSummaryImpl;
	class TypeSummaryOptions;
	class TypeSystem;
	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;
	struct CompilerContext;
	struct LineEntry;
	struct PropertyDefinition;
	struct ScriptSummaryFormat;
	struct StringSummaryFormat;
	template <unsigned N> class StreamBuffer;			template <unsigned N> class StreamBuffer;

	} // namespace lldb_private			} // namespace lldb_private

	// lldb forward declarations			// lldb forward declarations
	namespace lldb {			namespace lldb {

	typedef std::shared_ptr<lldb_private::ABI> ABISP;			#define LLDB_FORWARD_CLASS(Name) \
	typedef std::shared_ptr<lldb_private::Baton> BatonSP;			typedef std::shared_ptr<lldb_private::Name> Name##SP;
	typedef std::shared_ptr<lldb_private::Block> BlockSP;			#include "lldb-forward.def"
	typedef std::shared_ptr<lldb_private::Breakpoint> BreakpointSP;			#undef LLDB_FORWARD_CLASS
	typedef std::weak_ptr<lldb_private::Breakpoint> BreakpointWP;
	typedef std::shared_ptr<lldb_private::BreakpointSite> BreakpointSiteSP;			#define LLDB_FORWARD_CLASS(Name) \
	typedef std::shared_ptr<lldb_private::BreakpointLocation> BreakpointLocationSP;			typedef std::unique_ptr<lldb_private::Name> Name##UP;
	typedef std::weak_ptr<lldb_private::BreakpointLocation> BreakpointLocationWP;			#include "lldb-forward.def"
	typedef std::shared_ptr<lldb_private::BreakpointPrecondition>			#undef LLDB_FORWARD_CLASS
	BreakpointPreconditionSP;
	typedef std::shared_ptr<lldb_private::BreakpointResolver> BreakpointResolverSP;			#define LLDB_FORWARD_CLASS(Name) \
	typedef std::shared_ptr<lldb_private::Broadcaster> BroadcasterSP;			typedef std::weak_ptr<lldb_private::Name> Name##WP;
	typedef std::shared_ptr<lldb_private::BroadcasterManager> BroadcasterManagerSP;			#include "lldb-forward.def"
	typedef std::weak_ptr<lldb_private::BroadcasterManager> BroadcasterManagerWP;			#undef LLDB_FORWARD_CLASS
	typedef std::shared_ptr<lldb_private::UserExpression> UserExpressionSP;
	typedef std::shared_ptr<lldb_private::CommandObject> CommandObjectSP;			#define LLDB_FORWARD_STRUCT(Name) \
	typedef std::shared_ptr<lldb_private::Connection> ConnectionSP;			typedef std::shared_ptr<lldb_private::Name> Name##SP;
	typedef std::shared_ptr<lldb_private::CompileUnit> CompUnitSP;			#include "lldb-forward.def"
	typedef std::shared_ptr<lldb_private::DataBuffer> DataBufferSP;			#undef LLDB_FORWARD_STRUCT
	typedef std::shared_ptr<lldb_private::WritableDataBuffer> WritableDataBufferSP;
	typedef std::shared_ptr<lldb_private::DataExtractor> DataExtractorSP;			#define LLDB_FORWARD_STRUCT(Name) \
	typedef std::shared_ptr<lldb_private::Debugger> DebuggerSP;			typedef std::unique_ptr<lldb_private::Name> Name##UP;
	typedef std::weak_ptr<lldb_private::Debugger> DebuggerWP;			#include "lldb-forward.def"
	typedef std::shared_ptr<lldb_private::Disassembler> DisassemblerSP;			#undef LLDB_FORWARD_STRUCT
	typedef std::unique_ptr<lldb_private::DynamicCheckerFunctions>
	DynamicCheckerFunctionsUP;			#define LLDB_FORWARD_STRUCT(Name) \
	typedef std::unique_ptr<lldb_private::DynamicLoader> DynamicLoaderUP;			typedef std::weak_ptr<lldb_private::Name> Name##WP;
	typedef std::shared_ptr<lldb_private::Event> EventSP;			#include "lldb-forward.def"
	typedef std::shared_ptr<lldb_private::EventData> EventDataSP;			#undef LLDB_FORWARD_STRUCT
	typedef std::shared_ptr<lldb_private::EventDataStructuredData>
	EventDataStructuredDataSP;			// FIXME: Replace CompUnitSP with CompileUnitSP
	typedef std::shared_ptr<lldb_private::ExecutionContextRef>			typedef CompileUnitSP CompUnitSP;
	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::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::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::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::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::unique_ptr<lldb_private::ScriptedProcessInterface>
	ScriptedProcessInterfaceUP;
	typedef std::shared_ptr<lldb_private::ScriptedThreadInterface>
	ScriptedThreadInterfaceSP;
	typedef std::shared_ptr<lldb_private::Section> SectionSP;
	typedef std::unique_ptr<lldb_private::SectionList> SectionListUP;
	typedef std::weak_ptr<lldb_private::Section> SectionWP;
	typedef std::shared_ptr<lldb_private::SectionLoadList> SectionLoadListSP;
	typedef std::shared_ptr<lldb_private::SearchFilter> SearchFilterSP;
	typedef std::unique_ptr<lldb_private::SourceManager> SourceManagerUP;
	typedef std::shared_ptr<lldb_private::StackFrame> StackFrameSP;
	typedef std::weak_ptr<lldb_private::StackFrame> StackFrameWP;
	typedef std::shared_ptr<lldb_private::StackFrameList> StackFrameListSP;
	typedef std::shared_ptr<lldb_private::StackFrameRecognizer>
	StackFrameRecognizerSP;
	typedef std::unique_ptr<lldb_private::StackFrameRecognizerManager>
	StackFrameRecognizerManagerUP;
	typedef std::shared_ptr<lldb_private::StopInfo> StopInfoSP;
	typedef std::shared_ptr<lldb_private::Stream> StreamSP;
	typedef std::shared_ptr<lldb_private::StreamFile> StreamFileSP;
	typedef std::shared_ptr<lldb_private::StringSummaryFormat>
	StringTypeSummaryImplSP;
	typedef std::unique_ptr<lldb_private::StructuredDataImpl> StructuredDataImplUP;
	typedef std::shared_ptr<lldb_private::StructuredDataPlugin>
	StructuredDataPluginSP;
	typedef std::weak_ptr<lldb_private::StructuredDataPlugin>
	StructuredDataPluginWP;
	typedef std::shared_ptr<lldb_private::SymbolFileType> SymbolFileTypeSP;
	typedef std::shared_ptr<lldb_private::SymbolContextSpecifier>
	SymbolContextSpecifierSP;
	typedef std::unique_ptr<lldb_private::SymbolVendor> SymbolVendorUP;
	typedef std::shared_ptr<lldb_private::SyntheticChildren> SyntheticChildrenSP;
	typedef std::shared_ptr<lldb_private::SyntheticChildrenFrontEnd>
	SyntheticChildrenFrontEndSP;
	typedef std::shared_ptr<lldb_private::Target> TargetSP;
	typedef std::weak_ptr<lldb_private::Target> TargetWP;
	typedef std::shared_ptr<lldb_private::Thread> ThreadSP;
	typedef std::weak_ptr<lldb_private::Thread> ThreadWP;
	typedef std::shared_ptr<lldb_private::ThreadCollection> ThreadCollectionSP;
	typedef std::shared_ptr<lldb_private::ThreadPlan> ThreadPlanSP;
	typedef std::shared_ptr<lldb_private::ThreadPostMortemTrace>
	ThreadPostMortemTraceSP;
	typedef std::weak_ptr<lldb_private::ThreadPlan> ThreadPlanWP;
	typedef std::shared_ptr<lldb_private::ThreadPlanTracer> ThreadPlanTracerSP;
	typedef std::shared_ptr<lldb_private::Trace> TraceSP;
	typedef std::unique_ptr<lldb_private::TraceExporter> TraceExporterUP;
	typedef std::shared_ptr<lldb_private::TraceCursor> TraceCursorSP;
	typedef std::shared_ptr<lldb_private::Type> TypeSP;
	typedef std::weak_ptr<lldb_private::Type> TypeWP;
	typedef std::shared_ptr<lldb_private::TypeCategoryImpl> TypeCategoryImplSP;
	typedef std::shared_ptr<lldb_private::TypeImpl> TypeImplSP;
	typedef std::shared_ptr<lldb_private::TypeMemberFunctionImpl>
	TypeMemberFunctionImplSP;
	typedef std::shared_ptr<lldb_private::TypeEnumMemberImpl> TypeEnumMemberImplSP;
	typedef std::shared_ptr<lldb_private::TypeFilterImpl> TypeFilterImplSP;
	typedef std::shared_ptr<lldb_private::TypeSystem> TypeSystemSP;
	typedef std::shared_ptr<lldb_private::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::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;

	} // namespace lldb			} // namespace lldb

	#endif // #if defined(__cplusplus)			#endif // #if defined(__cplusplus)
	#endif // LLDB_LLDB_FORWARD_H			#endif // LLDB_LLDB_FORWARD_H

lldb/include/lldb/lldb-forward.def

This file was added.

				/===-- lldb-forward.def ---------------------------------------- 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_FORWARD_CLASS
				#define LLDB_FORWARD_CLASS(Name)
				#endif

				LLDB_FORWARD_CLASS(ABI)
				LLDB_FORWARD_CLASS(ASTResultSynthesizer)
				LLDB_FORWARD_CLASS(ASTStructExtractor)
				LLDB_FORWARD_CLASS(Address)
				LLDB_FORWARD_CLASS(AddressRange)
				LLDB_FORWARD_CLASS(AddressResolver)
				LLDB_FORWARD_CLASS(ArchSpec)
				LLDB_FORWARD_CLASS(Architecture)
				LLDB_FORWARD_CLASS(Args)
				LLDB_FORWARD_CLASS(ArmUnwindInfo)
				LLDB_FORWARD_CLASS(Baton)
				LLDB_FORWARD_CLASS(Block)
				LLDB_FORWARD_CLASS(Breakpoint)
				LLDB_FORWARD_CLASS(BreakpointID)
				LLDB_FORWARD_CLASS(BreakpointIDList)
				LLDB_FORWARD_CLASS(BreakpointList)
				LLDB_FORWARD_CLASS(BreakpointLocation)
				LLDB_FORWARD_CLASS(BreakpointLocationCollection)
				LLDB_FORWARD_CLASS(BreakpointLocationList)
				LLDB_FORWARD_CLASS(BreakpointName)
				LLDB_FORWARD_CLASS(BreakpointOptionGroup)
				LLDB_FORWARD_CLASS(BreakpointOptions)
				LLDB_FORWARD_CLASS(BreakpointPrecondition)
				LLDB_FORWARD_CLASS(BreakpointResolver)
				LLDB_FORWARD_CLASS(BreakpointSite)
				LLDB_FORWARD_CLASS(BreakpointSiteList)
				LLDB_FORWARD_CLASS(BroadcastEventSpec)
				LLDB_FORWARD_CLASS(Broadcaster)
				LLDB_FORWARD_CLASS(BroadcasterManager)
				LLDB_FORWARD_CLASS(CXXSyntheticChildren)
				LLDB_FORWARD_CLASS(CallFrameInfo)
				LLDB_FORWARD_CLASS(CommandInterpreter)
				LLDB_FORWARD_CLASS(CommandInterpreterRunOptions)
				LLDB_FORWARD_CLASS(CommandObject)
				LLDB_FORWARD_CLASS(CommandObjectMultiword)
				LLDB_FORWARD_CLASS(CommandReturnObject)
				LLDB_FORWARD_CLASS(Communication)
				LLDB_FORWARD_CLASS(CompactUnwindInfo)
				LLDB_FORWARD_CLASS(CompileUnit)
				LLDB_FORWARD_CLASS(CompilerDecl)
				LLDB_FORWARD_CLASS(CompilerDeclContext)
				LLDB_FORWARD_CLASS(CompilerType)
				LLDB_FORWARD_CLASS(Connection)
				LLDB_FORWARD_CLASS(ConnectionFileDescriptor)
				LLDB_FORWARD_CLASS(ConstString)
				LLDB_FORWARD_CLASS(ConstStringTable)
				LLDB_FORWARD_CLASS(DWARFCallFrameInfo)
				LLDB_FORWARD_CLASS(DWARFDataExtractor)
				LLDB_FORWARD_CLASS(DWARFExpression)
				LLDB_FORWARD_CLASS(DWARFExpressionList)
				LLDB_FORWARD_CLASS(DataBuffer)
				LLDB_FORWARD_CLASS(WritableDataBuffer)
				LLDB_FORWARD_CLASS(DataBufferHeap)
				LLDB_FORWARD_CLASS(DataEncoder)
				LLDB_FORWARD_CLASS(DataExtractor)
				LLDB_FORWARD_CLASS(DataFileCache)
				LLDB_FORWARD_CLASS(Debugger)
				LLDB_FORWARD_CLASS(Declaration)
				LLDB_FORWARD_CLASS(DiagnosticManager)
				LLDB_FORWARD_CLASS(Disassembler)
				LLDB_FORWARD_CLASS(DumpValueObjectOptions)
				LLDB_FORWARD_CLASS(DynamicCheckerFunctions)
				LLDB_FORWARD_CLASS(DynamicLoader)
				LLDB_FORWARD_CLASS(Editline)
				LLDB_FORWARD_CLASS(EmulateInstruction)
				LLDB_FORWARD_CLASS(Environment)
				LLDB_FORWARD_CLASS(EvaluateExpressionOptions)
				LLDB_FORWARD_CLASS(Event)
				LLDB_FORWARD_CLASS(EventData)
				LLDB_FORWARD_CLASS(EventDataStructuredData)
				LLDB_FORWARD_CLASS(ExecutionContext)
				LLDB_FORWARD_CLASS(ExecutionContextRef)
				LLDB_FORWARD_CLASS(ExecutionContextScope)
				LLDB_FORWARD_CLASS(Expression)
				LLDB_FORWARD_CLASS(ExpressionTypeSystemHelper)
				LLDB_FORWARD_CLASS(ExpressionVariable)
				LLDB_FORWARD_CLASS(ExpressionVariableList)
				LLDB_FORWARD_CLASS(File)
				LLDB_FORWARD_CLASS(FileSpec)
				LLDB_FORWARD_CLASS(FileSpecList)
				LLDB_FORWARD_CLASS(Flags)
				LLDB_FORWARD_CLASS(FormatManager)
				LLDB_FORWARD_CLASS(FormattersMatchCandidate)
				LLDB_FORWARD_CLASS(FuncUnwinders)
				LLDB_FORWARD_CLASS(Function)
				LLDB_FORWARD_CLASS(FunctionCaller)
				LLDB_FORWARD_CLASS(FunctionInfo)
				LLDB_FORWARD_CLASS(IOHandler)
				LLDB_FORWARD_CLASS(IOObject)
				LLDB_FORWARD_CLASS(IRExecutionUnit)
				LLDB_FORWARD_CLASS(InlineFunctionInfo)
				LLDB_FORWARD_CLASS(Instruction)
				LLDB_FORWARD_CLASS(InstructionList)
				LLDB_FORWARD_CLASS(InstrumentationRuntime)
				LLDB_FORWARD_CLASS(JITLoader)
				LLDB_FORWARD_CLASS(JITLoaderList)
				LLDB_FORWARD_CLASS(Language)
				LLDB_FORWARD_CLASS(LanguageCategory)
				LLDB_FORWARD_CLASS(LanguageRuntime)
				LLDB_FORWARD_CLASS(LineTable)
				LLDB_FORWARD_CLASS(Listener)
				LLDB_FORWARD_CLASS(Log)
				LLDB_FORWARD_CLASS(Mangled)
				LLDB_FORWARD_CLASS(Materializer)
				LLDB_FORWARD_CLASS(MemoryHistory)
				LLDB_FORWARD_CLASS(MemoryRegionInfo)
				LLDB_FORWARD_CLASS(MemoryRegionInfos)
				LLDB_FORWARD_CLASS(Module)
				LLDB_FORWARD_CLASS(ModuleList)
				LLDB_FORWARD_CLASS(ModuleSpec)
				LLDB_FORWARD_CLASS(ModuleSpecList)
				LLDB_FORWARD_CLASS(ObjectContainer)
				LLDB_FORWARD_CLASS(ObjectFile)
				LLDB_FORWARD_CLASS(ObjectFileJITDelegate)
				LLDB_FORWARD_CLASS(OperatingSystem)
				LLDB_FORWARD_CLASS(OptionGroup)
				LLDB_FORWARD_CLASS(OptionGroupOptions)
				LLDB_FORWARD_CLASS(OptionGroupPlatform)
				LLDB_FORWARD_CLASS(OptionValue)
				LLDB_FORWARD_CLASS(OptionValueArch)
				LLDB_FORWARD_CLASS(OptionValueArgs)
				LLDB_FORWARD_CLASS(OptionValueArray)
				LLDB_FORWARD_CLASS(OptionValueBoolean)
				LLDB_FORWARD_CLASS(OptionValueChar)
				LLDB_FORWARD_CLASS(OptionValueDictionary)
				LLDB_FORWARD_CLASS(OptionValueEnumeration)
				LLDB_FORWARD_CLASS(OptionValueFileSpec)
				LLDB_FORWARD_CLASS(OptionValueFileSpecList)
				LLDB_FORWARD_CLASS(OptionValueFormat)
				LLDB_FORWARD_CLASS(OptionValueFormatEntity)
				LLDB_FORWARD_CLASS(OptionValueLanguage)
				LLDB_FORWARD_CLASS(OptionValuePathMappings)
				LLDB_FORWARD_CLASS(OptionValueProperties)
				LLDB_FORWARD_CLASS(OptionValueRegex)
				LLDB_FORWARD_CLASS(OptionValueSInt64)
				LLDB_FORWARD_CLASS(OptionValueString)
				LLDB_FORWARD_CLASS(OptionValueUInt64)
				LLDB_FORWARD_CLASS(OptionValueUUID)
				LLDB_FORWARD_CLASS(Options)
				LLDB_FORWARD_CLASS(PathMappingList)
				LLDB_FORWARD_CLASS(PersistentExpressionState)
				LLDB_FORWARD_CLASS(Platform)
				LLDB_FORWARD_CLASS(Process)
				LLDB_FORWARD_CLASS(ProcessAttachInfo)
				LLDB_FORWARD_CLASS(ProcessInfo)
				LLDB_FORWARD_CLASS(ProcessInstanceInfo)
				LLDB_FORWARD_CLASS(ProcessInstanceInfoMatch)
				LLDB_FORWARD_CLASS(ProcessLaunchInfo)
				LLDB_FORWARD_CLASS(ProcessModID)
				LLDB_FORWARD_CLASS(Property)
				LLDB_FORWARD_CLASS(Queue)
				LLDB_FORWARD_CLASS(QueueImpl)
				LLDB_FORWARD_CLASS(QueueItem)
				LLDB_FORWARD_CLASS(REPL)
				LLDB_FORWARD_CLASS(RecognizedStackFrame)
				LLDB_FORWARD_CLASS(RegisterCheckpoint)
				LLDB_FORWARD_CLASS(RegisterContext)
				LLDB_FORWARD_CLASS(RegisterValue)
				LLDB_FORWARD_CLASS(RegularExpression)
				LLDB_FORWARD_CLASS(RichManglingContext)
				LLDB_FORWARD_CLASS(Scalar)
				LLDB_FORWARD_CLASS(ScriptInterpreter)
				LLDB_FORWARD_CLASS(ScriptInterpreterLocker)
				LLDB_FORWARD_CLASS(ScriptedProcessInterface)
				LLDB_FORWARD_CLASS(ScriptedThreadInterface)
				LLDB_FORWARD_CLASS(ScriptedSyntheticChildren)
				LLDB_FORWARD_CLASS(SearchFilter)
				LLDB_FORWARD_CLASS(Section)
				LLDB_FORWARD_CLASS(SectionList)
				LLDB_FORWARD_CLASS(SectionLoadHistory)
				LLDB_FORWARD_CLASS(SectionLoadList)
				LLDB_FORWARD_CLASS(Settings)
				LLDB_FORWARD_CLASS(SourceManager)
				LLDB_FORWARD_CLASS(SourceManagerImpl)
				LLDB_FORWARD_CLASS(StackFrame)
				LLDB_FORWARD_CLASS(StackFrameList)
				LLDB_FORWARD_CLASS(StackFrameRecognizer)
				LLDB_FORWARD_CLASS(StackFrameRecognizerManager)
				LLDB_FORWARD_CLASS(StackID)
				LLDB_FORWARD_CLASS(Status)
				LLDB_FORWARD_CLASS(StopInfo)
				LLDB_FORWARD_CLASS(Stoppoint)
				LLDB_FORWARD_CLASS(StoppointCallbackContext)
				LLDB_FORWARD_CLASS(Stream)
				LLDB_FORWARD_CLASS(StreamFile)
				LLDB_FORWARD_CLASS(StreamString)
				LLDB_FORWARD_CLASS(StringList)
				LLDB_FORWARD_CLASS(StringTableReader)
				LLDB_FORWARD_CLASS(StructuredDataImpl)
				LLDB_FORWARD_CLASS(StructuredDataPlugin)
				LLDB_FORWARD_CLASS(Symbol)
				LLDB_FORWARD_CLASS(SymbolContext)
				LLDB_FORWARD_CLASS(SymbolContextList)
				LLDB_FORWARD_CLASS(SymbolContextScope)
				LLDB_FORWARD_CLASS(SymbolContextSpecifier)
				LLDB_FORWARD_CLASS(SymbolFile)
				LLDB_FORWARD_CLASS(SymbolFileType)
				LLDB_FORWARD_CLASS(SymbolVendor)
				LLDB_FORWARD_CLASS(Symtab)
				LLDB_FORWARD_CLASS(SyntheticChildren)
				LLDB_FORWARD_CLASS(SyntheticChildrenFrontEnd)
				LLDB_FORWARD_CLASS(SystemRuntime)
				LLDB_FORWARD_CLASS(Target)
				LLDB_FORWARD_CLASS(TargetList)
				LLDB_FORWARD_CLASS(TargetProperties)
				LLDB_FORWARD_CLASS(Thread)
				LLDB_FORWARD_CLASS(ThreadCollection)
				LLDB_FORWARD_CLASS(ThreadList)
				LLDB_FORWARD_CLASS(ThreadPlan)
				LLDB_FORWARD_CLASS(ThreadPlanBase)
				LLDB_FORWARD_CLASS(ThreadPlanRunToAddress)
				LLDB_FORWARD_CLASS(ThreadPlanStepInstruction)
				LLDB_FORWARD_CLASS(ThreadPlanStepOut)
				LLDB_FORWARD_CLASS(ThreadPlanStepOverBreakpoint)
				LLDB_FORWARD_CLASS(ThreadPlanStepRange)
				LLDB_FORWARD_CLASS(ThreadPlanStepThrough)
				LLDB_FORWARD_CLASS(ThreadPlanTracer)
				LLDB_FORWARD_CLASS(ThreadSpec)
				LLDB_FORWARD_CLASS(ThreadPostMortemTrace)
				LLDB_FORWARD_CLASS(ThreadedCommunication)
				LLDB_FORWARD_CLASS(Trace)
				LLDB_FORWARD_CLASS(TraceCursor)
				LLDB_FORWARD_CLASS(TraceExporter)
				LLDB_FORWARD_CLASS(Type)
				LLDB_FORWARD_CLASS(TypeAndOrName)
				LLDB_FORWARD_CLASS(TypeCategoryImpl)
				LLDB_FORWARD_CLASS(TypeCategoryMap)
				LLDB_FORWARD_CLASS(TypeEnumMemberImpl)
				LLDB_FORWARD_CLASS(TypeEnumMemberListImpl)
				LLDB_FORWARD_CLASS(TypeFilterImpl)
				LLDB_FORWARD_CLASS(TypeFormatImpl)
				LLDB_FORWARD_CLASS(TypeImpl)
				LLDB_FORWARD_CLASS(TypeList)
				LLDB_FORWARD_CLASS(TypeListImpl)
				LLDB_FORWARD_CLASS(TypeMap)
				LLDB_FORWARD_CLASS(TypeMemberFunctionImpl)
				LLDB_FORWARD_CLASS(TypeMemberImpl)
				LLDB_FORWARD_CLASS(TypeNameSpecifierImpl)
				LLDB_FORWARD_CLASS(TypeSummaryImpl)
				LLDB_FORWARD_CLASS(TypeSummaryOptions)
				LLDB_FORWARD_CLASS(TypeSystem)
				LLDB_FORWARD_CLASS(UUID)
				LLDB_FORWARD_CLASS(UnixSignals)
				LLDB_FORWARD_CLASS(Unwind)
				LLDB_FORWARD_CLASS(UnwindAssembly)
				LLDB_FORWARD_CLASS(UnwindPlan)
				LLDB_FORWARD_CLASS(UnwindTable)
				LLDB_FORWARD_CLASS(UserExpression)
				LLDB_FORWARD_CLASS(UtilityFunction)
				LLDB_FORWARD_CLASS(VMRange)
				LLDB_FORWARD_CLASS(Value)
				LLDB_FORWARD_CLASS(ValueList)
				LLDB_FORWARD_CLASS(ValueObject)
				LLDB_FORWARD_CLASS(ValueObjectChild)
				LLDB_FORWARD_CLASS(ValueObjectConstResult)
				LLDB_FORWARD_CLASS(ValueObjectConstResultChild)
				LLDB_FORWARD_CLASS(ValueObjectConstResultImpl)
				LLDB_FORWARD_CLASS(ValueObjectList)
				LLDB_FORWARD_CLASS(ValueObjectPrinter)
				LLDB_FORWARD_CLASS(Variable)
				LLDB_FORWARD_CLASS(VariableList)
				LLDB_FORWARD_CLASS(Watchpoint)
				LLDB_FORWARD_CLASS(WatchpointList)
				LLDB_FORWARD_CLASS(WatchpointOptions)

				#undef LLDB_FORWARD_CLASS

				#ifndef LLDB_FORWARD_STRUCT
				#define LLDB_FORWARD_STRUCT(Name)
				#endif

				LLDB_FORWARD_STRUCT(CacheSignature)
				LLDB_FORWARD_STRUCT(CompilerContext)
				LLDB_FORWARD_STRUCT(LineEntry)
				LLDB_FORWARD_STRUCT(PropertyDefinition)
				LLDB_FORWARD_STRUCT(ScriptSummaryFormat)
				LLDB_FORWARD_STRUCT(StringSummaryFormat)

				#undef LLDB_FORWARD_STRUCT

This is an archive of the discontinued LLVM Phabricator instance.

[lldb] Generate lldb-forward with .def fileAcceptedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 460262

lldb/include/lldb/lldb-forward.h

lldb/include/lldb/lldb-forward.def

[lldb] Generate lldb-forward with .def file
AcceptedPublic