#include "CppInterOp/CppInterOp.h"
#include "Unwrap.h"
#include "Compatibility.h"
#include "Sins.h"
#include "Tracing.h"
#include "clang/AST/Attrs.inc"
#include "clang/AST/CXXInheritance.h"
#include "clang/AST/Comment.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclAccessPair.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/DeclarationName.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/GlobalDecl.h"
#include "clang/AST/Mangle.h"
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/QualTypeNames.h"
#include "clang/AST/RawCommentList.h"
#include "clang/AST/RecordLayout.h"
#include "clang/AST/Stmt.h"
#include "clang/AST/Type.h"
#include "clang/AST/VTableBuilder.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/DiagnosticSema.h"
#include "clang/Basic/LangStandard.h"
#include "clang/Basic/Linkage.h"
#include "clang/Basic/OperatorKinds.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/Specifiers.h"
#include "clang/Basic/Version.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Interpreter/Interpreter.h"
#include "clang/Sema/Lookup.h"
#include "clang/Sema/Overload.h"
#include "clang/Sema/Ownership.h"
#include "clang/Sema/Redeclaration.h"
#include "clang/Sema/Sema.h"
#include "clang/Sema/TemplateDeduction.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Demangle/Demangle.h"
#include "llvm/ExecutionEngine/JITSymbol.h"
#include "llvm/ExecutionEngine/Orc/AbsoluteSymbols.h"
#include "llvm/ExecutionEngine/Orc/Core.h"
#include "llvm/ExecutionEngine/Orc/CoreContainers.h"
#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Process.h"
#include "llvm/Support/Signals.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TargetParser/Host.h"
#include "llvm/TargetParser/Triple.h"
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/types.h>
#include <unistd.h>
#include <utility>
#include <dlfcn.h>
#include <vector>
#include "CppInterOp/BuildInfo.inc"
#include "clang/Basic/OperatorKinds.def"

Classes
struct	__clang_Interpreter_NewTag

struct	Cpp::InterpreterInfo

struct	Cpp::InterpreterShutdown
	RAII guard whose dtor calls llvm_shutdown for the owned-interpreter case. More...

struct	Cpp::CurScope__LINE__< Only, Member >

struct	Cpp::Only_CurScope< clang::Sema >

struct	Cpp::VTableOverlay

struct	Cpp::Types__LINE__< Only, Member >

struct	Cpp::Only_Types< ASTContext >

class	Cpp::StreamCaptureInfo

Namespaces
namespace	Cpp

Macros
#define	CPPINTEROP_MSAN_UNPOISON_VALUE(v) ((void)0)

#define	DEBUG_TYPE "jitcall"

#define	DEBUG_TYPE "jitcall"

#define	DEBUG_TYPE "exec"

#define	X(TyRef, name)

#define	DEBUG_TYPE "orc"

#define	OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly)

#define	OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly)

Functions
void *	__clang_Interpreter_SetValueWithAlloc (void This, void OutVal, void *OpaqueType)

void	__clang_Interpreter_SetValueNoAlloc (void This, void OutVal, void *OpaqueType,...)

static void	Cpp::DefaultProcessCrashHandler (void *)

static std::deque< InterpreterInfo > &	Cpp::GetInterpreters (bool SetCrashHandler=true)

static void	Cpp::RegisterInterpreter (compat::Interpreter *I, bool Owned)

static InterpreterInfo &	Cpp::getInterpInfo (compat::Interpreter *I=nullptr)

static compat::Interpreter &	Cpp::getInterp (InterpRef I=nullptr)

InterpRef	Cpp::GetInterpreter ()

void	Cpp::UseExternalInterpreter (InterpRef I)

bool	Cpp::ActivateInterpreter (InterpRef I)

bool	Cpp::DeleteInterpreter (InterpRef I)

static clang::Sema &	Cpp::getSema ()

static clang::ASTContext &	Cpp::getASTContext ()

static void	Cpp::ForceCodeGen (Decl *D, compat::Interpreter &I)

void	Cpp::CppInterOpTraceJitCallInvokeImpl (const JitCall JC, void result, void *args, std::size_t nargs, void self)

void	Cpp::CppInterOpTraceJitCallInvokeDestructorImpl (const JitCall JC, void object, unsigned long nary, int withFree)

void	Cpp::CppInterOpTraceJitCallInvokeReturnImpl (const JitCall JC, void result)

std::string	Cpp::GetVersion ()

std::string	Cpp::GetBuildInfo ()

std::string	Cpp::Demangle (const std::string &mangled_name)

void	Cpp::EnableDebugOutput (bool value)

bool	Cpp::IsDebugOutputEnabled ()

static void	Cpp::InstantiateFunctionDefinition (Decl *D)

bool	Cpp::IsAggregate (ConstDeclRef DRef)

bool	Cpp::IsNamespace (ConstDeclRef DRef)

bool	Cpp::IsClass (ConstDeclRef DRef)

bool	Cpp::IsFunction (ConstDeclRef DRef)

bool	Cpp::IsFunctionPointerType (ConstTypeRef TyRef)

bool	Cpp::IsClassPolymorphic (ConstDeclRef DRef)

static SourceLocation	Cpp::GetValidSLoc (Sema &semaRef)

bool	Cpp::IsComplete (ConstDeclRef DRef)

size_t	Cpp::SizeOf (ConstDeclRef DRef)

bool	Cpp::IsBuiltin (ConstTypeRef TyRef)

bool	Cpp::IsTemplate (ConstDeclRef DRef)

bool	Cpp::IsTemplateSpecialization (ConstDeclRef DRef)

bool	Cpp::IsTypedefed (ConstDeclRef DRef)

bool	Cpp::IsAbstract (ConstDeclRef DRef)

bool	Cpp::IsEnumScope (ConstDeclRef DRef)

bool	Cpp::IsEnumConstant (ConstDeclRef DRef)

bool	Cpp::IsEnumType (ConstTypeRef TyRef)

static bool	Cpp::isSmartPointer (const RecordType *RT)

bool	Cpp::IsSmartPtrType (ConstTypeRef TyRef)

TypeRef	Cpp::GetIntegerTypeFromEnumScope (ConstDeclRef DRef)

TypeRef	Cpp::GetIntegerTypeFromEnumType (ConstTypeRef enum_type)

std::vector< DeclRef >	Cpp::GetEnumConstants (ConstDeclRef DRef)

TypeRef	Cpp::GetEnumConstantType (ConstDeclRef DRef)

size_t	Cpp::GetEnumConstantValue (ConstDeclRef DRef)

size_t	Cpp::GetSizeOfType (ConstTypeRef TyRef)

bool	Cpp::IsVariable (ConstDeclRef DRef)

std::string	Cpp::GetName (ConstDeclRef DRef)

static std::string	Cpp::GetCompleteNameImpl (ConstDeclRef DRef, bool qualified)

std::string	Cpp::GetCompleteName (ConstDeclRef DRef)

std::string	Cpp::GetQualifiedName (ConstDeclRef DRef)

std::string	Cpp::GetQualifiedCompleteName (ConstDeclRef DRef)

std::string	Cpp::GetDoxygenComment (ConstDeclRef DRef, bool strip_comment_markers)

std::vector< DeclRef >	Cpp::GetUsingNamespaces (ConstDeclRef DRef)

DeclRef	Cpp::GetGlobalScope ()

static Decl *	Cpp::GetScopeFromType (QualType QT)

DeclRef	Cpp::GetScopeFromType (ConstTypeRef TyRef)

static const clang::Decl *	Cpp::GetUnderlyingScopeImpl (const clang::Decl *D)

DeclRef	Cpp::GetUnderlyingScope (ConstDeclRef DRef)

DeclRef	Cpp::GetScope (const std::string &name, ConstDeclRef parent)

DeclRef	Cpp::GetScopeFromCompleteName (const std::string &name)

DeclRef	Cpp::GetNamed (const std::string &name, ConstDeclRef parent)

DeclRef	Cpp::GetParentScope (ConstDeclRef DRef)

size_t	Cpp::GetNumBases (ConstDeclRef DRef)

DeclRef	Cpp::GetBaseClass (ConstDeclRef DRef, size_t ibase)

bool	Cpp::IsSubclass (ConstDeclRef derived, ConstDeclRef base)

static unsigned	Cpp::ComputeBaseOffset (const ASTContext &Context, const CXXRecordDecl *DerivedRD, const CXXBasePath &Path)

int64_t	Cpp::GetBaseClassOffset (ConstDeclRef derived, ConstDeclRef base)

template<typename DeclType , typename HandleType >
static void	Cpp::GetClassDecls (ConstDeclRef DRef, std::vector< HandleType > &methods)

void	Cpp::GetClassMethods (ConstDeclRef DRef, std::vector< FuncRef > &methods)

void	Cpp::GetFunctionTemplatedDecls (ConstDeclRef DRef, std::vector< FuncRef > &methods)

bool	Cpp::HasDefaultConstructor (ConstDeclRef DRef)

FuncRef	Cpp::GetDefaultConstructor (compat::Interpreter &interp, DeclRef DRef)

FuncRef	Cpp::GetDefaultConstructor (DeclRef DRef)

FuncRef	Cpp::GetDestructor (ConstDeclRef DRef)

void	Cpp::DumpScope (ConstDeclRef DRef)

std::vector< FuncRef >	Cpp::GetFunctionsUsingName (ConstDeclRef DRef, const std::string &name)

TypeRef	Cpp::GetFunctionReturnType (ConstFuncRef func)

bool	Cpp::IsFunctionProtoType (ConstTypeRef TyRef)

void	Cpp::GetFnTypeSignature (ConstTypeRef fn_type, std::vector< TypeRef > &sig)

size_t	Cpp::GetFunctionNumArgs (ConstFuncRef func)

size_t	Cpp::GetFunctionRequiredArgs (ConstFuncRef func)

TypeRef	Cpp::GetFunctionArgType (ConstFuncRef func, size_t iarg)

bool	Cpp::IsTemplateParmType (ConstTypeRef TyRef)

std::string	Cpp::GetFunctionSignature (ConstFuncRef func)

bool	Cpp::IsFunctionDeleted (ConstFuncRef function)

bool	Cpp::IsTemplatedFunction (ConstFuncRef func)

bool	Cpp::ExistsFunctionTemplate (const std::string &name, ConstDeclRef parent)

void	Cpp::LookupConstructors (const std::string &name, ConstDeclRef parent, std::vector< FuncRef > &funcs)

bool	Cpp::GetClassTemplatedMethods (const std::string &name, ConstDeclRef parent, std::vector< FuncRef > &funcs)

FuncRef	Cpp::BestOverloadFunctionMatch (const std::vector< FuncRef > &candidates, const std::vector< TemplateArgInfo > &explicit_types, const std::vector< TemplateArgInfo > &arg_types)

bool	Cpp::CheckMethodAccess (ConstFuncRef method, AccessSpecifier AS)

bool	Cpp::IsMethod (ConstFuncRef method)

bool	Cpp::IsPublicMethod (ConstFuncRef method)

bool	Cpp::IsProtectedMethod (ConstFuncRef method)

bool	Cpp::IsPrivateMethod (ConstFuncRef method)

bool	Cpp::IsConstructor (ConstFuncRef method)

bool	Cpp::IsDestructor (ConstFuncRef method)

bool	Cpp::IsStaticMethod (ConstFuncRef method)

bool	Cpp::IsExplicit (ConstFuncRef method)

void *	Cpp::GetFunctionAddress (const char *mangled_name)

static void *	Cpp::GetFunctionAddress (const FunctionDecl *FD)

void *	Cpp::GetFunctionAddress (FuncRef method)

bool	Cpp::IsVirtualMethod (ConstFuncRef method)

static int	Cpp::virtualMethodSlot (ConstFuncRef method)

static int	Cpp::vtableMethodSlotCount (ConstDeclRef DRef)

static bool	Cpp::hasComplexVTableLayout (const CXXRecordDecl *RD)

void	Cpp::cppinteropVTableOverlayDtorWrapper (void *self)

static VTableOverlay *	Cpp::applyVTableOverlay (void inst, int total_method_slots, const int slots, void const fns, std::size_t n, std::size_t n_extra_prefix_slots)

VTableOverlay *	Cpp::MakeVTableOverlay (void inst, ConstDeclRef base, const ConstFuncRef methods, void const overlay_fns, std::size_t n_overlays, std::size_t n_extra_prefix_slots, VTableOverlayDtorHook on_destroy, void *cleanup_data)

void	Cpp::DestroyVTableOverlay (VTableOverlay *overlay)

void	Cpp::GetDatamembers (DeclRef DRef, std::vector< DeclRef > &datamembers)

void	Cpp::GetStaticDatamembers (ConstDeclRef DRef, std::vector< DeclRef > &datamembers)

void	Cpp::GetEnumConstantDatamembers (ConstDeclRef DRef, std::vector< DeclRef > &datamembers, bool include_enum_class)

DeclRef	Cpp::LookupDatamember (const std::string &name, ConstDeclRef parent)

bool	Cpp::IsLambdaClass (ConstTypeRef TyRef)

TypeRef	Cpp::GetVariableType (ConstDeclRef var)

intptr_t	Cpp::GetVariableOffset (compat::Interpreter &I, Decl D, CXXRecordDecl BaseCXXRD)

intptr_t	Cpp::GetVariableOffset (ConstDeclRef var, ConstDeclRef parent)

bool	Cpp::CheckVariableAccess (ConstDeclRef var, AccessSpecifier AS)

bool	Cpp::IsPublicVariable (ConstDeclRef var)

bool	Cpp::IsProtectedVariable (ConstDeclRef var)

bool	Cpp::IsPrivateVariable (ConstDeclRef var)

bool	Cpp::IsStaticVariable (ConstDeclRef var)

bool	Cpp::IsConstVariable (ConstDeclRef var)

bool	Cpp::IsRecordType (ConstTypeRef TyRef)

bool	Cpp::IsPODType (ConstTypeRef TyRef)

bool	Cpp::IsIntegerType (ConstTypeRef TyRef, Signedness *s)

bool	Cpp::IsFloatingType (ConstTypeRef TyRef)

bool	Cpp::IsSameType (ConstTypeRef type_a, ConstTypeRef type_b)

bool	Cpp::IsPointerType (ConstTypeRef TyRef)

bool	Cpp::IsVoidPointerType (ConstTypeRef TyRef)

TypeRef	Cpp::GetPointeeType (ConstTypeRef TyRef)

bool	Cpp::IsReferenceType (ConstTypeRef TyRef)

ValueKind	Cpp::GetValueKind (ConstTypeRef TyRef)

TypeRef	Cpp::GetPointerType (ConstTypeRef TyRef)

TypeRef	Cpp::GetReferencedType (ConstTypeRef TyRef, bool rvalue)

TypeRef	Cpp::GetNonReferenceType (ConstTypeRef TyRef)

TypeRef	Cpp::GetUnderlyingType (ConstTypeRef TyRef)

std::string	Cpp::GetTypeAsString (ConstTypeRef var)

TypeRef	Cpp::GetCanonicalType (ConstTypeRef TyRef)

bool	Cpp::HasTypeQualifier (ConstTypeRef TyRef, QualKind qual)

TypeRef	Cpp::RemoveTypeQualifier (ConstTypeRef TyRef, QualKind qual)

TypeRef	Cpp::AddTypeQualifier (ConstTypeRef TyRef, QualKind qual)

static void	Cpp::RegisterPerms (llvm::StringMap< QualType > &Map, QualType QT, llvm::SmallVectorImpl< llvm::StringRef > &Words)

static void	Cpp::PopulateBuiltinMap (ASTContext &Context)

static QualType	Cpp::findBuiltinType (llvm::StringRef typeName, ASTContext &Context)

static std::optional< QualType >	Cpp::GetTypeInternal (const Decl *D)

TypeRef	Cpp::GetType (const std::string &name, ConstDeclRef parent)

TypeRef	Cpp::GetComplexType (ConstTypeRef TyRef)

TypeRef	Cpp::GetTypeFromScope (ConstDeclRef DRef)

JitCall	Cpp::MakeFunctionCallable (InterpRef I, ConstFuncRef func)

JitCall	Cpp::MakeFunctionCallable (ConstFuncRef func)

InterpRef	Cpp::CreateInterpreter (const std::vector< const char * > &Args, const std::vector< const char * > &GpuArgs)

InterpreterLanguage	Cpp::GetLanguage (InterpRef I)

InterpreterLanguageStandard	Cpp::GetLanguageStandard (InterpRef I)

void	Cpp::AddSearchPath (const char *dir, bool isUser, bool prepend)

const char *	Cpp::GetResourceDir ()

static bool	Cpp::exec (const char *cmd, std::vector< std::string > &outputs)

std::string	Cpp::DetectResourceDir (const char *ClangBinaryName)

void	Cpp::DetectSystemCompilerIncludePaths (std::vector< std::string > &Paths, const char *CompilerName)

void	Cpp::AddIncludePath (const char *dir)

void	Cpp::GetIncludePaths (std::vector< std::string > &IncludePaths, bool withSystem, bool withFlags)

int	Cpp::Declare (compat::Interpreter &I, const char *code, bool silent)

int	Cpp::Declare (const char *code, bool silent)

int	Cpp::Process (const char *code)

static Cpp::Box::Kind	Cpp::classifyByQualType (clang::QualType QT)

Box	Cpp::Evaluate (const char *code)

std::string	Cpp::LookupLibrary (const char *lib_name)

bool	Cpp::LoadLibrary (const char *lib_stem, bool lookup)

void	Cpp::UnloadLibrary (const char *lib_stem)

std::string	Cpp::SearchLibrariesForSymbol (const char *mangled_name, bool search_system)

bool	Cpp::InsertOrReplaceJitSymbol (compat::Interpreter &I, const char *linker_mangled_name, uint64_t address)

bool	Cpp::InsertOrReplaceJitSymbol (const char *linker_mangled_name, uint64_t address)

std::string	Cpp::ObjToString (const char TyRef, void obj)

static Decl *	Cpp::InstantiateTemplate (TemplateDecl *TemplateD, TemplateArgumentListInfo &TLI, Sema &S, bool instantiate_body)

Decl *	Cpp::InstantiateTemplate (TemplateDecl *TemplateD, ArrayRef< TemplateArgument > TemplateArgs, Sema &S, bool instantiate_body)

DeclRef	Cpp::InstantiateTemplate (compat::Interpreter &I, DeclRef tmpl, const TemplateArgInfo *template_args, size_t template_args_size, bool instantiate_body)

DeclRef	Cpp::InstantiateTemplate (DeclRef tmpl, const TemplateArgInfo *template_args, size_t template_args_size, bool instantiate_body)

DeclRef	Cpp::InstantiateTemplate (DeclRef tmpl, const std::vector< TemplateArgInfo > &template_args, bool instantiate_body)

void	Cpp::GetClassTemplateArgs (ConstDeclRef templ_instance, std::vector< TemplateArgInfo > &args)

void	Cpp::GetClassTemplateInstantiationArgs (ConstDeclRef templ_instance, std::vector< TemplateArgInfo > &args)

FuncRef	Cpp::InstantiateTemplateFunctionFromString (const char *function_template)

void	Cpp::GetAllCppNames (ConstDeclRef DRef, std::set< std::string > &names)

void	Cpp::GetEnums (ConstDeclRef DRef, std::vector< std::string > &Result)

std::vector< long int >	Cpp::GetDimensions (ConstTypeRef TyRef)

bool	Cpp::IsTypeDerivedFrom (ConstTypeRef derived, ConstTypeRef base)

std::string	Cpp::GetFunctionArgDefault (ConstFuncRef func, size_t param_index)

bool	Cpp::IsConstMethod (ConstFuncRef method)

std::string	Cpp::GetFunctionArgName (ConstFuncRef func, size_t param_index)

std::string	Cpp::GetSpellingFromOperator (Operator Operator)

Operator	Cpp::GetOperatorFromSpelling (const std::string &op)

OperatorArity	Cpp::GetOperatorArity (ConstFuncRef op)

void	Cpp::GetOperator (ConstDeclRef DRef, Operator op, std::vector< FuncRef > &operators, OperatorArity kind)

ObjectRef	Cpp::Allocate (DeclRef DRef, size_t count)

void	Cpp::Deallocate (DeclRef DRef, ObjectRef address, size_t count)

ObjectRef	Cpp::Construct (compat::Interpreter &interp, DeclRef DRef, void *arena, size_t count)

ObjectRef	Cpp::Construct (DeclRef DRef, void *arena, size_t count)

bool	Cpp::Destruct (compat::Interpreter &interp, ObjectRef This, const Decl *Class, bool withFree, size_t nary)

bool	Cpp::Destruct (ObjectRef This, DeclRef DRef, bool withFree, size_t count)

static std::stack< StreamCaptureInfo > &	Cpp::GetRedirectionStack ()

void	Cpp::BeginStdStreamCapture (CaptureStreamKind fd_kind)

std::string	Cpp::EndStdStreamCapture ()

void	Cpp::CodeComplete (std::vector< std::string > &Results, const char *code, unsigned complete_line, unsigned complete_column)

int	Cpp::Undo (unsigned N)

Variables
struct __clang_Interpreter_NewTag	__ci_newtag

static bool	Cpp::SkipShutDown = false
	Set by UseExternalInterpreter to suppress llvm_shutdown at process exit – the client owns LLVM in that case.

constexpr int	Cpp::kABIPrefixSize = 2

constexpr int	Cpp::kMinVTableMethodSlots = 2

constexpr int	Cpp::kDeletingDtorSlot = 1

Macro Definition Documentation

◆ CPPINTEROP_MSAN_UNPOISON_VALUE

#define CPPINTEROP_MSAN_UNPOISON_VALUE ( v ) ((void)0)

Definition at line 30 of file CppInterOp.cpp.

◆ DEBUG_TYPE [1/4]

#define DEBUG_TYPE "jitcall"

Definition at line 432 of file CppInterOp.cpp.

◆ DEBUG_TYPE [2/4]

#define DEBUG_TYPE "jitcall"

Definition at line 432 of file CppInterOp.cpp.

◆ DEBUG_TYPE [3/4]

#define DEBUG_TYPE "exec"

Definition at line 432 of file CppInterOp.cpp.

◆ DEBUG_TYPE [4/4]

#define DEBUG_TYPE "orc"

Definition at line 432 of file CppInterOp.cpp.

◆ OVERLOADED_OPERATOR [1/2]

#define OVERLOADED_OPERATOR	(	Name,
		Spelling,
		Token,
		Unary,
		Binary,
		MemberOnly
	)

Value:

  if ((Spelling) == op) {                                                      \
    return INTEROP_RETURN((Operator)OO_##Name);                                \
  }

◆ OVERLOADED_OPERATOR [2/2]

#define OVERLOADED_OPERATOR	(	Name,
		Spelling,
		Token,
		Unary,
		Binary,
		MemberOnly
	)

Value:

  case OO_##Name:                                                              \
    if ((Unary) && (Binary))                                                   \
      return INTEROP_RETURN(kBoth);                                            \
    if (Unary)                                                                 \
      return INTEROP_RETURN(kUnary);                                           \
    if (Binary)                                                                \
      return INTEROP_RETURN(kBinary);                                          \
    break;

◆ X

#define X	(	TyRef,
		name
	)

Value:

  case Cpp::Box::K_##name:                                                     \
    return INTEROP_RETURN(                                                     \
        Cpp::Box::Create<TyRef>(compat::convertTo<TyRef>(V), qt));

Function Documentation

◆ __clang_Interpreter_SetValueNoAlloc()

void __clang_Interpreter_SetValueNoAlloc	(	void *	This,
		void *	OutVal,
		void *	OpaqueType,
			...
	)

Referenced by Cpp::CreateInterpreter().

◆ __clang_Interpreter_SetValueWithAlloc()

void * __clang_Interpreter_SetValueWithAlloc	(	void *	This,
		void *	OutVal,
		void *	OpaqueType
	)

Referenced by Cpp::CreateInterpreter().

Variable Documentation

◆ __ci_newtag

struct __clang_Interpreter_NewTag __ci_newtag

Referenced by Cpp::CreateInterpreter().

◆ fDiagEngine

clang::DiagnosticsEngine& fDiagEngine

protected

Definition at line 4673 of file CppInterOp.cpp.

◆ fOldDiagValue

bool fOldDiagValue

protected

Definition at line 4674 of file CppInterOp.cpp.

Classes

Namespaces

Macros

Functions

Variables

Macro Definition Documentation

◆ CPPINTEROP_MSAN_UNPOISON_VALUE

◆ DEBUG_TYPE [1/4]

◆ DEBUG_TYPE [2/4]

◆ DEBUG_TYPE [3/4]

◆ DEBUG_TYPE [4/4]

◆ OVERLOADED_OPERATOR [1/2]

◆ OVERLOADED_OPERATOR [2/2]

◆ X

Function Documentation

◆ __clang_Interpreter_SetValueNoAlloc()

◆ __clang_Interpreter_SetValueWithAlloc()

Variable Documentation

◆ __ci_newtag

◆ fDiagEngine

◆ fOldDiagValue