InterpreterValuePrinter.cpp Source File (original) (raw)

25#include "llvm/Support/Error.h"

26#include "llvm/Support/raw_ostream.h"

28#include

29#include

30#include

31#include

32#include

34#define DEBUG_TYPE "interp-value"

36using namespace clang;

39 std::string Str;

40 llvm::raw_string_ostream SS(Str);

44 return Str;

45}

55 struct LocalPrintingPolicyRAII {

61 Context.setPrintingPolicy(PP);

62 }

63 ~LocalPrintingPolicyRAII() { Context.setPrintingPolicy(Policy); }

64 } X(Ctx, Policy);

68 if (const auto *TTy = llvm::dyn_cast(NonRefTy))

71 if (const auto *TRy = dyn_cast(NonRefTy))

81 if (const auto *TDTy = dyn_cast(NonRefTy)) {

90 if (llvm::isa(SSDesugar))

92 else if (llvm::isa(SSDesugar))

95 }

97}

100 std::string Str;

101 llvm::raw_string_ostream SS(Str);

103

104 uint64_t Data = V.convertTo<uint64_t>();

107

108 auto *ED = V.getType()->castAsEnumDecl();

109 for (auto I = ED->enumerator_begin(), E = ED->enumerator_end(); I != E; ++I) {

110 if (I->getInitVal() == AP) {

112 SS << " ? ";

113 SS << "(" + I->getQualifiedNameAsString() << ")";

115 }

116 }

118 AP.toString(APStr, 10);

119 SS << " : " << QualTypeToString(Ctx, ED->getIntegerType()) << " " << APStr;

120 return Str;

121}

122

124 std::string Str;

125 llvm::raw_string_ostream SS(Str);

126 SS << "Function @" << Ptr;

127

128 const DeclContext *PTU = V.getASTContext().getTranslationUnitDecl();

129

130

135

136

137

139 if (auto *InterfaceCall = llvm::dyn_cast(TLSD->getStmt())) {

140 const auto *Arg = InterfaceCall->getArg( 3);

141

142 while (const CastExpr *CastE = llvm::dyn_cast(Arg))

143 Arg = CastE->getSubExpr();

144 if (const DeclRefExpr *DeclRefExp = llvm::dyn_cast(Arg))

145 FD = llvm::dyn_cast(DeclRefExp->getDecl());

146

147 if (FD) {

148 SS << '\n';

152 }

153 }

154 return Str;

155}

156

158 std::string Str;

159 llvm::raw_string_ostream SS(Str);

160 SS << Ptr;

161 return Str;

162}

163

165 if (!Ptr)

166 return "0";

167

168 std::string Result = "\"";

169 Result += Ptr;

170 Result += '"';

171 return Result;

172}

173

175

182

183std::string Interpreter::ValueDataToString(const Value &V) const {

186

188

190 QualType ElemTy = CAT->getElementType();

194

195

197 char last = *(char *)(((uintptr_t)V.getPtr()) + ElemCount * ElemSize - 1);

198 if (last == '\0')

200 }

201

202 std::string Result = "{ ";

203 for (unsigned Idx = 0, N = CAT->getZExtSize(); Idx < N; ++Idx) {

204 ValueRef InnerV = ValueRef(this, ElemTy.getAsOpaquePtr());

206

208 InnerV.setRawBits((void *)Offset, ElemSize * 8);

209 } else {

210

211 size_t Stride = ElemCount / N;

213 InnerV.setPtr((void *)Offset);

214 }

215

216 Result += ValueDataToString(InnerV);

217

218

219 if (Idx < N - 1)

221 }

224 }

225

228

229

230

231

232

233

234

236

237 auto formatFloating = [](auto Val, char Suffix = '\0') -> std::string {

238 std::string Out;

239 llvm::raw_string_ostream SS(Out);

240

242 SS << llvm::format("%g", Val);

243 return SS.str();

244 }

245 if (Val == static_cast<decltype(Val)>(static_cast<int64_t>(Val)))

246 SS << llvm::format("%.1f", Val);

247 else if (std::abs(Val) < 1e-4 || std::abs(Val) > 1e6 || Suffix == 'f')

248 SS << llvm::format("%#.6g", Val);

249 else if (Suffix == 'L')

250 SS << llvm::format("%#.12Lg", Val);

251 else

252 SS << llvm::format("%#.8g", Val);

253

254 if (Suffix != '\0')

255 SS << Suffix;

256 return SS.str();

257 };

258

259 std::string Str;

260 llvm::raw_string_ostream SS(Str);

261 switch (BT->getKind()) {

262 default:

263 return "{ error: unknown builtin type '" + std::to_string(BT->getKind()) +

264 " '}";

265 case clang::BuiltinType::Bool:

266 SS << ((V.getBool()) ? "true" : "false");

267 return Str;

268 case clang::BuiltinType::Char_S:

269 SS << '\'' << V.getChar_S() << '\'';

270 return Str;

271 case clang::BuiltinType::SChar:

272 SS << '\'' << V.getSChar() << '\'';

273 return Str;

274 case clang::BuiltinType::Char_U:

275 SS << '\'' << V.getChar_U() << '\'';

276 return Str;

277 case clang::BuiltinType::UChar:

278 SS << '\'' << V.getUChar() << '\'';

279 return Str;

280 case clang::BuiltinType::Short:

281 SS << V.getShort();

282 return Str;

283 case clang::BuiltinType::UShort:

284 SS << V.getUShort();

285 return Str;

286 case clang::BuiltinType::Int:

287 SS << V.getInt();

288 return Str;

289 case clang::BuiltinType::UInt:

290 SS << V.getUInt();

291 return Str;

292 case clang::BuiltinType::Long:

293 SS << V.getLong();

294 return Str;

295 case clang::BuiltinType::ULong:

296 SS << V.getULong();

297 return Str;

298 case clang::BuiltinType::LongLong:

299 SS << V.getLongLong();

300 return Str;

301 case clang::BuiltinType::ULongLong:

302 SS << V.getULongLong();

303 return Str;

304 case clang::BuiltinType::Float:

305 return formatFloating(V.getFloat(), 'f');

306

307 case clang::BuiltinType::Double:

308 return formatFloating(V.getDouble());

309

310 case clang::BuiltinType::LongDouble:

311 return formatFloating(V.getLongDouble(), 'L');

312 }

313 }

314

318

321

324

326 return "nullptr\n";

327

328

332

334 }

335

336

338}

339

340std::string Interpreter::ValueTypeToString(const Value &V) const {

341 ASTContext &Ctx = const_cast<ASTContext &>(V.getASTContext());

342 QualType QT = V.getType();

343

345

347 QTStr += " &";

348

349 return QTStr;

350}

351

353Interpreter::CompileDtorCall(CXXRecordDecl *CXXRD) const {

354 assert(CXXRD && "Cannot compile a destructor for a nullptr");

355 if (auto Dtor = Dtors.find(CXXRD); Dtor != Dtors.end())

356 return Dtor->getSecond();

357

359 return llvm::orc::ExecutorAddr{};

360

361 CXXDestructorDecl *DtorRD =

363

364 llvm::StringRef Name =

365 Act->getCodeGen()->GetMangledName(GlobalDecl(DtorRD, Dtor_Base));

367 if (!AddrOrErr)

368 return AddrOrErr.takeError();

369

370 Dtors[CXXRD] = *AddrOrErr;

371 return AddrOrErr;

372}

373

375

377 : public TypeVisitor<InterfaceKindVisitor, InterfaceKind> {

378

382

383public:

385 : S(S), E(E), Args(Args) {}

386

390

394

398

402

404 HandlePtrType(Ty);

406 }

407

409 HandlePtrType(Ty);

411 }

412

415 E->IgnoreImpCasts());

416 assert(!AddrOfE.isInvalid() && "Can not create unary expression");

417 Args.push_back(AddrOfE.get());

419 }

420

423 Args.push_back(E);

425 Args.push_back(E);

427 HandleIntegralOrEnumType(Ty);

429

430 }

431

433 }

434

436 HandleIntegralOrEnumType(Ty);

438 }

439

440private:

441

442

443 void HandleIntegralOrEnumType(const Type *Ty) {

450 assert(!CastedExpr.isInvalid() && "Cannot create cstyle cast expr");

451 Args.push_back(CastedExpr.get());

452 }

453

454 void HandlePtrType(const Type *Ty) {

459 assert(!CastedExpr.isInvalid() && "Can not create cstyle cast expression");

460 Args.push_back(CastedExpr.get());

461 }

462};

463

464static constexpr llvm::StringRef VPName[] = {

465 "__clang_Interpreter_SetValueNoAlloc",

466 "__clang_Interpreter_SetValueWithAlloc",

467 "__clang_Interpreter_SetValueCopyArr", "__ci_newtag"};

468

469

470

471

472

473

474

475

476

477

478

479

480

481

485

486

487 if (!ValuePrintingInfo[0]) {

488 assert(llvm::all_of(ValuePrintingInfo, [](Expr *E) { return !E; }));

489

490 auto LookupInterface = [&](Expr *&Interface,

491 llvm::StringRef Name) -> llvm::Error {

492 LookupResult R(S, &Ctx.Idents.get(Name), SourceLocation(),

496 if (R.empty())

497 return llvm::make_errorllvm::StringError(

498 Name + " not found!", llvm::inconvertibleErrorCode());

499

500 CXXScopeSpec CSS;

502 return llvm::Error::success();

503 };

504 if (llvm::Error Err =

506 return std::move(Err);

507

508 if (llvm::Error Err =

510 return std::move(Err);

511

512 if (llvm::Error Err =

514 return std::move(Err);

515

517 if (llvm::Error Err =

519 return std::move(Err);

520 }

521 }

522

523 llvm::SmallVector<Expr *, 4> AdjustedArgs;

524

526

527

528 AdjustedArgs.push_back(

530

531

532

533

534 if (auto *EWC = llvm::dyn_cast_if_present(E))

535 E = EWC->getSubExpr();

536

539

540

544 }

545

546 Expr *TypeArg =

548

549 AdjustedArgs.push_back(TypeArg);

550

551

552

553 InterfaceKindVisitor V(S, E, AdjustedArgs);

554 Scope *Scope = nullptr;

557 switch (Kind) {

559 [[fallthrough]];

561

566 return llvm::make_errorllvm::StringError(

568 llvm::inconvertibleErrorCode());

569

571

572

575 Dtor->addAttr(UsedAttr::CreateImplicit(Ctx));

577 DeclGroupRef(Dtor));

578 }

579

580

584

588

590 Expr *Args[] = {E, AllocCall.get(), ArrSizeExpr};

591 SetValueE =

593 SourceLocation(), Args, SourceLocation());

595 return llvm::make_errorllvm::StringError(

597 llvm::inconvertibleErrorCode());

598 break;

599 }

603 true, SourceLocation(), Args,

604 SourceLocation(),

605 SourceRange(), TSI->getType(), TSI, std::nullopt,

607

609 return llvm::make_errorllvm::StringError(

610 "Cannot build a call to placement new",

611 llvm::inconvertibleErrorCode());

612

614 false);

615 break;

616 }

617

619 SetValueE =

622 break;

623 }

624 default:

625 llvm_unreachable("Unhandled InterfaceKind");

626 }

627

628

630 return E;

631

632 return SetValueE.get();

633}

634

635}

636

637using namespace clang;

638

639

640extern "C" {

643 void *OpaqueType) {

646 return VRef.getPtr();

647}

648

651 ...) {

654 VRef = Value(I, OpaqueType);

656 return;

657

659 va_start(args, OpaqueType);

660

664 } else {

666 QT = ED->getIntegerType();

668 default:

669 llvm_unreachable("unknown type kind!");

670 break;

671

672 case BuiltinType::Bool:

673 VRef.setBool(va_arg(args, int));

674 break;

675 case BuiltinType::Char_S:

676 VRef.setChar_S(va_arg(args, int));

677 break;

678 case BuiltinType::SChar:

679 VRef.setSChar(va_arg(args, int));

680 break;

681 case BuiltinType::Char_U:

682 VRef.setChar_U(va_arg(args, unsigned));

683 break;

684 case BuiltinType::UChar:

685 VRef.setUChar(va_arg(args, unsigned));

686 break;

687 case BuiltinType::Short:

688 VRef.setShort(va_arg(args, int));

689 break;

690 case BuiltinType::UShort:

691 VRef.setUShort(va_arg(args, unsigned));

692 break;

693 case BuiltinType::Int:

694 VRef.setInt(va_arg(args, int));

695 break;

696 case BuiltinType::UInt:

697 VRef.setUInt(va_arg(args, unsigned));

698 break;

699 case BuiltinType::Long:

700 VRef.setLong(va_arg(args, long));

701 break;

702 case BuiltinType::ULong:

703 VRef.setULong(va_arg(args, unsigned long));

704 break;

705 case BuiltinType::LongLong:

706 VRef.setLongLong(va_arg(args, long long));

707 break;

708 case BuiltinType::ULongLong:

709 VRef.setULongLong(va_arg(args, unsigned long long));

710 break;

711

712 case BuiltinType::Float:

713 VRef.setFloat(va_arg(args, double));

714 break;

715 case BuiltinType::Double:

716 VRef.setDouble(va_arg(args, double));

717 break;

718 case BuiltinType::LongDouble:

719 VRef.setLongDouble(va_arg(args, long double));

720 break;

721

722 }

723 }

725}

726}

727

728

729

730

731

732

736

737 return operator new(__sz, __p);

738}

Defines the clang::ASTContext interface.

unsigned IsFirst

Indicates that this is the first token of the file.

static std::string EnumToString(const Value &V)

Definition InterpreterValuePrinter.cpp:99

static std::string QualTypeToString(ASTContext &Ctx, QualType QT)

Definition InterpreterValuePrinter.cpp:47

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

Definition InterpreterValuePrinter.cpp:642

static std::string FunctionToString(const Value &V, const void *Ptr)

Definition InterpreterValuePrinter.cpp:123

static std::string VoidPtrToString(const void *Ptr)

Definition InterpreterValuePrinter.cpp:157

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

Definition InterpreterValuePrinter.cpp:650

static std::string DeclTypeToString(const QualType &QT, NamedDecl *D)

Definition InterpreterValuePrinter.cpp:38

static std::string CharPtrToString(const char *Ptr)

Definition InterpreterValuePrinter.cpp:164

#define REPL_EXTERNAL_VISIBILITY

Defines the clang::Preprocessor interface.

@ ForVisibleRedeclaration

The lookup results will be used for redeclaration of a name, if an entity by that name already exists...

C Language Family Type Representation.

#define va_start(ap, param)

__builtin_va_list va_list

static __inline__ uint32_t volatile uint32_t * __p

a trap message and trap category.

virtual bool HandleTopLevelDecl(DeclGroupRef D)

HandleTopLevelDecl - Handle the specified top-level declaration.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

TranslationUnitDecl * getTranslationUnitDecl() const

const ConstantArrayType * getAsConstantArrayType(QualType T) const

QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const

Return the uniqued reference to the type for an lvalue reference to the specified type.

const LangOptions & getLangOpts() const

TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const

Allocate a TypeSourceInfo where all locations have been initialized to a given location,...

const clang::PrintingPolicy & getPrintingPolicy() const

uint64_t getTypeSize(QualType T) const

Return the size of the specified (complete) type T, in bits.

CharUnits getTypeSizeInChars(QualType T) const

Return the size of the specified (complete) type T, in characters.

llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const

Make an APSInt of the appropriate width and signedness for the given Value and integer Type.

uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const

Return number of constant array elements.

QualType getBitIntType(bool Unsigned, unsigned NumBits) const

Return a bit-precise integer type with the specified signedness and bit count.

This class is used for builtin types like 'int'.

Represents a C++ struct/union/class.

bool hasIrrelevantDestructor() const

Determine whether this class has a destructor which has no semantic effect.

CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...

QuantityType getQuantity() const

getQuantity - Get the raw integer representation of this quantity.

ASTConsumer & getASTConsumer() const

Represents the canonical version of C arrays with a specified constant size.

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

decl_range noload_decls() const

noload_decls_begin/end - Iterate over the declarations stored in this context that are currently load...

A reference to a declared variable, function, enum, etc.

Decl - This represents one declaration (or definition), e.g.

void print(raw_ostream &Out, unsigned Indentation=0, bool PrintInstantiation=false) const

This represents one expression.

bool isLValue() const

isLValue - True if this expression is an "l-value" according to the rules of the current language.

Expr * IgnoreImpCasts() LLVM_READONLY

Skip past any implicit casts which might surround this expression until reaching a fixed point.

Represents a function declaration or definition.

bool hasBody(const FunctionDecl *&Definition) const

Returns true if the function has a body.

FunctionType - C99 6.7.5.3 - Function Declarators.

IdentifierInfo & get(StringRef Name)

Return the identifier token info for the specified named identifier.

InterfaceKind VisitConstantArrayType(const ConstantArrayType *Ty)

Definition InterpreterValuePrinter.cpp:399

InterfaceKind computeInterfaceKind(QualType Ty)

Definition InterpreterValuePrinter.cpp:387

InterfaceKind VisitReferenceType(const ReferenceType *Ty)

Definition InterpreterValuePrinter.cpp:413

InterfaceKind VisitPointerType(const PointerType *Ty)

Definition InterpreterValuePrinter.cpp:408

InterfaceKind VisitEnumType(const EnumType *Ty)

Definition InterpreterValuePrinter.cpp:435

InterfaceKind VisitBuiltinType(const BuiltinType *Ty)

Definition InterpreterValuePrinter.cpp:421

InterfaceKind VisitFunctionType(const FunctionType *Ty)

Definition InterpreterValuePrinter.cpp:403

InterfaceKind VisitRecordType(const RecordType *Ty)

Definition InterpreterValuePrinter.cpp:391

InterfaceKind VisitMemberPointerType(const MemberPointerType *Ty)

Definition InterpreterValuePrinter.cpp:395

InterfaceKindVisitor(Sema &S, Expr *E, llvm::SmallVectorImpl< Expr * > &Args)

Definition InterpreterValuePrinter.cpp:384

Provides top-level interfaces for incremental compilation and execution.

llvm::Expected< llvm::orc::ExecutorAddr > getSymbolAddress(GlobalDecl GD) const

const CompilerInstance * getCompilerInstance() const

A pointer to member type per C++ 8.3.3 - Pointers to members.

This represents a decl that may have a name.

std::string getQualifiedNameAsString() const

PointerType - C99 6.7.5.1 - Pointer Declarators.

A (possibly-)qualified type.

bool hasQualifiers() const

Determine whether this type has any qualifiers.

QualType getDesugaredType(const ASTContext &Context) const

Return the specified type with any "sugar" removed from the type.

const Type * getTypePtr() const

Retrieves a pointer to the underlying (unqualified) type.

Qualifiers getQualifiers() const

Retrieve the set of qualifiers applied to this type.

QualType getNonReferenceType() const

If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...

QualType getCanonicalType() const

void * getAsOpaquePtr() const

static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)

std::string getAsString() const

Base for LValueReferenceType and RValueReferenceType.

Sema - This implements semantic analysis and AST building for C.

@ LookupOrdinaryName

Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....

ASTContext & getASTContext() const

CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)

Look for the destructor of the given class.

ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional< Expr * > ArraySize, SourceRange DirectInitRange, Expr *Initializer)

ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, SourceLocation RParenLoc, Expr *Op)

ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)

bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)

Perform qualified name lookup into a given context.

ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr)

ActOnCallExpr - Handle a call to Fn with the specified array of arguments.

ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)

Encodes a location in the source.

SourceLocation getEndLoc() const LLVM_READONLY

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

SourceLocation getBeginLoc() const LLVM_READONLY

A declaration that models statements at global scope.

A container of type source information.

QualType getType() const

Return the type wrapped by this type source info.

InterfaceKind Visit(const Type *T)

The base class of the type hierarchy.

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

QualType getLocallyUnqualifiedSingleStepDesugaredType() const

Pull a single level of sugar off of this locally-unqualified type.

bool isFunctionPointerType() const

bool isPointerType() const

const T * castAs() const

Member-template castAs.

bool isReferenceType() const

bool isEnumeralType() const

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

bool isBuiltinType() const

Helper methods to distinguish type categories.

const Type * getBaseElementTypeUnsafe() const

Get the base element type of this type, potentially discarding type qualifiers.

bool isMemberPointerType() const

bool isFunctionProtoType() const

EnumDecl * getAsEnumDecl() const

Retrieves the EnumDecl this type refers to.

bool isFunctionType() const

bool isFloatingType() const

const T * getAs() const

Member-template getAs'.

bool isNullPtrType() const

bool isRecordType() const

void setRawBits(void *Ptr, unsigned NBits=sizeof(Storage))

The JSON file list parser is used to communicate input to InstallAPI.

bool isa(CodeGen::Address addr)

std::string GetFullTypeName(ASTContext &Ctx, QualType QT)

InterfaceKind

Definition InterpreterValuePrinter.cpp:374

@ NewTag

Definition InterpreterValuePrinter.cpp:374

@ NoAlloc

Definition InterpreterValuePrinter.cpp:374

@ WithAlloc

Definition InterpreterValuePrinter.cpp:374

@ CopyArray

Definition InterpreterValuePrinter.cpp:374

@ Result

The result type of a method or function.

IntegerLiteral * IntegerLiteralExpr(ASTContext &C, uint64_t Val)

@ Dtor_Base

Base object dtor.

Expr * CStyleCastPtrExpr(Sema &S, QualType Ty, Expr *E)

U cast(CodeGen::Address addr)

static constexpr llvm::StringRef VPName[]

Definition InterpreterValuePrinter.cpp:464

@ Interface

The "__interface" keyword introduces the elaborated-type-specifier.

ActionResult< Expr * > ExprResult

__DEVICE__ bool isnan(float __x)

__DEVICE__ _Tp abs(const std::complex< _Tp > &__c)

__DEVICE__ bool isinf(float __x)

__UINTPTR_TYPE__ uintptr_t

An unsigned integer type with the property that any valid pointer to void can be converted to this ty...

Describes how types, statements, expressions, and declarations should be printed.

unsigned SuppressUnwrittenScope

Suppress printing parts of scope specifiers that are never written, e.g., for anonymous namespaces.

unsigned SuppressDefaultTemplateArgs

When true, attempt to suppress template arguments that match the default argument for the parameter.

unsigned SplitTemplateClosers

Whether nested templates must be closed like 'a<b >' rather than 'a<b>'.

ValueRef(const Interpreter *In, void *Ty)

Definition InterpreterValuePrinter.cpp:177