This is an archive of the discontinued LLVM Phabricator instance.

Differential D66808

[ConstExprPreter] Full patch of the interpreter.
Needs ReviewPublic

Authored by nand on Aug 27 2019, 9:13 AM.

Details

Reviewers
rsmith
Bigcheese
jfb
dexonsmith
jdoerfert
Summary

Constant expression interpreter - see ConstantInterpreter.rst.

Diff Detail

Event Timeline

nand created this revision.Aug 27 2019, 9:13 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptAug 27 2019, 9:13 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: cfe-commits, jfb, mgorny. · View Herald Transcript
Harbormaster completed remote builds in B37368: Diff 217422.Aug 27 2019, 9:13 AM
nand edited reviewers, added: rsmith, Bigcheese, jfb, dexonsmith; removed: jdoerfert.Aug 27 2019, 9:14 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptAug 27 2019, 9:14 AM
jdoerfert resigned from this revision.Aug 27 2019, 9:17 AM
tschuett added a subscriber: tschuett.Aug 27 2019, 9:46 AM
riccibruno added a subscriber: riccibruno.Aug 27 2019, 10:29 AM
nand updated this revision to Diff 218131.Aug 30 2019, 10:34 AM

Added more features

Harbormaster completed remote builds in B37580: Diff 218131.Aug 30 2019, 10:34 AM
nand updated this revision to Diff 222568.Oct 1 2019, 2:29 AM

minor fixes

Harbormaster completed remote builds in B38798: Diff 222568.Oct 1 2019, 2:30 AM

Revision Contents

PathSize
clang/
lib/
AST/
Interp/
27 lines
103 lines
117 lines
1814 lines
10 lines
355 lines
1 line
15 lines
161 lines
6 lines
20 lines
176 lines
647 lines
244 lines
31 lines
321 lines
100 lines
96 lines
133 lines
36 lines
test/
AST/
Interp/
6 lines
20 lines
12 lines
17 lines
31 lines
42 lines
boolean.cpp
cond.cpp
11 lines
12 lines
14 lines
18 lines
14 lines
71 lines
40 lines
17 lines
10 lines
9 lines
21 lines
28 lines
13 lines
41 lines
86 lines
50 lines
28 lines
27 lines
18 lines
68 lines
76 lines
21 lines
23 lines
23 lines
27 lines
117 lines
27 lines
117 lines
27 lines
28 lines
21 lines
22 lines
25 lines
21 lines
33 lines
12 lines
51 lines
14 lines
17 lines
74 lines
19 lines
121 lines
16 lines
48 lines
8 lines
20 lines
24 lines
15 lines
23 lines
19 lines
rvo.cpp
cond.cpp
15 lines
51 lines
18 lines
19 lines
55 lines
20 lines
72 lines
25 lines
struct.cpp
cond.cpp
19 lines
39 lines
28 lines
22 lines
toplevel.cpp
cond.cpp
10 lines
11 lines
12 lines
14 lines
13 lines
36 lines
20 lines
45 lines

Diff 217422

clang/lib/AST/Interp/Builtin.h

  • This file was added.
//===--- Builtin.h - Builtins for the constexpr VM --------------*- 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
//
//===----------------------------------------------------------------------===//
//
// Builtin dispatch method definition.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_AST_INTERP_BUILTIN_H
#define LLVM_CLANG_AST_INTERP_BUILTIN_H
#include "Function.h"
namespace clang {
namespace interp {
class InterpState;
bool InterpBuiltin(InterpState &S, CodePtr OpPC, unsigned BuiltinOp);
} // namespace interp
} // namespace clang
#endif

clang/lib/AST/Interp/Builtin.cpp

  • This file was added.
//===--- Builtin.cpp - Builtins for the constexpr VM ------------*- 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
//
//===----------------------------------------------------------------------===//
#include "Builtin.h"
#include "Interp.h"
#include "InterpState.h"
#include "Pointer.h"
#include "Program.h"
#include "Type.h"
#include "clang/AST/ASTContext.h"
#include "clang/Basic/Builtins.h"
using namespace clang;
using namespace clang::interp;
static bool BuiltinLength(InterpState &S, CodePtr OpPC) {
using ResultT = PrimConv<PT_Uint64>::T;
// Get the pointer to the string and ensure it's an array of primitives.
const auto &Ptr = S.Stk.pop<Pointer>();
if (!CheckLive(S, OpPC, Ptr, AK_Read))
return false;
if (!CheckExtern(S, OpPC, Ptr))
return false;
if (!CheckRange(S, OpPC, Ptr, AK_Read))
return false;
if (!Ptr.inPrimitiveArray())
return false;
// Find the null terminator, starting at the pointed element.
const unsigned Size = Ptr.getSize() - Ptr.getOffset();
char *Data = &Ptr.narrow().deref<char>();
switch (Ptr.elemSize()) {
case 1:
for (unsigned Off = 0, I = 0; Off < Size; Off += 1, ++I) {
if (*reinterpret_cast<int8_t *>(Data + Off) == 0) {
S.Stk.push<ResultT>(ResultT::from(I));
return true;
}
}
break;
case 2:
for (unsigned Off = 0, I = 0; Off < Size; Off += 2, ++I) {
if (*reinterpret_cast<uint16_t *>(Data + Off) == 0) {
S.Stk.push<ResultT>(ResultT::from(I));
return true;
}
}
break;
case 4:
for (unsigned Off = 0, I = 0; Off < Size; Off += 4, ++I) {
if (*reinterpret_cast<uint32_t *>(Data + Off) == 0) {
S.Stk.push<ResultT>(ResultT::from(I));
return true;
}
}
break;
default:
llvm_unreachable("Unsupported character width!");
}
const SourceInfo &Loc = S.Current->getSource(OpPC);
S.FFDiag(Loc, diag::note_constexpr_access_past_end) << AK_Read;
return false;
}
static void ReportInvalidExpr(InterpState &S, CodePtr OpPC, unsigned Op) {
const char *Name = S.getCtx().BuiltinInfo.getName(Op);
const SourceInfo &Loc = S.Current->getSource(OpPC);
if (S.getLangOpts().CPlusPlus11)
S.CCEDiag(Loc, diag::note_constexpr_invalid_function)
<< /*isConstexpr*/ 0 << /*isConstructor*/ 0
<< (std::string("'") + Name + "'");
else
S.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
}
namespace clang {
namespace interp {
bool InterpBuiltin(InterpState &S, CodePtr OpPC, unsigned Op) {
switch (Op) {
case Builtin::BIstrlen:
case Builtin::BIwcslen:
ReportInvalidExpr(S, OpPC, Op);
return BuiltinLength(S, OpPC);
case Builtin::BI__builtin_strlen:
case Builtin::BI__builtin_wcslen:
return BuiltinLength(S, OpPC);
default:
// Builtin is not constexpr.
return false;
}
}
} // namespace interp
} // namespace clang

clang/lib/AST/Interp/ByteCodeExprGen.h

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
public: public:
/// Initializes the compiler and the backend emitter. /// Initializes the compiler and the backend emitter.
template <typename... Tys> template <typename... Tys>
ByteCodeExprGen(Context &Ctx, Program &P, Tys &&... Args) ByteCodeExprGen(Context &Ctx, Program &P, Tys &&... Args)
: Emitter(Ctx, P, Args...), Ctx(Ctx), P(P) {} : Emitter(Ctx, P, Args...), Ctx(Ctx), P(P) {}
// Expression visitors - result returned on stack. // Expression visitors - result returned on stack.
bool VisitDeclRefExpr(const DeclRefExpr *E);
bool VisitCastExpr(const CastExpr *E); bool VisitCastExpr(const CastExpr *E);
bool VisitConstantExpr(const ConstantExpr *E);
bool VisitIntegerLiteral(const IntegerLiteral *E); bool VisitIntegerLiteral(const IntegerLiteral *E);
bool VisitFloatingLiteral(const FloatingLiteral *E);
bool VisitStringLiteral(const StringLiteral *E);
bool VisitCharacterLiteral(const CharacterLiteral *E);
bool VisitParenExpr(const ParenExpr *E); bool VisitParenExpr(const ParenExpr *E);
bool VisitBinaryOperator(const BinaryOperator *E); bool VisitBinaryOperator(const BinaryOperator *E);
bool VisitUnaryPostInc(const UnaryOperator *E);
bool VisitUnaryPostDec(const UnaryOperator *E);
bool VisitUnaryPreInc(const UnaryOperator *E);
bool VisitUnaryPreDec(const UnaryOperator *E);
bool VisitUnaryAddrOf(const UnaryOperator *E);
bool VisitUnaryDeref(const UnaryOperator *E);
bool VisitUnaryPlus(const UnaryOperator *E);
bool VisitUnaryMinus(const UnaryOperator *E);
bool VisitUnaryNot(const UnaryOperator *E);
bool VisitUnaryLNot(const UnaryOperator *E);
bool VisitUnaryReal(const UnaryOperator *E);
bool VisitUnaryImag(const UnaryOperator *E);
bool VisitConditionalOperator(const ConditionalOperator *E);
bool VisitBinaryConditionalOperator(const BinaryConditionalOperator *E);
bool VisitMemberExpr(const MemberExpr *E);
bool VisitCallExpr(const CallExpr *E);
bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
bool VisitExprWithCleanups(const ExprWithCleanups *E);
bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E);
bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E);
bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
bool VisitSizeOfPackExpr(const SizeOfPackExpr *E);
bool VisitOpaqueValueExpr(const OpaqueValueExpr *E);
bool VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E);
bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E);
bool VisitInitListExpr(const InitListExpr *E);
bool VisitTypeTraitExpr(const TypeTraitExpr *E);
bool VisitCXXConstructExpr(const CXXConstructExpr *E);
bool VisitCXXMemberCallExpr(const CXXMemberCallExpr *E);
bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E);
bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E);
bool VisitCXXThisExpr(const CXXThisExpr *E);
bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E);
bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E);
bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E);
bool VisitCXXThrowExpr(const CXXThrowExpr *E);
bool VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E);
bool VisitCXXTypeidExpr(const CXXTypeidExpr *E);
bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E);
bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E);
bool VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
protected: protected:
bool visitExpr(const Expr *E) override; bool visitExpr(const Expr *E) override;
bool visitDecl(const VarDecl *VD) override; bool visitDecl(const VarDecl *VD) override;
protected: protected:
/// Emits scope cleanup instructions. /// Emits scope cleanup instructions.
void emitCleanup(); void emitCleanup();
/// Returns a record type from a record or pointer type. /// Returns a record type from a record or pointer type.
const RecordType *getRecordTy(QualType Ty); const RecordType *getRecordTy(QualType Ty);
/// Returns a record from a record or pointer type. /// Returns a record from a record or pointer type.
Record *getRecord(QualType Ty); Record *getRecord(QualType Ty);
Record *getRecord(const RecordDecl *RD); Record *getRecord(const RecordDecl *RD);
/// Perform an action if a record field is found.
bool withField(const FieldDecl *F,
llvm::function_ref<bool(const Record::Field *)> GenField);
/// Returns the size int bits of an integer. /// Returns the size int bits of an integer.
unsigned getIntWidth(QualType Ty) { unsigned getIntWidth(QualType Ty) {
auto &ASTContext = Ctx.getASTContext(); auto &ASTContext = Ctx.getASTContext();
return ASTContext.getIntWidth(Ty); return ASTContext.getIntWidth(Ty);
} }
/// Returns the applicable fp semantics.
const fltSemantics *getFltSemantics(QualType Ty) {
return &Ctx.getASTContext().getFloatTypeSemantics(Ty);
}
/// Returns the value of CHAR_BIT. /// Returns the value of CHAR_BIT.
unsigned getCharBit() const { unsigned getCharBit() const {
auto &ASTContext = Ctx.getASTContext(); auto &ASTContext = Ctx.getASTContext();
return ASTContext.getTargetInfo().getCharWidth(); return ASTContext.getTargetInfo().getCharWidth();
} }
/// Classifies a type. /// Classifies a type.
llvm::Optional<PrimType> classify(const Expr *E) const { llvm::Optional<PrimType> classify(const Expr *E) const {
return E->isGLValue() ? PT_Ptr : classify(E->getType()); return E->isGLValue() ? PT_Ptr : classify(E->getType());
} }
llvm::Optional<PrimType> classify(QualType Ty) const { llvm::Optional<PrimType> classify(QualType Ty) const {
return Ctx.classify(Ty); return Ctx.classify(Ty);
} }
/// Checks if a pointer needs adjustment. /// Checks if a pointer needs adjustment.
bool needsAdjust(QualType Ty) const { bool needsAdjust(QualType Ty) const {
if (llvm::Optional<PrimType> T = classify(Ty))
return T != PT_MemPtr && T != PT_FnPtr;
return true; return true;
} }
/// Classifies a known primitive type /// Classifies a known primitive type
PrimType classifyPrim(QualType Ty) const { PrimType classifyPrim(QualType Ty) const {
if (auto T = classify(Ty)) { if (auto T = classify(Ty)) {
return *T; return *T;
} }
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linesprivate:
friend class LocalScope<Emitter>; friend class LocalScope<Emitter>;
friend class RecordScope<Emitter>; friend class RecordScope<Emitter>;
friend class DeclScope<Emitter>; friend class DeclScope<Emitter>;
friend class OptionScope<Emitter>; friend class OptionScope<Emitter>;
/// Emits a zero initializer. /// Emits a zero initializer.
bool visitZeroInitializer(PrimType T, const Expr *E); bool visitZeroInitializer(PrimType T, const Expr *E);
/// Emits a direct function call.
bool emitFunctionCall(const FunctionDecl *Callee, llvm::Optional<PrimType> T,
const Expr *Call);
/// Emits a direct method call.
bool emitMethodCall(const CXXMethodDecl *Callee, llvm::Optional<PrimType> T,
const Expr *Call);
/// Compiles an offset calculator.
bool visitOffset(const Expr *Ptr, const Expr *Offset, const Expr *E,
UnaryFn OffsetFn);
/// Fetches a member of a structure given by a pointer. /// Fetches a member of a structure given by a pointer.
bool visitIndirectMember(const BinaryOperator *E); bool visitIndirectMember(const BinaryOperator *E);
/// Compiles simple or compound assignments.
bool visitAssign(PrimType T, const BinaryOperator *BO);
bool visitShiftAssign(PrimType RHS, BinaryFn F, const BinaryOperator *BO);
bool visitCompoundAssign(PrimType RHS, UnaryFn F, const BinaryOperator *BO);
bool visitPtrAssign(PrimType RHS, UnaryFn F, const BinaryOperator *BO);
/// Emits a cast between two types. /// Emits a cast between two types.
bool emitConv(PrimType From, QualType FromTy, PrimType To, QualType ToTy, bool emitConv(PrimType From, QualType FromTy, PrimType To, QualType ToTy,
const Expr *Cast); const Expr *Cast);
bool visitShortCircuit(const BinaryOperator *E);
enum class DerefKind { enum class DerefKind {
/// Value is read and pushed to stack. /// Value is read and pushed to stack.
Read, Read,
/// Direct method generates a value which is written. Returns pointer. /// Direct method generates a value which is written. Returns pointer.
Write, Write,
/// Direct method receives the value, pushes mutated value. Returns pointer. /// Direct method receives the value, pushes mutated value. Returns pointer.
ReadWrite, ReadWrite,
}; };
/// Method to directly load a value. If the value can be fetched directly, /// Method to directly load a value. If the value can be fetched directly,
/// the direct handler is called. Otherwise, a pointer is left on the stack /// the direct handler is called. Otherwise, a pointer is left on the stack
/// and the indirect handler is expected to operate on that. /// and the indirect handler is expected to operate on that.
bool dereference(const Expr *LV, DerefKind AK, bool dereference(const Expr *LV, DerefKind AK,
llvm::function_ref<bool(PrimType)> Direct, llvm::function_ref<bool(PrimType)> Direct,
llvm::function_ref<bool(PrimType)> Indirect); llvm::function_ref<bool(PrimType)> Indirect);
bool dereferenceParam(const Expr *LV, PrimType T, const ParmVarDecl *PD, bool dereferenceParam(const Expr *LV, PrimType T, const ParmVarDecl *PD,
DerefKind AK, DerefKind AK,
llvm::function_ref<bool(PrimType)> Direct, llvm::function_ref<bool(PrimType)> Direct,
llvm::function_ref<bool(PrimType)> Indirect); llvm::function_ref<bool(PrimType)> Indirect);
bool dereferenceVar(const Expr *LV, PrimType T, const VarDecl *PD, bool dereferenceVar(const Expr *LV, PrimType T, const VarDecl *PD,
DerefKind AK, llvm::function_ref<bool(PrimType)> Direct, DerefKind AK, llvm::function_ref<bool(PrimType)> Direct,
llvm::function_ref<bool(PrimType)> Indirect); llvm::function_ref<bool(PrimType)> Indirect);
bool dereferenceMember(const MemberExpr *PD, PrimType T, DerefKind AK,
llvm::function_ref<bool(PrimType)> Direct,
llvm::function_ref<bool(PrimType)> Indirect);
/// Emits an APInt constant. /// Emits an APInt constant.
bool emitConst(PrimType T, unsigned NumBits, const llvm::APInt &Value, bool emitConst(PrimType T, unsigned NumBits, const llvm::APInt &Value,
const Expr *E); const Expr *E);
/// Emits an integer constant. /// Emits an integer constant.
template <typename T> bool emitConst(const Expr *E, T Value) { template <typename T> bool emitConst(const Expr *E, T Value) {
QualType Ty = E->getType(); QualType Ty = E->getType();
unsigned NumBits = getIntWidth(Ty); unsigned NumBits = getIntWidth(Ty);
APInt WrappedValue(NumBits, Value, std::is_signed<T>::value); APInt WrappedValue(NumBits, Value, std::is_signed<T>::value);
return emitConst(*Ctx.classify(Ty), NumBits, WrappedValue, E); return emitConst(*Ctx.classify(Ty), NumBits, WrappedValue, E);
} }
/// Compiles a list of arguments.
bool visitArguments(ArrayRef<const Expr *> Args);
/// Compiles an argument.
bool visitArgument(const Expr *E);
/// Visits a constant function invocation. /// Visits a constant function invocation.
bool getPtrConstFn(const FunctionDecl *FD, const Expr *E); bool getPtrConstFn(const FunctionDecl *FD, const Expr *E);
/// Returns a pointer to a variable declaration. /// Returns a pointer to a variable declaration.
bool getPtrVarDecl(const VarDecl *VD, const Expr *E); bool getPtrVarDecl(const VarDecl *VD, const Expr *E);
/// Returns the index of a global. /// Returns the index of a global.
llvm::Optional<unsigned> getGlobalIdx(const VarDecl *VD); llvm::Optional<unsigned> getGlobalIdx(const VarDecl *VD);
/// Compiles a string initializer.
bool visitStringInitializer(const StringLiteral *S);
/// Compiles an array initializer.
bool visitArrayInitializer(const ConstantArrayType *AT,
llvm::function_ref<const Expr *(uint64_t)> Elem);
/// Visits a record initializer.
bool visitRecordInitializer(const RecordType *RT, const InitListExpr *List);
/// Visits a complex initializer.
bool visitComplexInitializer(const ComplexType *CT, const InitListExpr *List);
/// Visits a cast to complex.
bool visitCastToComplex(const CastExpr *CE);
/// Zero initializer for a record.
bool visitZeroInitializer(const Expr *E, const RecordDecl *RD);
/// Registers an opaque expression.
bool visitOpaqueExpr(const OpaqueValueExpr *Expr);
/// Visits a conditional operator.
bool visitConditionalOperator(const AbstractConditionalOperator *CO);
/// Materializes a composite.
bool materialize(const Expr *Alloc, const Expr *Init, bool IsConst,
bool IsGlobal, bool IsExtended);
/// Emits the initialized pointer. /// Emits the initialized pointer.
bool emitInitFn() { bool emitInitFn() {
assert(InitFn && "missing initializer"); assert(InitFn && "missing initializer");
return (*InitFn)(); return (*InitFn)();
} }
/// Returns the alignment of a type.
CharUnits getAlignOfType(QualType T, bool IsPreferred);
/// Returns the alignment of an expresion.
CharUnits getAlignOfExpr(const Expr *E, bool IsPreferred);
protected: protected:
/// Variable to storage mapping. /// Variable to storage mapping.
llvm::DenseMap<const ValueDecl *, Scope::Local> Locals; llvm::DenseMap<const ValueDecl *, Scope::Local> Locals;
/// OpaqueValueExpr to location mapping. /// OpaqueValueExpr to location mapping.
llvm::DenseMap<const OpaqueValueExpr *, unsigned> OpaqueExprs; llvm::DenseMap<const OpaqueValueExpr *, unsigned> OpaqueExprs;
/// Current scope. /// Current scope.
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

clang/lib/AST/Interp/ByteCodeExprGen.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Linesprivate:
/// Old pointer emitter to restore. /// Old pointer emitter to restore.
llvm::Optional<InitFnRef> OldInitFn; llvm::Optional<InitFnRef> OldInitFn;
}; };
} // namespace interp } // namespace interp
} // namespace clang } // namespace clang
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitDeclRefExpr(const DeclRefExpr *DE) {
if (DiscardResult)
return true;
if (auto *PD = dyn_cast<ParmVarDecl>(DE->getDecl())) {
QualType Ty = PD->getType();
auto It = this->Params.find(PD);
if (It == this->Params.end()) {
// Pointers to parameters are not constant expressions.
return this->emitTrap(DE);
} else {
// Generate a pointer to a parameter.
if (Ty->isReferenceType() || !classify(Ty))
return this->emitGetParamPtr(It->second, DE);
else
return this->emitGetPtrParam(It->second, DE);
}
}
if (auto *VD = dyn_cast<VarDecl>(DE->getDecl())) {
auto It = Locals.find(VD);
if (It == Locals.end()) {
return getPtrVarDecl(VD, DE);
} else {
// Generate a pointer to a local.
if (VD->getType()->isReferenceType())
return this->emitGetLocal(PT_Ptr, It->second.Offset, DE);
else
return this->emitGetPtrLocal(It->second.Offset, DE);
}
}
if (auto *ED = dyn_cast<EnumConstantDecl>(DE->getDecl())) {
QualType Ty = ED->getType();
if (Optional<PrimType> T = classify(Ty))
return this->emitConst(*T, getIntWidth(Ty), ED->getInitVal(), DE);
return this->bail(DE);
}
if (auto *FD = dyn_cast<FunctionDecl>(DE->getDecl())) {
if (auto *CD = dyn_cast<CXXMethodDecl>(DE->getDecl()))
if (!CD->isStatic())
return this->emitConstMem(CD, DE);
return getPtrConstFn(FD, DE);
}
if (auto *FD = dyn_cast<FieldDecl>(DE->getDecl()))
return this->emitConstMem(FD, DE);
// TODO: compile other decls.
return this->bail(DE);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCastExpr(const CastExpr *CE) { bool ByteCodeExprGen<Emitter>::VisitCastExpr(const CastExpr *CE) {
auto *SubExpr = CE->getSubExpr(); auto *SubExpr = CE->getSubExpr();
switch (CE->getCastKind()) { switch (CE->getCastKind()) {
case CK_LValueToRValue: { case CK_LValueToRValue: {
return dereference( return dereference(
CE->getSubExpr(), DerefKind::Read, CE->getSubExpr(), DerefKind::Read,
[](PrimType) { [](PrimType) {
// Value loaded - nothing to do here. // Value loaded - nothing to do here.
return true; return true;
}, },
[this, CE](PrimType T) { [this, CE](PrimType T) {
// Pointer on stack - dereference it. // Pointer on stack - dereference it.
if (!this->emitLoadPop(T, CE)) if (!this->emitLoadPop(T, CE))
return false; return false;
return DiscardResult ? this->emitPop(T, CE) : true; return DiscardResult ? this->emitPop(T, CE) : true;
}); });
} }
case CK_IntegralToBoolean: {
if (DiscardResult)
return discard(SubExpr);
if (!visit(SubExpr))
return false;
return this->emitTest(*classify(SubExpr->getType()), CE);
}
case CK_IntegralCast: {
if (DiscardResult)
return discard(SubExpr);
if (!visit(SubExpr))
return false;
QualType ArgTy = SubExpr->getType();
QualType RetTy = CE->getType();
auto ArgT = *classify(ArgTy);
auto RetT = *classify(RetTy);
if (isFixedIntegral(RetT))
return this->emitCastFP(ArgT, RetT, getIntWidth(RetTy), CE);
else
return this->emitCast(ArgT, RetT, CE);
}
case CK_FloatingCast:
case CK_IntegralToFloating: {
if (DiscardResult)
return discard(SubExpr);
if (!visit(SubExpr))
return false;
QualType ArgTy = SubExpr->getType();
QualType RetTy = CE->getType();
auto ArgT = *classify(ArgTy);
return this->emitCastRealFP(ArgT, getFltSemantics(RetTy), CE);
}
case CK_FloatingToIntegral: {
if (!visit(SubExpr))
return false;
QualType RetTy = CE->getType();
PrimType ArgT = *classify(SubExpr->getType());
PrimType RetT = *classify(RetTy);
if (isFixedIntegral(RetT)) {
if (!this->emitCastRealFPToAluFP(ArgT, RetT, getIntWidth(RetTy), CE))
return false;
} else {
if (!this->emitCastRealFPToAlu(ArgT, RetT, CE))
return false;
}
return DiscardResult ? this->emitPop(RetT, CE) : true;
}
case CK_NullToPointer:
case CK_NullToMemberPointer:
// Emit a null pointer, avoiding redundancy when casting from nullptr.
if (!isa<CXXNullPtrLiteralExpr>(SubExpr)) {
if (!discard(SubExpr))
return false;
}
if (DiscardResult)
return true;
return visitZeroInitializer(classifyPrim(CE->getType()), CE);
case CK_PointerToBoolean: {
if (DiscardResult)
return discard(SubExpr);
else
return visit(SubExpr) && this->emitTestPtr(CE);
}
case CK_ArrayToPointerDecay: case CK_ArrayToPointerDecay:
case CK_AtomicToNonAtomic: case CK_AtomicToNonAtomic:
case CK_ConstructorConversion: case CK_ConstructorConversion:
case CK_FunctionToPointerDecay: case CK_FunctionToPointerDecay:
case CK_NonAtomicToAtomic: case CK_NonAtomicToAtomic:
case CK_NoOp: case CK_NoOp:
case CK_UserDefinedConversion: case CK_UserDefinedConversion:
return this->Visit(SubExpr); return this->Visit(SubExpr);
case CK_ToVoid: case CK_ToVoid:
return discard(SubExpr); return discard(SubExpr);
case CK_IntegralRealToComplex:
case CK_FloatingRealToComplex:
return visitCastToComplex(CE);
case CK_DerivedToBase:
case CK_UncheckedDerivedToBase: {
if (!visit(SubExpr))
return false;
const Record *R = getRecord(SubExpr->getType());
if (!R)
return false;
for (auto *Step : CE->path()) {
auto *Decl = Step->getType()->getAs<RecordType>()->getDecl();
const Record::Base *Base;
if (Step->isVirtual()) {
Base = R->getVirtualBase(Decl);
if (!this->emitGetPtrVirtBase(Decl, CE))
return false;
} else {
Base = R->getBase(Decl);
if (!this->emitGetPtrBase(Base->Offset, CE))
return false;
}
R = Base->Record;
}
return DiscardResult ? this->emitPopPtr(CE) : true;
}
case CK_BaseToDerived: {
if (!visit(SubExpr))
return false;
if (!this->emitCastToDerived(CE, CE))
return false;
return DiscardResult ? this->emitPopPtr(CE) : true;
}
case CK_DerivedToBaseMemberPointer: {
if (!visit(SubExpr))
return false;
for (auto *Step : CE->path()) {
auto *R = Step->getType()->getAs<RecordType>()->getDecl();
if (!this->emitCastMemberToBase(cast<CXXRecordDecl>(R), CE))
return false;
}
return DiscardResult ? this->emitPopMemPtr(CE) : true;
}
case CK_BaseToDerivedMemberPointer: {
if (CE->path_empty())
return discard(SubExpr);
if (!visit(SubExpr))
return false;
// Single cast step from base to derived.
auto Step = [this, CE](const Type *T) {
auto *R = cast<CXXRecordDecl>(T->getAs<RecordType>()->getDecl());
return this->emitCastMemberToDerived(R, CE);
};
// Base-to-derived member pointer casts store the path in derived-to-base
// order, so iterate backwards. The CXXBaseSpecifier also provides us with
// the wrong end of the derived->base arc, so stagger the path by one class.
typedef std::reverse_iterator<CastExpr::path_const_iterator> Rev;
for (auto It = Rev(CE->path_end() - 1); It != Rev(CE->path_begin()); ++It) {
if (!Step((*It)->getType().getTypePtr()))
return false;
}
// The final type is encoded in the type of the cast.
if (!Step(CE->getType()->getAs<MemberPointerType>()->getClass()))
return false;
return DiscardResult ? this->emitPopMemPtr(CE) : true;
}
case CK_BitCast: {
if (!this->Visit(SubExpr))
return false;
QualType T = CE->getType();
if (!T->isVoidPointerType()) {
if (T->isMemberFunctionPointerType())
return false;
if (T->isMemberPointerType())
return false;
if (T->isFunctionPointerType())
return false;
return this->emitPointerBitCast(SubExpr);
}
return true;
}
case CK_IntegralToPointer:
case CK_PointerToIntegral: {
if (!this->Visit(SubExpr))
return false;
return this->emitPointerBitCast(SubExpr);
}
default: { default: {
// TODO: implement other casts. // TODO: implement other casts.
return this->bail(CE); return this->bail(CE);
} }
} }
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitConstantExpr(const ConstantExpr *CE) {
if (DiscardResult)
return true;
switch (CE->getResultStorageKind()) {
case ConstantExpr::RSK_Int64: {
QualType Ty = CE->getType();
PrimType T = *classify(Ty);
return this->emitConst(T, getIntWidth(Ty), CE->getResultAsAPSInt(), CE);
}
case ConstantExpr::RSK_APValue: {
return this->bail(CE);
}
case ConstantExpr::RSK_None: {
return this->Visit(CE->getSubExpr());
}
}
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitIntegerLiteral(const IntegerLiteral *LE) { bool ByteCodeExprGen<Emitter>::VisitIntegerLiteral(const IntegerLiteral *LE) {
if (DiscardResult) if (DiscardResult)
return true; return true;
auto Val = LE->getValue(); auto Val = LE->getValue();
QualType LitTy = LE->getType(); QualType LitTy = LE->getType();
if (Optional<PrimType> T = classify(LitTy)) if (Optional<PrimType> T = classify(LitTy))
return emitConst(*T, getIntWidth(LitTy), LE->getValue(), LE); return emitConst(*T, getIntWidth(LitTy), LE->getValue(), LE);
return this->bail(LE); return this->bail(LE);
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitFloatingLiteral(const FloatingLiteral *E) {
if (DiscardResult)
return true;
return this->emitConstRealFP(E, E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitStringLiteral(const StringLiteral *E) {
if (InitFn)
return visitStringInitializer(E);
if (DiscardResult)
return true;
return this->emitGetPtrGlobal(P.createGlobalString(E), E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCharacterLiteral(
const CharacterLiteral *CE) {
if (DiscardResult)
return true;
QualType CharTy = CE->getType();
if (Optional<PrimType> T = classify(CharTy)) {
APInt Char(sizeof(unsigned) * CHAR_BIT, CE->getValue(), false);
return this->emitConst(*T, getIntWidth(CharTy), Char, CE);
}
return this->bail(CE);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitParenExpr(const ParenExpr *PE) { bool ByteCodeExprGen<Emitter>::VisitParenExpr(const ParenExpr *PE) {
return this->Visit(PE->getSubExpr()); return this->Visit(PE->getSubExpr());
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitBinaryOperator(const BinaryOperator *BO) { bool ByteCodeExprGen<Emitter>::VisitBinaryOperator(const BinaryOperator *BO) {
const Expr *LHS = BO->getLHS(); const Expr *LHS = BO->getLHS();
const Expr *RHS = BO->getRHS(); const Expr *RHS = BO->getRHS();
// Deal with operations which have composite or void types. // Deal with operations which have composite or void types.
switch (BO->getOpcode()) { switch (BO->getOpcode()) {
case BO_PtrMemD:
case BO_PtrMemI:
return visitIndirectMember(BO);
case BO_Comma: case BO_Comma:
if (!discard(LHS)) if (!discard(LHS))
return false; return false;
if (!this->Visit(RHS)) if (!this->Visit(RHS))
return false; return false;
return true; return true;
default: default:
break; break;
} }
// Typecheck the args. // Typecheck the args.
Optional<PrimType> LT = classify(LHS->getType()); Optional<PrimType> LT = classify(LHS->getType());
Optional<PrimType> RT = classify(RHS->getType()); Optional<PrimType> RT = classify(RHS->getType());
if (!LT || !RT) { if (!LT || !RT) {
return this->bail(BO); return this->bail(BO);
} }
if (Optional<PrimType> T = classify(BO->getType())) { if (Optional<PrimType> T = classify(BO->getType())) {
switch (BO->getOpcode()) {
case BO_Assign:
return visitAssign(*T, BO);
case BO_AddAssign:
if (LT == PT_Ptr)
return visitPtrAssign(*RT, &ByteCodeExprGen::emitAddOffset, BO);
else
return visitCompoundAssign(*RT, &ByteCodeExprGen::emitAdd, BO);
case BO_SubAssign:
if (LT == PT_Ptr)
return visitPtrAssign(*RT, &ByteCodeExprGen::emitSubOffset, BO);
else
return visitCompoundAssign(*RT, &ByteCodeExprGen::emitSub, BO);
case BO_MulAssign:
return visitCompoundAssign(*RT, &ByteCodeExprGen::emitMul, BO);
case BO_DivAssign:
return visitCompoundAssign(*RT, &ByteCodeExprGen::emitDiv, BO);
case BO_RemAssign:
return visitCompoundAssign(*RT, &ByteCodeExprGen::emitRem, BO);
case BO_AndAssign:
return visitCompoundAssign(*RT, &ByteCodeExprGen::emitAnd, BO);
case BO_XorAssign:
return visitCompoundAssign(*RT, &ByteCodeExprGen::emitXor, BO);
case BO_OrAssign:
return visitCompoundAssign(*RT, &ByteCodeExprGen::emitOr, BO);
case BO_ShlAssign:
if (Ctx.getLangOpts().OpenCL)
return this->bail(BO);
return visitShiftAssign(*RT, &ByteCodeExprGen::emitShl, BO);
case BO_ShrAssign:
if (Ctx.getLangOpts().OpenCL)
return this->bail(BO);
return visitShiftAssign(*RT, &ByteCodeExprGen::emitShr, BO);
case BO_Add: {
if (*LT == PT_Ptr && *RT != PT_Ptr)
return visitOffset(LHS, RHS, BO, &ByteCodeExprGen::emitAddOffset);
if (*LT != PT_Ptr && *RT == PT_Ptr)
return visitOffset(RHS, LHS, BO, &ByteCodeExprGen::emitAddOffset);
break;
}
case BO_Sub: {
if (*LT == PT_Ptr && *RT == PT_Ptr) {
if (!visit(LHS))
return false;
if (!visit(RHS))
return false;
if (isFixedIntegral(*T)) {
if (!this->emitPtrDiffFP(*T, getIntWidth(BO->getType()), BO))
return false;
} else {
if (!this->emitPtrDiff(*T, BO))
return false;
}
return DiscardResult ? this->emitPop(*T, BO) : true;
}
if (*LT == PT_Ptr && *RT != PT_Ptr)
return visitOffset(LHS, RHS, BO, &ByteCodeExprGen::emitSubOffset);
break;
}
case BO_LOr:
case BO_LAnd:
return visitShortCircuit(BO);
default:
break;
}
if (!visit(LHS)) if (!visit(LHS))
return false; return false;
if (!visit(RHS)) if (!visit(RHS))
return false; return false;
auto Discard = [this, T, BO](bool Result) { auto Discard = [this, T, BO](bool Result) {
if (!Result) if (!Result)
return false; return false;
return DiscardResult ? this->emitPop(*T, BO) : true; return DiscardResult ? this->emitPop(*T, BO) : true;
}; };
switch (BO->getOpcode()) { switch (BO->getOpcode()) {
case BO_EQ: case BO_EQ:
return Discard(this->emitEQ(*LT, BO)); return Discard(this->emitEQ(*LT, BO));
case BO_NE: case BO_NE:
return Discard(this->emitNE(*LT, BO)); return Discard(this->emitNE(*LT, BO));
case BO_LT: case BO_LT:
return Discard(this->emitLT(*LT, BO)); return Discard(this->emitLT(*LT, BO));
case BO_LE: case BO_LE:
return Discard(this->emitLE(*LT, BO)); return Discard(this->emitLE(*LT, BO));
case BO_GT: case BO_GT:
return Discard(this->emitGT(*LT, BO)); return Discard(this->emitGT(*LT, BO));
case BO_GE: case BO_GE:
return Discard(this->emitGE(*LT, BO)); return Discard(this->emitGE(*LT, BO));
case BO_Or:
return Discard(this->emitOr(*T, BO));
case BO_And:
return Discard(this->emitAnd(*T, BO));
case BO_Xor:
return Discard(this->emitXor(*T, BO));
case BO_Rem:
return Discard(this->emitRem(*T, BO));
case BO_Div:
return Discard(this->emitDiv(*T, BO));
case BO_Sub: case BO_Sub:
return Discard(this->emitSub(*T, BO)); return Discard(this->emitSub(*T, BO));
case BO_Add: case BO_Add:
return Discard(this->emitAdd(*T, BO)); return Discard(this->emitAdd(*T, BO));
case BO_Mul: case BO_Mul:
return Discard(this->emitMul(*T, BO)); return Discard(this->emitMul(*T, BO));
case BO_Shr:
if (Ctx.getLangOpts().OpenCL)
return this->bail(BO);
return Discard(this->emitShr(*LT, *RT, BO));
case BO_Shl:
if (Ctx.getLangOpts().OpenCL)
return this->bail(BO);
return Discard(this->emitShl(*LT, *RT, BO));
default: default:
return this->bail(BO); return this->bail(BO);
} }
} }
return this->bail(BO); return this->bail(BO);
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryPlus(const UnaryOperator *UO) {
return this->Visit(UO->getSubExpr());
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryMinus(const UnaryOperator *UM) {
if (!visit(UM->getSubExpr()))
return false;
if (Optional<PrimType> T = classify(UM->getType())) {
if (!this->emitMinus(*T, UM))
return false;
return DiscardResult ? this->emitPop(*T, UM) : true;
}
return this->bail(UM);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryDeref(const UnaryOperator *E) {
if (!this->Visit(E->getSubExpr()))
return false;
if (DiscardResult)
return true;
if (needsAdjust(E->getType()))
return this->emitNarrowPtr(E);
return true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryAddrOf(const UnaryOperator *E) {
if (!this->Visit(E->getSubExpr()))
return false;
if (DiscardResult)
return true;
if (needsAdjust(E->getType()))
return this->emitExpandPtr(E);
return true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryPostInc(const UnaryOperator *E) {
if (!visit(E->getSubExpr()))
return false;
PrimType T = *classify(E->getType());
if (!this->emitPostInc(T, E))
return false;
return DiscardResult ? this->emitPop(T, E) : true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryPostDec(const UnaryOperator *E) {
if (!visit(E->getSubExpr()))
return false;
PrimType T = *classify(E->getType());
if (!this->emitPostDec(T, E))
return false;
return DiscardResult ? this->emitPop(T, E) : true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryPreInc(const UnaryOperator *E) {
if (!visit(E->getSubExpr()))
return false;
PrimType T = *classify(E->getType());
if (!this->emitPreInc(T, E))
return false;
return DiscardResult ? this->emitPopPtr(E) : true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryPreDec(const UnaryOperator *E) {
if (!visit(E->getSubExpr()))
return false;
PrimType T = *classify(E->getType());
if (!this->emitPreDec(T, E))
return false;
return DiscardResult ? this->emitPopPtr(E) : true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryNot(const UnaryOperator *UO) {
if (!this->Visit(UO->getSubExpr()))
return false;
PrimType T = *classify(UO->getType());
return DiscardResult ? true : this->emitNot(T, UO);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryLNot(const UnaryOperator *UO) {
if (!this->Visit(UO->getSubExpr()))
return false;
PrimType T = *classify(UO->getType());
return DiscardResult ? true : this->emitLogicalNot(T, UO);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryReal(const UnaryOperator *UO) {
const Expr *SubExpr = UO->getSubExpr();
if (!isa<ComplexType>(SubExpr->getType()))
return this->Visit(SubExpr);
if (!visit(SubExpr))
return false;
if (!this->emitRealElem(UO))
return false;
return DiscardResult ? this->emitPop(PT_Ptr, UO) : true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryImag(const UnaryOperator *UO) {
const Expr *SubExpr = UO->getSubExpr();
if (!isa<ComplexType>(SubExpr->getType()))
return this->Visit(SubExpr);
if (!visit(SubExpr))
return false;
if (!this->emitImagElem(UO))
return false;
return DiscardResult ? this->emitPop(PT_Ptr, UO) : true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitConditionalOperator(
const ConditionalOperator *CO) {
return visitConditionalOperator(CO);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitBinaryConditionalOperator(
const BinaryConditionalOperator *BO) {
if (!visitOpaqueExpr(BO->getOpaqueValue()))
return false;
return visitConditionalOperator(BO);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitConditionalOperator(
const AbstractConditionalOperator *CO) {
if (!visitBool(CO->getCond()))
return false;
LabelTy LabelFalse = this->getLabel();
LabelTy LabelEnd = this->getLabel();
if (!this->jumpFalse(LabelFalse))
return false;
if (!this->Visit(CO->getTrueExpr()))
return false;
if (!this->jump(LabelEnd))
return false;
this->emitLabel(LabelFalse);
if (!this->Visit(CO->getFalseExpr()))
return false;
if (!this->fallthrough(LabelEnd))
return false;
return true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitMemberExpr(const MemberExpr *ME) {
// Fetch a pointer to the required field.
if (auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
return withField(FD, [this, FD, ME](const Record::Field *F) {
const bool IsReference = FD->getType()->isReferenceType();
if (isa<CXXThisExpr>(ME->getBase())) {
if (IsReference) {
if (!this->emitGetThisFieldPtr(F->Offset, ME))
return false;
} else {
if (!this->emitGetPtrThisField(F->Offset, ME))
return false;
}
} else {
if (!visit(ME->getBase()))
return false;
if (IsReference) {
if (!this->emitGetFieldPopPtr(F->Offset, ME))
return false;
} else {
if (!this->emitGetPtrField(F->Offset, ME))
return false;
}
}
return DiscardResult ? this->emitPopPtr(ME) : true;
});
}
// Emit the enum constant value of the enum field.
if (auto *ED = dyn_cast<EnumConstantDecl>(ME->getMemberDecl()))
return this->Visit(ED->getInitExpr());
// Pointer to static field.
if (auto *VD = dyn_cast<VarDecl>(ME->getMemberDecl()))
return DiscardResult ? true : getPtrVarDecl(VD, ME);
// Pointer to static method or method.
if (auto *MD = dyn_cast<CXXMethodDecl>(ME->getMemberDecl())) {
assert(MD->isStatic() && "Method is not static");
return DiscardResult ? true : getPtrConstFn(MD, ME);
}
llvm_unreachable("Invalid member field");
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCallExpr(const CallExpr *CE) {
// Emit the pointer to build the return value into.
if (InitFn && !emitInitFn())
return false;
// Emit the call.
auto T = classify(CE->getType());
if (unsigned BuiltinOp = CE->getBuiltinCallee()) {
// If the callee is a builtin, lower args and invoke.
if (!visitArguments(llvm::makeArrayRef(CE->getArgs(), CE->getNumArgs())))
return false;
if (!this->emitBuiltin(BuiltinOp, CE))
return false;
return DiscardResult && T ? this->emitPop(*T, CE) : true;
} else if (const FunctionDecl *Callee = CE->getDirectCallee()) {
// Emit a direct call if the callee is known.
if (isa<CXXMethodDecl>(Callee) && !Callee->isStatic()) {
auto Args = llvm::makeArrayRef(CE->getArgs(), CE->getNumArgs());
if (!visitArguments(Args.slice(1)))
return false;
if (Args.size() < 1 || !visit(Args[0]))
return false;
return emitMethodCall(dyn_cast<CXXMethodDecl>(Callee), T, CE);
} else {
// Lower arguments.
if (!visitArguments(llvm::makeArrayRef(CE->getArgs(), CE->getNumArgs())))
return false;
return emitFunctionCall(Callee, T, CE);
}
} else {
// Function pointer call.
if (!visitArguments(llvm::makeArrayRef(CE->getArgs(), CE->getNumArgs())))
return false;
if (!visit(CE->getCallee()))
return false;
if (!this->emitIndirectCall(CE))
return false;
return DiscardResult && T ? this->emitPop(*T, CE) : true;
}
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXConstructExpr(
const CXXConstructExpr *E) {
CXXMethodDecl *Cons = E->getConstructor();
bool IsZeroInit = E->requiresZeroInitialization();
// Helper to invoke the constructor to initialize the pointer in InitFn.
auto InvokeConstructor = [this, E, Cons, IsZeroInit] {
if (IsZeroInit && Cons->isTrivial()) {
// Do not invoke constructor, fill in with 0.
auto *RT = E->getType()->getAs<RecordType>();
return visitZeroInitializer(E, RT->getDecl());
} else {
// Avoid materialization.
if (E->isElidable()) {
if (auto *ME = dyn_cast<MaterializeTemporaryExpr>(E->getArg(0)))
return this->Visit(ME->GetTemporaryExpr());
}
// Invoke constructor with 'this' as the pointer.
if (!visitArguments(llvm::makeArrayRef(E->getArgs(), E->getNumArgs())))
return false;
if (!emitInitFn())
return false;
return emitMethodCall(E->getConstructor(), {}, E);
}
};
// Invoke the constructor on each array element or on the single record.
if (auto *CAT = dyn_cast<ConstantArrayType>(E->getType())) {
uint64_t NumElems = CAT->getSize().getZExtValue();
for (unsigned I = 0; I < NumElems; ++I) {
OptionScope<Emitter> Scope(this, [this, I, E](InitFnRef Base) {
if (!Base())
return false;
if (!this->emitConstUint32(I, E))
return false;
if (!this->emitAddOffsetUint32(E))
return false;
return this->emitNarrowPtr(E);
});
if (!InvokeConstructor())
return false;
}
return true;
}
return InvokeConstructor();
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXMemberCallExpr(
const CXXMemberCallExpr *CE) {
// Emit the pointer to build the return value into.
if (InitFn && !emitInitFn())
return false;
// Emit the arguments, this pointer and the call.
auto T = classify(CE->getType());
auto Args = llvm::makeArrayRef(CE->getArgs(), CE->getNumArgs());
if (!visitArguments(Args))
return false;
// Identify member calls with direct targets, invoking them.
if (auto *MD = dyn_cast_or_null<CXXMethodDecl>(CE->getDirectCallee())) {
// Lower the 'this' pointer.
if (!visit(CE->getImplicitObjectArgument()))
return false;
// Direct member call.
if (!MD->isVirtual())
return emitMethodCall(MD, T, CE);
// Indirect virtual call.
if (!this->emitVirtualInvoke(MD, CE))
return false;
return DiscardResult && T ? this->emitPop(*T, CE) : true;
}
// Pattern match the callee for indirect calls to avoid materializing
// the bound member function pointer on the stack.
const Expr *Callee = CE->getCallee();
if (Callee->getType()->isSpecificBuiltinType(BuiltinType::BoundMember)) {
auto *BO = dyn_cast<BinaryOperator>(Callee->IgnoreParens());
switch (BO->getOpcode()) {
case BO_PtrMemD:
case BO_PtrMemI:
// Emit 'this' pointer.
if (!visit(BO->getLHS()))
return false;
// Emit member function.
if (!visit(BO->getRHS()))
return false;
// Emit invocation.
if (!this->emitIndirectInvoke(CE))
return false;
return DiscardResult && T ? this->emitPop(*T, CE) : true;
default:
llvm_unreachable("invalid indirect callee");
}
}
llvm_unreachable("invalid member call expression callee");
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::emitFunctionCall(const FunctionDecl *Callee,
Optional<PrimType> T,
const Expr *E) {
if (Expected<Function *> Func = P.getOrCreateFunction(Callee)) {
if (*Func) {
if (!this->emitCall(*Func, E))
return false;
} else {
if (!this->emitNoCall(Callee, E))
return false;
}
} else {
consumeError(Func.takeError());
return this->bail(E);
}
return DiscardResult && T ? this->emitPop(*T, E) : true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::emitMethodCall(const CXXMethodDecl *Callee,
Optional<PrimType> T,
const Expr *E) {
if (Expected<Function *> Func = P.getOrCreateFunction(Callee)) {
if (*Func) {
if (!this->emitInvoke(*Func, E))
return false;
} else {
if (!this->emitNoInvoke(Callee, E))
return false;
}
} else {
consumeError(Func.takeError());
return this->bail(E);
}
return DiscardResult && T ? this->emitPop(*T, E) : true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitArraySubscriptExpr(
const ArraySubscriptExpr *E) {
if (!visit(E->getBase()))
return false;
auto *Idx = E->getIdx();
if (!visit(Idx))
return false;
if (!this->emitAddOffset(*classify(Idx->getType()), E))
return false;
return DiscardResult ? this->emitPopPtr(E) : this->emitNarrowPtr(E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitExprWithCleanups(
const ExprWithCleanups *CE) {
return this->Visit(CE->getSubExpr());
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCompoundLiteralExpr(
const CompoundLiteralExpr *E) {
return materialize(E, E->getInitializer(),
/*isConst=*/E->getType().isConstQualified(),
/*isGlobal=*/E->isFileScope(),
/*isExtended=*/false);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitMaterializeTemporaryExpr(
const MaterializeTemporaryExpr *ME) {
const bool IsConst = ME->getType().isConstQualified();
const bool IsGlobal = ME->getStorageDuration() == SD_Static;
const bool IsExtended = ME->getStorageDuration() == SD_Automatic;
return materialize(ME, ME->GetTemporaryExpr(), IsConst, IsGlobal, IsExtended);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::materialize(const Expr *Alloc, const Expr *Init,
bool IsConst, bool IsGlobal,
bool IsExtended) {
if (IsGlobal) {
if (auto I = P.createGlobal(Alloc)) {
if (Optional<PrimType> T = classify(Init->getType())) {
// Primitive global - compute and set.
if (!visit(Init))
return false;
if (!this->emitInitGlobal(*T, *I, Alloc))
return false;
return DiscardResult ? true : this->emitGetPtrGlobal(*I, Alloc);
} else {
// Composite global - initialize in place.
if (!visitGlobalInitializer(Init, *I))
return false;
return DiscardResult ? true : this->emitGetPtrGlobal(*I, Alloc);
}
}
} else {
if (Optional<PrimType> T = classify(Init->getType())) {
auto I = allocateLocalPrimitive(Init, *T, IsConst, IsExtended);
if (!visit(Init))
return false;
if (!this->emitSetLocal(*T, I, Init))
return false;
return DiscardResult ? true : this->emitGetPtrLocal(I, Init);
} else {
// Composite types - allocate storage and initialize it.
// This operation leaves a pointer to the temporary on the stack.
if (auto I = allocateLocal(Alloc, IsExtended)) {
if (!visitLocalInitializer(Init, *I))
return false;
return DiscardResult ? true : this->emitGetPtrLocal(*I, Alloc);
}
}
}
return this->bail(Alloc);
}
template <class Emitter>
CharUnits ByteCodeExprGen<Emitter>::getAlignOfType(QualType T,
bool IsPreferred) {
// C++ [expr.alignof]p3:
// When alignof is applied to a reference type, the result is the
// alignment of the referenced type.
if (const ReferenceType *Ref = T->getAs<ReferenceType>())
T = Ref->getPointeeType();
if (T.getQualifiers().hasUnaligned())
return CharUnits::One();
const auto &AST = Ctx.getASTContext();
const bool AlignOfReturnsPreferred =
AST.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver7;
// __alignof is defined to return the preferred alignment.
// Before 8, clang returned the preferred alignment for alignof and _Alignof
// as well.
if (IsPreferred || AlignOfReturnsPreferred)
return AST.toCharUnitsFromBits(AST.getPreferredTypeAlign(T.getTypePtr()));
// alignof and _Alignof are defined to return the ABI alignment.
return AST.getTypeAlignInChars(T.getTypePtr());
}
template <class Emitter>
CharUnits ByteCodeExprGen<Emitter>::getAlignOfExpr(const Expr *E,
bool IsPreferred) {
E = E->IgnoreParens();
// The kinds of expressions that we have special-case logic here for
// should be kept up to date with the special checks for those
// expressions in Sema.
// alignof decl is always accepted, even if it doesn't make sense: we default
// to 1 in those cases.
if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
return Ctx.getASTContext().getDeclAlign(DRE->getDecl(),
/*RefAsPointee*/ true);
if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
return Ctx.getASTContext().getDeclAlign(ME->getMemberDecl(),
/*RefAsPointee*/ true);
return getAlignOfType(E->getType(), IsPreferred);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitImplicitValueInitExpr(
const ImplicitValueInitExpr *E) {
QualType Ty = E->getType();
if (auto *AT = Ty->getAs<AtomicType>())
Ty = AT->getValueType();
if (auto T = Ctx.classify(Ty))
return DiscardResult ? true : visitZeroInitializer(*T, E);
if (auto *RT = Ty->getAs<RecordType>())
return visitZeroInitializer(E, RT->getDecl());
if (auto *CAT = dyn_cast<ConstantArrayType>(Ty)) {
ImplicitValueInitExpr E(CAT->getElementType());
return visitArrayInitializer(CAT, [&E](unsigned) { return &E; });
}
return false;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitSubstNonTypeTemplateParmExpr(
const SubstNonTypeTemplateParmExpr *E) {
return this->Visit(E->getReplacement());
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitUnaryExprOrTypeTraitExpr(
const UnaryExprOrTypeTraitExpr *TE) {
switch (TE->getKind()) {
case UETT_PreferredAlignOf:
case UETT_AlignOf: {
const bool IsPreferred = TE->getKind() == UETT_PreferredAlignOf;
CharUnits Align;
if (TE->isArgumentType())
Align = getAlignOfType(TE->getArgumentType(), IsPreferred);
else
Align = getAlignOfExpr(TE->getArgumentExpr(), IsPreferred);
return DiscardResult ? true : emitConst(TE, Align.getQuantity());
}
case UETT_VecStep: {
return this->bail(TE);
}
case UETT_SizeOf: {
QualType ArgTy = TE->getTypeOfArgument();
// C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
// the result is the size of the referenced type."
if (auto *Ref = ArgTy->getAs<ReferenceType>())
ArgTy = Ref->getPointeeType();
CharUnits Size;
if (ArgTy->isVoidType() || ArgTy->isFunctionType()) {
Size = CharUnits::One();
} else if (ArgTy->isDependentType()) {
return this->emitTrap(TE);
} else if (!ArgTy->isConstantSizeType()) {
// sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
// FIXME: Better diagnostic.
return this->emitTrap(TE);
} else {
Size = Ctx.getASTContext().getTypeSizeInChars(ArgTy);
}
// Emit the size as an integer.
return DiscardResult ? true : emitConst(TE, Size.getQuantity());
}
case UETT_OpenMPRequiredSimdAlign: {
return this->bail(TE);
}
}
llvm_unreachable("unknown expr/type trait");
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
if (DiscardResult)
return true;
return emitConst(E, E->getPackLength());
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
// The opaque expression was evaluated earlier and the pointer was cached in
// a local variable. Load the pointer at this point.
PrimType Ty;
if (Optional<PrimType> T = classify(E->getType())) {
Ty = *T;
} else {
Ty = PT_Ptr;
}
auto It = OpaqueExprs.find(E);
if (It != OpaqueExprs.end()) {
return DiscardResult ? true : this->emitGetLocal(Ty, It->second, E);
} else {
return this->emitTrap(E);
}
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitArrayInitLoopExpr(
const ArrayInitLoopExpr *E) {
// Evaluate the common expression, a pointer to the array copied from.
if (auto *C = E->getCommonExpr()) {
if (!visitOpaqueExpr(C))
return false;
}
// Initialise each element of the array. In this scope, ArrayIndex is set to
// refer to the index of the element being initialised in the callback which
// returns the initialiser of that element.
auto OldArrayIndex = ArrayIndex;
auto ElemInit = [this, E](uint64_t I) {
ArrayIndex = I;
return E->getSubExpr();
};
auto *AT = E->getType()->getAsArrayTypeUnsafe();
if (!visitArrayInitializer(cast<ConstantArrayType>(AT), ElemInit))
return false;
ArrayIndex = OldArrayIndex;
return true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitArrayInitIndexExpr(
const ArrayInitIndexExpr *E) {
assert(!DiscardResult && "ArrayInitIndexExpr should not be discarded");
return ArrayIndex ? this->emitConst(E, *ArrayIndex) : this->emitTrap(E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitInitListExpr(const InitListExpr *E) {
// Initialise a scalar with a given value or zero.
if (auto T = Ctx.classify(E->getType())) {
if (E->getNumInits() == 0)
return DiscardResult ? true : visitZeroInitializer(*T, E);
if (E->getNumInits() == 1)
return this->Visit(E->getInit(0));
return false;
}
// Desugar the type and decide which initializer to call based on it.
QualType Ty = E->getType();
if (auto *AT = dyn_cast<AtomicType>(Ty))
Ty = AT->getValueType();
if (auto *RT = Ty->getAs<RecordType>())
return visitRecordInitializer(RT, E);
if (auto *CT = Ty->getAs<ComplexType>())
return visitComplexInitializer(CT, E);
if (E->isStringLiteralInit()) {
auto *S = cast<StringLiteral>(E->getInit(0)->IgnoreParens());
return visitStringInitializer(S);
}
if (auto CT = Ty->getAsArrayTypeUnsafe()) {
if (auto CAT = dyn_cast<ConstantArrayType>(CT)) {
return visitArrayInitializer(CAT, [E](uint64_t I) {
if (I < E->getNumInits())
return E->getInit(I);
else
return E->getArrayFiller();
});
}
}
return this->bail(E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitTypeTraitExpr(const TypeTraitExpr *E) {
return DiscardResult ? true : this->emitConstBool(E->getValue(), E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXNullPtrLiteralExpr(
const CXXNullPtrLiteralExpr *E) {
return DiscardResult ? true : this->emitNullPtr(E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXBoolLiteralExpr(
const CXXBoolLiteralExpr *B) {
return DiscardResult ? true : this->emitConstBool(B->getValue(), B);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXThisExpr(const CXXThisExpr *TE) {
if (!this->emitThis(TE))
return false;
return DiscardResult ? this->emitPopPtr(TE) : true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXDefaultArgExpr(
const CXXDefaultArgExpr *DE) {
return this->Visit(DE->getExpr());
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXDefaultInitExpr(
const CXXDefaultInitExpr *DE) {
if (auto *E = DE->getExpr())
return this->Visit(E);
return this->emitTrap(DE);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXScalarValueInitExpr(
const CXXScalarValueInitExpr *E) {
QualType Ty = E->getType();
if (auto T = Ctx.classify(Ty))
return DiscardResult ? true : visitZeroInitializer(*T, E);
// Complex numbers are not really scalar.
if (auto *CT = Ty->getAs<ComplexType>()) {
QualType ElemType = CT->getElementType();
PrimType T = classifyPrim(ElemType);
ImplicitValueInitExpr ZE(ElemType);
if (!emitInitFn())
return false;
if (!visit(&ZE))
return false;
if (!this->emitInitElem(T, 0, E))
return false;
if (!visit(&ZE))
return false;
return this->emitInitElemPop(T, 1, E);
}
return false;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXThrowExpr(const CXXThrowExpr *E) {
return this->emitTrap(E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXTemporaryObjectExpr(
const CXXTemporaryObjectExpr *E) {
// In-place construction, simply invoke constructor.
if (InitFn)
return VisitCXXConstructExpr(cast<CXXConstructExpr>(E));
// Allocate a temporary and build into it.
if (auto I = allocateLocal(E, /*isExtended=*/false)) {
OptionScope<Emitter> Scope(this, InitFnRef{[this, &I, E] {
return this->emitGetPtrLocal(*I, E);
}});
if (!VisitCXXConstructExpr(cast<CXXConstructExpr>(E)))
return false;
return DiscardResult ? true : this->emitGetPtrLocal(*I, E);
}
return this->bail(E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
// TODO: implement typeid.
return this->bail(E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXReinterpretCastExpr(
const CXXReinterpretCastExpr *E) {
if (!this->emitReinterpretCastWarning(E))
return false;
return VisitCastExpr(E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXDynamicCastExpr(
const CXXDynamicCastExpr *E) {
if (!Ctx.getLangOpts().CPlusPlus2a) {
if (!this->emitDynamicCastWarning(E))
return false;
}
return VisitCastExpr(E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXInheritedCtorInitExpr(
const CXXInheritedCtorInitExpr *E) {
auto *Ctor = E->getConstructor();
// Forward all parameters.
unsigned Offset = 0;
for (auto *PD : Ctor->parameters()) {
PrimType Ty;
if (Optional<PrimType> T = classify(PD->getType())) {
Ty = *T;
} else {
Ty = PT_Ptr;
}
if (!this->emitGetParam(Ty, Offset, E))
return false;
Offset += align(primSize(Ty));
}
// Invoke the constructor on the same 'this'.
return emitInitFn() && emitMethodCall(Ctor, {}, E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::discard(const Expr *E) { bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
OptionScope<Emitter> Scope(this, /*discardResult=*/true); OptionScope<Emitter> Scope(this, /*discardResult=*/true);
return this->Visit(E); return this->Visit(E);
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::visit(const Expr *E) { bool ByteCodeExprGen<Emitter>::visit(const Expr *E) {
OptionScope<Emitter> Scope(this, /*discardResult=*/false); OptionScope<Emitter> Scope(this, /*discardResult=*/false);
return this->Visit(E); return this->Visit(E);
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitBool(const Expr *E) { bool ByteCodeExprGen<Emitter>::visitBool(const Expr *E) {
if (Optional<PrimType> T = classify(E->getType())) { if (Optional<PrimType> T = classify(E->getType())) {
return visit(E); if (!visit(E))
return false;
return (*T != PT_Bool) ? this->emitTest(*T, E) : true;
} else { } else {
return this->bail(E); return this->bail(E);
} }
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitZeroInitializer(PrimType T, const Expr *E) { bool ByteCodeExprGen<Emitter>::visitZeroInitializer(PrimType T, const Expr *E) {
switch (T) { switch (T) {
Show All 10 Linesbool ByteCodeExprGen<Emitter>::visitZeroInitializer(PrimType T, const Expr *E) {
case PT_Sint32: case PT_Sint32:
return this->emitZeroSint32(E); return this->emitZeroSint32(E);
case PT_Uint32: case PT_Uint32:
return this->emitZeroUint32(E); return this->emitZeroUint32(E);
case PT_Sint64: case PT_Sint64:
return this->emitZeroSint64(E); return this->emitZeroSint64(E);
case PT_Uint64: case PT_Uint64:
return this->emitZeroUint64(E); return this->emitZeroUint64(E);
case PT_UintFP:
return this->emitZeroFPUintFP(getIntWidth(E->getType()), E);
case PT_SintFP:
return this->emitZeroFPSintFP(getIntWidth(E->getType()), E);
case PT_RealFP:
return this->emitZeroRealFP(getFltSemantics(E->getType()), E);
case PT_Ptr: case PT_Ptr:
return this->emitNullPtr(E); return this->emitNullPtr(E);
case PT_FnPtr:
return this->emitNullFnPtr(E);
case PT_MemPtr:
return this->emitNullMemPtr(E);
} }
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitOffset(const Expr *Ptr, const Expr *Offset,
const Expr *E, UnaryFn OffsetFn) {
if (!visit(Ptr))
return false;
if (!visit(Offset))
return false;
if (!(this->*OffsetFn)(*classify(Offset->getType()), E))
return false;
return DiscardResult ? this->emitPopPtr(E) : true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitIndirectMember(const BinaryOperator *E) {
if (!visit(E->getLHS()))
return false;
if (!visit(E->getRHS()))
return false;
if (!this->emitGetPtrFieldIndirect(E))
return false;
if (DiscardResult && !this->emitPopPtr(E))
return false;
return true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitAssign(PrimType T,
const BinaryOperator *BO) {
return dereference(
BO->getLHS(), DerefKind::Write,
[this, BO](PrimType) {
// Generate a value to store - will be set.
return visit(BO->getRHS());
},
[this, BO](PrimType T) {
// Pointer on stack - compile RHS and assign to pointer.
if (!visit(BO->getRHS()))
return false;
if (BO->getLHS()->refersToBitField()) {
if (DiscardResult)
return this->emitStoreBitFieldPop(T, BO);
else
return this->emitStoreBitField(T, BO);
} else {
if (DiscardResult)
return this->emitStorePop(T, BO);
else
return this->emitStore(T, BO);
}
});
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitShiftAssign(PrimType RHS, BinaryFn F,
const BinaryOperator *BO) {
return dereference(
BO->getLHS(), DerefKind::ReadWrite,
[this, F, RHS, BO](PrimType LHS) {
if (!visit(BO->getRHS()))
return false;
(this->*F)(LHS, RHS, BO);
return true;
},
[this, F, RHS, BO](PrimType LHS) {
if (!this->emitLoad(LHS, BO))
return false;
if (!visit(BO->getRHS()))
return false;
if (!(this->*F)(LHS, RHS, BO))
return false;
if (BO->getLHS()->refersToBitField()) {
if (DiscardResult)
return this->emitStoreBitFieldPop(LHS, BO);
else
return this->emitStoreBitField(LHS, BO);
} else {
if (DiscardResult)
return this->emitStorePop(LHS, BO);
else
return this->emitStore(LHS, BO);
}
});
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitCompoundAssign(PrimType RHS, UnaryFn F,
const BinaryOperator *BO) {
auto ApplyOperation = [this, F, BO, RHS](PrimType LHS) {
auto *ExprRHS = BO->getRHS();
auto *ExprLHS = BO->getLHS();
if (ExprLHS->getType() == ExprRHS->getType()) {
if (!visit(BO->getRHS()))
return false;
if (!(this->*F)(LHS, BO))
return false;
} else {
if (!emitConv(LHS, ExprLHS->getType(), RHS, ExprRHS->getType(), ExprRHS))
return false;
if (!visit(ExprRHS))
return false;
if (!(this->*F)(RHS, BO))
return false;
if (!emitConv(RHS, ExprRHS->getType(), LHS, ExprLHS->getType(), ExprLHS))
return false;
}
return true;
};
return dereference(
BO->getLHS(), DerefKind::ReadWrite, ApplyOperation,
[this, BO, &ApplyOperation](PrimType LHS) -> bool {
if (!this->emitLoad(LHS, BO))
return false;
if (!ApplyOperation(LHS))
return false;
if (BO->getLHS()->refersToBitField()) {
if (DiscardResult)
return this->emitStoreBitFieldPop(LHS, BO);
else
return this->emitStoreBitField(LHS, BO);
} else {
if (DiscardResult)
return this->emitStorePop(LHS, BO);
else
return this->emitStore(LHS, BO);
}
});
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitPtrAssign(PrimType RHS, UnaryFn F,
const BinaryOperator *BO) {
return dereference(
BO->getLHS(), DerefKind::ReadWrite,
[this, F, BO, RHS](PrimType LHS) {
if (!visit(BO->getRHS()))
return false;
if (!(this->*F)(RHS, BO))
return false;
return true;
},
[this, BO, F, RHS](PrimType LHS) -> bool {
if (!this->emitLoad(LHS, BO))
return false;
if (!visit(BO->getRHS()))
return false;
if (!(this->*F)(RHS, BO))
return false;
if (BO->getLHS()->refersToBitField())
return this->bail(BO);
if (DiscardResult)
return this->emitStorePop(LHS, BO);
else
return this->emitStore(LHS, BO);
});
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::emitConv(PrimType LHS, QualType TyLHS,
PrimType RHS, QualType TyRHS,
const Expr *Cast) {
if (isPrimitiveIntegral(RHS)) {
if (isFixedReal(LHS)) {
return this->emitCastRealFPToAlu(LHS, RHS, Cast);
} else {
return this->emitCast(LHS, RHS, Cast);
}
} else if (isFixedIntegral(RHS)) {
if (isFixedReal(LHS)) {
return this->emitCastRealFPToAluFP(LHS, RHS, getIntWidth(TyRHS), Cast);
} else {
return this->emitCastFP(LHS, RHS, getIntWidth(TyRHS), Cast);
}
} else if (isFixedReal(RHS)) {
return this->emitCastRealFP(LHS, getFltSemantics(TyRHS), Cast);
}
llvm_unreachable("Invalid conversion");
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitShortCircuit(const BinaryOperator *E) {
if (!visitBool(E->getLHS()))
return false;
LabelTy Short = this->getLabel();
const bool IsTrue = E->getOpcode() == BO_LAnd;
if (DiscardResult) {
if (!(IsTrue ? this->jumpFalse(Short) : this->jumpTrue(Short)))
return false;
if (!this->discard(E->getRHS()))
return false;
} else {
if (!this->emitDupBool(E))
return false;
if (!(IsTrue ? this->jumpFalse(Short) : this->jumpTrue(Short)))
return false;
if (!this->emitPopBool(E))
return false;
if (!visitBool(E->getRHS()))
return false;
}
this->fallthrough(Short);
return true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::dereference( bool ByteCodeExprGen<Emitter>::dereference(
const Expr *LV, DerefKind AK, llvm::function_ref<bool(PrimType)> Direct, const Expr *LV, DerefKind AK, llvm::function_ref<bool(PrimType)> Direct,
llvm::function_ref<bool(PrimType)> Indirect) { llvm::function_ref<bool(PrimType)> Indirect) {
if (Optional<PrimType> T = classify(LV->getType())) { if (Optional<PrimType> T = classify(LV->getType())) {
if (!LV->refersToBitField()) { if (!LV->refersToBitField()) {
// Only primitive, non bit-field types can be dereferenced directly. // Only primitive, non bit-field types can be dereferenced directly.
if (auto *DE = dyn_cast<DeclRefExpr>(LV)) { if (auto *DE = dyn_cast<DeclRefExpr>(LV)) {
if (!DE->getDecl()->getType()->isReferenceType()) { if (!DE->getDecl()->getType()->isReferenceType()) {
if (auto *PD = dyn_cast<ParmVarDecl>(DE->getDecl())) if (auto *PD = dyn_cast<ParmVarDecl>(DE->getDecl()))
return dereferenceParam(LV, *T, PD, AK, Direct, Indirect); return dereferenceParam(LV, *T, PD, AK, Direct, Indirect);
if (auto *VD = dyn_cast<VarDecl>(DE->getDecl())) if (auto *VD = dyn_cast<VarDecl>(DE->getDecl()))
return dereferenceVar(LV, *T, VD, AK, Direct, Indirect); return dereferenceVar(LV, *T, VD, AK, Direct, Indirect);
} }
} }
if (auto *ME = dyn_cast<MemberExpr>(LV)) {
if (!ME->getMemberDecl()->getType()->isReferenceType())
return dereferenceMember(ME, *T, AK, Direct, Indirect);
}
} }
if (!visit(LV)) if (!visit(LV))
return false; return false;
return Indirect(*T); return Indirect(*T);
} }
return false; return false;
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Lines if (!DiscardResult && AK == DerefKind::Read) {
} }
} }
// Value cannot be produced - try to emit pointer. // Value cannot be produced - try to emit pointer.
return visit(LV) && Indirect(T); return visit(LV) && Indirect(T);
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::dereferenceMember(
const MemberExpr *ME, PrimType T, DerefKind AK,
llvm::function_ref<bool(PrimType)> Direct,
llvm::function_ref<bool(PrimType)> Indirect) {
// Fetch or read the required field.
if (auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
return withField(FD, [this, ME, AK, T, Direct](const Record::Field *F) {
const unsigned Off = F->Offset;
if (isa<CXXThisExpr>(ME->getBase())) {
switch (AK) {
case DerefKind::Read:
if (!this->emitGetThisField(T, Off, ME))
return false;
return DiscardResult ? this->emitPop(T, ME) : true;
case DerefKind::Write:
if (!Direct(T))
return false;
if (!this->emitSetThisField(T, Off, ME))
return false;
return DiscardResult ? true : this->emitGetPtrThisField(Off, ME);
case DerefKind::ReadWrite:
if (!this->emitGetThisField(T, Off, ME))
return false;
if (!Direct(T))
return false;
if (!this->emitSetThisField(T, Off, ME))
return false;
return DiscardResult ? true : this->emitGetPtrThisField(Off, ME);
}
} else {
if (!visit(ME->getBase()))
return false;
switch (AK) {
case DerefKind::Read:
if (!this->emitGetFieldPop(T, Off, ME))
return false;
return DiscardResult ? this->emitPop(T, ME) : true;
case DerefKind::Write:
if (!Direct(T))
return false;
if (!this->emitSetField(T, Off, ME))
return false;
return DiscardResult ? true : this->emitGetPtrField(Off, ME);
case DerefKind::ReadWrite:
if (!this->emitGetField(T, Off, ME))
return false;
if (!Direct(T))
return false;
if (!this->emitSetField(T, Off, ME))
return false;
return DiscardResult ? true : this->emitGetPtrField(Off, ME);
}
}
});
}
// Value cannot be produced - try to emit pointer.
return visit(ME) && Indirect(T);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::emitConst(PrimType T, unsigned NumBits, bool ByteCodeExprGen<Emitter>::emitConst(PrimType T, unsigned NumBits,
const APInt &Value, const Expr *E) { const APInt &Value, const Expr *E) {
switch (T) { switch (T) {
case PT_Sint8: case PT_Sint8:
return this->emitConstSint8(Value.getSExtValue(), E); return this->emitConstSint8(Value.getSExtValue(), E);
case PT_Uint8: case PT_Uint8:
return this->emitConstUint8(Value.getZExtValue(), E); return this->emitConstUint8(Value.getZExtValue(), E);
case PT_Sint16: case PT_Sint16:
return this->emitConstSint16(Value.getSExtValue(), E); return this->emitConstSint16(Value.getSExtValue(), E);
case PT_Uint16: case PT_Uint16:
return this->emitConstUint16(Value.getZExtValue(), E); return this->emitConstUint16(Value.getZExtValue(), E);
case PT_Sint32: case PT_Sint32:
return this->emitConstSint32(Value.getSExtValue(), E); return this->emitConstSint32(Value.getSExtValue(), E);
case PT_Uint32: case PT_Uint32:
return this->emitConstUint32(Value.getZExtValue(), E); return this->emitConstUint32(Value.getZExtValue(), E);
case PT_Sint64: case PT_Sint64:
return this->emitConstSint64(Value.getSExtValue(), E); return this->emitConstSint64(Value.getSExtValue(), E);
case PT_Uint64: case PT_Uint64:
return this->emitConstUint64(Value.getZExtValue(), E); return this->emitConstUint64(Value.getZExtValue(), E);
case PT_SintFP:
return this->emitConstFPSintFP(NumBits, Value.getSExtValue(), E);
case PT_UintFP:
return this->emitConstFPUintFP(NumBits, Value.getZExtValue(), E);
case PT_Bool: case PT_Bool:
return this->emitConstBool(Value.getBoolValue(), E); return this->emitConstBool(Value.getBoolValue(), E);
case PT_Ptr: case PT_Ptr:
case PT_FnPtr:
case PT_RealFP:
case PT_MemPtr:
llvm_unreachable("Invalid integral type"); llvm_unreachable("Invalid integral type");
break; break;
} }
} }
template <class Emitter> template <class Emitter>
unsigned ByteCodeExprGen<Emitter>::allocateLocalPrimitive(DeclTy &&Src, unsigned ByteCodeExprGen<Emitter>::allocateLocalPrimitive(DeclTy &&Src,
PrimType Ty, PrimType Ty,
Show All 31 LinesByteCodeExprGen<Emitter>::allocateLocal(DeclTy &&Src, bool IsExtended) {
Scope::Local Local = this->createLocal(D); Scope::Local Local = this->createLocal(D);
if (Key) if (Key)
Locals.insert({Key, Local}); Locals.insert({Key, Local});
VarScope->add(Local, IsExtended); VarScope->add(Local, IsExtended);
return Local.Offset; return Local.Offset;
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitArguments(ArrayRef<const Expr *> Args) {
for (auto *Arg : Args) {
if (!visitArgument(Arg))
return false;
}
return true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitArgument(const Expr *E) {
// Primitive or pointer argument - leave it on the stack.
if (Optional<PrimType> T = classify(E))
return visit(E);
// Composite argument - copy construct and push pointer.
if (auto I = allocateLocal(E, /*isExtended=*/false)) {
if (!visitLocalInitializer(E, *I))
return false;
return this->emitGetPtrLocal(*I, E);
}
return this->bail(E);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitInitializer( bool ByteCodeExprGen<Emitter>::visitInitializer(
const Expr *Init, InitFnRef InitFn) { const Expr *Init, InitFnRef InitFn) {
OptionScope<Emitter> Scope(this, InitFn); OptionScope<Emitter> Scope(this, InitFn);
return this->Visit(Init); return this->Visit(Init);
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::getPtrConstFn(const FunctionDecl *FD,
const Expr *E) {
if (Expected<Function *> Func = P.getOrCreateFunction(FD)) {
if (*Func)
return this->emitConstFn(*Func, E);
else
return this->emitConstNoFn(FD, E);
} else {
consumeError(Func.takeError());
return this->emitConstNoFn(FD, E);
}
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::getPtrVarDecl(const VarDecl *VD, const Expr *E) { bool ByteCodeExprGen<Emitter>::getPtrVarDecl(const VarDecl *VD, const Expr *E) {
// Generate a pointer to the local, loading refs. // Generate a pointer to the local, loading refs.
if (Optional<unsigned> Idx = getGlobalIdx(VD)) { if (Optional<unsigned> Idx = getGlobalIdx(VD)) {
if (VD->getType()->isReferenceType()) if (VD->getType()->isReferenceType())
return this->emitGetGlobalPtr(*Idx, E); return this->emitGetGlobalPtr(*Idx, E);
else else
return this->emitGetPtrGlobal(*Idx, E); return this->emitGetPtrGlobal(*Idx, E);
} }
Show All 11 Lines if (!VD->hasLocalStorage()) {
// Not constexpr, but a global var - can have pointer taken. // Not constexpr, but a global var - can have pointer taken.
Program::DeclScope Scope(P, VD); Program::DeclScope Scope(P, VD);
return P.getOrCreateGlobal(VD); return P.getOrCreateGlobal(VD);
} }
return {}; return {};
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitStringInitializer(const StringLiteral *S) {
// Find the type to represent characters.
const unsigned CharBytes = S->getCharByteWidth();
PrimType CharType;
switch (CharBytes) {
case 1:
CharType = PT_Sint8;
break;
case 2:
CharType = PT_Uint16;
break;
case 4:
CharType = PT_Uint32;
break;
default:
llvm_unreachable("Unsupported character width!");
}
if (!emitInitFn())
return false;
// Initialise elements one by one, advancing the pointer.
const unsigned NumBits = CharBytes * getCharBit();
for (unsigned I = 0, N = S->getLength(); I < N; ++I) {
// Set individual characters here.
APInt CodeUnit(NumBits, S->getCodeUnit(I));
// Lower the code point.
if (!emitConst(CharType, NumBits, CodeUnit, S))
return false;
// Set the character.
if (!this->emitInitElem(CharType, I, S))
return false;
}
// Set the null terminator.
if (!emitConst(CharType, NumBits, APInt(NumBits, 0), S))
return false;
if (!this->emitInitElemPop(CharType, S->getLength(), S))
return false;
// String was initialised.
return true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitRecordInitializer(
const RecordType *RT, const InitListExpr *List) {
if (auto *R = P.getOrCreateRecord(RT->getDecl())) {
auto InitElem = [this, R](const Record::Field *F, const Expr *Init) {
if (Optional<PrimType> T = classify(Init)) {
if (!emitInitFn())
return false;
if (!visit(Init))
return false;
if (R->isUnion())
return this->emitInitFieldActive(*T, F->Offset, Init);
else if (F->Decl->isBitField())
return this->emitInitBitField(*T, F, Init);
else
return this->emitInitField(*T, F->Offset, Init);
} else {
OptionScope<Emitter> Scope(this, [this, F, Init](InitFnRef Ptr) {
return Ptr() && this->emitGetPtrField(F->Offset, Init);
});
return this->Visit(Init);
}
};
if (R->isUnion()) {
if (auto *InitField = List->getInitializedFieldInUnion()) {
auto *F = R->getField(InitField);
switch (List->getNumInits()) {
case 0: {
// Clang doesn't provide an initializer - need to default init.
ImplicitValueInitExpr Init(InitField->getType());
return InitElem(F, &Init);
}
case 1:
// Initialise the element.
return InitElem(F, List->getInit(0));
default:
// Malformed initializer.
return false;
}
} else {
/// Union with no fields.
return true;
}
} else {
for (unsigned I = 0, N = R->getNumBases(); I < N; ++I) {
unsigned Off = R->getBase(I)->Offset;
const Expr *Init = List->getInit(I);
OptionScope<Emitter> Scope(this, [this, Off, Init] (InitFnRef Ptr) {
return Ptr() && this->emitGetPtrBase(Off, Init);
});
if (!this->Visit(Init))
return false;
}
for (unsigned I = 0, N = R->getNumFields(); I < N; ++I) {
const Expr * Init = List->getInit(I + R->getNumBases());
if (!InitElem(R->getField(I), Init))
return false;
}
}
return true;
}
return this->bail(RT->getDecl());
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitComplexInitializer(
const ComplexType *CT, const InitListExpr *List) {
QualType ElemTy = CT->getElementType();
ImplicitValueInitExpr ZE(ElemTy);
PrimType T = classifyPrim(ElemTy);
auto InitElem = [this, T](unsigned Index, const Expr *E) -> bool {
if (!emitInitFn())
return false;
if (!visit(E))
return false;
return this->emitInitElemPop(T, Index, E);
};
switch (List->getNumInits()) {
case 0:
return InitElem(0, &ZE) && InitElem(1, &ZE);
case 1:
return this->Visit(List->getInit(0));
case 2:
return InitElem(0, List->getInit(0)) && InitElem(1, List->getInit(1));
default:
llvm_unreachable("invalid complex initializer");
}
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitCastToComplex(const CastExpr *CE) {
QualType SubType = CE->getSubExpr()->getType();
PrimType T = classifyPrim(SubType);
if (!emitInitFn())
return false;
if (!this->visit(CE->getSubExpr()))
return false;
if (!this->emitInitElem(T, 0, CE))
return false;
ImplicitValueInitExpr ZE(SubType);
if (!visit(&ZE))
return false;
return this->emitInitElemPop(T, 1, CE);
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitArrayInitializer(
const ConstantArrayType *AT,
llvm::function_ref<const Expr *(uint64_t)> Elem) {
uint64_t NumElems = AT->getSize().getZExtValue();
if (Optional<PrimType> T = classify(AT->getElementType())) {
if (NumElems > 0 && !emitInitFn())
return false;
for (unsigned I = 0; I < NumElems; ++I) {
const Expr *ElemInit = Elem(I);
// Construct the value.
if (!visit(ElemInit))
return false;
// Set the element.
if (I + 1 != NumElems) {
if (!this->emitInitElem(*T, I, ElemInit))
return false;
} else {
if (!this->emitInitElemPop(*T, I, ElemInit))
return false;
}
}
return true;
} else {
for (unsigned I = 0; I < NumElems; ++I) {
const Expr *ElemInit = Elem(I);
// Generate a pointer to the field from the array pointer.
OptionScope<Emitter> Scope(this, [this, I, ElemInit](InitFnRef Ptr) {
if (!Ptr())
return false;
if (!this->emitConstUint32(I, ElemInit))
return false;
if (!this->emitAddOffsetUint32(ElemInit))
return false;
return this->emitNarrowPtr(ElemInit);
});
if (!this->Visit(ElemInit))
return false;
}
return true;
}
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitZeroInitializer(const Expr *E,
const RecordDecl *RD) {
Record *R = P.getOrCreateRecord(RD);
if (!R)
return false;
for (auto &B : R->bases()) {
OptionScope<Emitter> Scope(this, [this, &B, E](InitFnRef Ptr) {
if (!Ptr())
return false;
return this->emitGetPtrBase(B.Offset, E);
});
if (!visitZeroInitializer(E, B.Decl))
return false;
}
for (auto &F : R->fields()) {
ImplicitValueInitExpr Init(F.Decl->getType());
if (Optional<PrimType> T = classify(F.Decl->getType())) {
if (!emitInitFn())
return false;
if (!visitZeroInitializer(*T, &Init))
return false;
if (F.Decl->isBitField()) {
if (!this->emitInitBitField(*T, &F, E))
return false;
} else {
if (!this->emitInitField(*T, F.Offset, E))
return false;
}
} else {
OptionScope<Emitter> Scope(this, [this, &F, E](InitFnRef Ptr) {
if (!Ptr())
return false;
return this->emitGetPtrField(F.Offset, E);
});
if (!this->Visit(&Init))
return false;
}
}
return true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::withField(
const FieldDecl *F,
llvm::function_ref<bool(const Record::Field *)> GenField) {
if (auto *R = getRecord(F->getParent()))
if (auto *Field = R->getField(F))
return GenField(Field);
return false;
}
template <class Emitter>
const RecordType *ByteCodeExprGen<Emitter>::getRecordTy(QualType Ty) { const RecordType *ByteCodeExprGen<Emitter>::getRecordTy(QualType Ty) {
if (auto *PT = dyn_cast<PointerType>(Ty)) if (auto *PT = dyn_cast<PointerType>(Ty))
return PT->getPointeeType()->getAs<RecordType>(); return PT->getPointeeType()->getAs<RecordType>();
else else
return Ty->getAs<RecordType>(); return Ty->getAs<RecordType>();
} }
template <class Emitter> template <class Emitter>
Record *ByteCodeExprGen<Emitter>::getRecord(QualType Ty) { Record *ByteCodeExprGen<Emitter>::getRecord(QualType Ty) {
if (auto *RecordTy = getRecordTy(Ty)) { if (auto *RecordTy = getRecordTy(Ty)) {
return getRecord(RecordTy->getDecl()); return getRecord(RecordTy->getDecl());
} }
return nullptr; return nullptr;
} }
template <class Emitter> template <class Emitter>
Record *ByteCodeExprGen<Emitter>::getRecord(const RecordDecl *RD) { Record *ByteCodeExprGen<Emitter>::getRecord(const RecordDecl *RD) {
return P.getOrCreateRecord(RD); return P.getOrCreateRecord(RD);
} }
template <class Emitter> template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitOpaqueExpr(const OpaqueValueExpr *E) {
PrimType Ty;
if (Optional<PrimType> T = classify(E->getType())) {
Ty = *T;
} else {
Ty = PT_Ptr;
}
auto Off = allocateLocalPrimitive(E, Ty, /*isConst=*/true);
if (!visit(E->getSourceExpr()))
return false;
this->emitSetLocal(Ty, Off, E);
OpaqueExprs.insert({E, Off});
return true;
}
template <class Emitter>
bool ByteCodeExprGen<Emitter>::visitExpr(const Expr *Exp) { bool ByteCodeExprGen<Emitter>::visitExpr(const Expr *Exp) {
ExprScope<Emitter> RootScope(this); ExprScope<Emitter> RootScope(this);
if (!visit(Exp)) if (!visit(Exp))
return false; return false;
if (Optional<PrimType> T = classify(Exp)) if (Optional<PrimType> T = classify(Exp))
return this->emitRet(*T, Exp); return this->emitRet(*T, Exp);
else else
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

clang/lib/AST/Interp/ByteCodeStmtGen.h

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linesprivate:
friend class LabelScope<Emitter>; friend class LabelScope<Emitter>;
friend class LoopScope<Emitter>; friend class LoopScope<Emitter>;
friend class SwitchScope<Emitter>; friend class SwitchScope<Emitter>;
// Statement visitors. // Statement visitors.
bool visitStmt(const Stmt *S); bool visitStmt(const Stmt *S);
bool visitCompoundStmt(const CompoundStmt *S); bool visitCompoundStmt(const CompoundStmt *S);
bool visitDeclStmt(const DeclStmt *DS); bool visitDeclStmt(const DeclStmt *DS);
bool visitForStmt(const ForStmt *FS);
bool visitWhileStmt(const WhileStmt *DS);
bool visitDoStmt(const DoStmt *DS);
bool visitReturnStmt(const ReturnStmt *RS); bool visitReturnStmt(const ReturnStmt *RS);
bool visitIfStmt(const IfStmt *IS); bool visitIfStmt(const IfStmt *IS);
bool visitBreakStmt(const BreakStmt *BS);
bool visitContinueStmt(const ContinueStmt *CS);
bool visitSwitchStmt(const SwitchStmt *SS);
bool visitCaseStmt(const SwitchCase *CS);
/// Compiles a variable declaration. /// Compiles a variable declaration.
bool visitVarDecl(const VarDecl *VD); bool visitVarDecl(const VarDecl *VD);
/// Visits a field initializer.
bool visitCtorInit(Record *This, const CXXCtorInitializer *Init);
private: private:
/// Type of the expression returned by the function. /// Type of the expression returned by the function.
llvm::Optional<PrimType> ReturnType; llvm::Optional<PrimType> ReturnType;
/// Current scope. /// Current scope.
LabelScope<Emitter> *LabelScope = nullptr; LabelScope<Emitter> *LabelScope = nullptr;
/// Switch case mapping. /// Switch case mapping.
Show All 16 Lines

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

Show First 20 Lines • Show All 99 Lines • ▼ Show 20 Lines
} // namespace clang } // namespace clang
template <class Emitter> template <class Emitter>
bool ByteCodeStmtGen<Emitter>::visitFunc(const FunctionDecl *F) { bool ByteCodeStmtGen<Emitter>::visitFunc(const FunctionDecl *F) {
// Classify the return type. // Classify the return type.
ReturnType = this->classify(F->getReturnType()); ReturnType = this->classify(F->getReturnType());
// Set up fields and context if a constructor. // Set up fields and context if a constructor.
if (auto *MD = dyn_cast<CXXMethodDecl>(F)) if (auto *MD = dyn_cast<CXXMethodDecl>(F)) {
return this->bail(MD); const CXXRecordDecl *RD = MD->getParent()->getCanonicalDecl();
if (auto *R = this->getRecord(RD)) {
if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
if (CD->isDelegatingConstructor()) {
CXXConstructorDecl::init_const_iterator I = CD->init_begin();
{
ExprScope<Emitter> InitScope(this);
if (!this->visitThisInitializer((*I)->getInit()))
return false;
}
} else {
// Compile all member initializers.
for (const CXXCtorInitializer *Init : CD->inits()) {
if (!visitCtorInit(R, Init))
return false;
}
}
}
} else {
return this->bail(RD);
}
}
if (auto *Body = F->getBody()) if (auto *Body = F->getBody())
if (!visitStmt(Body)) if (!visitStmt(Body))
return false; return false;
// Emit a guard return to protect against a code path missing one. // Emit a guard return to protect against a code path missing one.
if (F->getReturnType()->isVoidType()) if (F->getReturnType()->isVoidType())
return this->emitRetVoid(SourceInfo{}); return this->emitRetVoid(SourceInfo{});
else else
return this->emitNoRet(SourceInfo{}); return this->emitNoRet(SourceInfo{});
} }
template <class Emitter> template <class Emitter>
bool ByteCodeStmtGen<Emitter>::visitStmt(const Stmt *S) { bool ByteCodeStmtGen<Emitter>::visitStmt(const Stmt *S) {
switch (S->getStmtClass()) { switch (S->getStmtClass()) {
case Stmt::CompoundStmtClass: case Stmt::CompoundStmtClass:
return visitCompoundStmt(cast<CompoundStmt>(S)); return visitCompoundStmt(cast<CompoundStmt>(S));
case Stmt::DeclStmtClass: case Stmt::DeclStmtClass:
return visitDeclStmt(cast<DeclStmt>(S)); return visitDeclStmt(cast<DeclStmt>(S));
case Stmt::ForStmtClass:
return visitForStmt(cast<ForStmt>(S));
case Stmt::WhileStmtClass:
return visitWhileStmt(cast<WhileStmt>(S));
case Stmt::DoStmtClass:
return visitDoStmt(cast<DoStmt>(S));
case Stmt::ReturnStmtClass: case Stmt::ReturnStmtClass:
return visitReturnStmt(cast<ReturnStmt>(S)); return visitReturnStmt(cast<ReturnStmt>(S));
case Stmt::IfStmtClass: case Stmt::IfStmtClass:
return visitIfStmt(cast<IfStmt>(S)); return visitIfStmt(cast<IfStmt>(S));
case Stmt::BreakStmtClass:
return visitBreakStmt(cast<BreakStmt>(S));
case Stmt::ContinueStmtClass:
return visitContinueStmt(cast<ContinueStmt>(S));
case Stmt::SwitchStmtClass:
return visitSwitchStmt(cast<SwitchStmt>(S));
case Stmt::CaseStmtClass:
case Stmt::DefaultStmtClass:
return visitCaseStmt(cast<SwitchCase>(S));
case Stmt::NullStmtClass: case Stmt::NullStmtClass:
return true; return true;
default: { default: {
if (auto *Exp = dyn_cast<Expr>(S)) if (auto *Exp = dyn_cast<Expr>(S))
return this->discard(Exp); return this->discard(Exp);
return this->bail(S); return this->bail(S);
} }
} }
Show All 24 Lines if (auto *DD = dyn_cast<DecompositionDecl>(D)) {
return this->bail(DD); return this->bail(DD);
} }
} }
return true; return true;
} }
template <class Emitter> template <class Emitter>
bool ByteCodeStmtGen<Emitter>::visitForStmt(const ForStmt *FS) {
// Compile the initialisation statement in an outer scope.
BlockScope<Emitter> OuterScope(this);
if (auto *Init = FS->getInit())
if (!visitStmt(Init))
return false;
LabelTy LabelStart = this->getLabel();
LabelTy LabelEnd = this->getLabel();
// Compile the condition, body and increment in the loop scope.
this->emitLabel(LabelStart);
{
BlockScope<Emitter> InnerScope(this);
if (auto *Cond = FS->getCond()) {
if (auto *CondDecl = FS->getConditionVariableDeclStmt())
if (!visitDeclStmt(CondDecl))
return false;
if (!this->visit(Cond))
return false;
if (!this->jumpFalse(LabelEnd))
return false;
}
if (auto *Body = FS->getBody()) {
LabelTy LabelSkip = this->getLabel();
LoopScope<Emitter> FlowScope(this, LabelEnd, LabelSkip);
if (!visitStmt(Body))
return false;
this->emitLabel(LabelSkip);
}
if (auto *Inc = FS->getInc()) {
ExprScope<Emitter> IncScope(this);
if (!this->discard(Inc))
return false;
}
if (!this->jump(LabelStart))
return false;
}
this->emitLabel(LabelEnd);
return true;
}
template <class Emitter>
bool ByteCodeStmtGen<Emitter>::visitWhileStmt(const WhileStmt *WS) {
LabelTy LabelStart = this->getLabel();
LabelTy LabelEnd = this->getLabel();
this->emitLabel(LabelStart);
{
BlockScope<Emitter> InnerScope(this);
if (auto *CondDecl = WS->getConditionVariableDeclStmt())
if (!visitDeclStmt(CondDecl))
return false;
if (!this->visit(WS->getCond()))
return false;
if (!this->jumpFalse(LabelEnd))
return false;
{
LoopScope<Emitter> FlowScope(this, LabelEnd, LabelStart);
if (!visitStmt(WS->getBody()))
return false;
}
if (!this->jump(LabelStart))
return false;
}
this->emitLabel(LabelEnd);
return true;
}
template <class Emitter>
bool ByteCodeStmtGen<Emitter>::visitDoStmt(const DoStmt *DS) {
LabelTy LabelStart = this->getLabel();
LabelTy LabelEnd = this->getLabel();
LabelTy LabelSkip = this->getLabel();
this->emitLabel(LabelStart);
{
{
LoopScope<Emitter> FlowScope(this, LabelEnd, LabelSkip);
if (!visitStmt(DS->getBody()))
return false;
this->emitLabel(LabelSkip);
}
{
ExprScope<Emitter> CondScope(this);
if (!this->visitBool(DS->getCond()))
return false;
}
if (!this->jumpTrue(LabelStart))
return false;
}
this->emitLabel(LabelEnd);
return true;
}
template <class Emitter>
bool ByteCodeStmtGen<Emitter>::visitReturnStmt(const ReturnStmt *RS) { bool ByteCodeStmtGen<Emitter>::visitReturnStmt(const ReturnStmt *RS) {
if (const Expr *RE = RS->getRetValue()) { if (const Expr *RE = RS->getRetValue()) {
ExprScope<Emitter> RetScope(this); ExprScope<Emitter> RetScope(this);
if (ReturnType) { if (ReturnType) {
// Primitive types are simply returned. // Primitive types are simply returned.
if (!this->visit(RE)) if (!this->visit(RE))
return false; return false;
this->emitCleanup(); this->emitCleanup();
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines if (!visitStmt(IS->getThen()))
return false; return false;
this->emitLabel(LabelEnd); this->emitLabel(LabelEnd);
} }
return true; return true;
} }
template <class Emitter> template <class Emitter>
bool ByteCodeStmtGen<Emitter>::visitBreakStmt(const BreakStmt *BS) {
if (!BreakLabel)
return this->bail(BS);
return this->jump(*BreakLabel);
}
template <class Emitter>
bool ByteCodeStmtGen<Emitter>::visitContinueStmt(const ContinueStmt *CS) {
if (!ContinueLabel)
return this->bail(CS);
return this->jump(*ContinueLabel);
}
template <class Emitter>
bool ByteCodeStmtGen<Emitter>::visitSwitchStmt(const SwitchStmt *SS) {
BlockScope<Emitter> InnerScope(this);
if (Optional<PrimType> T = this->classify(SS->getCond()->getType())) {
// The condition is stored in a local and fetched for every test.
unsigned Off = this->allocateLocalPrimitive(SS->getCond(), *T,
/*isConst=*/true);
// Compile the condition in its own scope.
{
ExprScope<Emitter> CondScope(this);
if (const Stmt *CondInit = SS->getInit())
if (!visitStmt(SS->getInit()))
return false;
if (const DeclStmt *CondDecl = SS->getConditionVariableDeclStmt())
if (!visitDeclStmt(CondDecl))
return false;
if (!this->visit(SS->getCond()))
return false;
if (!this->emitSetLocal(*T, Off, SS->getCond()))
return false;
}
LabelTy LabelEnd = this->getLabel();
// Generate code to inspect all case labels, jumping to the matched one.
const DefaultStmt *Default = nullptr;
CaseMap Labels;
for (auto *SC = SS->getSwitchCaseList(); SC; SC = SC->getNextSwitchCase()) {
LabelTy Label = this->getLabel();
Labels.insert({SC, Label});
if (auto *DS = dyn_cast<DefaultStmt>(SC)) {
Default = DS;
continue;
}
if (auto *CS = dyn_cast<CaseStmt>(SC)) {
if (!this->emitGetLocal(*T, Off, CS))
return false;
if (!this->visit(CS->getLHS()))
return false;
if (auto *RHS = CS->getRHS()) {
if (!this->visit(CS->getRHS()))
return false;
if (!this->emitInRange(*T, CS))
return false;
} else {
if (!this->emitEQ(*T, CS))
return false;
}
if (!this->jumpTrue(Label))
return false;
continue;
}
return this->bail(SS);
}
// If a case wasn't matched, jump to default or skip the body.
if (!this->jump(Default ? Labels[Default] : LabelEnd))
return false;
OptLabelTy DefaultLabel = Default ? Labels[Default] : OptLabelTy{};
// Compile the body, using labels defined previously.
SwitchScope<Emitter> LabelScope(this, std::move(Labels), LabelEnd,
DefaultLabel);
if (!visitStmt(SS->getBody()))
return false;
this->emitLabel(LabelEnd);
return true;
} else {
return this->bail(SS);
}
}
template <class Emitter>
bool ByteCodeStmtGen<Emitter>::visitCaseStmt(const SwitchCase *CS) {
auto It = CaseLabels.find(CS);
if (It == CaseLabels.end())
return this->bail(CS);
this->emitLabel(It->second);
return visitStmt(CS->getSubStmt());
}
template <class Emitter>
bool ByteCodeStmtGen<Emitter>::visitVarDecl(const VarDecl *VD) { bool ByteCodeStmtGen<Emitter>::visitVarDecl(const VarDecl *VD) {
auto DT = VD->getType(); auto DT = VD->getType();
if (!VD->hasLocalStorage()) { if (!VD->hasLocalStorage()) {
// No code generation required. // No code generation required.
return true; return true;
} }
Show All 13 Lines if (Optional<PrimType> T = this->classify(DT)) {
if (auto Off = this->allocateLocal(VD)) { if (auto Off = this->allocateLocal(VD)) {
return this->visitLocalInitializer(VD->getInit(), *Off); return this->visitLocalInitializer(VD->getInit(), *Off);
} else { } else {
return this->bail(VD); return this->bail(VD);
} }
} }
} }
template <class Emitter>
bool ByteCodeStmtGen<Emitter>::visitCtorInit(Record *This,
const CXXCtorInitializer *Ctor) {
auto *Init = Ctor->getInit();
if (auto *Base = Ctor->getBaseClass()) {
auto *BaseType = Base->getAs<RecordType>();
auto *Decl = BaseType->getDecl();
return this->visitInitializer(Init, [this, &This, Init, Ctor, Decl] {
if (Ctor->isBaseVirtual()) {
return this->emitGetPtrThisVirtBase(Decl, Init);
} else {
auto *R = This->getBase(Decl);
return this->emitGetPtrThisBase(R->Offset, Init);
}
});
}
if (const FieldDecl *FD = Ctor->getMember()) {
ExprScope<Emitter> Scope(this);
return this->withField(FD, [this, FD, Init, This](const Record::Field *F) {
if (Optional<PrimType> T = this->classify(FD->getType())) {
// Primitive type, can be computed and set.
if (!this->visit(Init))
return false;
if (This->isUnion())
return this->emitInitThisFieldActive(*T, F->Offset, Init);
if (F->Decl->isBitField())
return this->emitInitThisBitField(*T, F, Init);
return this->emitInitThisField(*T, F->Offset, Init);
} else {
// Nested structures.
return this->visitInitializer(Init, [this, F, Init] {
return this->emitGetPtrThisField(F->Offset, Init);
});
}
});
}
if (auto *FD = Ctor->getIndirectMember()) {
auto *Init = Ctor->getInit();
if (Optional<PrimType> T = this->classify(Init->getType())) {
ArrayRef<NamedDecl *> Chain = FD->chain();
Record *R = This;
for (unsigned I = 0, N = Chain.size(); I < N; ++I) {
const bool IsUnion = R->isUnion();
auto *Member = cast<FieldDecl>(Chain[I]);
auto MemberTy = Member->getType();
auto *FD = R->getField(Member);
if (!FD)
return this->bail(Member);
const unsigned Off = FD->Offset;
if (I + 1 == N) {
// Last member - set the field.
if (!this->visit(Init))
return false;
if (IsUnion) {
return this->emitInitFieldActive(*T, Off, Init);
} else {
return this->emitInitField(*T, Off, Init);
}
} else {
// Next field must be a record - fetch it.
R = this->getRecord(cast<RecordType>(MemberTy)->getDecl());
if (!R)
return this->bail(Member);
if (IsUnion) {
if (I == 0) {
// Base member - activate this pointer.
if (!this->emitGetPtrActiveThisField(Off, Member))
return false;
} else {
// Intermediate - active subfield.
if (!this->emitGetPtrActiveField(Off, Member))
return false;
}
} else {
if (I == 0) {
// Base member - get this pointer.
if (!this->emitGetPtrThisField(Off, Member))
return false;
} else {
// Intermediate - get pointer.
if (!this->emitGetPtrField(Off, Member))
return false;
}
}
}
}
} else {
return this->bail(FD);
}
return true;
}
llvm_unreachable("unknown base initializer kind");
}
namespace clang { namespace clang {
namespace interp { namespace interp {
template class ByteCodeStmtGen<ByteCodeEmitter>; template class ByteCodeStmtGen<ByteCodeEmitter>;
} // namespace interp } // namespace interp
} // namespace clang } // namespace clang

clang/lib/AST/Interp/CMakeLists.txt

set(LLVM_LINK_COMPONENTS set(LLVM_LINK_COMPONENTS
) )
clang_tablegen(Opcodes.inc clang_tablegen(Opcodes.inc
-gen-clang-opcodes -gen-clang-opcodes
SOURCE Opcodes.td SOURCE Opcodes.td
TARGET Opcodes) TARGET Opcodes)
add_clang_library(clangInterp add_clang_library(clangInterp
Block.cpp Block.cpp
Builtin.cpp
ByteCodeEmitter.cpp ByteCodeEmitter.cpp
ByteCodeExprGen.cpp ByteCodeExprGen.cpp
ByteCodeStmtGen.cpp ByteCodeStmtGen.cpp
ByteCodeGenError.cpp ByteCodeGenError.cpp
Context.cpp Context.cpp
Descriptor.cpp Descriptor.cpp
Disasm.cpp Disasm.cpp
EvalEmitter.cpp EvalEmitter.cpp
Show All 16 Lines

clang/lib/AST/Interp/Context.cpp

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 LinesInterpResult Context::evaluateAsInitializer(State &Parent, const VarDecl *VD,
ByteCodeExprGen<EvalEmitter> C(*this, *P, Parent, Stk, Result); ByteCodeExprGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
return Check(Parent, C.interpretDecl(VD)); return Check(Parent, C.interpretDecl(VD));
} }
const LangOptions &Context::getLangOpts() const { return Ctx.getLangOpts(); } const LangOptions &Context::getLangOpts() const { return Ctx.getLangOpts(); }
llvm::Optional<PrimType> Context::classify(QualType T) { llvm::Optional<PrimType> Context::classify(QualType T) {
if (T->isReferenceType() || T->isPointerType()) { if (T->isReferenceType() || T->isPointerType()) {
if (T->isFunctionPointerType())
return PT_FnPtr;
return PT_Ptr; return PT_Ptr;
} }
if (T->isBooleanType()) if (T->isBooleanType())
return PT_Bool; return PT_Bool;
if (T->isSignedIntegerOrEnumerationType()) { if (T->isSignedIntegerOrEnumerationType()) {
switch (Ctx.getIntWidth(T)) { switch (Ctx.getIntWidth(T)) {
case 64: case 64:
return PT_Sint64; return PT_Sint64;
case 32: case 32:
return PT_Sint32; return PT_Sint32;
case 16: case 16:
return PT_Sint16; return PT_Sint16;
case 8: case 8:
return PT_Sint8; return PT_Sint8;
default: default:
return {}; return PT_SintFP;
} }
} }
if (T->isUnsignedIntegerOrEnumerationType()) { if (T->isUnsignedIntegerOrEnumerationType()) {
switch (Ctx.getIntWidth(T)) { switch (Ctx.getIntWidth(T)) {
case 64: case 64:
return PT_Uint64; return PT_Uint64;
case 32: case 32:
return PT_Uint32; return PT_Uint32;
case 16: case 16:
return PT_Uint16; return PT_Uint16;
case 8: case 8:
return PT_Uint8; return PT_Uint8;
default: default:
return {}; return PT_UintFP;
} }
} }
if (T->isRealFloatingType())
return PT_RealFP;
if (T->isNullPtrType()) if (T->isNullPtrType())
return PT_Ptr; return PT_Ptr;
if (T->isMemberPointerType())
return PT_MemPtr;
if (T->isFunctionProtoType())
return PT_FnPtr;
if (auto *AT = dyn_cast<AtomicType>(T)) if (auto *AT = dyn_cast<AtomicType>(T))
return classify(AT->getValueType()); return classify(AT->getValueType());
return {}; return {};
} }
unsigned Context::getCharBit() const { unsigned Context::getCharBit() const {
return Ctx.getTargetInfo().getCharWidth(); return Ctx.getTargetInfo().getCharWidth();
Show All 32 Lines

clang/lib/AST/Interp/EvalEmitter.cpp

Show All 13 Lines
#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclCXX.h"
using namespace clang; using namespace clang;
using namespace clang::interp; using namespace clang::interp;
using APSInt = llvm::APSInt; using APSInt = llvm::APSInt;
template <typename T> using Expected = llvm::Expected<T>; template <typename T> using Expected = llvm::Expected<T>;
static APSInt GetInt(PrimType Ty, const Pointer &R) {
INT_TYPE_SWITCH(Ty, return R.deref<T>().toAPSInt());
}
static APFloat GetFloat(const Pointer &Ptr) {
return Ptr.deref<Real>().toAPFloat();
}
EvalEmitter::EvalEmitter(Context &Ctx, Program &P, State &Parent, EvalEmitter::EvalEmitter(Context &Ctx, Program &P, State &Parent,
InterpStack &Stk, APValue &Result) InterpStack &Stk, APValue &Result)
: Ctx(Ctx), P(P), S(Parent, P, Stk, Ctx, this), Result(Result) { : Ctx(Ctx), P(P), S(Parent, P, Stk, Ctx, this), Result(Result) {
// Create a dummy frame for the interpreter which does not have locals. // Create a dummy frame for the interpreter which does not have locals.
S.Current = new InterpFrame(S, nullptr, nullptr, CodePtr(), Pointer()); S.Current = new InterpFrame(S, nullptr, nullptr, CodePtr(), Pointer());
} }
llvm::Expected<bool> EvalEmitter::interpretExpr(const Expr *E) { llvm::Expected<bool> EvalEmitter::interpretExpr(const Expr *E) {
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
bool EvalEmitter::fallthrough(const LabelTy &Label) { bool EvalEmitter::fallthrough(const LabelTy &Label) {
if (isActive()) if (isActive())
ActiveLabel = Label; ActiveLabel = Label;
CurrentLabel = Label; CurrentLabel = Label;
return true; return true;
} }
bool EvalEmitter::emitInvoke(Function *Fn, const SourceInfo &Info) {
if (!isActive())
return true;
Pointer This = S.Stk.pop<Pointer>();
if (!CheckInvoke(S, OpPC, This))
return false;
if (S.checkingPotentialConstantExpression())
return false;
// Interpret the method in its own frame.
return ExecuteCall(Fn, std::move(This), Info);
}
bool EvalEmitter::emitCall(Function *Fn, const SourceInfo &Info) {
if (!isActive())
return true;
if (S.checkingPotentialConstantExpression())
return false;
// Interpret the function in its own frame.
return ExecuteCall(Fn, Pointer(), Info);
}
bool EvalEmitter::emitVirtualInvoke(const CXXMethodDecl *MD,
const SourceInfo &Info) {
// Get the this pointer, ensure it's live.
Pointer This = S.Stk.pop<Pointer>();
if (!CheckInvoke(S, OpPC, This))
return false;
if (S.checkingPotentialConstantExpression())
return false;
// Dispatch to the virtual method.
CurrentSource = Info;
const CXXMethodDecl *Override = VirtualLookup(This, MD);
if (!CheckPure(S, OpPC, Override))
return false;
if (Expected<Function *> Func = P.getOrCreateFunction(Override)) {
if (*Func) {
return ExecuteCall(*Func, std::move(This), Info);
} else {
return ExecuteNoCall(Override, Info);
}
} else {
// Failed to compile method - bail out.
return false;
}
}
template <PrimType OpType> bool EvalEmitter::emitRet(const SourceInfo &Info) { template <PrimType OpType> bool EvalEmitter::emitRet(const SourceInfo &Info) {
if (!isActive()) if (!isActive())
return true; return true;
using T = typename PrimConv<OpType>::T; using T = typename PrimConv<OpType>::T;
return ReturnValue<T>(S.Stk.pop<T>(), Result); return ReturnValue<T>(S.Stk.pop<T>(), Result);
} }
bool EvalEmitter::emitRetVoid(const SourceInfo &Info) { return true; } bool EvalEmitter::emitRetVoid(const SourceInfo &Info) { return true; }
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines if (auto *AT = Ty->getAsArrayTypeUnsafe()) {
if (llvm::Optional<PrimType> T = Ctx.classify(ElemTy)) { if (llvm::Optional<PrimType> T = Ctx.classify(ElemTy)) {
TYPE_SWITCH(*T, Ok &= ReturnValue<T>(EP.deref<T>(), Slot)); TYPE_SWITCH(*T, Ok &= ReturnValue<T>(EP.deref<T>(), Slot));
} else { } else {
Ok &= Composite(ElemTy, EP.narrow(), Slot); Ok &= Composite(ElemTy, EP.narrow(), Slot);
} }
} }
return Ok; return Ok;
} }
if (auto *CT = Ty->getAs<ComplexType>()) {
const Pointer &PtrReal = Ptr.atIndex(0);
const Pointer &PtrImag = Ptr.atIndex(1);
switch (auto T = *Ctx.classify(CT->getElementType())) {
case PT_Sint8:
case PT_Uint8:
case PT_Sint16:
case PT_Uint16:
case PT_Sint32:
case PT_Uint32:
case PT_Sint64:
case PT_Uint64:
case PT_SintFP:
case PT_UintFP:
R = APValue(GetInt(T, PtrReal), GetInt(T, PtrImag));
return true;
case PT_RealFP:
R = APValue(GetFloat(PtrReal), GetFloat(PtrImag));
return true;
default:
llvm_unreachable("invalid complex element");
}
}
llvm_unreachable("invalid value to return"); llvm_unreachable("invalid value to return");
}; };
// Return the composite type. // Return the composite type.
const auto &Ptr = S.Stk.pop<Pointer>(); const auto &Ptr = S.Stk.pop<Pointer>();
return Composite(Ptr.getType(), Ptr, Result); return Composite(Ptr.getType(), Ptr, Result);
} }
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines for (auto &Local : Descriptors[I]) {
auto It = Locals.find(Local.Offset); auto It = Locals.find(Local.Offset);
assert(It != Locals.end() && "Missing local variable"); assert(It != Locals.end() && "Missing local variable");
S.deallocate(reinterpret_cast<Block *>(It->second.get())); S.deallocate(reinterpret_cast<Block *>(It->second.get()));
} }
return true; return true;
} }
bool EvalEmitter::emitNoCall(const FunctionDecl *F, const SourceInfo &Info) {
if (S.checkingPotentialConstantExpression())
return false;
return ExecuteNoCall(F, Info);
}
bool EvalEmitter::emitNoInvoke(const CXXMethodDecl *F, const SourceInfo &Info) {
if (S.checkingPotentialConstantExpression())
return false;
return ExecuteNoCall(F, Info);
}
bool EvalEmitter::emitIndirectCall(const SourceInfo &Info) {
if (S.checkingPotentialConstantExpression())
return false;
const FnPointer &FnPtr = S.Stk.pop<FnPointer>();
if (FnPtr.isZero()) {
S.FFDiag(Info);
return false;
}
if (Function *F = FnPtr.asFunction())
return ExecuteCall(F, Pointer(), Info);
const FunctionDecl *Decl = FnPtr.asDecl();
if (Expected<Function *> Func = S.P.getOrCreateFunction(Decl)) {
if (*Func)
return ExecuteCall(*Func, Pointer(), Info);
else
return ExecuteNoCall(Decl, Info);
} else {
consumeError(Func.takeError());
return false;
}
}
bool EvalEmitter::emitIndirectInvoke(const SourceInfo &Info) {
if (S.checkingPotentialConstantExpression())
return false;
const MemberPointer &Field = S.Stk.pop<MemberPointer>();
Pointer This = S.Stk.pop<Pointer>();
// Fetch a pointer to the member function.
const CXXMethodDecl *Method = IndirectLookup(S, OpPC, This, Field);
if (!Method)
return false;
if (!CheckPure(S, OpPC, Method))
return false;
if (Expected<Function *> Func = S.P.getOrCreateFunction(Method)) {
if (*Func)
return ExecuteCall(*Func, std::move(This), Info);
else
return ExecuteNoCall(Method, Info);
} else {
consumeError(Func.takeError());
return false;
}
}
bool EvalEmitter::ExecuteCall(Function *F, Pointer &&This,
const SourceInfo &Info) {
CurrentSource = Info;
if (!CheckCallable(S, OpPC, F))
return false;
S.Current = new InterpFrame(S, F, S.Current, OpPC, std::move(This));
return Interpret(S, Result);
}
bool EvalEmitter::ExecuteNoCall(const FunctionDecl *F, const SourceInfo &Info) {
S.FFDiag(Info, diag::note_constexpr_invalid_function, 1)
<< F->isConstexpr() << (bool)dyn_cast<CXXConstructorDecl>(F) << F;
S.Note(F->getLocation(), diag::note_declared_at);
return false;
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Opcode evaluators // Opcode evaluators
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define GET_EVAL_IMPL #define GET_EVAL_IMPL
#include "Opcodes.inc" #include "Opcodes.inc"
#undef GET_EVAL_IMPL #undef GET_EVAL_IMPL

clang/lib/AST/Interp/Function.h

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Linespublic:
using arg_reverse_iterator = SmallVectorImpl<PrimType>::reverse_iterator; using arg_reverse_iterator = SmallVectorImpl<PrimType>::reverse_iterator;
llvm::iterator_range<arg_reverse_iterator> args_reverse() { llvm::iterator_range<arg_reverse_iterator> args_reverse() {
return llvm::make_range(ParamTypes.rbegin(), ParamTypes.rend()); return llvm::make_range(ParamTypes.rbegin(), ParamTypes.rend());
} }
/// Returns a specific scope. /// Returns a specific scope.
Scope &getScope(unsigned Idx) { return Scopes[Idx]; } Scope &getScope(unsigned Idx) { return Scopes[Idx]; }
/// Solves a call relocation.
void relocateCall(CodePtr Loc, Function *Callee);
/// Solves an invoke relocation.
void relocateInvoke(CodePtr Loc, Function *Callee);
/// Returns the source information at a given PC. /// Returns the source information at a given PC.
SourceInfo getSource(CodePtr PC) const; SourceInfo getSource(CodePtr PC) const;
/// Checks if the function is valid to call in constexpr. /// Checks if the function is valid to call in constexpr.
bool isConstexpr() const { return IsValid; } bool isConstexpr() const { return IsValid; }
/// Checks if the function is virtual. /// Checks if the function is virtual.
bool isVirtual() const; bool isVirtual() const;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

clang/lib/AST/Interp/Function.cpp

Show All 25 Lines
CodePtr Function::getCodeEnd() const { return Code.data() + Code.size(); } CodePtr Function::getCodeEnd() const { return Code.data() + Code.size(); }
Function::ParamDescriptor Function::getParamDescriptor(unsigned Offset) const { Function::ParamDescriptor Function::getParamDescriptor(unsigned Offset) const {
auto It = Params.find(Offset); auto It = Params.find(Offset);
assert(It != Params.end() && "Invalid parameter offset"); assert(It != Params.end() && "Invalid parameter offset");
return It->second; return It->second;
} }
void Function::relocateCall(CodePtr Loc, Function *Callee) {
using namespace llvm::support;
char *Ptr = Code.data() + (Loc - getCodeBegin());
const auto Addr = reinterpret_cast<uintptr_t>(Callee);
*(reinterpret_cast<Opcode *>(Ptr) - 1) = OP_Call;
endian::write<uintptr_t, endianness::native, 1>(Ptr, Addr);
}
void Function::relocateInvoke(CodePtr Loc, Function *Callee) {
using namespace llvm::support;
char *Ptr = Code.data() + (Loc - getCodeBegin());
const auto Addr = reinterpret_cast<uintptr_t>(Callee);
*(reinterpret_cast<Opcode *>(Ptr) - 1) = OP_Invoke;
endian::write<uintptr_t, endianness::native, 1>(Ptr, Addr);
}
SourceInfo Function::getSource(CodePtr PC) const { SourceInfo Function::getSource(CodePtr PC) const {
unsigned Offset = PC - getCodeBegin(); unsigned Offset = PC - getCodeBegin();
using Elem = std::pair<unsigned, SourceInfo>; using Elem = std::pair<unsigned, SourceInfo>;
auto It = std::lower_bound(SrcMap.begin(), SrcMap.end(), Elem{Offset, {}}, auto It = std::lower_bound(SrcMap.begin(), SrcMap.end(), Elem{Offset, {}},
[](Elem A, Elem B) { return A.first < B.first; }); [](Elem A, Elem B) { return A.first < B.first; });
if (It == SrcMap.end() || It->first != Offset) if (It == SrcMap.end() || It->first != Offset)
llvm::report_fatal_error("missing source location"); llvm::report_fatal_error("missing source location");
return It->second; return It->second;
} }
bool Function::isVirtual() const { bool Function::isVirtual() const {
if (auto *M = dyn_cast<CXXMethodDecl>(F)) if (auto *M = dyn_cast<CXXMethodDecl>(F))
return M->isVirtual(); return M->isVirtual();
return false; return false;
} }

clang/lib/AST/Interp/Integral.h

Show First 20 Lines • Show All 276 Lines • ▼ Show 20 Linesprivate:
template <typename T, T Min, T Max> template <typename T, T Min, T Max>
static typename std::enable_if<std::is_unsigned<T>::value, bool>::type static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
CheckRange(int64_t V) { CheckRange(int64_t V) {
return V >= 0 && static_cast<uint64_t>(V) <= Max; return V >= 0 && static_cast<uint64_t>(V) <= Max;
} }
}; };
/// Specialisation for fixed precision integers.
template <bool Signed> class Integral<0, Signed> {
private:
template <unsigned OtherBits, bool OtherSigned> friend class Integral;
/// Value is stored in an APSInt.
APSInt V;
public:
/// Integral initialized to an undefined value.
Integral() : V() {}
/// Construct an integral from a value based on signedness.
explicit Integral(const APSInt &V) : V(V, !Signed) {}
bool operator<(const Integral &RHS) const { return V < RHS.V; }
bool operator>(const Integral &RHS) const { return V > RHS.V; }
bool operator<=(const Integral &RHS) const { return V <= RHS.V; }
bool operator>=(const Integral &RHS) const { return V >= RHS.V; }
bool operator==(const Integral &RHS) const { return V == RHS.V; }
bool operator!=(const Integral &RHS) const { return V != RHS.V; }
template <typename T>
bool operator>(T RHS) const {
constexpr bool ArgSigned = std::is_signed<T>::value;
return V > APSInt(APInt(V.getBitWidth(), RHS, ArgSigned), !ArgSigned);
}
template <typename T>
bool operator<(T RHS) const {
constexpr bool ArgSigned = std::is_signed<T>::value;
return V < APSInt(APInt(V.getBitWidth(), RHS, ArgSigned), !ArgSigned);
}
Integral operator+(const Integral &RHS) const { return Integral(V + RHS.V); }
Integral operator-(const Integral &RHS) const { return Integral(V - RHS.V); }
Integral operator*(const Integral &RHS) const { return Integral(V * RHS.V); }
Integral operator/(const Integral &RHS) const { return Integral(V / RHS.V); }
Integral operator%(const Integral &RHS) const { return Integral(V % RHS.V); }
Integral operator&(const Integral &RHS) const { return Integral(V & RHS.V); }
Integral operator|(const Integral &RHS) const { return Integral(V | RHS.V); }
Integral operator^(const Integral &RHS) const { return Integral(V ^ RHS.V); }
Integral operator-() const { return Integral(-V); }
Integral operator~() const { return Integral(~V); }
Integral operator>>(unsigned RHS) const { return Integral(V >> RHS); }
Integral operator<<(unsigned RHS) const { return Integral(V << RHS); }
explicit operator off_t() const {
return Signed ? V.getSExtValue() : V.getZExtValue();
}
explicit operator unsigned() const {
return Signed ? V.getZExtValue() : V.getZExtValue();
}
APSInt toAPSInt() const { return V; }
APSInt toAPSInt(unsigned NumBits) const {
if (Signed)
return APSInt(toAPSInt().sextOrTrunc(NumBits), !Signed);
else
return APSInt(toAPSInt().zextOrTrunc(NumBits), !Signed);
}
APValue toAPValue() const { return APValue(toAPSInt()); }
Integral<0, false> toUnsigned() const {
return Integral<0, false>::from(*this, bitWidth());
}
unsigned bitWidth() const { return V.getBitWidth(); }
bool isZero() const { return V.isNullValue(); }
bool isMin() const {
if (Signed)
return V.isMinSignedValue();
else
return V.isMinValue();
}
bool isMinusOne() const { return Signed && V.isAllOnesValue(); }
constexpr static bool isSigned() { return Signed; }
bool isNegative() const { return V.isNegative(); }
bool isPositive() const { return !isNegative(); }
ComparisonCategoryResult compare(const Integral &RHS) const {
if (V < RHS.V)
return ComparisonCategoryResult::Less;
if (V > RHS.V)
return ComparisonCategoryResult::Greater;
return ComparisonCategoryResult::Equal;
}
unsigned countLeadingZeros() const { return V.countLeadingZeros(); }
Integral truncate(unsigned TruncBits) const {
if (TruncBits >= bitWidth())
return *this;
return Integral(V.trunc(TruncBits).extend(bitWidth()));
}
void print(llvm::raw_ostream &OS) const { OS << V; }
static Integral min(unsigned NumBits) {
if (Signed)
return Integral(APSInt(APInt::getSignedMinValue(NumBits), !Signed));
else
return Integral(APSInt(APInt::getMinValue(NumBits), !Signed));
}
static Integral max(unsigned NumBits) {
if (Signed)
return Integral(APSInt(APInt::getSignedMaxValue(NumBits), !Signed));
else
return Integral(APSInt(APInt::getMaxValue(NumBits), !Signed));
}
template <typename T>
static typename std::enable_if<std::is_integral<T>::value, Integral>::type
from(T Value, unsigned NumBits) {
const bool SrcSign = std::is_signed<T>::value;
return Integral(APSInt(APInt(NumBits, Value, SrcSign), !SrcSign));
}
template <unsigned SrcBits, bool SrcSign>
static typename std::enable_if<SrcBits != 0, Integral>::type
from(Integral<SrcBits, SrcSign> Value, unsigned NumBits) {
return Integral(APSInt(APInt(NumBits, Value.V, SrcSign), !SrcSign));
}
template <bool SrcSign>
static Integral from(Integral<0, SrcSign> Value, unsigned NumBits) {
if (SrcSign)
return Integral(APSInt(Value.V.sextOrTrunc(NumBits), !Signed));
else
return Integral(APSInt(Value.V.zextOrTrunc(NumBits), !Signed));
}
static Integral zero(unsigned NumBits) { return from(0, NumBits); }
static bool inRange(int64_t Value, unsigned NumBits) {
APSInt V(APInt(NumBits, Value, true), false);
return min(NumBits).V <= V && V <= max(NumBits).V;
}
static bool increment(Integral A, Integral *R) {
*R = A + Integral::from(1, A.bitWidth());
return A.isSigned() && !A.isNegative() && R->isNegative();
}
static bool decrement(Integral A, Integral *R) {
*R = A - Integral::from(1, A.bitWidth());
return !A.isSigned() && A.isNegative() && !R->isNegative();
}
static bool add(Integral A, Integral B, unsigned OpBits, Integral *R) {
APSInt Value(A.V.extend(OpBits) + B.V.extend(OpBits));
*R = Integral(Value.trunc(A.bitWidth()));
return R->V.extend(OpBits) != Value;
}
static bool sub(Integral A, Integral B, unsigned OpBits, Integral *R) {
APSInt Value(A.V.extend(OpBits) - B.V.extend(OpBits));
*R = Integral(Value.trunc(A.bitWidth()));
return R->V.extend(OpBits) != Value;
}
static bool mul(Integral A, Integral B, unsigned OpBits, Integral *R) {
APSInt Value(A.V.extend(OpBits) * B.V.extend(OpBits));
*R = Integral(Value.trunc(A.bitWidth()));
return R->V.extend(OpBits) != Value;
}
};
template <unsigned Bits, bool Signed> template <unsigned Bits, bool Signed>
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, Integral<Bits, Signed> I) { llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, Integral<Bits, Signed> I) {
I.print(OS); I.print(OS);
return OS; return OS;
} }
template <> template <>
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
Show All 9 Lines

clang/lib/AST/Interp/Interp.h

//===--- Interp.h - Interpreter for the constexpr VM ------------*- C++ -*-===// //===--- Interp.h - Interpreter for the constexpr VM ------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Definition of the interpreter state and entry point. // Definition of the interpreter state and entry point.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_AST_INTERP_INTERP_H #ifndef LLVM_CLANG_AST_INTERP_INTERP_H
#define LLVM_CLANG_AST_INTERP_INTERP_H #define LLVM_CLANG_AST_INTERP_INTERP_H
#include "Builtin.h"
#include "Function.h" #include "Function.h"
#include "InterpFrame.h" #include "InterpFrame.h"
#include "InterpStack.h" #include "InterpStack.h"
#include "InterpState.h" #include "InterpState.h"
#include "Opcode.h" #include "Opcode.h"
#include "Program.h" #include "Program.h"
#include "State.h" #include "State.h"
#include "Type.h" #include "Type.h"
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
/// Checks the 'this' pointer. /// Checks the 'this' pointer.
bool CheckThis(InterpState &S, CodePtr OpPC, const Pointer &This); bool CheckThis(InterpState &S, CodePtr OpPC, const Pointer &This);
/// Checks if a method is pure virtual. /// Checks if a method is pure virtual.
bool CheckPure(InterpState &S, CodePtr OpPC, const CXXMethodDecl *MD); bool CheckPure(InterpState &S, CodePtr OpPC, const CXXMethodDecl *MD);
template <typename T> inline bool IsTrue(const T &V) { return !V.isZero(); } template <typename T> inline bool IsTrue(const T &V) { return !V.isZero(); }
/// Finds the record to which a pointer points and ajudsts this to it.
Record *PointerLookup(Pointer &This, const MemberPointer &Field);
/// Finds a virtual override and adjusts This to point to the object.
const CXXMethodDecl *VirtualLookup(Pointer &This, const CXXMethodDecl *MD);
/// Indirect method lookup.
const CXXMethodDecl *IndirectLookup(InterpState &S, CodePtr OpPC, Pointer &This,
const MemberPointer &Ptr);
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Add, Sub, Mul // Add, Sub, Mul
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
template <typename T, bool (*OpFW)(T, T, unsigned, T *), template <typename T, bool (*OpFW)(T, T, unsigned, T *),
template <typename U> class OpAP> template <typename U> class OpAP>
bool AddSubMulHelper(InterpState &S, CodePtr OpPC, unsigned Bits, const T &LHS, bool AddSubMulHelper(InterpState &S, CodePtr OpPC, unsigned Bits, const T &LHS,
const T &RHS) { const T &RHS) {
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
template <PrimType Name, class T = typename PrimConv<Name>::T> template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Mul(InterpState &S, CodePtr OpPC) { bool Mul(InterpState &S, CodePtr OpPC) {
const T &RHS = S.Stk.pop<T>(); const T &RHS = S.Stk.pop<T>();
const T &LHS = S.Stk.pop<T>(); const T &LHS = S.Stk.pop<T>();
const unsigned Bits = RHS.bitWidth() * 2; const unsigned Bits = RHS.bitWidth() * 2;
return AddSubMulHelper<T, T::mul, std::multiplies>(S, OpPC, Bits, LHS, RHS); return AddSubMulHelper<T, T::mul, std::multiplies>(S, OpPC, Bits, LHS, RHS);
} }
template <Real (*Op)(const Real &, const Real &, RoundingMode), RoundingMode M>
bool RealArithHelper(InterpState &S, CodePtr OpPC) {
const Real &RHS = S.Stk.pop<Real>();
const Real &LHS = S.Stk.pop<Real>();
Real Result = Op(LHS, RHS, M);
S.Stk.push<Real>(Result);
if (!Result.isNaN())
return true;
const SourceInfo &Src = S.Current->getSource(OpPC);
S.CCEDiag(Src, diag::note_constexpr_float_arithmetic) << Result.isNaN();
return S.noteUndefinedBehavior();
}
template <> inline bool Add<PT_RealFP>(InterpState &S, CodePtr OpPC) {
return RealArithHelper<Real::add, APFloat::rmNearestTiesToEven>(S, OpPC);
}
template <> inline bool Sub<PT_RealFP>(InterpState &S, CodePtr OpPC) {
return RealArithHelper<Real::sub, APFloat::rmNearestTiesToEven>(S, OpPC);
}
template <> inline bool Mul<PT_RealFP>(InterpState &S, CodePtr OpPC) {
return RealArithHelper<Real::mul, APFloat::rmNearestTiesToEven>(S, OpPC);
}
//===----------------------------------------------------------------------===//
// Div, Rem
//===----------------------------------------------------------------------===//
template <typename T, T (*OpFW)(T, T), typename OpAP>
bool DivRemHelper(InterpState &S, CodePtr OpPC) {
const T RHS = S.Stk.pop<T>();
const T LHS = S.Stk.pop<T>();
// Bail on division by zero.
if (RHS.isZero()) {
S.FFDiag(S.Current->getSource(OpPC), diag::note_expr_divide_by_zero);
return false;
}
if (RHS.isSigned()) {
// (-MAX - 1) / -1 = MAX + 1 overflows.
if (LHS.isMin() && RHS.isMinusOne()) {
// Push the truncated value in case the interpreter continues.
S.Stk.push<T>(T::min(RHS.bitWidth()));
// Compute the actual value for the diagnostic.
const size_t Bits = RHS.bitWidth() + 1;
APSInt Value = OpAP()(LHS.toAPSInt(Bits), RHS.toAPSInt(Bits));
return S.reportOverflow(S.Current->getExpr(OpPC), Value);
}
}
// Safe to execute division here.
S.Stk.push<T>(OpFW(LHS, RHS));
return true;
}
template <typename T> T DivFn(T a, T b) { return a / b; }
template <typename T> T RemFn(T a, T b) { return a % b; }
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Div(InterpState &S, CodePtr OpPC) {
return DivRemHelper<T, DivFn<T>, std::divides<APSInt>>(S, OpPC);
}
template <> inline bool Div<PT_RealFP>(InterpState &S, CodePtr OpPC) {
const Real RHS = S.Stk.pop<Real>();
const Real LHS = S.Stk.pop<Real>();
if (RHS.isZero()) {
S.FFDiag(S.Current->getSource(OpPC), diag::note_expr_divide_by_zero);
return false;
}
S.Stk.push<Real>(Real::div(LHS, RHS, APFloat::rmNearestTiesToEven));
return true;
}
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Rem(InterpState &S, CodePtr OpPC) {
return DivRemHelper<T, RemFn<T>, std::modulus<APSInt>>(S, OpPC);
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// EQ, NE, GT, GE, LT, LE // EQ, NE, GT, GE, LT, LE
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
using CompareFn = llvm::function_ref<bool(ComparisonCategoryResult)>; using CompareFn = llvm::function_ref<bool(ComparisonCategoryResult)>;
template <typename T> template <typename T>
bool CmpHelper(InterpState &S, CodePtr OpPC, CompareFn Fn) { bool CmpHelper(InterpState &S, CodePtr OpPC, CompareFn Fn) {
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linesinline bool CmpHelperEQ<Pointer>(InterpState &S, CodePtr OpPC, CompareFn Fn) {
} else { } else {
unsigned VL = LHS.getByteOffset(); unsigned VL = LHS.getByteOffset();
unsigned VR = RHS.getByteOffset(); unsigned VR = RHS.getByteOffset();
S.Stk.push<BoolT>(BoolT::from(Fn(Compare(VL, VR)))); S.Stk.push<BoolT>(BoolT::from(Fn(Compare(VL, VR))));
return true; return true;
} }
} }
template <>
inline bool CmpHelperEQ<MemberPointer>(InterpState &S, CodePtr OpPC,
CompareFn Fn) {
using BoolT = PrimConv<PT_Bool>::T;
const auto &RHS = S.Stk.pop<MemberPointer>();
const auto &LHS = S.Stk.pop<MemberPointer>();
auto CheckVirtual = [OpPC, &S](const MemberPointer &Ptr) {
if (auto *MD = dyn_cast<CXXMethodDecl>(Ptr.getDecl())) {
if (MD->isVirtual()) {
const SourceInfo &E = S.Current->getSource(OpPC);
S.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
return false;
}
}
return true;
};
using CCR = ComparisonCategoryResult;
if (!LHS.getDecl() || !RHS.getDecl()) {
CCR Result = !LHS.getDecl() && !RHS.getDecl() ? CCR::Equal : CCR::Nonequal;
S.Stk.push<BoolT>(BoolT::from(Fn(Result)));
return true;
}
if (!CheckVirtual(LHS) || !CheckVirtual(RHS))
return false;
S.Stk.push<BoolT>(BoolT::from(Fn(LHS == RHS ? CCR::Equal : CCR::Nonequal)));
return true;
}
template <PrimType Name, class T = typename PrimConv<Name>::T> template <PrimType Name, class T = typename PrimConv<Name>::T>
bool EQ(InterpState &S, CodePtr OpPC) { bool EQ(InterpState &S, CodePtr OpPC) {
return CmpHelperEQ<T>(S, OpPC, [](ComparisonCategoryResult R) { return CmpHelperEQ<T>(S, OpPC, [](ComparisonCategoryResult R) {
return R == ComparisonCategoryResult::Equal; return R == ComparisonCategoryResult::Equal;
}); });
} }
template <PrimType Name, class T = typename PrimConv<Name>::T> template <PrimType Name, class T = typename PrimConv<Name>::T>
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linesbool InRange(InterpState &S, CodePtr OpPC) {
const T LHS = S.Stk.pop<T>(); const T LHS = S.Stk.pop<T>();
const T Value = S.Stk.pop<T>(); const T Value = S.Stk.pop<T>();
S.Stk.push<bool>(LHS <= Value && Value <= RHS); S.Stk.push<bool>(LHS <= Value && Value <= RHS);
return true; return true;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Minus, Not, LogicalNot
//===----------------------------------------------------------------------===//
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Minus(InterpState &S, CodePtr OpPC) {
const T &Arg = S.Stk.pop<T>();
if (Arg.isSigned() && Arg.isMin()) {
// Push the truncated value in case the interpreter continues.
S.Stk.push<T>(T::min(Arg.bitWidth()));
// Compute the actual value for the diagnostic.
const size_t Bits = Arg.bitWidth() + 1;
const APSInt Value = std::negate<APSInt>()(Arg.toAPSInt(Bits));
return S.reportOverflow(S.Current->getExpr(OpPC), Value);
}
S.Stk.push<T>(std::negate<T>()(Arg));
return true;
}
template <>
inline bool Minus<PT_RealFP>(InterpState &S, CodePtr OpPC) {
S.Stk.push<Real>(Real::negate(S.Stk.pop<Real>()));
return true;
}
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Not(InterpState &S, CodePtr OpPC) {
S.Stk.push<T>(~S.Stk.pop<T>());
return true;
}
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool LogicalNot(InterpState &S, CodePtr OpPC) {
S.Stk.push<bool>(!IsTrue<T>(S.Stk.pop<T>()));
return true;
}
//===----------------------------------------------------------------------===//
// Dup, Pop, Test // Dup, Pop, Test
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
template <PrimType Name, class T = typename PrimConv<Name>::T> template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Dup(InterpState &S, CodePtr OpPC) { bool Dup(InterpState &S, CodePtr OpPC) {
S.Stk.push<T>(S.Stk.peek<T>()); S.Stk.push<T>(S.Stk.peek<T>());
return true; return true;
} }
template <PrimType Name, class T = typename PrimConv<Name>::T> template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Pop(InterpState &S, CodePtr OpPC) { bool Pop(InterpState &S, CodePtr OpPC) {
S.Stk.pop<T>(); S.Stk.pop<T>();
return true; return true;
} }
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Test(InterpState &S, CodePtr OpPC) {
S.Stk.push<bool>(IsTrue<T>(S.Stk.pop<T>()));
return true;
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Const // Const, ConstFP
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
template <PrimType Name, class T = typename PrimConv<Name>::T> template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Const(InterpState &S, CodePtr OpPC, const T &Arg) { bool Const(InterpState &S, CodePtr OpPC, const T &Arg) {
S.Stk.push<T>(Arg); S.Stk.push<T>(Arg);
return true; return true;
} }
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool ConstFP(InterpState &S, CodePtr OpPC, uint32_t Bits, uint64_t Value) {
S.Stk.push<T>(T::from(Value, Bits));
return true;
}
inline bool ConstRealFP(InterpState &S, CodePtr OpPC,
const FloatingLiteral *Value) {
S.Stk.push<Real>(Real::from(Value->getValue(), Value->getSemantics()));
return true;
}
//===----------------------------------------------------------------------===//
// ConstFn, ConstNoFn, ConstMem
//===----------------------------------------------------------------------===//
inline bool ConstFn(InterpState &S, CodePtr OpPC, Function *Fn) {
S.Stk.push<FnPointer>(Fn);
return true;
}
inline bool ConstNoFn(InterpState &S, CodePtr OpPC, const FunctionDecl *FD) {
// TODO: try to compile and rewrite opcode.
S.Stk.push<FnPointer>(FD);
return true;
}
inline bool ConstMem(InterpState &S, CodePtr OpPC, const ValueDecl *VD) {
S.Stk.push<MemberPointer>(VD);
return true;
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Get/Set Local/Param/Global/This // Get/Set Local/Param/Global/This
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
template <PrimType Name, class T = typename PrimConv<Name>::T> template <PrimType Name, class T = typename PrimConv<Name>::T>
bool GetLocal(InterpState &S, CodePtr OpPC, uint32_t I) { bool GetLocal(InterpState &S, CodePtr OpPC, uint32_t I) {
S.Stk.push<T>(S.Current->getLocal<T>(I)); S.Stk.push<T>(S.Current->getLocal<T>(I));
return true; return true;
▲ Show 20 Lines • Show All 296 Lines • ▼ Show 20 Linesinline bool GetPtrThisVirtBase(InterpState &S, CodePtr OpPC,
if (S.checkingPotentialConstantExpression()) if (S.checkingPotentialConstantExpression())
return false; return false;
const Pointer &This = S.Current->getThis(); const Pointer &This = S.Current->getThis();
if (!CheckThis(S, OpPC, This)) if (!CheckThis(S, OpPC, This))
return false; return false;
return VirtBaseHelper(S, OpPC, D, S.Current->getThis()); return VirtBaseHelper(S, OpPC, D, S.Current->getThis());
} }
inline bool GetPtrFieldIndirect(InterpState &S, CodePtr OpPC) {
// Fetch a pointer to the member.
const MemberPointer &Field = S.Stk.pop<MemberPointer>();
// Fetch and validate the object.
Pointer Ptr = S.Stk.pop<Pointer>();
if (!CheckNull(S, OpPC, Ptr, CSK_Field))
return false;
if (!CheckRange(S, OpPC, Ptr, CSK_Field))
return false;
// Validate the pointer.
if (Field.isZero()) {
S.FFDiag(S.Current->getSource(OpPC));
return false;
}
// Find the correct class in the hierarchy and fetch the pointer.
if (auto *Decl = dyn_cast<FieldDecl>(Field.getDecl())) {
if (Record *R = PointerLookup(Ptr, Field)) {
S.Stk.push<Pointer>(Ptr.atField(R->getField(Decl)->Offset));
return true;
}
}
S.FFDiag(S.Current->getSource(OpPC));
return false;
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Load, Store, Init // Load, Store, Init
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
template <PrimType Name, class T = typename PrimConv<Name>::T> template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Load(InterpState &S, CodePtr OpPC) { bool Load(InterpState &S, CodePtr OpPC) {
const Pointer &Ptr = S.Stk.peek<Pointer>(); const Pointer &Ptr = S.Stk.peek<Pointer>();
if (!CheckLoad(S, OpPC, Ptr)) if (!CheckLoad(S, OpPC, Ptr))
▲ Show 20 Lines • Show All 180 Lines • ▼ Show 20 Lines
template <PrimType TIn, PrimType TOut> bool Cast(InterpState &S, CodePtr OpPC) { template <PrimType TIn, PrimType TOut> bool Cast(InterpState &S, CodePtr OpPC) {
using T = typename PrimConv<TIn>::T; using T = typename PrimConv<TIn>::T;
using U = typename PrimConv<TOut>::T; using U = typename PrimConv<TOut>::T;
S.Stk.push<U>(U::from(S.Stk.pop<T>())); S.Stk.push<U>(U::from(S.Stk.pop<T>()));
return true; return true;
} }
template <PrimType TIn, PrimType TOut>
bool CastFP(InterpState &S, CodePtr OpPC, uint32_t Bits) {
using T = typename PrimConv<TIn>::T;
using U = typename PrimConv<TOut>::T;
S.Stk.push<U>(U::from(S.Stk.pop<T>(), Bits));
return true;
}
template <PrimType TIn>
bool CastRealFP(InterpState &S, CodePtr OpPC, const fltSemantics *Sema) {
using T = typename PrimConv<TIn>::T;
S.Stk.push<Real>(Real::from(S.Stk.pop<T>(), *Sema));
return true;
}
template <typename U>
bool RealToIntHelper(InterpState &S, CodePtr OpPC, const APFloat &Value,
uintptr_t Bits) {
APSInt Result(Bits, !U::isSigned());
bool Ignored;
// Conver to int and check for overflow.
if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &Ignored) &
APFloat::opInvalidOp) {
const Expr *E = S.Current->getExpr(OpPC);
S.CCEDiag(E, diag::note_constexpr_overflow) << Value << E->getType();
return S.noteUndefinedBehavior();
}
S.Stk.push<U>(Result);
return true;
}
template <PrimType TIn, PrimType TOut>
bool CastRealFPToAlu(InterpState &S, CodePtr OpPC) {
using T = typename PrimConv<TIn>::T;
using U = typename PrimConv<TOut>::T;
return RealToIntHelper<U>(S, OpPC, S.Stk.pop<T>().toAPFloat(), U::bitWidth());
}
template <PrimType TIn, PrimType TOut>
bool CastRealFPToAluFP(InterpState &S, CodePtr OpPC, uint32_t Bits) {
using T = typename PrimConv<TIn>::T;
using U = typename PrimConv<TOut>::T;
return RealToIntHelper<U>(S, OpPC, S.Stk.pop<T>().toAPFloat(), Bits);
}
//===----------------------------------------------------------------------===//
// CastMemberToBase, CastMemberToDerived
//===----------------------------------------------------------------------===//
inline bool CastMemberToBase(InterpState &S, CodePtr OpPC,
const CXXRecordDecl *R) {
if (S.Stk.peek<MemberPointer>().toBase(R))
return true;
S.FFDiag(S.Current->getSource(OpPC));
return false;
}
inline bool CastMemberToDerived(InterpState &S, CodePtr OpPC,
const CXXRecordDecl *R) {
if (S.Stk.peek<MemberPointer>().toDerived(R))
return true;
S.FFDiag(S.Current->getSource(OpPC));
return false;
}
//===----------------------------------------------------------------------===//
// PointerBitCast, DynCastWarning
//===----------------------------------------------------------------------===//
inline bool PointerBitCast(InterpState &S, CodePtr OpPC) {
auto *E = S.Current->getExpr(OpPC);
if (E->getType()->isVoidPointerType())
S.CCEDiag(E, diag::note_constexpr_invalid_cast) << 3 << E->getType();
else
S.CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
// TODO: invalidate pointer.
return false;
}
inline bool ReinterpretCastWarning(InterpState &S, CodePtr OpPC) {
auto *E = S.Current->getExpr(OpPC);
S.CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
return true;
}
inline bool DynamicCastWarning(InterpState &S, CodePtr OpPC) {
auto *E = S.Current->getExpr(OpPC);
S.CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
return true;
}
//===----------------------------------------------------------------------===//
// CastToDerived
//===----------------------------------------------------------------------===//
inline bool CastToDerived(InterpState &S, CodePtr OpPC, const Expr *E) {
QualType Ty = E->getType();
if (const PointerType *PT = Ty->getAs<PointerType>())
Ty = PT->getPointeeType();
Pointer Base = S.Stk.pop<Pointer>();
if (!CheckNull(S, OpPC, Base, CSK_Derived))
return false;
if (auto *R = S.P.getOrCreateRecord(Ty->getAs<RecordType>()->getDecl())) {
// Traverse the chain of bases (actually derived classes).
while (Base.isBaseClass()) {
// Step to deriving class.
Base = Base.getBase();
// Found the derived class.
if (Base.getRecord() == R) {
S.Stk.push<Pointer>(std::move(Base));
return true;
}
}
}
// Emit the diagnostic.
S.CCEDiag(E, diag::note_constexpr_invalid_downcast) << Base.getType() << Ty;
return false;
}
//===----------------------------------------------------------------------===//
// Inc, Dec
//===----------------------------------------------------------------------===//
template <typename T>
using IncDecFn = bool (*) (InterpState &, CodePtr, const T&, T&);
template <typename T>
bool Post(InterpState &S, CodePtr OpPC, AccessKinds AK, IncDecFn<T> Op) {
// Bail if not C++14.
if (!S.getLangOpts().CPlusPlus14 && !S.keepEvaluatingAfterFailure()) {
S.FFDiag(S.Current->getSource(OpPC));
return false;
}
// Get the pointer to the object to mutate.
const Pointer &Ptr = S.Stk.pop<Pointer>();
if (!CheckLive(S, OpPC, Ptr, AK))
return false;
if (!CheckConst(S, OpPC, Ptr))
return false;
// Return the original value.
const T Arg = Ptr.deref<T>();
S.Stk.push<T>(Arg);
// Perform the operation.
if (!Op(S, OpPC, Arg, Ptr.deref<T>()))
return false;
return true;
}
template <typename T>
bool Pre(InterpState &S, CodePtr OpPC, AccessKinds AK, IncDecFn<T> Op) {
// Bail if not C++14.
if (!S.getLangOpts().CPlusPlus14 && !S.keepEvaluatingAfterFailure()) {
S.FFDiag(S.Current->getSource(OpPC));
return false;
}
// Read the value to mutate.
Pointer Ptr = S.Stk.peek<Pointer>();
if (!CheckLive(S, OpPC, Ptr, AK))
return false;
if (!CheckConst(S, OpPC, Ptr))
return false;
// Perform the operation.
const T Arg = Ptr.deref<T>();
if (!Op(S, OpPC, Arg, Ptr.deref<T>()))
return false;
return true;
}
template <typename T, bool (*OpFW)(T A, T *R), template <typename U> class OpAP>
bool IncDecInt(InterpState &S, CodePtr OpPC, const T &Arg, T &R) {
if (std::is_unsigned<T>::value) {
// Unsigned increment/decrement is defined to wrap around.
R = OpAP<T>()(Arg, T::from(1, Arg.bitWidth()));
return true;
} else {
// Signed increment/decrement is undefined, catch that.
if (!OpFW(Arg, &R))
return true;
// Compute the actual value for the diagnostic.
const size_t Bits = R.bitWidth() + 1;
APSInt One(APInt(Bits, 1, Arg.isSigned()), !Arg.isSigned());
APSInt Value = OpAP<APSInt>()(Arg.toAPSInt(Bits), One);
return S.reportOverflow(S.Current->getExpr(OpPC), Value);
}
}
template <template <typename U> class Op>
bool IncDecPtr(InterpState &S, CodePtr OpPC, const Pointer &Arg, Pointer &R) {
if (!CheckNull(S, OpPC, Arg, CSK_ArrayIndex))
return false;
if (!CheckArray(S, OpPC, Arg))
return false;
// Compute the new offset with unsigned wraparound.
const int64_t NewIndex = Op<int64_t>()(Arg.getIndex(), 1);
const int64_t MaxIndex = Arg.getNumElems();
// Ensure the new index is in bounds.
if (NewIndex < 0 || NewIndex > MaxIndex) {
S.CCEDiag(S.Current->getSource(OpPC), diag::note_constexpr_array_index)
<< Integral<64, true>::from(NewIndex).toAPSInt()
<< /*array*/ static_cast<int>(!Arg.inArray())
<< static_cast<unsigned>(MaxIndex);
return false;
}
// Compute the offset from the index.
R = Arg.atIndex(NewIndex);
return true;
}
template <Real (*Op) (const Real &)>
bool IncDecReal(InterpState &S, CodePtr OpPC, const Real &Arg, Real &R) {
R = Op(Arg);
return true;
}
template <typename T> struct IncOps {
static constexpr IncDecFn<T> Fn = IncDecInt<T, T::increment, std::plus>;
};
template <> struct IncOps<Pointer> {
static constexpr IncDecFn<Pointer> Fn = IncDecPtr<std::plus>;
};
template <> struct IncOps<Real> {
static constexpr IncDecFn<Real> Fn = IncDecReal<Real::increment>;
};
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool PostInc(InterpState &S, CodePtr OpPC) {
return Post<T>(S, OpPC, AK_Increment, IncOps<T>::Fn);
}
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool PreInc(InterpState &S, CodePtr OpPC) {
return Pre<T>(S, OpPC, AK_Increment, IncOps<T>::Fn);
}
template <typename T> struct DecOps {
static constexpr IncDecFn<T> Fn = IncDecInt<T, T::decrement, std::minus>;
};
template <> struct DecOps<Pointer> {
static constexpr IncDecFn<Pointer> Fn = IncDecPtr<std::minus>;
};
template <> struct DecOps<Real> {
static constexpr IncDecFn<Real> Fn = IncDecReal<Real::decrement>;
};
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool PostDec(InterpState &S, CodePtr OpPC) {
return Post<T>(S, OpPC, AK_Decrement, DecOps<T>::Fn);
}
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool PreDec(InterpState &S, CodePtr OpPC) {
return Pre<T>(S, OpPC, AK_Decrement, DecOps<T>::Fn);
}
//===----------------------------------------------------------------------===//
// And, Or, Xor
//===----------------------------------------------------------------------===//
template <typename T, template <typename U> class Op>
bool LogicalHelper(InterpState &S, CodePtr OpPC) {
const T &RHS = S.Stk.pop<T>();
const T &LHS = S.Stk.pop<T>();
S.Stk.push<T>(Op<T>()(LHS, RHS));
return true;
}
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool And(InterpState &S, CodePtr OpPC) {
return LogicalHelper<T, std::bit_and>(S, OpPC);
}
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Or(InterpState &S, CodePtr OpPC) {
return LogicalHelper<T, std::bit_or>(S, OpPC);
}
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Xor(InterpState &S, CodePtr OpPC) {
return LogicalHelper<T, std::bit_xor>(S, OpPC);
}
//===----------------------------------------------------------------------===//
// Builtin
//===----------------------------------------------------------------------===//
inline bool Builtin(InterpState &S, CodePtr OpPC, uint32_t I) {
if (S.checkingPotentialConstantExpression())
return false;
return InterpBuiltin(S, OpPC, I);
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Zero, Nullptr // Zero, Nullptr
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
template <PrimType Name, class T = typename PrimConv<Name>::T> template <PrimType Name, class T = typename PrimConv<Name>::T>
bool Zero(InterpState &S, CodePtr OpPC) { bool Zero(InterpState &S, CodePtr OpPC) {
S.Stk.push<T>(T::zero()); S.Stk.push<T>(T::zero());
return true; return true;
} }
template <PrimType Name, class T = typename PrimConv<Name>::T> template <PrimType Name, class T = typename PrimConv<Name>::T>
bool ZeroFP(InterpState &S, CodePtr OpPC, uint32_t Bits) {
S.Stk.push<T>(T::zero(Bits));
return true;
}
inline bool ZeroRealFP(InterpState &S, CodePtr OpPC, const fltSemantics *Sema) {
S.Stk.push<Real>(Real::zero(*Sema));
return true;
}
template <PrimType Name, class T = typename PrimConv<Name>::T>
inline bool Null(InterpState &S, CodePtr OpPC) { inline bool Null(InterpState &S, CodePtr OpPC) {
S.Stk.push<T>(); S.Stk.push<T>();
return true; return true;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// This, ImplicitThis // This, ImplicitThis
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 117 Lines • ▼ Show 20 Lines
} }
inline bool ExpandPtr(InterpState &S, CodePtr OpPC) { inline bool ExpandPtr(InterpState &S, CodePtr OpPC) {
const Pointer &Ptr = S.Stk.pop<Pointer>(); const Pointer &Ptr = S.Stk.pop<Pointer>();
S.Stk.push<Pointer>(Ptr.expand()); S.Stk.push<Pointer>(Ptr.expand());
return true; return true;
} }
//===----------------------------------------------------------------------===//
// PtrDiff
//===----------------------------------------------------------------------===//
template <typename T>
bool PtrDiffHelper(InterpState &S, CodePtr OpPC, unsigned BitWidth) {
const Pointer &RHS = S.Stk.pop<Pointer>();
const Pointer &LHS = S.Stk.pop<Pointer>();
// Pointers must point to the same object.
if (LHS.isZero() || !LHS.isLive()) {
S.FFDiag(S.Current->getExpr(OpPC));
return false;
}
if (RHS.isZero() || !RHS.isLive()) {
S.FFDiag(S.Current->getExpr(OpPC));
return false;
}
if (!Pointer::hasSameBase(LHS, RHS)) {
S.FFDiag(S.Current->getExpr(OpPC));
return false;
}
// Pointers must point to the same array.
if (!Pointer::hasSameArray(LHS, RHS)) {
const Expr *E = S.Current->getExpr(OpPC);
S.CCEDiag(E, diag::note_constexpr_pointer_subtraction_not_same_array);
return false;
}
// Compute the difference.
auto RHSIndex = static_cast<int64_t>(RHS.getIndex());
auto LHSIndex = static_cast<int64_t>(LHS.getIndex());
auto Diff = LHSIndex - RHSIndex;
S.Stk.push<T>(T::from(Diff, BitWidth));
if (!T::inRange(Diff, BitWidth)) {
auto APDiff = Integral<64, true>::from(Diff).toAPSInt();
const Expr *E = S.Current->getExpr(OpPC);
S.CCEDiag(E, diag::note_constexpr_overflow) << APDiff << E->getType();
return S.noteUndefinedBehavior();
}
return true;
}
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool PtrDiff(InterpState &S, CodePtr OpPC) {
return PtrDiffHelper<T>(S, OpPC, T::bitWidth());
}
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool PtrDiffFP(InterpState &S, CodePtr OpPC, uint32_t Bits) {
return PtrDiffHelper<T>(S, OpPC, Bits);
}
//===----------------------------------------------------------------------===//
// RealElem, ImagElem
//===----------------------------------------------------------------------===//
inline bool ComplexAccess(InterpState &S, CodePtr OpPC, unsigned Idx,
CheckSubobjectKind CSK) {
const auto &Ptr = S.Stk.pop<Pointer>();
if (!CheckNull(S, OpPC, Ptr, CSK))
return false;
if (!CheckRange(S, OpPC, Ptr, CSK))
return false;
S.Stk.push<Pointer>(Ptr.atIndex(Idx));
return true;
}
inline bool RealElem(InterpState &S, CodePtr OpPC) {
return ComplexAccess(S, OpPC, 0, CSK_Real);
}
inline bool ImagElem(InterpState &S, CodePtr OpPC) {
return ComplexAccess(S, OpPC, 1, CSK_Imag);
}
//===----------------------------------------------------------------------===//
// Trap
//===----------------------------------------------------------------------===//
inline bool Trap(InterpState &S, CodePtr OpPC) {
const SourceLocation &Loc = S.Current->getLocation(OpPC);
S.FFDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
return false;
}
/// Interpreter entry point. /// Interpreter entry point.
bool Interpret(InterpState &S, APValue &Result); bool Interpret(InterpState &S, APValue &Result);
} // namespace interp } // namespace interp
} // namespace clang } // namespace clang
#endif #endif

clang/lib/AST/Interp/Interp.cpp

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
static bool Jf(InterpState &S, CodePtr &PC, int32_t Offset) { static bool Jf(InterpState &S, CodePtr &PC, int32_t Offset) {
if (!S.Stk.pop<bool>()) { if (!S.Stk.pop<bool>()) {
PC += Offset; PC += Offset;
} }
return true; return true;
} }
//===----------------------------------------------------------------------===//
// Call, NoCall, Invoke, NoInvoke, IndirectInvoke
//===----------------------------------------------------------------------===//
static bool HandleCall(InterpState &S, CodePtr &PC, CodePtr OpPC, Function *F,
Pointer &&This) {
if (!CheckCallable(S, OpPC, F))
return false;
// Adjust the state.
S.CallStackDepth++;
// Construct a new frame.
S.Current = new InterpFrame(S, F, S.Current, PC, std::move(This));
// Transfer control to the callee.
PC = F->getCodeBegin();
return true;
}
static bool HandleNoCall(InterpState &S, CodePtr PC, const FunctionDecl *FD) {
const SourceLocation &Loc = S.Current->getLocation(PC - sizeof(FD));
S.FFDiag(Loc, diag::note_constexpr_invalid_function, 1)
<< FD->isConstexpr() << isa<CXXConstructorDecl>(FD) << FD;
S.Note(FD->getLocation(), diag::note_declared_at);
return false;
}
static bool Call(InterpState &S, CodePtr &PC, Function *F) {
if (S.checkingPotentialConstantExpression())
return false;
return HandleCall(S, PC, PC - sizeof(F), F, {});
}
static bool Invoke(InterpState &S, CodePtr &PC, Function *F) {
CodePtr OpPC = PC - sizeof(F);
// Get the this pointer, ensure it's live.
Pointer This = S.Stk.pop<Pointer>();
if (!CheckInvoke(S, OpPC, This))
return false;
if (S.checkingPotentialConstantExpression())
return false;
// Dispatch to the method.
return HandleCall(S, PC, PC - sizeof(F), F, std::move(This));
}
static bool VirtualInvoke(InterpState &S, CodePtr &PC, const CXXMethodDecl *M) {
CodePtr OpPC = PC - sizeof(M);
// Get the this pointer, ensure it's live.
Pointer This = S.Stk.pop<Pointer>();
if (!CheckInvoke(S, OpPC, This))
return false;
if (S.checkingPotentialConstantExpression())
return false;
// Dispatch to the virtual method.
const CXXMethodDecl *Override = VirtualLookup(This, M);
if (!CheckPure(S, OpPC, Override))
return false;
if (auto Func = S.P.getOrCreateFunction(Override)) {
if (*Func) {
return HandleCall(S, PC, OpPC, *Func, std::move(This));
} else {
return HandleNoCall(S, PC, Override);
}
} else {
consumeError(Func.takeError());
return false;
}
}
static bool NoCall(InterpState &S, CodePtr &PC, const FunctionDecl *FD) {
// Do not execute function calls when checking if expr is constant.
if (S.checkingPotentialConstantExpression())
return false;
CodePtr OpPC = PC - sizeof(FD);
// Function was not defined - emit a diagnostic.
if (auto *F = S.P.getFunction(FD)) {
// Function was defined in the meantime - rewrite opcode.
S.Current->getFunction()->relocateCall(OpPC, F);
return HandleCall(S, PC, OpPC, F, {});
} else {
// Function was not defined - emit a diagnostic.
return HandleNoCall(S, PC, FD);
}
}
static bool NoInvoke(InterpState &S, CodePtr &PC, const CXXMethodDecl *MD) {
// Do not execute function calls when checking if expr is constant.
if (S.checkingPotentialConstantExpression())
return false;
CodePtr OpPC = PC - sizeof(MD);
// Access checks.
Pointer This = S.Stk.pop<Pointer>();
if (!CheckInvoke(S, OpPC, This))
return false;
if (auto *F = S.P.getFunction(MD)) {
// Function was defined in the meantime - rewrite opcode.
S.Current->getFunction()->relocateInvoke(OpPC, F);
return HandleCall(S, PC, OpPC, F, std::move(This));
} else {
// Function was not defined - emit a diagnostic.
return HandleNoCall(S, PC, MD);
}
}
static bool IndirectCall(InterpState &S, CodePtr &PC) {
if (S.checkingPotentialConstantExpression())
return false;
const auto &FnPtr = S.Stk.pop<FnPointer>();
if (FnPtr.isZero()) {
S.FFDiag(S.Current->getLocation(PC));
return false;
}
if (Function *F = FnPtr.asFunction()) {
return HandleCall(S, PC, PC, F, {});
} else {
auto *Decl = FnPtr.asDecl();
if (auto Func = S.P.getOrCreateFunction(FnPtr.asDecl())) {
if (*Func)
return HandleCall(S, PC, PC, *Func, {});
else
return HandleNoCall(S, PC, FnPtr.asDecl());
} else {
consumeError(Func.takeError());
}
const SourceLocation &Loc = S.Current->getLocation(PC);
S.FFDiag(Loc, diag::note_constexpr_invalid_function, 1)
<< Decl->isConstexpr() << isa<CXXConstructorDecl>(Decl) << Decl;
S.Note(Decl->getLocation(), diag::note_declared_at);
return false;
}
}
static bool IndirectInvoke(InterpState &S, CodePtr &PC) {
if (S.checkingPotentialConstantExpression())
return false;
const MemberPointer &Field = S.Stk.pop<MemberPointer>();
Pointer This = S.Stk.pop<Pointer>();
// Fetch a pointer to the member function.
const CXXMethodDecl *Method = IndirectLookup(S, PC, This, Field);
if (!Method)
return false;
if (!CheckPure(S, PC, Method))
return false;
if (Expected<Function *> Func = S.P.getOrCreateFunction(Method)) {
if (*Func)
return HandleCall(S, PC, PC, *Func, std::move(This));
else
return HandleNoCall(S, PC, Method);
} else {
consumeError(Func.takeError());
return false;
}
}
static bool CheckInitialized(InterpState &S, CodePtr OpPC, const Pointer &Ptr, static bool CheckInitialized(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
AccessKinds AK) { AccessKinds AK) {
if (Ptr.isInitialized()) if (Ptr.isInitialized())
return true; return true;
if (!S.checkingPotentialConstantExpression()) { if (!S.checkingPotentialConstantExpression()) {
const SourceInfo &Loc = S.Current->getSource(OpPC); const SourceInfo &Loc = S.Current->getSource(OpPC);
S.FFDiag(Loc, diag::note_constexpr_access_uninit) << AK << false; S.FFDiag(Loc, diag::note_constexpr_access_uninit) << AK << false;
} }
▲ Show 20 Lines • Show All 284 Lines • ▼ Show 20 Lines
bool CheckPure(InterpState &S, CodePtr OpPC, const CXXMethodDecl *MD) { bool CheckPure(InterpState &S, CodePtr OpPC, const CXXMethodDecl *MD) {
if (!MD->isPure()) if (!MD->isPure())
return true; return true;
const SourceInfo &E = S.Current->getSource(OpPC); const SourceInfo &E = S.Current->getSource(OpPC);
S.FFDiag(E, diag::note_constexpr_pure_virtual_call, 1) << MD; S.FFDiag(E, diag::note_constexpr_pure_virtual_call, 1) << MD;
S.Note(MD->getLocation(), diag::note_declared_at); S.Note(MD->getLocation(), diag::note_declared_at);
return false; return false;
} }
const CXXMethodDecl *VirtualLookup(Pointer &This, const CXXMethodDecl *MD) {
// Traverse the chain of derived classes, from base to derived.
auto *Impl = MD;
while (This.isBaseClass() && This.isInitialized()) {
// Step into the derived class.
This = This.getBase();
// Fetch the class declaration.
Record *R = This.getRecord();
assert(R != nullptr && "virtual dispatch allowed only on records");
auto *Class = dyn_cast<CXXRecordDecl>(R->getDecl());
assert(Class != nullptr && "not a CXX record");
// Find the most overriden method.
auto *Override = MD->getCorrespondingMethodDeclaredInClass(Class, false);
if (Override) {
Impl = Override;
}
}
return Impl;
}
Record *PointerLookup(Pointer &This, const MemberPointer &Field) {
Record *R = This.getRecord();
// Get the offset inside the record.
if (Field.isDerived()) {
// Walk down the chain to derived classes.
for (const CXXRecordDecl *Step : Field.steps()) {
if (!This.isBaseClass())
return nullptr;
This = This.getBase();
R = This.getRecord();
if (R->getDecl() != Step)
return nullptr;
}
} else {
// Walk up the chain of base classes.
for (const CXXRecordDecl *Step : Field.steps()) {
This = This.atField(R->getBase(Step)->Offset);
R = This.getRecord();
}
}
return R;
}
const CXXMethodDecl *IndirectLookup(InterpState &S, CodePtr OpPC, Pointer &This,
const MemberPointer &Ptr) {
// Fetch and validate the object.
if (!CheckInvoke(S, OpPC, This))
return nullptr;
// Validate the pointer.
if (Ptr.isZero()) {
S.FFDiag(S.Current->getSource(OpPC));
return nullptr;
}
// Find the member and create a function pointer.
if (auto *Decl = dyn_cast<CXXMethodDecl>(Ptr.getDecl())) {
if (Record *R = PointerLookup(This, Ptr)) {
if (!Decl->isVirtual()) {
return Decl;
}
return VirtualLookup(This, Decl);
}
}
// Not found - bail out.
return nullptr;
}
bool Interpret(InterpState &S, APValue &Result) { bool Interpret(InterpState &S, APValue &Result) {
CodePtr PC = S.Current->getPC(); CodePtr PC = S.Current->getPC();
for (;;) { for (;;) {
auto Op = PC.read<Opcode>(); auto Op = PC.read<Opcode>();
CodePtr OpPC = PC; CodePtr OpPC = PC;
switch (Op) { switch (Op) {
Show All 9 Lines

clang/lib/AST/Interp/InterpFrame.cpp

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines if (auto Index = It->getIndex()) {
OS << " + " << Index; OS << " + " << Index;
continue; continue;
} }
OS << "."; OS << ".";
printDesc(It->getFieldDesc()); printDesc(It->getFieldDesc());
} }
} }
template <>
void print(llvm::raw_ostream &OS, const FnPointer &P, ASTContext &,
QualType Ty) {
const FunctionDecl *Decl = nullptr;
if (Function *F = P.asFunction())
Decl = F->getDecl();
if (const FunctionDecl *FD = P.asDecl())
Decl = FD;
if (!Decl) {
OS << "nullptr";
return;
}
if (Ty->isReferenceType()) {
OS << Decl->getName();
} else {
OS << "&" << Decl->getName();
}
}
template <>
void print(llvm::raw_ostream &OS, const MemberPointer &P, ASTContext &,
QualType) {
if (const ValueDecl *VD = P.getDecl())
OS << '&' << *cast<CXXRecordDecl>(VD->getDeclContext()) << "::" << *VD;
else
OS << "0";
return;
}
void InterpFrame::describe(llvm::raw_ostream &OS) { void InterpFrame::describe(llvm::raw_ostream &OS) {
const FunctionDecl *F = getCallee(); const FunctionDecl *F = getCallee();
auto *M = dyn_cast<CXXMethodDecl>(F); auto *M = dyn_cast<CXXMethodDecl>(F);
if (M && M->isInstance() && !isa<CXXConstructorDecl>(F)) { if (M && M->isInstance() && !isa<CXXConstructorDecl>(F)) {
print(OS, This, S.getCtx(), S.getCtx().getRecordType(M->getParent())); print(OS, This, S.getCtx(), S.getCtx().getRecordType(M->getParent()));
OS << "->"; OS << "->";
} }
OS << *F << "("; OS << *F << "(";
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

clang/lib/AST/Interp/Opcodes.td

Show All 19 Lines
def Sint8 : Type; def Sint8 : Type;
def Uint8 : Type; def Uint8 : Type;
def Sint16 : Type; def Sint16 : Type;
def Uint16 : Type; def Uint16 : Type;
def Sint32 : Type; def Sint32 : Type;
def Uint32 : Type; def Uint32 : Type;
def Sint64 : Type; def Sint64 : Type;
def Uint64 : Type; def Uint64 : Type;
def SintFP : Type;
def UintFP : Type;
def RealFP : Type;
def Ptr : Type; def Ptr : Type;
def FnPtr : Type;
def MemPtr : Type;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Types transferred to the interpreter. // Types transferred to the interpreter.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
class ArgType { string Name = ?; } class ArgType { string Name = ?; }
def ArgSint8 : ArgType { let Name = "int8_t"; } def ArgSint8 : ArgType { let Name = "int8_t"; }
def ArgUint8 : ArgType { let Name = "uint8_t"; } def ArgUint8 : ArgType { let Name = "uint8_t"; }
Show All 28 Lines
} }
def AluTypeClass : TypeClass { def AluTypeClass : TypeClass {
let Types = [Sint8, Uint8, Sint16, Uint16, Sint32, let Types = [Sint8, Uint8, Sint16, Uint16, Sint32,
Uint32, Sint64, Uint64, Bool]; Uint32, Sint64, Uint64, Bool];
} }
def PtrTypeClass : TypeClass { def PtrTypeClass : TypeClass {
let Types = [Ptr]; let Types = [Ptr, FnPtr, MemPtr];
}
def FPTypeClass : TypeClass {
let Types = [SintFP, UintFP];
}
def RealFPTypeClass : TypeClass {
let Types = [RealFP];
}
def AluFPTypeClass : TypeClass {
let Types = !listconcat(AluTypeClass.Types, FPTypeClass.Types);
}
def AluFPRealFPTypeClass : TypeClass {
let Types = !listconcat(AluTypeClass.Types, FPTypeClass.Types,
RealFPTypeClass.Types);
} }
def AllTypeClass : TypeClass { def AllTypeClass : TypeClass {
let Types = !listconcat(AluTypeClass.Types, PtrTypeClass.Types); let Types = !listconcat(AluFPRealFPTypeClass.Types, PtrTypeClass.Types);
} }
def ComparableTypeClass : TypeClass { def ArithTypeClass : TypeClass {
let Types = !listconcat(AluTypeClass.Types, [Ptr]); let Types = !listconcat(AluFPRealFPTypeClass.Types, [Ptr]);
} }
class SingletonTypeClass<Type Ty> : TypeClass { class SingletonTypeClass<Type Ty> : TypeClass {
let Types = [Ty]; let Types = [Ty];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Record describing all opcodes. // Record describing all opcodes.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
class Opcode { class Opcode {
list<TypeClass> Types = []; list<TypeClass> Types = [];
list<ArgType> Args = []; list<ArgType> Args = [];
string Name = ""; string Name = "";
bit CanReturn = 0; bit CanReturn = 0;
bit ChangesPC = 0; bit ChangesPC = 0;
bit HasCustomLink = 0; bit HasCustomLink = 0;
bit HasCustomEval = 0; bit HasCustomEval = 0;
bit HasGroup = 0; bit HasGroup = 0;
} }
class AluOpcode : Opcode { class AluOpcode : Opcode {
let Types = [AluTypeClass]; let Types = [AluFPTypeClass];
let HasGroup = 1;
}
class AluRealOpcode : Opcode {
let Types = [AluFPRealFPTypeClass];
let HasGroup = 1; let HasGroup = 1;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Jump opcodes // Jump opcodes
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
class JumpOpcode : Opcode { class JumpOpcode : Opcode {
let Args = [ArgSint32]; let Args = [ArgSint32];
let ChangesPC = 1; let ChangesPC = 1;
let HasCustomEval = 1; let HasCustomEval = 1;
} }
// [] -> [] // [] -> []
def Jmp : JumpOpcode; def Jmp : JumpOpcode;
// [Bool] -> [], jumps if true. // [Bool] -> [], jumps if true.
def Jt : JumpOpcode; def Jt : JumpOpcode;
// [Bool] -> [], jumps if false. // [Bool] -> [], jumps if false.
def Jf : JumpOpcode; def Jf : JumpOpcode;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Call opcodes
//
// The default calling convention, which does not support varargs, pops the
// arguments on exit. Vararg functions require arguments to be caller-popped.
//
//===----------------------------------------------------------------------===//
// [Args...] -> []
def Call : Opcode {
let Args = [ArgFunction];
let ChangesPC = 1;
let HasCustomEval = 1;
}
// [Args..., FnPointer] -> []
def IndirectCall : Opcode {
let ChangesPC = 1;
let HasCustomEval = 1;
}
// [Args..., Pointer] -> []
def Invoke : Opcode {
let Args = [ArgFunction];
let ChangesPC = 1;
let HasCustomEval = 1;
}
// [Args..., Pointer, MemberPtr] -> []
def IndirectInvoke : Opcode {
let ChangesPC = 1;
let HasCustomEval = 1;
}
// [Args..., Pointer] -> []
def VirtualInvoke : Opcode {
let Args = [ArgCXXMethodDecl];
let ChangesPC = 1;
let HasCustomEval = 1;
}
// [Args...] -> []
def Builtin : Opcode {
let Args = [ArgUint32];
}
//===----------------------------------------------------------------------===//
// Invalid relocation trap
//===----------------------------------------------------------------------===//
// [] -> EXIT
def NoCall : Opcode {
let Args = [ArgFunctionDecl];
let ChangesPC = 1;
let HasCustomEval = 1;
}
// [] -> EXIT
def NoInvoke : Opcode {
let Args = [ArgCXXMethodDecl];
let ChangesPC = 1;
let HasCustomEval = 1;
}
//===----------------------------------------------------------------------===//
// Returns // Returns
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// [Value] -> [] // [Value] -> []
def Ret : Opcode { def Ret : Opcode {
let Types = [AllTypeClass]; let Types = [AllTypeClass];
let ChangesPC = 1; let ChangesPC = 1;
let CanReturn = 1; let CanReturn = 1;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
def ConstUint16 : ConstOpcode<Uint16, ArgUint16>; def ConstUint16 : ConstOpcode<Uint16, ArgUint16>;
def ConstSint32 : ConstOpcode<Sint32, ArgSint32>; def ConstSint32 : ConstOpcode<Sint32, ArgSint32>;
def ConstUint32 : ConstOpcode<Uint32, ArgUint32>; def ConstUint32 : ConstOpcode<Uint32, ArgUint32>;
def ConstSint64 : ConstOpcode<Sint64, ArgSint64>; def ConstSint64 : ConstOpcode<Sint64, ArgSint64>;
def ConstUint64 : ConstOpcode<Uint64, ArgUint64>; def ConstUint64 : ConstOpcode<Uint64, ArgUint64>;
def ConstBool : ConstOpcode<Bool, ArgBool>; def ConstBool : ConstOpcode<Bool, ArgBool>;
// [] -> [Integer] // [] -> [Integer]
def ConstFP : Opcode {
let Types = [FPTypeClass];
let Args = [ArgUint32, ArgUint64];
let Name = "ConstFP";
}
// [] -> [Real]
def ConstRealFP : Opcode {
let Args = [ArgFloatingLiteral];
}
// [] -> [FnPointer]
def ConstFn : Opcode {
let Args = [ArgFunction];
}
// [] -> [FnPointer]
def ConstNoFn : Opcode {
let Args = [ArgFunctionDecl];
}
// [] -> [MemberPointer]
def ConstMem : Opcode {
let Args = [ArgValueDecl];
}
// [] -> [Integer]
def Zero : Opcode { def Zero : Opcode {
let Types = [AluTypeClass]; let Types = [AluTypeClass];
} }
// [] -> [Integer]
def ZeroFP : Opcode {
let Types = [FPTypeClass];
let Args = [ArgUint32];
}
// [] -> [Real]
def ZeroRealFP : Opcode {
let Args = [ArgSema];
}
// [] -> [Pointer] // [] -> [Pointer]
def Null : Opcode { def Null : Opcode {
let Types = [PtrTypeClass]; let Types = [PtrTypeClass];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Pointer generation // Pointer generation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// [] -> [Pointer] // [] -> [Pointer]
def GetPtrLocal : Opcode { def GetPtrLocal : Opcode {
// Offset of local.
let Args = [ArgUint32]; let Args = [ArgUint32];
bit HasCustomEval = 1; bit HasCustomEval = 1;
} }
// [] -> [Pointer] // [] -> [Pointer]
def GetPtrParam : Opcode { def GetPtrParam : Opcode {
// Offset of parameter.
let Args = [ArgUint32]; let Args = [ArgUint32];
} }
// [] -> [Pointer] // [] -> [Pointer]
def GetPtrGlobal : Opcode { def GetPtrGlobal : Opcode {
// Index of global.
let Args = [ArgUint32]; let Args = [ArgUint32];
} }
// [Pointer] -> [Pointer] // [Pointer] -> [Pointer]
def GetPtrField : Opcode { def GetPtrField : Opcode {
// Offset of field.
let Args = [ArgUint32]; let Args = [ArgUint32];
} }
// [Pointer] -> [Pointer] // [Pointer] -> [Pointer]
def GetPtrActiveField : Opcode { def GetPtrActiveField : Opcode {
// Offset of field.
let Args = [ArgUint32]; let Args = [ArgUint32];
} }
// [] -> [Pointer] // [] -> [Pointer]
def GetPtrActiveThisField : Opcode { def GetPtrActiveThisField : Opcode {
// Offset of field.
let Args = [ArgUint32]; let Args = [ArgUint32];
} }
// [] -> [Pointer] // [] -> [Pointer]
def GetPtrThisField : Opcode { def GetPtrThisField : Opcode {
// Offset of field.
let Args = [ArgUint32]; let Args = [ArgUint32];
} }
// [Pointer] -> [Pointer] // [Pointer] -> [Pointer]
def GetPtrBase : Opcode { def GetPtrBase : Opcode {
// Offset of field, which is a base.
let Args = [ArgUint32]; let Args = [ArgUint32];
} }
// [Pointer] -> [Pointer] // [Pointer] -> [Pointer]
def GetPtrVirtBase : Opcode { def GetPtrVirtBase : Opcode {
// RecordDecl of base class.
let Args = [ArgRecordDecl]; let Args = [ArgRecordDecl];
} }
// [] -> [Pointer] // [] -> [Pointer]
def GetPtrThisBase : Opcode { def GetPtrThisBase : Opcode {
// Offset of field, which is a base.
let Args = [ArgUint32]; let Args = [ArgUint32];
} }
// [] -> [Pointer] // [] -> [Pointer]
def GetPtrThisVirtBase : Opcode { def GetPtrThisVirtBase : Opcode {
// RecordDecl of base class.
let Args = [ArgRecordDecl]; let Args = [ArgRecordDecl];
} }
// [] -> [Pointer] // [] -> [Pointer]
def This : Opcode; def This : Opcode;
// [Pointer, MemberPointer] -> [Pointer]
def GetPtrFieldIndirect : Opcode;
// [Pointer] -> [Pointer] // [Pointer] -> [Pointer]
def NarrowPtr : Opcode; def NarrowPtr : Opcode;
// [Pointer] -> [Pointer] // [Pointer] -> [Pointer]
def ExpandPtr : Opcode; def ExpandPtr : Opcode;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Direct field accessors // Direct field accessors
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
class AccessOpcode : Opcode { class AccessOpcode : Opcode {
let Types = [AllTypeClass]; let Types = [AllTypeClass];
let Args = [ArgUint32]; let Args = [ArgUint32];
let HasGroup = 1; let HasGroup = 1;
} }
class BitFieldOpcode : Opcode { class BitFieldOpcode : Opcode {
let Types = [AluTypeClass]; let Types = [AluFPTypeClass];
let Args = [ArgRecordField]; let Args = [ArgRecordField];
let HasGroup = 1; let HasGroup = 1;
} }
// [] -> [Pointer] // [] -> [Pointer]
def GetLocal : AccessOpcode { let HasCustomEval = 1; } def GetLocal : AccessOpcode { let HasCustomEval = 1; }
// [] -> [Pointer] // [] -> [Pointer]
def SetLocal : AccessOpcode { let HasCustomEval = 1; } def SetLocal : AccessOpcode { let HasCustomEval = 1; }
Show All 30 Lines
def InitThisBitField : BitFieldOpcode; def InitThisBitField : BitFieldOpcode;
// [Pointer, Value] -> [] // [Pointer, Value] -> []
def InitField : AccessOpcode; def InitField : AccessOpcode;
// [Pointer, Value] -> [] // [Pointer, Value] -> []
def InitBitField : BitFieldOpcode; def InitBitField : BitFieldOpcode;
// [Pointer, Value] -> [] // [Pointer, Value] -> []
def InitFieldActive : AccessOpcode; def InitFieldActive : AccessOpcode;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Pointer access // Pointer access
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
class LoadOpcode : Opcode { class LoadOpcode : Opcode {
let Types = [AllTypeClass]; let Types = [AllTypeClass];
let HasGroup = 1; let HasGroup = 1;
} }
// [Pointer] -> [Pointer, Value] // [Pointer] -> [Pointer, Value]
def Load : LoadOpcode {} def Load : LoadOpcode {}
// [Pointer] -> [Value] // [Pointer] -> [Value]
def LoadPop : LoadOpcode {} def LoadPop : LoadOpcode {}
class StoreOpcode : Opcode { class StoreOpcode : Opcode {
let Types = [AllTypeClass]; let Types = [AllTypeClass];
let HasGroup = 1; let HasGroup = 1;
} }
class StoreBitFieldOpcode : Opcode { class StoreBitFieldOpcode : Opcode {
let Types = [AluTypeClass]; let Types = [AluFPTypeClass];
let HasGroup = 1; let HasGroup = 1;
} }
// [Pointer, Value] -> [Pointer] // [Pointer, Value] -> [Pointer]
def Store : StoreOpcode {} def Store : StoreOpcode {}
// [Pointer, Value] -> [] // [Pointer, Value] -> []
def StorePop : StoreOpcode {} def StorePop : StoreOpcode {}
Show All 21 Lines
// Pointer arithmetic. // Pointer arithmetic.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// [Pointer, Integral] -> [Pointer] // [Pointer, Integral] -> [Pointer]
def AddOffset : AluOpcode; def AddOffset : AluOpcode;
// [Pointer, Integral] -> [Pointer] // [Pointer, Integral] -> [Pointer]
def SubOffset : AluOpcode; def SubOffset : AluOpcode;
// [Pointer, Pointer] -> [Integral]
def PtrDiff : Opcode {
let Types = [AluTypeClass];
let HasGroup = 1;
}
// [Pointer, Pointer] -> [Integral]
def PtrDiffFP : Opcode {
let Types = [FPTypeClass];
let Args = [ArgUint32];
let HasGroup = 1;
}
def RealElem : Opcode;
def ImagElem : Opcode;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Binary operators. // Binary operators.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// [Real, Real] -> [Real] // [Real, Real] -> [Real]
def Sub : AluOpcode; def Sub : AluRealOpcode;
def Add : AluOpcode; def Add : AluRealOpcode;
def Mul : AluOpcode; def Mul : AluRealOpcode;
def Div : AluRealOpcode;
// [Integral, Integral] -> [Integral]
def Rem : AluOpcode;
def And : AluOpcode;
def Or : AluOpcode;
def Xor : AluOpcode;
//===----------------------------------------------------------------------===//
// Bit shift operators.
//===----------------------------------------------------------------------===//
class ShiftOpcode : Opcode {
let Types = [AluFPTypeClass, AluFPTypeClass];
let HasGroup = 1;
}
// [Integral, Integral] -> [Integral]
def Shr : ShiftOpcode;
def Shl : ShiftOpcode;
//===----------------------------------------------------------------------===//
// Unary operators.
//===----------------------------------------------------------------------===//
// [Real] -> [Real]
def Minus : AluRealOpcode;
// [Integral] -> [Integral]
def Not : AluOpcode;
// [Integral] -> [Integral]
def Test : Opcode {
let Types = [AllTypeClass];
let HasGroup = 1;
}
//===----------------------------------------------------------------------===//
// Logical negation.
//===----------------------------------------------------------------------===//
// [Value] -> [Bool]
def LogicalNot : Opcode {
let Types = [AllTypeClass];
let HasGroup = 1;
}
//===----------------------------------------------------------------------===//
// Increment/decrement.
//===----------------------------------------------------------------------===//
class IncDecOpcode : Opcode {
let Types = [ArithTypeClass];
let HasGroup = 1;
}
// [Pointer] -> [Arith]
def PostInc : IncDecOpcode;
// [Pointer] -> [Arith]
def PostDec : IncDecOpcode;
// [Pointer] -> [Pointer]
def PreInc : IncDecOpcode;
// [Pointer] -> [Pointer]
def PreDec : IncDecOpcode;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Comparison opcodes. // Comparison opcodes.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
class EqualityOpcode : Opcode { class EqualityOpcode : Opcode {
let Types = [AllTypeClass]; let Types = [AllTypeClass];
let HasGroup = 1; let HasGroup = 1;
} }
def EQ : EqualityOpcode; def EQ : EqualityOpcode;
def NE : EqualityOpcode; def NE : EqualityOpcode;
class ComparisonOpcode : Opcode { class ComparisonOpcode : Opcode {
let Types = [ComparableTypeClass]; let Types = [ArithTypeClass];
let HasGroup = 1; let HasGroup = 1;
} }
def LT : ComparisonOpcode; def LT : ComparisonOpcode;
def LE : ComparisonOpcode; def LE : ComparisonOpcode;
def GT : ComparisonOpcode; def GT : ComparisonOpcode;
def GE : ComparisonOpcode; def GE : ComparisonOpcode;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Range test.
//===----------------------------------------------------------------------===//
// [Real, Real, Real] -> [Bool]
def InRange : Opcode {
let Types = [AluFPTypeClass];
let HasGroup = 1;
}
//===----------------------------------------------------------------------===//
// Stack management. // Stack management.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// [Value] -> [] // [Value] -> []
def Pop : Opcode { def Pop : Opcode {
let Types = [AllTypeClass]; let Types = [AllTypeClass];
let HasGroup = 1; let HasGroup = 1;
} }
// [Value] -> [Value, Value] // [Value] -> [Value, Value]
def Dup : Opcode { def Dup : Opcode {
let Types = [AllTypeClass]; let Types = [AllTypeClass];
let HasGroup = 1; let HasGroup = 1;
} }
//===----------------------------------------------------------------------===//
// Cast operators
//===----------------------------------------------------------------------===//
// [Value] -> [Value]
def Cast : Opcode {
let Types = [AluFPTypeClass, AluTypeClass];
let HasGroup = 1;
}
// [Real] -> [Alu]
def CastRealFPToAlu : Opcode {
let Types = [RealFPTypeClass, AluTypeClass];
let HasGroup = 1;
}
// [Real] -> [AluFP]
def CastRealFPToAluFP : Opcode {
let Types = [RealFPTypeClass, AluFPTypeClass];
let Args = [ArgUint32];
let HasGroup = 1;
}
// [Value] -> [Value]
def CastFP : Opcode {
let Types = [AluFPTypeClass, FPTypeClass];
let Args = [ArgUint32];
let HasGroup = 1;
}
// [Value] -> [Real]
def CastRealFP : Opcode {
let Types = [AluFPRealFPTypeClass];
let Args = [ArgSema];
let HasGroup = 1;
}
// [MemberPtr] -> [MemberPtr]
def CastMemberToDerived : Opcode {
let Args = [ArgCXXRecordDecl];
}
// [MemberPtr] -> [MemberPtr]
def CastMemberToBase : Opcode {
let Args = [ArgCXXRecordDecl];
}
// [Pointer] -> [Pointer]
def CastToDerived : Opcode {
let Args = [ArgExpr];
}
// [Pointer] -> [Pointer]
def PointerBitCast : Opcode {
let Args = [];
}
// [] -> []
def ReinterpretCastWarning : Opcode;
def DynamicCastWarning : Opcode;
//===----------------------------------------------------------------------===//
// Trap instruction.
//===----------------------------------------------------------------------===//
def Trap : Opcode;

clang/lib/AST/Interp/Pointer.h

Show First 20 Lines • Show All 336 Lines • ▼ Show 20 Linesprivate:
unsigned Offset = 0; unsigned Offset = 0;
/// Previous link in the pointer chain. /// Previous link in the pointer chain.
Pointer *Prev = nullptr; Pointer *Prev = nullptr;
/// Next link in the pointer chain. /// Next link in the pointer chain.
Pointer *Next = nullptr; Pointer *Next = nullptr;
}; };
/// Function pointer.
class FnPointer {
public:
FnPointer();
FnPointer(Function *F);
FnPointer(const FunctionDecl *FD);
/// Converts the pointer to an APValue.
APValue toAPValue() const;
/// Checks if the pointer is a null function pointer.
bool isZero() const;
/// Returns the declaration.
const FunctionDecl *asDecl() const;
/// Returns the function.
Function *asFunction() const;
/// Compares two function pointers.
ComparisonCategoryResult compare(const FnPointer &RHS) const;
/// Prints the pointer.
void print(llvm::raw_ostream &OS) const {
if (isZero())
OS << "nullptr";
else
OS << *asDecl();
}
private:
llvm::PointerUnion<const FunctionDecl *, Function *> Pointer;
};
/// Base class for member and member function pointers.
class MemberPointer {
/// Structure holding intermediary conversion steps.
using StepList = SmallVector<const CXXRecordDecl *, 4>;
using step_iterator = StepList::const_reverse_iterator;
/// The declaration to which this pointer points.
const ValueDecl *F;
/// Flag indicating that the pointer points to a field
/// in a class derived from the pointer's class.
bool IsDerived = false;
/// Chain of derived or base classes to look in.
SmallVector<const CXXRecordDecl *, 4> Steps;
public:
/// Pointer construction.
MemberPointer() : F(nullptr) {}
MemberPointer(const ValueDecl *F)
: F(F), Steps({cast<CXXRecordDecl>(F->getDeclContext())}) {}
/// Converts the pointer to an APValue.
APValue toAPValue() const { return APValue(F, IsDerived, Steps); }
/// Checks if the pointer is a null member pointer.
bool isZero() const { return !F; }
/// Checks if the field is of a derived class.
bool isDerived() const { return IsDerived; }
/// Compares two member pointers.
bool operator==(const MemberPointer &RHS) const;
/// Converts to a base pointer, in place.
bool toBase(const CXXRecordDecl *B);
/// Converts to a derived pointer, in place.
bool toDerived(const CXXRecordDecl *D);
/// Returns the underlying declaration.
const ValueDecl *getDecl() const { return F; }
/// Iterators over the conversion chain, excluding the last class.
llvm::iterator_range<step_iterator> steps() const {
return llvm::make_range(Steps.rbegin() + 1, Steps.rend());
}
/// Prints the pointer.
void print(llvm::raw_ostream &OS) const {
if (isZero())
OS << "nullptr";
else
OS << *getDecl();
}
};
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Pointer &P) { inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Pointer &P) {
P.print(OS); P.print(OS);
return OS; return OS;
} }
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
const FnPointer &P) {
P.print(OS);
return OS;
}
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
const MemberPointer &P) {
P.print(OS);
return OS;
}
} // namespace interp } // namespace interp
} // namespace clang } // namespace clang
#endif #endif

clang/lib/AST/Interp/Pointer.cpp

Show First 20 Lines • Show All 185 Lines • ▼ Show 20 Lines
bool Pointer::hasSameBase(const Pointer &A, const Pointer &B) { bool Pointer::hasSameBase(const Pointer &A, const Pointer &B) {
return A.Pointee == B.Pointee; return A.Pointee == B.Pointee;
} }
bool Pointer::hasSameArray(const Pointer &A, const Pointer &B) { bool Pointer::hasSameArray(const Pointer &A, const Pointer &B) {
return A.Base == B.Base && A.getFieldDesc()->IsArray; return A.Base == B.Base && A.getFieldDesc()->IsArray;
} }
FnPointer::FnPointer() : Pointer(nullptr) {}
FnPointer::FnPointer(Function *F) : Pointer(F) {}
FnPointer::FnPointer(const FunctionDecl *FD) : Pointer(FD) {}
APValue FnPointer::toAPValue() const {
APValue::LValueBase Base;
llvm::SmallVector<APValue::LValuePathEntry, 5> Path;
bool IsNullPtr;
bool IsOnePastEnd;
if (isZero()) {
Base = static_cast<const Expr *>(nullptr);
IsNullPtr = true;
IsOnePastEnd = false;
} else {
IsNullPtr = false;
if (const FunctionDecl *FD = asDecl())
Base = FD;
if (Function *F = asFunction())
Base = F->getDecl();
// TODO: determine IsOnePastEnd
IsOnePastEnd = false;
}
return APValue(Base, CharUnits::Zero(), Path, IsOnePastEnd, IsNullPtr);
}
const FunctionDecl *FnPointer::asDecl() const {
if (Function *F = asFunction())
return F->getDecl();
return Pointer.dyn_cast<const FunctionDecl *>();
}
Function *FnPointer::asFunction() const {
return Pointer.dyn_cast<Function *>();
}
bool FnPointer::isZero() const { return !Pointer; }
ComparisonCategoryResult FnPointer::compare(const FnPointer &RHS) const {
if (asDecl() == RHS.asDecl()) {
return ComparisonCategoryResult::Equal;
} else {
return ComparisonCategoryResult::Nonequal;
}
}
/// Compares two member pointers.
bool MemberPointer::operator==(const MemberPointer &RHS) const {
if (!F || !RHS.F)
return !F && !RHS.F;
return F == RHS.F && IsDerived == RHS.IsDerived && Steps == RHS.Steps;
}
/// Converts to a base pointer, in place.
bool MemberPointer::toBase(const CXXRecordDecl *B) {
if (isZero())
return true;
if (Steps.size() == 1) {
IsDerived = true;
Steps.push_back(B);
return true;
}
if (IsDerived) {
Steps.push_back(B);
return true;
}
if (*(Steps.rbegin() + 1) != B)
return false;
Steps.pop_back();
return true;
}
/// Converts to a derived pointer, in place.
bool MemberPointer::toDerived(const CXXRecordDecl *D) {
if (isZero())
return true;
// No dangling derived member - extend path.
if (!IsDerived) {
Steps.push_back(D);
return true;
}
// The class we are casting to must match the class in the path.
// The only path which is allowed is the one that traces back to base.
if (*(Steps.rbegin() + 1) != D)
return false;
Steps.pop_back();
if (Steps.size() == 1)
IsDerived = false;
return true;
}

clang/lib/AST/Interp/Real.h

  • This file was added.
//===--- Real.h - Wrapper for floating types for the VM ---------*- 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
//
//===----------------------------------------------------------------------===//
//
// Defines the VM types and helpers operating on types.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_AST_INTERP_REAL_H
#define LLVM_CLANG_AST_INTERP_REAL_H
#include "llvm/ADT/APFloat.h"
#include "llvm/Support/raw_ostream.h"
#include <cstddef>
#include <cstdint>
namespace clang {
namespace interp {
using APFloat = llvm::APFloat;
using fltSemantics = llvm::fltSemantics;
using RoundingMode = APFloat::roundingMode;
class Real {
APFloat V;
public:
Real() : V(llvm::APFloat::Bogus(), 0) {}
explicit Real(const APFloat &V) : V(V) {}
APFloat toAPFloat() const { return V; }
APValue toAPValue() const { return APValue(toAPFloat()); }
void print(llvm::raw_ostream &OS) const { V.print(OS); }
bool isZero() const { return V.isZero(); }
bool isNaN() const { return V.isNaN(); }
ComparisonCategoryResult compare(const Real &RHS) const {
switch (V.compare(RHS.V)) {
case APFloat::cmpEqual:
return ComparisonCategoryResult::Equal;
case APFloat::cmpLessThan:
return ComparisonCategoryResult::Less;
case APFloat::cmpGreaterThan:
return ComparisonCategoryResult::Greater;
case APFloat::cmpUnordered:
return ComparisonCategoryResult::Unordered;
}
}
template <unsigned Bits, bool Sign>
static Real from(const Integral<Bits, Sign> &I, const fltSemantics &S) {
APFloat Result(S, 1);
Result.convertFromAPInt(I.toAPSInt(), I.isSigned(),
APFloat::rmNearestTiesToEven);
return Real(Result);
}
static Real from(const APFloat &F, const llvm::fltSemantics &S) {
return Real(F);
}
static Real zero(const llvm::fltSemantics &S) {
return Real(APFloat::getZero(S));
}
static Real from(const Real &F, const llvm::fltSemantics &S) {
APFloat Result = F.V;
bool Ignored;
Result.convert(S, APFloat::rmNearestTiesToEven, &Ignored);
return Real(Result);
}
static Real increment(const Real &A) {
APFloat R = A.V;
R.add(APFloat(R.getSemantics(), 1), APFloat::rmNearestTiesToEven);
return Real(R);
}
static Real decrement(const Real &A) {
APFloat R = A.V;
R.subtract(APFloat(R.getSemantics(), 1), APFloat::rmNearestTiesToEven);
return Real(R);
}
static Real add(const Real &LHS, const Real &RHS, APFloat::roundingMode M) {
APFloat Result = LHS.V;
Result.add(RHS.V, M);
return Real(Result);
}
static Real sub(const Real &LHS, const Real &RHS, APFloat::roundingMode M) {
APFloat Result = LHS.V;
Result.subtract(RHS.V, M);
return Real(Result);
}
static Real mul(const Real &LHS, const Real &RHS, APFloat::roundingMode M) {
APFloat Result = LHS.V;
Result.multiply(RHS.V, M);
return Real(Result);
}
static Real div(const Real &LHS, const Real &RHS, APFloat::roundingMode M) {
APFloat Result = LHS.V;
Result.divide(RHS.V, M);
return Real(Result);
}
static Real negate(const Real &Arg) {
APFloat Result = Arg.V;
Result.changeSign();
return Real(Result);
}
};
inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Real &F) {
F.print(OS);
return OS;
}
} // namespace interp
} // namespace clang
#endif

clang/lib/AST/Interp/Type.h

Show All 9 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_AST_INTERP_TYPE_H #ifndef LLVM_CLANG_AST_INTERP_TYPE_H
#define LLVM_CLANG_AST_INTERP_TYPE_H #define LLVM_CLANG_AST_INTERP_TYPE_H
#include "Integral.h" #include "Integral.h"
#include "Pointer.h" #include "Pointer.h"
#include "Real.h"
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <climits> #include <climits>
namespace clang { namespace clang {
namespace interp { namespace interp {
/// Enumeration of the primitive types of the VM. /// Enumeration of the primitive types of the VM.
enum PrimType : unsigned { enum PrimType : unsigned {
PT_Sint8, PT_Sint8,
PT_Uint8, PT_Uint8,
PT_Sint16, PT_Sint16,
PT_Uint16, PT_Uint16,
PT_Sint32, PT_Sint32,
PT_Uint32, PT_Uint32,
PT_Sint64, PT_Sint64,
PT_Uint64, PT_Uint64,
PT_SintFP,
PT_UintFP,
PT_RealFP,
PT_Bool, PT_Bool,
PT_Ptr, PT_Ptr,
PT_FnPtr,
PT_MemPtr,
}; };
/// Mapping from primitive types to their representation. /// Mapping from primitive types to their representation.
template <PrimType T> struct PrimConv; template <PrimType T> struct PrimConv;
template <> struct PrimConv<PT_Sint8> { using T = Integral<8, true>; }; template <> struct PrimConv<PT_Sint8> { using T = Integral<8, true>; };
template <> struct PrimConv<PT_Uint8> { using T = Integral<8, false>; }; template <> struct PrimConv<PT_Uint8> { using T = Integral<8, false>; };
template <> struct PrimConv<PT_Sint16> { using T = Integral<16, true>; }; template <> struct PrimConv<PT_Sint16> { using T = Integral<16, true>; };
template <> struct PrimConv<PT_Uint16> { using T = Integral<16, false>; }; template <> struct PrimConv<PT_Uint16> { using T = Integral<16, false>; };
template <> struct PrimConv<PT_Sint32> { using T = Integral<32, true>; }; template <> struct PrimConv<PT_Sint32> { using T = Integral<32, true>; };
template <> struct PrimConv<PT_Uint32> { using T = Integral<32, false>; }; template <> struct PrimConv<PT_Uint32> { using T = Integral<32, false>; };
template <> struct PrimConv<PT_Sint64> { using T = Integral<64, true>; }; template <> struct PrimConv<PT_Sint64> { using T = Integral<64, true>; };
template <> struct PrimConv<PT_Uint64> { using T = Integral<64, false>; }; template <> struct PrimConv<PT_Uint64> { using T = Integral<64, false>; };
template <> struct PrimConv<PT_SintFP> { using T = Integral<0, true>; };
template <> struct PrimConv<PT_UintFP> { using T = Integral<0, false>; };
template <> struct PrimConv<PT_RealFP> { using T = Real; };
template <> struct PrimConv<PT_Bool> { using T = Integral<1, false>; }; template <> struct PrimConv<PT_Bool> { using T = Integral<1, false>; };
template <> struct PrimConv<PT_Ptr> { using T = Pointer; }; template <> struct PrimConv<PT_Ptr> { using T = Pointer; };
template <> struct PrimConv<PT_FnPtr> { using T = FnPointer; };
template <> struct PrimConv<PT_MemPtr> { using T = MemberPointer; };
/// Returns the size of a primitive type in bytes. /// Returns the size of a primitive type in bytes.
size_t primSize(PrimType Type); size_t primSize(PrimType Type);
/// Aligns a size to the pointer alignment. /// Aligns a size to the pointer alignment.
constexpr size_t align(size_t Size) { constexpr size_t align(size_t Size) {
return ((Size + alignof(void *) - 1) / alignof(void *)) * alignof(void *); return ((Size + alignof(void *) - 1) / alignof(void *)) * alignof(void *);
} }
Show All 10 Linesinline bool isPrimitiveIntegral(PrimType Type) {
case PT_Sint64: case PT_Sint64:
case PT_Uint64: case PT_Uint64:
return true; return true;
default: default:
return false; return false;
} }
} }
inline bool isFixedIntegral(PrimType Type) {
switch (Type) {
case PT_SintFP:
case PT_UintFP:
return true;
default:
return false;
}
}
inline bool isFixedReal(PrimType Type) {
return Type == PT_RealFP;
}
} // namespace interp } // namespace interp
} // namespace clang } // namespace clang
/// Helper macro to simplify type switches. /// Helper macro to simplify type switches.
/// The macro implicitly exposes a type T in the scope of the inner block. /// The macro implicitly exposes a type T in the scope of the inner block.
#define TYPE_SWITCH_CASE(Name, B) \ #define TYPE_SWITCH_CASE(Name, B) \
case Name: { using T = PrimConv<Name>::T; do {B;} while(0); break; } case Name: { using T = PrimConv<Name>::T; do {B;} while(0); break; }
#define TYPE_SWITCH(Expr, B) \ #define TYPE_SWITCH(Expr, B) \
switch (Expr) { \ switch (Expr) { \
TYPE_SWITCH_CASE(PT_Sint8, B) \ TYPE_SWITCH_CASE(PT_Sint8, B) \
TYPE_SWITCH_CASE(PT_Uint8, B) \ TYPE_SWITCH_CASE(PT_Uint8, B) \
TYPE_SWITCH_CASE(PT_Sint16, B) \ TYPE_SWITCH_CASE(PT_Sint16, B) \
TYPE_SWITCH_CASE(PT_Uint16, B) \ TYPE_SWITCH_CASE(PT_Uint16, B) \
TYPE_SWITCH_CASE(PT_Sint32, B) \ TYPE_SWITCH_CASE(PT_Sint32, B) \
TYPE_SWITCH_CASE(PT_Uint32, B) \ TYPE_SWITCH_CASE(PT_Uint32, B) \
TYPE_SWITCH_CASE(PT_Sint64, B) \ TYPE_SWITCH_CASE(PT_Sint64, B) \
TYPE_SWITCH_CASE(PT_Uint64, B) \ TYPE_SWITCH_CASE(PT_Uint64, B) \
TYPE_SWITCH_CASE(PT_SintFP, B) \
TYPE_SWITCH_CASE(PT_UintFP, B) \
TYPE_SWITCH_CASE(PT_RealFP, B) \
TYPE_SWITCH_CASE(PT_Bool, B) \ TYPE_SWITCH_CASE(PT_Bool, B) \
TYPE_SWITCH_CASE(PT_Ptr, B) \ TYPE_SWITCH_CASE(PT_Ptr, B) \
TYPE_SWITCH_CASE(PT_FnPtr, B) \
TYPE_SWITCH_CASE(PT_MemPtr, B) \
} }
#define COMPOSITE_TYPE_SWITCH(Expr, B, D) \ #define COMPOSITE_TYPE_SWITCH(Expr, B, D) \
switch (Expr) { \ switch (Expr) { \
TYPE_SWITCH_CASE(PT_SintFP, B) \
TYPE_SWITCH_CASE(PT_UintFP, B) \
TYPE_SWITCH_CASE(PT_RealFP, B) \
TYPE_SWITCH_CASE(PT_Ptr, B) \ TYPE_SWITCH_CASE(PT_Ptr, B) \
TYPE_SWITCH_CASE(PT_MemPtr, B) \
default: do { D; } while(0); break; \ default: do { D; } while(0); break; \
} }
#define INT_TYPE_SWITCH(Expr, B) \ #define INT_TYPE_SWITCH(Expr, B) \
switch (Expr) { \ switch (Expr) { \
TYPE_SWITCH_CASE(PT_Sint8, B) \ TYPE_SWITCH_CASE(PT_Sint8, B) \
TYPE_SWITCH_CASE(PT_Uint8, B) \ TYPE_SWITCH_CASE(PT_Uint8, B) \
TYPE_SWITCH_CASE(PT_Sint16, B) \ TYPE_SWITCH_CASE(PT_Sint16, B) \
TYPE_SWITCH_CASE(PT_Uint16, B) \ TYPE_SWITCH_CASE(PT_Uint16, B) \
TYPE_SWITCH_CASE(PT_Sint32, B) \ TYPE_SWITCH_CASE(PT_Sint32, B) \
TYPE_SWITCH_CASE(PT_Uint32, B) \ TYPE_SWITCH_CASE(PT_Uint32, B) \
TYPE_SWITCH_CASE(PT_Sint64, B) \ TYPE_SWITCH_CASE(PT_Sint64, B) \
TYPE_SWITCH_CASE(PT_Uint64, B) \ TYPE_SWITCH_CASE(PT_Uint64, B) \
TYPE_SWITCH_CASE(PT_SintFP, B) \
TYPE_SWITCH_CASE(PT_UintFP, B) \
default: llvm_unreachable("not an integer"); \ default: llvm_unreachable("not an integer"); \
} }
#endif #endif

clang/test/AST/Interp/alignof.cpp

  • This file was added.
// RUN: %clang_cc1 -triple=x86_64-apple-darwin12 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -triple=x86_64-apple-darwin12 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
static_assert(alignof(void *) == 8);

clang/test/AST/Interp/arg_struct.cpp

  • This file was copied from clang/test/AST/Interp/cond.cpp.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics // expected-no-diagnostics
constexpr int cond_then_else(int a, int b) {
if (a < b) { struct S {
return b - a; int x = 1;
} else { };
return a - b;
constexpr int callee(S s, S t) {
return s.x + t.x;
} }
constexpr int caller(S s) {
return callee(s, {});
} }
static_assert(caller({}) == 2);

clang/test/AST/Interp/array.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
constexpr int *invalid_offset() { // expected-error {{constexpr function never produces a constant expression}}
int arr[3] = {1, 2};
return 4 + arr; // expected-note {{cannot refer to element 4 of array of 3 elements in a constant expression}} \
// expected-note {{cannot refer to element 4 of array of 3 elements in a constant expression}} \
// expected-warning {{address of stack memory associated with local variable 'arr' returned}}
}
constexpr int *invalid_value = invalid_offset(); // expected-error {{constexpr variable 'invalid_value' must be initialized by a constant expression}}\
// expected-note {{in call to 'invalid_offset()'}}

clang/test/AST/Interp/array_in_array.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
constexpr int f() {
int arr[2][2] = { { 1, 2 }, {3, 4 }};
return arr[0][0] + arr[0][1] + arr[1][0] + arr[1][1];
}
constexpr int g() {
int arr[2][2] = { { 1, 2 }, {3, 4 }};
return *(arr[0] + 0) + *(arr[0] + 1) + *(arr[1] + 0) + *(arr[1] + 1);
}
using A = int[10];
using A = int[f()];
using A = int[g()];

clang/test/AST/Interp/array_loop_init.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
struct S {
int x[2];
constexpr S(int y) : x{y, y} {}
};
constexpr int f() {
S a(1);
S b(a);
return b.x[0] + b.x[1];
}
static_assert(f() == 2);
struct P {
S s[2];
constexpr P(int y) : s{y, y} {}
};
constexpr int g() {
P a(1);
P b(a);
return b.s[0].x[0] + b.s[0].x[1] + b.s[1].x[0] + b.s[1].x[1];
}
static_assert(g() == 4);

clang/test/AST/Interp/bitfield.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
// expected-no-diagnostics
struct S128 {
__int128 n : 3;
constexpr S128(__int128 k) : n(k) {}
};
static_assert(S128(3).n == 3, "");
static_assert(S128(4).n == -4, "");
static_assert(S128(7).n == -1, "");
static_assert(S128(8).n == 0, "");
static_assert(S128(-1).n == -1, "");
static_assert(S128(-8889).n == -1, "");
struct S64 {
long long n : 3;
constexpr S64(long long k) : n(k) {}
};
static_assert(S64(3).n == 3, "");
static_assert(S64(4).n == -4, "");
static_assert(S64(7).n == -1, "");
static_assert(S64(8).n == 0, "");
static_assert(S64(-1).n == -1, "");
static_assert(S64(-8889).n == -1, "");
constexpr int shift_bitfield() {
S64 a{1};
a.n <<= 1;
return a.n;
}
static_assert(shift_bitfield() == 2);
constexpr int shift_bitfield_trunc() {
S64 a{1};
a.n <<= 10;
return a.n;
}
static_assert(shift_bitfield_trunc() == 0);

clang/test/AST/Interp/boolean.cpp

  • This file was copied from clang/test/AST/Interp/cond.cpp.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics // expected-no-diagnostics
constexpr int cond_then_else(int a, int b) { constexpr bool get_boolean(int a) {
if (a < b) { return a < 0 ? true : false;
return b - a;
} else {
return a - b;
}
} }
static_assert(get_boolean(-1));
static_assert(!get_boolean(1));

clang/test/AST/Interp/bound_member_ptr.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
// expected-no-diagnostics
struct Indirect {
constexpr int f() const { return 2; };
};
constexpr int (Indirect::*ptrF) () const = &Indirect::f;
using CheckThat = int[2];
using CheckThat = int[(Indirect().*ptrF)()];

clang/test/AST/Interp/call.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
constexpr int callee(int a) {
return a + 1000000000; // expected-note {{value 3000000000 is outside the range of representable values of type 'int'}}
}
constexpr int caller(int a) {
return callee(a + 1000000000); // expected-note {{in call to 'callee(2000000000)'}}
}
constexpr int n = caller(1000000000); // expected-error {{constexpr variable 'n' must be initialized by a constant expression}} \
// expected-note {{in call to 'caller(1000000000)'}}
static_assert(caller(0) == 2000000000);

clang/test/AST/Interp/case_range.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
constexpr int f(int n) {
switch (n) {
case 0 ... 5: return 1;
case 10 ... 20: return 2;
default: return 3;
}
}
using A = int[1];
using A = int[f(2)];
using B = int[2];
using B = int[f(12)];
using C = int[3];
using C = int[f(22)];

clang/test/AST/Interp/cast.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
constexpr unsigned f() {
return 100;
}
static_assert(f() == 100);
static_assert((long long)(unsigned short)-1 == 65535);
static_assert((long long)(unsigned char)-1 == 255);
static_assert((long long)(short)-1 == -1);
static_assert((long long)(char)-1 == -1);

clang/test/AST/Interp/compound_assign.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
constexpr int MulAssign(int a, int b) {
int x = a;
return x *= b;
}
using ResultMulAssign = int[6];
using ResultMulAssign = int[MulAssign(3, 2)];
constexpr int DivAssign(int a, int b) {
int x = a;
return x /= b;
}
using ResultDivAssign = int[3];
using ResultDivAssign = int[DivAssign(6, 2)];
constexpr int RemAssign(int a, int b) {
int x = a;
return x %= b;
}
using ResultRemAssign = int[1];
using ResultRemAssign = int[RemAssign(5, 2)];
constexpr int AddAssign(int a, int b) {
int x = a;
return x += b;
}
using ResultAddAssign = int[3];
using ResultAddAssign = int[AddAssign(1, 2)];
constexpr int SubAssign(int a, int b) {
int x = a;
return x -= b;
}
using ResultSubAssign = int[3];
using ResultSubAssign = int[SubAssign(5, 2)];
constexpr int AndAssign(int a, int b) {
int x = a;
return x &= b;
}
using ResultAndAssign = int[4];
using ResultAndAssign = int[AndAssign(7, 4)];
constexpr int XorAssign(int a, int b) {
int x = a;
return x ^= b;
}
using ResultXorAssign = int[1];
using ResultXorAssign = int[XorAssign(5, 4)];
constexpr int OrAssign(int a, int b) {
int x = a;
return x |= b;
}
using ResultOrAssign = int[6];
using ResultOrAssign = int[OrAssign(4, 2)];
constexpr int ShlAssign(int a, int b) {
int x = a;
return x <<= b;
}
static_assert(ShlAssign(1, 2) == 4);
constexpr int ShrAssign(int a, int b) {
int x = a;
return x >>= b;
}
static_assert(ShrAssign(4, 1) == 2);

clang/test/AST/Interp/cond.cpp

  • This file was copied to clang/test/AST/Interp/arg_struct.cpp, clang/test/AST/Interp/boolean.cpp, clang/test/AST/Interp/default_cons.cpp, clang/test/AST/Interp/ref_field.cpp, clang/test/AST/Interp/rvo.cpp, clang/test/AST/Interp/set_field.cpp, clang/test/AST/Interp/struct.cpp, clang/test/AST/Interp/struct_init.cpp, clang/test/AST/Interp/toplevel.cpp.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics // expected-no-diagnostics
constexpr int cond_then_else(int a, int b) { constexpr int cond_then_else(int a, int b) {
if (a < b) { if (a < b) {
return b - a; return b - a;
} else { } else {
return a - b; return a - b;
} }
} }
static_assert(cond_then_else(10, 20) == 10);
static_assert(cond_then_else(30, 10) == 20);
constexpr int cond_empty_then(int a) {
if (a < 0)
;
return 1;
}
static_assert(cond_empty_then(0) == 1);
constexpr int cond_else(int a) {
if (a < 0)
return 10;
return 1;
}
static_assert(cond_else(-1) == 10);
static_assert(cond_else(1) == 1);
constexpr int cond_decl(int a) {
if (int b = a + 1)
return b - 1;
else
return b + 1;
}
static_assert(cond_decl(-1) == 1);
static_assert(cond_decl(5) == 5);
constexpr int cond_decl_init(int a) {
if (int b = a + 1; b != 0)
return b - 1;
else
return b + 1;
}
static_assert(cond_decl_init(-1) == 1);
static_assert(cond_decl_init(5) == 5);

clang/test/AST/Interp/default_cons.cpp

  • This file was copied from clang/test/AST/Interp/cond.cpp.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics // expected-no-diagnostics
constexpr int cond_then_else(int a, int b) { struct B {
if (a < b) { int a = 0;
return b - a; int b = 2;
} else {
return a - b; constexpr int f() const { return a; }
} };
}
constexpr static B b;
constexpr int c = b.f();

clang/test/AST/Interp/designated_init.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
constexpr int uninitialized() {
int a[2] = { [0] = a[1] }; // expected-note {{read of object outside its lifetime is not allowed in a constant expression}}
return a[1];
}
constexpr int i = uninitialized(); // expected-error {{constexpr variable 'i' must be initialized by a constant expression}}\
// expected-note {{in call to 'uninitialized()'}}

clang/test/AST/Interp/double_to_int.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
constexpr double d = 1e300;
constexpr char a0 = d; // expected-error {{must be initialized}} expected-note {{outside the range}}
constexpr int a1 = d; // expected-error {{must be initialized}} expected-note {{outside the range}}
constexpr short a2 = d; // expected-error {{must be initialized}} expected-note {{outside the range}}
constexpr long long a3 = d; // expected-error {{must be initialized}} expected-note {{outside the range}}
constexpr __int128 a4 = d; // expected-error {{must be initialized}} expected-note {{outside the range}}

clang/test/AST/Interp/dummy.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
typedef long long size_t;
typedef struct __sFILE {
unsigned char *_p;
int _w;
int _lbfsize;
} FILE;
// In order to evaluate potentially constant expressions, the interpreter
// creates a dummy pointer to an external block which cannot be read, but
// supports pointer derivations.
int __sputc(int _c, FILE *_p) {
if (--_p->_w >= 0)
return 1;
return 0;
}

clang/test/AST/Interp/enum.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
enum EnumChar : char { ENUM_CHAR = 0 };
enum EnumShort : signed short { ENUM_SHORT = 256 };
enum EnumInt : int { ENUM_INT = 65536 };
enum EnumLong : long { ENUM_LONG = 4294967296};
constexpr EnumChar enum_char() {
return ENUM_CHAR;
}
constexpr EnumShort enum_short() {
return ENUM_SHORT;
}
constexpr EnumInt enum_int() {
return ENUM_INT;
}
constexpr EnumLong enum_long() {
return ENUM_LONG;
}

clang/test/AST/Interp/extern.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
struct S {
int a;
int b[10];
};
extern S s; // expected-note {{declared here}}
constexpr int fail_read_extern = s.a; // expected-error {{constexpr variable 'fail_read_extern' must be initialized by a constant expression}}\
// expected-note {{read of non-constexpr variable 's' is not allowed in a constant expression}}\

clang/test/AST/Interp/float.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
constexpr float a = 16777217; // expected-warning {{implicit conversion from 'int' to 'const float' changes value from 16777217 to 16777216}}
constexpr float f = 1.0 / 0.0f; // expected-error {{constexpr variable 'f' must be initialized by a constant expression}}\
// expected-note {{division by zero}}
static_assert(1 + 2.0f == 3.0f);
static_assert(4.0f + 1 == 5.0f);
static_assert(1.0f + 5.0f == 6.0f);
static_assert(1 + 1.0 == 2.0);
static_assert(1.0 + 2 == 3.0);
static_assert(1.0 + 1.0f == 2.0);
static_assert(1.0f + 1.0 == 2.0);
static_assert(1.0 + 1.0f == 2.0);
constexpr float inc_float() {
float x = 3.0f;
return ++x;
}
static_assert(inc_float() == 4.0f);
constexpr double inc_double() {
double x = 3.0;
return ++x;
}
static_assert(inc_double() == 4.0);
constexpr float dec_float() {
float x = 3.0f;
return --x;
}
static_assert(dec_float() == 2.0f);
constexpr double dec_double() {
double x = 3.0;
return --x;
}
static_assert(dec_double() == 2.0);

clang/test/AST/Interp/flow.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
constexpr int fn_for_break(int n) {
int x = 0;
for (int i = 0; i < 20; ++i) {
if (i == n)
break;
x++;
}
return x;
}
using A = int[5];
using A = int[fn_for_break(5)];
constexpr int fn_for_cont(int n) {
int x = 0;
for (int i = 0; i < 20; ++i) {
if (i < n)
continue;
x++;
}
return x;
}
using B = int[15];
using B = int[fn_for_cont(5)];
constexpr int fn_while_break(unsigned n) {
int x = 0;
int i = 0;
while (int next = ++i) {
if (next == n) {
break;
}
x++;
}
return x;
}
using C = int[4];
using C = int[fn_while_break(5)];
constexpr int fn_while_cont(unsigned n) {
int x = 0;
int i = 0;
while (i < 10) {
++i;
if (i < n) {
continue;
}
x++;
}
return x;
}
using D = int[6];
using D = int[fn_while_cont(5)];
constexpr int fn_do_break(unsigned n) {
int x = 0;
int i = 0;
do {
if (i == n) {
break;
}
x++;
i++;
} while (i < 20);
return x;
}
using E = int[5];
using E = int[fn_do_break(5)];
constexpr int fn_do_continue(unsigned n) {
int x = 0;
int i = 0;
do {
i++;
if (i < n) {
continue;
}
x++;
} while (i < 20);
return x;
}
using F = int[16];
using F = int[fn_do_continue(5)];

clang/test/AST/Interp/funcptr.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s -verify
constexpr int f(int a, int b);
constexpr int apply(int (*f)(int, int), int a, int b) {
return f(a, b); // expected-note {{undefined function 'g' cannot be used in a constant expression}}\\
// expected-note {{subexpression not valid in a constant expression}}
}
constexpr int a = apply(nullptr, 0, 1); // expected-error {{constexpr variable 'a' must be initialized by a constant expression}}\
// expected-note {{in call to 'apply(nullptr, 0, 1)'}}
constexpr int bind_delayed() {
return apply(f, 1, 2);
}
constexpr int f(int a, int b) {
return a + b;
}
constexpr int bind_now() {
return apply(f, 1, 2);
}
using A = int[3];
using A = int[bind_delayed()];
using A = int[bind_now()];
constexpr int g(int a, int b); // expected-note {{declared here}}
constexpr int bind_never() {
return apply(g, 1, 2); // expected-note {{in call to 'apply(&g, 1, 2)'}}
}
constexpr int x = bind_never(); // expected-error {{constexpr variable 'x' must be initialized by a constant expression}}\
// expected-note {{in call to 'bind_never()'}}
constexpr int (*fnPtr)(int, int) = f;
static_assert(fnPtr(1, 2) == 3, "oops");
static_assert(f != g, "!=");
static_assert(f != f, "!="); // expected-error {{static_assert failed due to requirement 'f != f' "!="}}
static_assert(f == f, "!=");
static_assert(f == g, "!="); // expected-error {{static_assert failed due to requirement 'f == g' "!="}}
static_assert(&f != nullptr, "!=nullptr");
static_assert(nullptr != &g, "nullptr!=");

clang/test/AST/Interp/global.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
constexpr int global_prim = 5;
constexpr int get_global_prim() {
return global_prim;
}
static_assert(get_global_prim() == global_prim);
constexpr int global_array[3] = {1, 2, 3};
constexpr int get_global_array() {
return global_array[0];
}
static_assert(get_global_array() == 1);
struct S {
int n;
constexpr S() : n(5) {}
};
constexpr S s;
static_assert(s.n == 5);

clang/test/AST/Interp/inheritance.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
struct A {
int x = 1;
};
struct B {
int y = 10;
};
struct C {
int z = 100;
};
struct D : public A, public B, public C {
int w = 1000;
};
constexpr int f() {
D d;
return d.x + d.y + d.z + d.w;
}
using CheckF = int[1111];
using CheckF = int[f()];

clang/test/AST/Interp/init.cpp

  • This file was added.
// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify -triple x86_64-linux-gnu
// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify -triple x86_64-linux-gnu -fforce-experimental-new-constant-interpreter
struct S;
constexpr int extract(const S &s);
struct S {
constexpr S() : n(extract(*this)), m(0) {} // expected-note {{in call to 'extract(s1)'}}
constexpr S(int k) : n(k), m(extract(*this)) {}
int n, m;
};
constexpr int extract(const S &s) { return s.n; } // expected-note {{read of object outside its lifetime is not allowed in a constant expression}}
void f() {
constexpr S s1; // expected-error {{constant expression}} \
// expected-note {{in call to 'S()'}}
}

clang/test/AST/Interp/int128.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
constexpr __int128 MAX_VALUE = (static_cast<__int128>(0x7FFFFFFFFFFFFFFF) << static_cast<__int128>(64)) | static_cast<__int128>(0xFFFFFFFFFFFFFFFF);
constexpr __int128 MIN_VALUE = -MAX_VALUE - 1;
constexpr __int128 add_pos(__int128 a) {
return a + a; // expected-note {{value 340282366920938463463374607431768211454 is outside the range of representable values of type '__int128'}}
}
constexpr __int128 v0 = add_pos(MAX_VALUE); // expected-error {{constexpr variable 'v0' must be initialized by a constant expression}} \
// expected-note {{in call to 'add_pos(170141183460469231731687303715884105727)'}}
constexpr __int128 add_neg(__int128 a) {
return a + a; // expected-note {{value -340282366920938463463374607431768211456 is outside the range of representable values of type '__int128'}}
}
constexpr __int128 v1 = add_neg(MIN_VALUE); // expected-error {{constexpr variable 'v1' must be initialized by a constant expression}} \
// expected-note {{in call to 'add_neg(-170141183460469231731687303715884105728)'}}
constexpr __int128 sub_neg(__int128 a, __int128 b) {
return a - b; // expected-note {{value -340282366920938463463374607431768211455 is outside the range of representable values of type '__int128'}}
}
constexpr __int128 v2 = sub_neg(MIN_VALUE, MAX_VALUE); // expected-error {{constexpr variable 'v2' must be initialized by a constant expression}} \
// expected-note {{in call to 'sub_neg(-170141183460469231731687303715884105728, 170141183460469231731687303715884105727)'}}
constexpr __int128 sub_pos(__int128 a, __int128 b) {
return a - b; // expected-note {{value 340282366920938463463374607431768211455 is outside the range of representable values of type '__int128'}}
}
constexpr __int128 v3 = sub_pos(MAX_VALUE, MIN_VALUE); // expected-error {{constexpr variable 'v3' must be initialized by a constant expression}} \
// expected-note {{in call to 'sub_pos(170141183460469231731687303715884105727, -170141183460469231731687303715884105728)'}}
constexpr __int128 mul(__int128 a, __int128 b) {
return a * b; // expected-note {{value 28948022309329048855892746252171976962977213799489202546401021394546514198529 is outside the range of representable values of type '__int128'}}
}
constexpr __int128 v4 = mul(MAX_VALUE, MAX_VALUE); // expected-error {{constexpr variable 'v4' must be initialized by a constant expression}} \
// expected-note {{in call to 'mul(170141183460469231731687303715884105727, 170141183460469231731687303715884105727)'}}
constexpr __int128 div_0(__int128 a, __int128 b) {
return a / b; // expected-note {{division by zero}}
}
constexpr __int128 v5 = div_0(1, 0); // expected-error {{constexpr variable 'v5' must be initialized by a constant expression}} \
// expected-note {{in call to 'div_0(1, 0)'}}
constexpr __int128 mod_0(__int128 a, __int128 b) {
return a % b; // expected-note {{division by zero}}
}
constexpr __int128 v6 = mod_0(1, 0); // expected-error {{constexpr variable 'v6' must be initialized by a constant expression}} \
// expected-note {{in call to 'mod_0(1, 0)'}}
constexpr __int128 div_ov(__int128 a, __int128 b) {
return a / b; // expected-note {{value 170141183460469231731687303715884105728 is outside the range of representable values of type '__int128'}}
}
constexpr __int128 v7 = div_ov(MIN_VALUE, -1); // expected-error {{constexpr variable 'v7' must be initialized by a constant expression}} \
// expected-note {{in call to 'div_ov(-170141183460469231731687303715884105728, -1)'}}
constexpr __int128 mod_ov(__int128 a, __int128 b) {
return a / b; // expected-note {{value 170141183460469231731687303715884105728 is outside the range of representable values of type '__int128'}}
}
constexpr __int128 v8 = mod_ov(MIN_VALUE, -1); // expected-error {{constexpr variable 'v8' must be initialized by a constant expression}} \
// expected-note {{in call to 'mod_ov(-170141183460469231731687303715884105728, -1)'}}
constexpr __int128 neg_ov(__int128 a) {
return -a; // expected-note {{value 170141183460469231731687303715884105728 is outside the range of representable values of type '__int128'}}
}
constexpr __int128 v9 = neg_ov(MIN_VALUE); // expected-error {{constexpr variable 'v9' must be initialized by a constant expression}} \
// expected-note {{in call to 'neg_ov(-170141183460469231731687303715884105728)'}}
static_assert((__int128)-1 == -1);
static_assert((__int128)(unsigned short)-1 == 65535);

clang/test/AST/Interp/int64.cpp

  • This file was added.
// RUN: %clang_cc1 -triple=x86_64-unknown-linux -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -triple=x86_64-unknown-linux -std=c++17 -fsyntax-only %s -verify
constexpr long long MAX_VALUE = 0x7FFFFFFFFFFFFFFF;
constexpr long long MIN_VALUE = -MAX_VALUE - 1;
constexpr long long add_pos(long long a) {
return a + a; // expected-note {{value 18446744073709551614 is outside the range of representable values of type 'long long'}}
}
constexpr long long v0 = add_pos(MAX_VALUE); // expected-error {{constexpr variable 'v0' must be initialized by a constant expression}} \
// expected-note {{in call to 'add_pos(9223372036854775807)'}}
constexpr long long add_neg(long long a) {
return a + a; // expected-note {{value -18446744073709551616 is outside the range of representable values of type 'long long'}}
}
constexpr long long v1 = add_neg(MIN_VALUE); // expected-error {{constexpr variable 'v1' must be initialized by a constant expression}} \
// expected-note {{in call to 'add_neg(-9223372036854775808)'}}
constexpr long long sub_neg(long long a, long long b) {
return a - b; // expected-note {{value -18446744073709551615 is outside the range of representable values of type 'long long'}}
}
constexpr long long v2 = sub_neg(MIN_VALUE, MAX_VALUE); // expected-error {{constexpr variable 'v2' must be initialized by a constant expression}} \
// expected-note {{in call to 'sub_neg(-9223372036854775808, 9223372036854775807)'}}
constexpr long long sub_pos(long long a, long long b) {
return a - b; // expected-note {{value 18446744073709551615 is outside the range of representable values of type 'long long'}}
}
constexpr long long v3 = sub_pos(MAX_VALUE, MIN_VALUE); // expected-error {{constexpr variable 'v3' must be initialized by a constant expression}} \
// expected-note {{in call to 'sub_pos(9223372036854775807, -9223372036854775808)'}}
constexpr long long mul(long long a, long long b) {
return a * b; // expected-note {{value 85070591730234615847396907784232501249 is outside the range of representable values of type 'long long'}}
}
constexpr long long v4 = mul(MAX_VALUE, MAX_VALUE); // expected-error {{constexpr variable 'v4' must be initialized by a constant expression}} \
// expected-note {{in call to 'mul(9223372036854775807, 9223372036854775807)'}}
constexpr long long div_0(long long a, long long b) {
return a / b; // expected-note {{division by zero}}
}
constexpr long long v5 = div_0(1, 0); // expected-error {{constexpr variable 'v5' must be initialized by a constant expression}} \
// expected-note {{in call to 'div_0(1, 0)'}}
constexpr long long mod_0(long long a, long long b) {
return a % b; // expected-note {{division by zero}}
}
constexpr long long v6 = mod_0(1, 0); // expected-error {{constexpr variable 'v6' must be initialized by a constant expression}} \
// expected-note {{in call to 'mod_0(1, 0)'}}
constexpr long long div_ov(long long a, long long b) {
return a / b; // expected-note {{value 9223372036854775808 is outside the range of representable values of type 'long long'}}
}
constexpr long long v7 = div_ov(MIN_VALUE, -1); // expected-error {{constexpr variable 'v7' must be initialized by a constant expression}} \
// expected-note {{in call to 'div_ov(-9223372036854775808, -1)'}}
constexpr long long mod_ov(long long a, long long b) {
return a / b; // expected-note {{value 9223372036854775808 is outside the range of representable values of type 'long long'}}
}
constexpr long long v8 = mod_ov(MIN_VALUE, -1); // expected-error {{constexpr variable 'v8' must be initialized by a constant expression}} \
// expected-note {{in call to 'mod_ov(-9223372036854775808, -1)'}}
constexpr long long neg_ov(long long a) {
return -a; // expected-note {{value 9223372036854775808 is outside the range of representable values of type 'long long'}}
}
constexpr long long v9 = neg_ov(MIN_VALUE); // expected-error {{constexpr variable 'v9' must be initialized by a constant expression}} \
// expected-note {{in call to 'neg_ov(-9223372036854775808)'}}
constexpr long long sub_zero_min(long long a, long long b) {
return a - b; // expected-note {{value 9223372036854775808 is outside the range of representable values of type 'long long'}}
}
constexpr long long v10 = sub_zero_min(0, MIN_VALUE); // expected-error {{constexpr variable 'v10' must be initialized by a constant expression}} \
// expected-note {{in call to 'sub_zero_min(0, -9223372036854775808)'}}
static_assert((long long)-1 == -1);
static_assert((long long)(unsigned char)-1 == 255);

clang/test/AST/Interp/lifetime.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
struct S { int x; constexpr S() : x(0) {} };
constexpr int extend_lifetime() {
const S &s = S();
return s.x;
}
constexpr int finish_lifetime() {
return S().x;
}
constexpr int extend_integer() {
const auto &s = 5;
return s;
}
using A = int[5];
using A = int[extend_integer()];

clang/test/AST/Interp/locals.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
constexpr void modifier(int *a) {
*a = 5; // expected-note {{modification of object of const-qualified type 'const int' is not allowed in a constant expression}}
}
constexpr bool mod_non_const() {
int a = 0;
modifier(&a);
return a == 5;
}
static_assert(mod_non_const());
constexpr bool mod_const() {
const int a = 0;
modifier((int *)&a); // expected-note {{in call to 'modifier(&a)'}}
return a == 5;
}
static_assert(mod_const()); // expected-error {{static_assert expression is not an integral constant expression}} \
// expected-note {{in call to 'mod_const()'}}

clang/test/AST/Interp/logical.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
constexpr int and_short_circuit() {
int a = 0;
if (0 && ++a) {
return 0;
}
return a == 0;
}
static_assert(and_short_circuit());
constexpr int or_short_circuit() {
int a = 0;
if (1 || ++a) {
return a == 0;
}
return 0;
}
static_assert(or_short_circuit());

clang/test/AST/Interp/loop.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
constexpr int sum_pow(int n) {
int a = 0;
for (int i = 0; i < n; i = i + 1) {
for (int j = 0; j < n; j = j + 1) {
a = (a + (i % 1000) + (j % 1000)) % 1000;
}
}
return a;
}
static_assert(sum_pow(2) == 4);
constexpr int loop_cond_var(int n) {
int a = 0;
for (int i = n; int b = a + 1; i = i + 1) {
if (i == 50) {
a = 0 - b;
}
}
return a - 1;
}
static_assert(loop_cond_var(10) == -2);

clang/test/AST/Interp/member_fn.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s -verify
struct A {
constexpr int a() const { return 1; }
};
struct B : public A {
constexpr int b() const { return 2; }
};
struct C : public B {
constexpr int c() const { return 3; }
};
constexpr A a{};
constexpr B b{};
constexpr C c{};
// Test direct pointers.
constexpr int (A::*pAa)() const = &A::a;
static_assert((a.*pAa)() == 1, "");
constexpr int (B::*pBa)() const = &B::a;
constexpr int (B::*pBb)() const = &B::b;
static_assert((b.*pBa)() == 1, "");
static_assert((b.*pBb)() == 2, "");
constexpr int (C::*pCa)() const = &C::a;
constexpr int (C::*pCb)() const = &C::b;
constexpr int (C::*pCc)() const = &C::c;
static_assert((c.*pCa)() == 1, "");
static_assert((c.*pCb)() == 2, "");
static_assert((c.*pCc)() == 3, "");
// Cast from base to derived.
constexpr int (B::*pABa)() const = pAa;
static_assert((b.*pABa)() == 1, "");
constexpr int (C::*pACa)() const = pAa;
static_assert((c.*pACa)() == 1, "");
constexpr int (C::*pABCa)() const = pBa;
static_assert((c.*pABCa)() == 1, "");
constexpr int (C::*pBCa)() const = pBa;
static_assert((c.*pBCa)() == 1, "");
constexpr int (C::*pBCb)() const = pBb;
static_assert((c.*pBCb)() == 2, "");
// Cast from derived to base.
constexpr int (B::*pCBa)() const = (int(B::*)() const)pCa;
constexpr int (B::*pCBb)() const = (int(B::*)() const)pCb;
constexpr int (B::*pCBc)() const = (int(B::*)() const)pCc;
constexpr int (A::*pCAa)() const = (int(A::*)() const)pCa;
constexpr int (A::*pCAb)() const = (int(A::*)() const)pCb;
constexpr int (A::*pCAc)() const = (int(A::*)() const)pCc;
constexpr int (A::*pCBAa)() const = (int(A::*)() const)pCBa;
constexpr int (A::*pCBAb)() const = (int(A::*)() const)pCBb;
constexpr int (A::*pCBAc)() const = (int(A::*)() const)pCBc;
static_assert((c.*pCBa)() == 1, "");
static_assert((c.*pCBb)() == 2, "");
static_assert((c.*pCBc)() == 3, "");
static_assert((c.*pCAa)() == 1, "");
static_assert((c.*pCAb)() == 2, "");
static_assert((c.*pCAc)() == 3, "");
static_assert((c.*pCBAa)() == 1, "");
static_assert((c.*pCBAb)() == 2, "");
static_assert((c.*pCBAc)() == 3, "");
static_assert((b.*pCBa)() == 1, "");
static_assert((b.*pCBb)() == 2, "");
static_assert((b.*pCBc)() == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert((b.*pCAa)() == 1, "");
static_assert((b.*pCAb)() == 2, "");
static_assert((b.*pCAc)() == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert((b.*pCBAa)() == 1, "");
static_assert((b.*pCBAb)() == 2, "");
static_assert((b.*pCBAc)() == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert((a.*pCAa)() == 1, "");
static_assert((a.*pCAb)() == 2, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert((a.*pCAc)() == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert((a.*pCBAa)() == 1, "");
static_assert((a.*pCBAb)() == 2, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert((a.*pCBAc)() == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
// Cast from B to A.
constexpr int (A::*qBAa)() const = (int(A::*)() const)pBa;
constexpr int (A::*qBAb)() const = (int(A::*)() const)pBb;
static_assert((c.*qBAa)() == 1, "");
static_assert((c.*qBAb)() == 2, "");
static_assert((b.*qBAa)() == 1, "");
static_assert((b.*qBAb)() == 2, "");
static_assert((a.*qBAa)() == 1, "");
static_assert((a.*qBAb)() == 2, ""); // expected-error {{static_assert expression is not an integral constant expression}}
// Cast from A to B and C.
constexpr int (B::*qABa)() const = (int(B::*)() const)pAa;
constexpr int (C::*qACa)() const = (int(C::*)() const)pAa;
constexpr int (C::*qABCa)() const = (int(C::*)() const)pAa;
static_assert((b.*qABa)() == 1, "");
static_assert((c.*qACa)() == 1, "");
static_assert((c.*qABCa)() == 1, "");
// Cast from B to C.
constexpr int (C::*qBCa)() const = (int(C::*)() const)pBa;
constexpr int (C::*qBCb)() const = (int(C::*)() const)pBb;
static_assert((c.*qBCa)() == 1, "");
static_assert((c.*qBCb)() == 2, "");

clang/test/AST/Interp/member_fn_virtual.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// expected-no-diagnostics
struct A {
int x = 1;
constexpr virtual int f() const { return x; }
};
constexpr int (A::*pF) () const = &A::f;
struct B : public A {
int y = 2;
constexpr int f() const override { return y; }
};
constexpr A a{};
static_assert((a.*pF)() == 1);
constexpr B b{};
static_assert((b.*pF)() == 2);
// The constexpr tree evaluator incorrectly marks this as never producing a constant.
constexpr int invoke_a() { A a{}; return (a.*pF)(); }
static_assert(invoke_a() == 1);
constexpr int invoke_b() { B b{}; return (b.*pF)(); }
static_assert(invoke_b() == 2);

clang/test/AST/Interp/member_ptr.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s -verify
struct A {
int a = 1;
};
struct B : public A {
int b = 2;
};
struct C : public B {
int c = 3;
};
constexpr A a{};
constexpr B b{};
constexpr C c{};
// Test direct pointers.
constexpr int (A::*pAa) = &A::a;
static_assert(a.*pAa == 1, "");
constexpr int (B::*pBa) = &B::a;
constexpr int (B::*pBb) = &B::b;
static_assert(b.*pBa == 1, "");
static_assert(b.*pBb == 2, "");
constexpr int (C::*pCa) = &C::a;
constexpr int (C::*pCb) = &C::b;
constexpr int (C::*pCc) = &C::c;
static_assert(c.*pCa == 1, "");
static_assert(c.*pCb == 2, "");
static_assert(c.*pCc == 3, "");
// Cast from base to derived.
constexpr int (B::*pABa) = pAa;
static_assert(b.*pABa == 1, "");
constexpr int (C::*pACa) = pAa;
static_assert(c.*pACa == 1, "");
constexpr int (C::*pABCa) = pBa;
static_assert(c.*pABCa == 1, "");
constexpr int (C::*pBCa) = pBa;
static_assert(c.*pBCa == 1, "");
constexpr int (C::*pBCb) = pBb;
static_assert(c.*pBCb == 2, "");
// Cast from C to B and A.
constexpr int (B::*pCBa) = (int(B::*))pCa;
constexpr int (B::*pCBb) = (int(B::*))pCb;
constexpr int (B::*pCBc) = (int(B::*))pCc;
constexpr int (A::*pCAa) = (int(A::*))pCa;
constexpr int (A::*pCAb) = (int(A::*))pCb;
constexpr int (A::*pCAc) = (int(A::*))pCc;
constexpr int (A::*pCBAa) = (int(A::*))pCBa;
constexpr int (A::*pCBAb) = (int(A::*))pCBb;
constexpr int (A::*pCBAc) = (int(A::*))pCBc;
static_assert(c.*pCBa == 1, "");
static_assert(c.*pCBb == 2, "");
static_assert(c.*pCBc == 3, "");
static_assert(c.*pCAa == 1, "");
static_assert(c.*pCAb == 2, "");
static_assert(c.*pCAc == 3, "");
static_assert(c.*pCBAa == 1, "");
static_assert(c.*pCBAb == 2, "");
static_assert(c.*pCBAc == 3, "");
static_assert(b.*pCBa == 1, "");
static_assert(b.*pCBb == 2, "");
static_assert(b.*pCBc == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert(b.*pCAa == 1, "");
static_assert(b.*pCAb == 2, "");
static_assert(b.*pCAc == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert(b.*pCBAa == 1, "");
static_assert(b.*pCBAb == 2, "");
static_assert(b.*pCBAc == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert(a.*pCAa == 1, "");
static_assert(a.*pCAb == 2, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert(a.*pCAc == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert(a.*pCBAa == 1, "");
static_assert(a.*pCBAb == 2, ""); // expected-error {{static_assert expression is not an integral constant expression}}
static_assert(a.*pCBAc == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
// Cast from B to A.
constexpr int (A::*qBAa) = (int(A::*))pBa;
constexpr int (A::*qBAb) = (int(A::*))pBb;
static_assert(c.*qBAa == 1, "");
static_assert(c.*qBAb == 2, "");
static_assert(b.*qBAa == 1, "");
static_assert(b.*qBAb == 2, "");
static_assert(a.*qBAa == 1, "");
static_assert(a.*qBAb == 2, ""); // expected-error {{static_assert expression is not an integral constant expression}}
// Cast from A to B and C.
constexpr int (B::*qABa) = (int(B::*))pAa;
constexpr int (C::*qACa) = (int(C::*))pAa;
constexpr int (C::*qABCa) = (int(C::*))pAa;
static_assert(b.*qABa == 1, "");
static_assert(c.*qACa == 1, "");
static_assert(c.*qABCa == 1, "");
// Cast from B to C.
constexpr int (C::*qBCa) = (int(C::*))pBa;
constexpr int (C::*qBCb) = (int(C::*))pBb;
static_assert(c.*qBCa == 1, "");
static_assert(c.*qBCb == 2, "");

clang/test/AST/Interp/member_ptr_ambiguity.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
struct A {
int x = 1;
};
struct B {
int x = 2;
};
struct C : public A, public B {
};
constexpr int (C::*pA) = &A::x;
constexpr int (C::*pB) = &B::x;
constexpr C c;
using Ax = int[1];
using Ax = int[c.*pA];
using Bx = int[2];
using Bx = int[c.*pB];

clang/test/AST/Interp/member_ptr_derived.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
struct A {
int a = 1;
};
struct B : A {
int b = 2;
};
struct C : B {
int c = 3;
};
constexpr int (A::*pA) = &A::a;
constexpr int (B::*pB) = &B::a;
constexpr int (C::*pC) = &C::a;
constexpr A a{};
constexpr B b{};
constexpr C c{};
static_assert(b.*pB == 1);
static_assert(c.*pC == 1);
static_assert(a.*pA == 1);

clang/test/AST/Interp/member_ptr_explicit_path.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
struct A {
int a = 1;
};
struct B : public A {
int b = 2;
};
struct C : public A {
int c = 2;
};
struct D : public B, public C {
int d = 3;
};
constexpr int (D::*pB) = (int(B::*))&A::a;

clang/test/AST/Interp/member_ptr_missing.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
struct A {
int a = 1;
};
struct B : public A {
int b = 2;
};
constexpr A a;
constexpr int (A::*pB) = (int(A::*))&B::b;
static_assert(a.*pB, ""); // expected-error {{static_assert expression is not an integral constant expression}}
constexpr int (A::*pA) = (int(A::*))&B::a;
static_assert(a.*pA == 1, "");
constexpr B b;
constexpr int (B::*pBack) = pB;
static_assert(b.*pBack == 2, "");

clang/test/AST/Interp/member_ptr_print.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions %s -verify
struct A {
int field = 0;
constexpr int fn() { return 0; }
};
constexpr int call_field(int (A::*p), bool flag = true) {
return flag ? throw : 0; // expected-note 2{{subexpression not valid in a constant expression}}
}
constexpr int a0 = call_field(&A::field); // expected-error {{constexpr variable 'a0' must be initialized by a constant expression}}\
// expected-note {{in call to 'call_field(&A::field, true)'}}
constexpr int a1 = call_field(nullptr); // expected-error {{onstexpr variable 'a1' must be initialized by a constant expression}}\
// expected-note {{in call to 'call_field(0, true)'}}
constexpr int call_fn(int (A::*p)(), bool flag = true) {
return flag ? throw : 0; // expected-note 2{{subexpression not valid in a constant expression}}
}
constexpr int a2 = call_fn(&A::fn); // expected-error {{constexpr variable 'a2' must be initialized by a constant expression}}\
// expected-note {{in call to 'call_fn(&A::fn, true)'}}
constexpr int a3 = call_fn(nullptr); // expected-error {{constexpr variable 'a3' must be initialized by a constant expression}}\
// expected-note {{in call to 'call_fn(0, true)'}}

clang/test/AST/Interp/member_ptr_wrong_path.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
struct A {
int a = 1;
};
struct B : public A {
int b = 2;
};
struct C : public A {
int c = 2;
};
struct D : public B, public C {
int d = 3;
};
constexpr D d;
constexpr int (D::*pB) = (int(C::*))((int(A::*))&B::b); // expected-error {{constexpr variable 'pB' must be initialized by a constant expression}}

clang/test/AST/Interp/method.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
struct S {
const int x;
constexpr S() : x(42) {}
constexpr int get_x() { return x; }
};
constexpr int invoke_S_method() {
return S().get_x();
}
using A = int[42];
using A = int[invoke_S_method()];
struct P {
const int x;
constexpr P();
constexpr int get_x();
};
constexpr P::P() : x(42) {}
constexpr int P::get_x() { return x; }
constexpr int invoke_P_method() {
return P().get_x();
}
using B = int[42];
using B = int[invoke_P_method()];

clang/test/AST/Interp/null_method.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
struct S {
constexpr void f() { }
};
constexpr void f() { // expected-error {{constexpr function never produces a constant expression}}
S *s = nullptr;
s->f(); // expected-note {{member call on dereferenced null pointer is not allowed in a constant expression}}
}

clang/test/AST/Interp/nullptr.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
constexpr int nullptr_deref() { // expected-error {{constexpr function never produces a constant expression}}
int *a = nullptr;
return *a; // expected-note {{read of dereferenced null pointer is not allowed in a constant expression}}
}
constexpr int zero_deref() { // expected-error {{constexpr function never produces a constant expression}}
int *a = (int*)0;
return *a; // expected-note {{read of dereferenced null pointer is not allowed in a constant expression}}
}
constexpr int nullptr_write() { // expected-error {{constexpr function never produces a constant expression}}
int *a = (int*)0;
*a = 5; // expected-note {{assignment to dereferenced null pointer is not allowed in a constant expression}}
return *a;
}
constexpr int *nullptr_inc() { // expected-error {{constexpr function never produces a constant expression}}
int *a = (int*)nullptr;
return a++; // expected-note {{cannot perform pointer arithmetic on null pointer}}
}
constexpr int *nullptr_dec() { // expected-error {{constexpr function never produces a constant expression}}
int *a = (int*)nullptr;
return a--; // expected-note {{cannot perform pointer arithmetic on null pointer}}
}
constexpr int *nullptr_offset() { // expected-error {{constexpr function never produces a constant expression}}
int *a = (int*)nullptr;
return a + 2; // expected-note {{cannot perform pointer arithmetic on null pointer}}
}
constexpr int nullptr_ref_int() { // expected-error {{constexpr function never produces a constant expression}}
int *a = nullptr;
int &b = *a;
return b; // expected-note {{read of dereferenced null pointer is not allowed in a constant expression}}
}
constexpr int nullptr_ref_inc() { // expected-error {{constexpr function never produces a constant expression}}
int *a = nullptr;
int &b = *a;
return b++; // expected-note {{increment of dereferenced null pointer is not allowed in a constant expression}}
}
constexpr int nullptr_ref_dec() { // expected-error {{constexpr function never produces a constant expression}}
int *a = nullptr;
int &b = *a;
return b--; // expected-note {{decrement of dereferenced null pointer is not allowed in a constant expression}}
}

clang/test/AST/Interp/nullptr_struct.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
struct S { int x; constexpr S() : x(0) {} };
constexpr int *nullptr_ptr() { // expected-error {{constexpr function never produces a constant expression}}
S *s = nullptr;
return &s->x; // expected-note {{cannot access field of null pointer}}
}
constexpr int nullptr_field() { // expected-error {{constexpr function never produces a constant expression}}
S *s = nullptr;
return s->x; // expected-note {{cannot access field of null pointer}}
}

clang/test/AST/Interp/operator.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify -fforce-experimental-new-constant-interpreter
// expected-no-diagnostics
struct S {
int X;
constexpr S(int X) : X(X) {}
constexpr S operator+(const S& RHS) {
return S(X + RHS.X);
}
};
static_assert((S(2) + S(3)).X == 5);

clang/test/AST/Interp/overflow.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
constexpr int add_pos(int a) {
return a + a; // expected-note {{value 4000000000 is outside the range of representable values of type 'int'}}
}
constexpr int v0 = add_pos(2000000000); // expected-error {{constexpr variable 'v0' must be initialized by a constant expression}} \
// expected-note {{in call to 'add_pos(2000000000)'}}
constexpr int add_neg(int a) {
return a + a; // expected-note {{value -4000000000 is outside the range of representable values of type 'int'}}
}
constexpr int v1 = add_neg(-2000000000); // expected-error {{constexpr variable 'v1' must be initialized by a constant expression}} \
// expected-note {{in call to 'add_neg(-2000000000)'}}
constexpr int sub_neg(int a, int b) {
return a - b; // expected-note {{value -4000000000 is outside the range of representable values of type 'int'}}
}
constexpr int v2 = sub_neg(-2000000000, 2000000000); // expected-error {{constexpr variable 'v2' must be initialized by a constant expression}} \
// expected-note {{in call to 'sub_neg(-2000000000, 2000000000)'}}
constexpr int sub_pos(int a, int b) {
return a - b; // expected-note {{value 4000000000 is outside the range of representable values of type 'int'}}
}
constexpr int v3 = sub_pos(2000000000, -2000000000); // expected-error {{constexpr variable 'v3' must be initialized by a constant expression}} \
// expected-note {{in call to 'sub_pos(2000000000, -2000000000)'}}
constexpr int mul(int a, int b) {
return a * b; // expected-note {{value 4900000000 is outside the range of representable values of type 'int'}}
}
constexpr int v4 = mul(70000, 70000); // expected-error {{constexpr variable 'v4' must be initialized by a constant expression}} \
// expected-note {{in call to 'mul(70000, 70000)'}}
constexpr int div_0(int a, int b) {
return a / b; // expected-note {{division by zero}}
}
constexpr int v5 = div_0(1, 0); // expected-error {{constexpr variable 'v5' must be initialized by a constant expression}} \
// expected-note {{in call to 'div_0(1, 0)'}}
constexpr int mod_0(int a, int b) {
return a % b; // expected-note {{division by zero}}
}
constexpr int v6 = mod_0(1, 0); // expected-error {{constexpr variable 'v6' must be initialized by a constant expression}} \
// expected-note {{in call to 'mod_0(1, 0)'}}
constexpr int div_ov(int a, int b) {
return a / b; // expected-note {{value 2147483648 is outside the range of representable values of type 'int'}}
}
constexpr int v7 = div_ov(-2147483647 - 1, -1); // expected-error {{constexpr variable 'v7' must be initialized by a constant expression}} \
// expected-note {{in call to 'div_ov(-2147483648, -1)'}}
constexpr int mod_ov(int a, int b) {
return a / b; // expected-note {{value 2147483648 is outside the range of representable values of type 'int'}}
}
constexpr int v8 = mod_ov(-2147483647 - 1, -1); // expected-error {{constexpr variable 'v8' must be initialized by a constant expression}} \
// expected-note {{in call to 'mod_ov(-2147483648, -1)'}}
constexpr unsigned sub_u(unsigned a) {
return 0u - a;
}
static_assert(sub_u(2000000000u) == 2294967296u);
constexpr int neg_ov(int a) {
return -a; // expected-note {{value 2147483648 is outside the range of representable values of type 'int'}}
}
constexpr int v9 = neg_ov(-2147483647 - 1); // expected-error {{constexpr variable 'v9' must be initialized by a constant expression}} \
// expected-note {{in call to 'neg_ov(-2147483648)'}}
constexpr unsigned neg_ov_u(unsigned a) {
return -a;
}
constexpr unsigned v10 = neg_ov_u(2147483647);

clang/test/AST/Interp/past_end.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
constexpr int add_pointer(int *st, int *en) {
int sum = 0;
for (int *i = st; i < en; i = i + 1) {
sum = sum + i[0];
}
return sum;
}
constexpr int pointer_adder() {
int arr[3] = {1, 2, 3};
return add_pointer(arr, arr + 3);
}
using A = int[6];
using A = int[pointer_adder()];

clang/test/AST/Interp/ptr.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
constexpr int f() {
int a = 0;
int &b = a;
a = 5;
b = 7;
return b;
}
static_assert(f() == 7);
constexpr int &g() {
int a = 0; // expected-note {{declared here}}
return a; // expected-warning {{reference to stack memory associated with local variable 'a' returned}}
}
constexpr int h() {
return g(); // expected-note {{read of variable whose lifetime has ended}}
}
constexpr int v0 = h(); // expected-error {{constexpr variable 'v0' must be initialized by a constant expression}} \
// expected-note {{in call to 'h()'}}
constexpr bool compare_valid_ptr() {
int a[2] = {};
return &a[0] < &a[1];
}
static_assert(compare_valid_ptr());
constexpr bool compare_ptr(int *a, int *b) {
return a < b; // expected-note {{subexpression not valid in a constant expression}} \
// expected-note {{subexpression not valid in a constant expression}} \
// expected-note {{subexpression not valid in a constant expression}}
}
constexpr int *return_arg(int a) {
return &a; // expected-warning {{address of stack memory associated with parameter 'a' returned}}
}
constexpr int *get_dead_ptr() {
int a = 0;
return &a; // expected-warning {{address of stack memory associated with local variable 'a' returned}}
}
constexpr bool compare_dead_lhs() {
int b = 2;
return compare_ptr(get_dead_ptr(), &b); // expected-note {{in call to 'compare_ptr(&a, &b)'}}
}
constexpr bool dead_lhs_comparison = compare_dead_lhs(); // expected-error {{constexpr variable 'dead_lhs_comparison' must be initialized by a constant expression}} \
// expected-note {{in call to 'compare_dead_lhs()'}}
constexpr bool compare_dead_rhs() {
int a = 2;
return compare_ptr(&a, get_dead_ptr()); // expected-note {{in call to 'compare_ptr(&a, &a)'}}
}
constexpr bool dead_rhs_comparison = compare_dead_rhs(); // expected-error {{constexpr variable 'dead_rhs_comparison' must be initialized by a constant expression}}\
// expected-note {{in call to 'compare_dead_rhs()'}}
constexpr bool compare_dead_lhs_rhs() {
return compare_ptr(get_dead_ptr(), get_dead_ptr()); // expected-note {{in call to 'compare_ptr(&a, &a)'}}
}
constexpr bool dead_lhs_rhs_comparison = compare_dead_lhs_rhs(); // expected-error {{constexpr variable 'dead_lhs_rhs_comparison' must be initialized by a constant expression}}\
// expected-note {{in call to 'compare_dead_lhs_rhs()'}}
constexpr bool compare_invalid_ptr() { // expected-error {{constexpr function never produces a constant expression}}
int a = 0;
int b = 1;
return &a < &b; // expected-note {{subexpression not valid in a constant expression}} \
// expected-note {{subexpression not valid in a constant expression}}
}
constexpr bool v1 = compare_invalid_ptr(); // expected-error {{constexpr variable 'v1' must be initialized by a constant expression}} \
// expected-note {{in call to 'compare_invalid_ptr()'}}
constexpr int add_callee(int *a, int *b) {
return *a + *b;
}
constexpr int add_caller(int a, int b) {
return add_callee(&a, &b);
}
static_assert(add_caller(2, 3) == 5);
constexpr void ptr_mutate_callee(int *a) {
*a = 10;
}
constexpr int ptr_mutate_caller() {
int a = 5;
ptr_mutate_callee(&a);
return a;
}
static_assert(ptr_mutate_caller() == 10);
constexpr void ptr_increment() { // expected-error {{constexpr function never produces a constant expression}}
int a = 0;
int *b = &a;
++b;
++b; // expected-note {{cannot refer to element 2 of non-array object in a constant expression}}
}
constexpr void ptr_decrement() { // expected-error {{constexpr function never produces a constant expression}}
int a = 0;
int *b = &a;
--b; // expected-note {{cannot refer to element -1 of non-array object in a constant expression}}
}
constexpr int *dead_ptr_offset() {
return get_dead_ptr() + 2; // expected-note {{cannot refer to element 2 of non-array object in a constant expression}}
}
constexpr int *v = dead_ptr_offset(); // expected-error {{constexpr variable 'v' must be initialized by a constant expression}}\
// expected-note {{in call to 'dead_ptr_offset()'}}

clang/test/AST/Interp/ptr_derived_cast.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
// expected-no-diagnostics
struct A {
int a = 0;
};
struct B : public A { int b = 1;};
struct C : public B { int c = 2;};
struct D : public C { int d = 3;};
constexpr D d{};
constexpr A *ap = (A*)&d;
constexpr D *dp = (D*)ap;
static_assert(dp->d == 3);

clang/test/AST/Interp/ptrdiff.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
constexpr int diff_bad() { // expected-error {{constexpr function never produces a constant expression}}
int a = 0;
int b = 0;
return &a - &b; // expected-note 2{{subexpression not valid in a constant expression}}
}
constexpr int bad = diff_bad(); // expected-error {{constexpr variable 'bad' must be initialized by a constant expression}}\
// expected-note {{in call to 'diff_bad()'}}}
constexpr int diff_bad_array() { // expected-error {{constexpr function never produces a constant expression}}
int a[1] = {0};
int b[1] = {0};
return &a[0] - &b[0]; // expected-note 2{{subexpression not valid in a constant expression}}
}
constexpr int bad_array = diff_bad_array(); // expected-error {{constexpr variable 'bad_array' must be initialized by a constant expression}}\
// expected-note {{in call to 'diff_bad_array()'}}}
constexpr int diff_pos() {
int a[2] = {0, 1};
return &a[1] - &a[0];
}
static_assert(diff_pos() == 1);
constexpr int diff_neg() {
int a[2] = {0, 1};
return &a[0] - &a[1];
}
static_assert(diff_neg() == -1);
struct S {
int a[1] = {1};
int b[1] = {2};
};
constexpr S s;
constexpr int diff_different_arrays() { // expected-error {{constexpr function never produces a constant expression}}
return &s.a[0] - &s.b[0]; // expected-note 2{{subtracted pointers are not elements of the same array}}
}
constexpr int different_arrays = diff_different_arrays(); // expected-error {{constexpr variable 'different_arrays' must be initialized by a constant expression}}\
// expected-note {{in call to 'diff_different_arrays()'}}

clang/test/AST/Interp/ptrdiff_overflow.cpp

  • This file was added.
// RUN: %clang_cc1 -triple=avr -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -triple=avr -std=c++2a -fsyntax-only %s -verify
constexpr int diff() { // expected-error {{constexpr function never produces a constant expression}}
char a[32769] = {0};
return &a[32769] - &a[0]; // expected-note {{value 32769 is outside the range of representable values of type 'int'}}
}

clang/test/AST/Interp/pure_virt_ind.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify -Wno-invalid-constexpr
struct A {
constexpr A();
constexpr virtual void f() const = 0; // expected-note {{declared here}}
};
constexpr void (A::*pF)() const = &A::f;
constexpr A::A() {
(this->*pF)(); // expected-note {{pure virtual function 'A::f' called}}
}
struct B : public A { // expected-note {{in call to 'A()'}}
constexpr virtual void f() const {};
};
constexpr B a{}; // expected-error {{constexpr variable 'a' must be initialized by a constant expression}}\
// expected-note {{in call to 'B()'}}

clang/test/AST/Interp/read_only.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
struct S { const int x; int y; constexpr S() : x(0), y(1) {} };
constexpr int mutate_x() {
S s;
int *x = const_cast<int *>(&s.x);
*x = 5; // expected-note {{modification of object of const-qualified type 'const int' is not allowed in a constant expression}}
return 0;
}
constexpr int x = mutate_x(); // expected-error {{constexpr variable 'x' must be initialized by a constant expression}}\
// expected-note {{in call to 'mutate_x()'}}
constexpr int mutate_y() {
S s;
int *y = const_cast<int *>(&s.y);
*y = 5;
return *y;
}
using A = int[5];
using A = int[mutate_y()];

clang/test/AST/Interp/ref_field.cpp

  • This file was copied from clang/test/AST/Interp/cond.cpp.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics // expected-no-diagnostics
constexpr int cond_then_else(int a, int b) { struct AggregateInit {
if (a < b) { const char &c;
return b - a; };
} else {
return a - b; constexpr AggregateInit agg1 = { "hello"[0] };
}
} using A = int[5];
using A = int[__builtin_strlen(&agg1.c)];

clang/test/AST/Interp/relocation.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
constexpr int solved_callee();
constexpr int solved_caller() {
return solved_callee();
}
constexpr int solved_callee() {
return 5;
}
static_assert(solved_caller() == 5);
constexpr int unsolved_callee(); // expected-note {{declared here}}
constexpr int unsolved_caller() {
return unsolved_callee(); // expected-note {{undefined function 'unsolved_callee' cannot be used in a constant expression}}
}
static_assert(unsolved_caller() == 5); // expected-error {{static_assert expression is not an integral constant expression}} \
// expected-note {{in call to 'unsolved_caller()'}}

clang/test/AST/Interp/return.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
constexpr int f(int a) {
if (a < 0)
return 10;
} // expected-warning {{control may reach end of non-void function}} \
// expected-note {{control reached end of constexpr function}}
constexpr int g(int a) {
return f(a); // expected-note {{in call to 'f(20)'}}
}
constexpr int h(int a) {
return g(a); // expected-note {{in call to 'g(20)'}}
}
constexpr int i = h(20); // expected-error {{constexpr variable 'i' must be initialized by a constant expression}} \
// expected-note {{in call to 'h(20)'}}

clang/test/AST/Interp/rvo.cpp

  • This file was copied from clang/test/AST/Interp/cond.cpp.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics // expected-no-diagnostics
constexpr int cond_then_else(int a, int b) { struct S {
if (a < b) { int x;
return b - a; constexpr S(int x) : x(x) {}
} else { };
return a - b;
} constexpr S struct_return(int x) {
return S(x);
} }
static_assert(struct_return(5).x == 5);

clang/test/AST/Interp/scoping.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter -verify %s
// Clang emits a diagnostic treating 'a' as a subobject, while the interpreter
// emits what we think is the appropriate diagnostic for local variables.
constexpr int scope_escape() { // expected-error {{constexpr function never produces a constant expression}}
int c = 0;
int *a = &c;
{
int b = 0; // expected-note {{declared here}} \
// expected-note {{declared here}}
a = &b;
}
return *a; // expected-note {{read of variable whose lifetime has ended}}\
// expected-note {{read of variable whose lifetime has ended}}
}
constexpr int invalid = scope_escape(); // expected-error {{constexpr variable 'invalid' must be initialized by a constant expression}} \
// expected-note {{in call to 'scope_escape()'}}
constexpr int scope_inc() { // expected-error {{constexpr function never produces a constant expression}}
int a = 0;
int *b = &a;
int **c = &b;
{
int *d = &a; // expected-note {{declared here}}\
// expected-note {{declared here}}
c = &d;
}
(*c)++; // expected-note {{increment of variable whose lifetime has ended}}\
// expected-note {{increment of variable whose lifetime has ended}}
return 1;
}
constexpr int invalid_inc = scope_inc(); // expected-error {{constexpr variable 'invalid_inc' must be initialized by a constant expression}}\
// expected-note {{in call to 'scope_inc()'}}
constexpr int scope_offset() {
int a = 0;
int *b = &a;
{
int d = 2;
b = &d;
}
int *e = b + 1;
return 1;
}
constexpr int invalid_off = scope_offset();

clang/test/AST/Interp/selfref.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++14 -fsyntax-only %s -verify
constexpr int a[2] = {a[1] + 1, a[0] + 1};
using A = int[1];
using A = int[a[0]];
using B = int[2];
using B = int[a[1]];
constexpr int f() {
constexpr int c[2] = {c[1] + 1, c[0] + 1}; // expected-note {{read of object outside its lifetime is not allowed in a constant expression}}\
// expected-error {{constexpr variable 'c' must be initialized by a constant expression}}
return c[0];
}
constexpr int b[2][2] = { b[1][1] + 1 };
using C = int[b[0][0]];
using C = int[1];

clang/test/AST/Interp/set_field.cpp

  • This file was copied from clang/test/AST/Interp/cond.cpp.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics // expected-no-diagnostics
constexpr int cond_then_else(int a, int b) { struct S {
if (a < b) { int a = 0;
return b - a; int b = 0;
} else {
return a - b; constexpr S() { b = 2; }
} };
constexpr int set_field() {
S s;
(s.a = 5) = 6;
return s.a + s.b;
} }
static_assert(set_field() == 8);

clang/test/AST/Interp/shift.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fforce-experimental-new-constant-interpreter -verify=all,cpp11 %s
// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter -verify=all %s
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=all,cpp11 %s
// RUN: %clang_cc1 -std=c++2a -fsyntax-only -verify=all %s
constexpr int shls(int a, int b) {
return a << b; // all-note {{negative shift count -200}}\
// all-note {{shift count 200 >= width of type 'int' (32 bits)}}\
// cpp11-note {{left shift of negative value -1}}\
// cpp11-note {{signed left shift discards bits}}
}
constexpr int v1 = shls(1, -200); // all-error {{constexpr variable 'v1' must be initialized by a constant expression}}\
// all-note {{in call to 'shls(1, -200)'}}
constexpr int v0 = shls(1, 200); // all-error {{constexpr variable 'v0' must be initialized by a constant expression}}\
// all-note {{in call to 'shls(1, 200)'}}
using A0 = int[8];
using A0 = int[shls(4, 1)];
using A1 = int[2];
using A1 = int[shls(4, -1)];
constexpr int v4 = shls(-1, 1); // cpp11-error {{constexpr variable 'v4' must be initialized by a constant expression}}\
// cpp11-note {{in call to 'shls(-1, 1)'}}
constexpr int v5 = shls(128, 30); // cpp11-error {{constexpr variable 'v5' must be initialized by a constant expression}}\
// cpp11-note {{in call to 'shls(128, 30)'}}
constexpr int shrs(int a, int b) {
return a >> b; // all-note {{negative shift count -200}}\
// all-note {{shift count 200 >= width of type 'int' (32 bits)}}\
// all-note {{shift count 32 >= width of type 'int' (32 bits)}}
}
constexpr int v2 = shrs(1, -200); // all-error {{constexpr variable 'v2' must be initialized by a constant expression}}\
// all-note {{in call to 'shrs(1, -200)'}}
constexpr int v3 = shrs(1, 200); // all-error {{constexpr variable 'v3' must be initialized by a constant expression}}\
// all-note {{in call to 'shrs(1, 200)'}}
using B0 = int[2];
using B0 = int[shrs(4, 1)];
using B1 = int[8];
using B1 = int[shrs(4, -1)];
constexpr int v6 = shrs(1, 32); // all-error {{constexpr variable 'v6' must be initialized by a constant expression}}\
// all-note {{in call to 'shrs(1, 32)'}}
static_assert(-1 >> 1 == -1, "");
static_assert(-1 >> 31 == -1, "");
static_assert(-2 >> 1 == -1, "");
static_assert(-3 >> 1 == -2, "");
static_assert(-4 >> 1 == -2, "");

clang/test/AST/Interp/sizeof.cpp

  • This file was added.
// RUN: %clang_cc1 -triple=x86_64-unknown-linux -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -triple=x86_64-unknown-linux -std=c++17 -fsyntax-only %s -verify
static_assert(sizeof(char) == 1);
static_assert(sizeof(short) == 2);
static_assert(sizeof(int) == 4);
static_assert(sizeof(long) == 8);
static_assert(sizeof(long long) == 8);
struct S; // expected-note {{forward declaration of 'S'}}
constexpr int size_of_bad_struct = sizeof(S); // expected-error {{invalid application of 'sizeof' to an incomplete type 'S'}}
template <typename... Ts>
struct P {
static constexpr unsigned n = sizeof...(Ts);
};
static_assert(P<int, int, int>::n == 3);

clang/test/AST/Interp/stack_trace.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
struct S {
const int x;
constexpr S() : x(2147483647) {}
constexpr int call0() { return x + x; } // expected-note {{value 4294967294 is outside the range of representable values of type 'int'}}
constexpr int call1() { return call0(); } // expected-note {{in call to '&S()->call0()'}}
constexpr int call2() { return call1(); } // expected-note {{in call to '&S()->call1()'}}
};
constexpr int method_root() {
return S().call2(); // expected-note {{in call to '&S()->call2()'}}
}
constexpr int x = method_root(); // expected-error {{constexpr variable 'x' must be initialized by a constant expression}}\
// expected-note {{in call to 'method_root()'}}
struct P {
const int x;
constexpr P(int y) : x(y + y) {}; // expected-note {{value 4294967294 is outside the range of representable values of type 'int'}}
};
constexpr int cons_root() {
return P(2147483647).x; // expected-note {{in call to 'P(2147483647)'}}
}
constexpr int y = cons_root(); // expected-error {{constexpr variable 'y' must be initialized by a constant expression}}\
// expected-note {{in call to 'cons_root()'}}
constexpr int callee_ptr(int *beg, int *end) {
const int x = 2147483647;
*beg = x + x; // expected-warning {{overflow in expression; result is -2 with type 'int'}}\
// expected-note 3{{value 4294967294 is outside the range of representable values of type 'int'}}
return *beg;
}
constexpr int caller_ptr() {
int x = 0;
return callee_ptr(&x, &x + 1); // expected-note {{in call to 'callee_ptr(&x, &x + 1)'}}
}
constexpr int z = caller_ptr(); // expected-error {{constexpr variable 'z' must be initialized by a constant expression}}\
// expected-note {{in call to 'caller_ptr()'}}
struct Q {
int x;
constexpr Q() : x(0) {}
};
constexpr int caller_field() {
Q q;
return callee_ptr(&q.x, &q.x + 1); // expected-note {{in call to 'callee_ptr(&q.x, &q.x + 1)'}}
}
constexpr int a = caller_field();// expected-error {{constexpr variable 'a' must be initialized by a constant expression}}\
// expected-note {{in call to 'caller_field()'}}
struct R {
Q q;
constexpr R() : q() {}
};
constexpr int caller_nested_field() {
R r;
return callee_ptr(&r.q.x, &r.q.x + 1); // expected-note {{in call to 'callee_ptr(&r.q.x, &r.q.x + 1)'}}
}
constexpr int b = caller_nested_field();// expected-error {{constexpr variable 'b' must be initialized by a constant expression}}\
// expected-note {{in call to 'caller_nested_field()'}}

clang/test/AST/Interp/string.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
constexpr bool streq(const char *a, const char *b) {
while (*a && *a == *b)
++a, ++b;
return *a == *b;
}
constexpr bool is_equal() {
const char *a = "Hello";
const char *b = "Hello";
return streq(a, b);
}
static_assert(is_equal());
constexpr bool not_equal() {
const char *a = "HA";
const char *b = "HB";
return streq(a, b);
}
static_assert(!not_equal());

clang/test/AST/Interp/struct.cpp

  • This file was copied from clang/test/AST/Interp/cond.cpp.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics // expected-no-diagnostics
constexpr int cond_then_else(int a, int b) { struct P {
if (a < b) { int x;
return b - a; int y;
} else {
return a - b; constexpr P(int x, int y) : x(x), y(y) {}
} };
constexpr int f() {
P p(5, 6);
return p.x + p.y;
} }
using A = int[11];
using A = int[f()];

clang/test/AST/Interp/struct_field_ptr.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
struct S {
int x;
int y;
constexpr S(int x) : x(x), y(0) {}
};
constexpr int inc_to_end() {
S s(5);
int *p = &s.x;
++p;
return *p; // expected-note {{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}}
}
constexpr int inc_to_end_val = inc_to_end(); // expected-error {{constexpr variable 'inc_to_end_val' must be initialized by a constant expression}}\
// expected-note {{in call to 'inc_to_end()'}}
constexpr int inc_past_end() {
S s(5);
int *p = &s.x;
++p;
++p; // expected-note {{cannot refer to element 2 of non-array object in a constant expression}}
return *p;
}
constexpr int inc_past_end_val = inc_past_end(); // expected-error {{constexpr variable 'inc_past_end_val' must be initialized by a constant expression}}\
// expected-note {{in call to 'inc_past_end()'}}
constexpr int off_past_end() {
S s(5);
int *p = &s.x;
return *(p + 2); // expected-note {{cannot refer to element 2 of non-array object in a constant expression}}
}
constexpr int off_past_end_val = off_past_end(); // expected-error {{constexpr variable 'off_past_end_val' must be initialized by a constant expression}}\
// expected-note {{in call to 'off_past_end()'}}

clang/test/AST/Interp/struct_in_array.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
struct S {
int x;
constexpr S() : x(1) {}
};
constexpr int f() {
S arr[2] = { {} };
return arr[0].x + arr[1].x;
}
using A = int[2];
using A = int[f()];
constexpr int g(S &s) {
return (&s + 1)->x;
}
constexpr int h() {
S arr[2] = {};
return g(arr[0]);
}
using B = int[1];
using B = int[h()];

clang/test/AST/Interp/struct_init.cpp

  • This file was copied from clang/test/AST/Interp/cond.cpp.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics // expected-no-diagnostics
constexpr int cond_then_else(int a, int b) { struct P {
if (a < b) { int x;
return b - a; };
} else {
return a - b; struct Q {
} int y;
P p;
};
constexpr int f() {
Q q = { 1, { 2 } };
return q.y + q.p.x;
} }
using A = int[3];
using A = int[f()];

clang/test/AST/Interp/toplevel.cpp

  • This file was copied from clang/test/AST/Interp/cond.cpp.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics // expected-no-diagnostics
constexpr int cond_then_else(int a, int b) { constexpr int f(int x) {
if (a < b) { return x + x;
return b - a;
} else {
return a - b;
}
} }
using A = int[f(f(20)) + 5];

clang/test/AST/Interp/unary.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
constexpr int inc_callee(int a, int b) {
return a;
}
constexpr int inc_caller() {
int n = 5;
return inc_callee(n++, ++n); // expected-warning {{multiple unsequenced modifications to 'n'}}
}

clang/test/AST/Interp/union.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
union U {
int a;
int b;
};
constexpr U u[4] = { { .a = 0 }, { .b = 1 }, { .a = 2 }, { .b = 3 } };
static_assert((&u[1].b)[1] == 2, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}

clang/test/AST/Interp/unknown_size.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
extern int arr[];
constexpr int *a = arr;
constexpr int *c = &arr[1]; // expected-error {{constant}} expected-note {{indexing of array without known bound}}
constexpr int *d = &a[1]; // expected-error {{constant}} expected-note {{indexing of array without known bound}}
constexpr int *e = a + 1; // expected-error {{constant}} expected-note {{indexing of array without known bound}}
static unsigned __hash_len_0_to_16(const char *__s) {
const unsigned char __a = __s[0];
return 0;
}

clang/test/AST/Interp/virtual_bases.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
// expected-no-diagnostics
struct VA { int va; };
struct VB { int vb; };
struct A : public virtual VA {};
struct B : public virtual VB {};
struct C : public A, public B, public virtual VA {};
C c;
constexpr int *a = &c.va;

clang/test/AST/Interp/virtual_cons.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
// expected-no-diagnostics
struct A {
virtual constexpr int f() const { return 1; }
int a = f();
};
struct B : public A {
virtual constexpr int f() const { return 2; }
int b = f();
};
struct C : public B {
virtual constexpr int f() const { return 3; }
int c = f();
};
constexpr B b{};
using CheckBa = int[1];
using CheckBa = int[b.a];
using CheckBb = int[2];
using CheckBb = int[b.b];
constexpr C c{};
using CheckCa = int[1];
using CheckCa = int[c.a];
using CheckCb = int[2];
using CheckCb = int[c.b];
using CheckCc = int[3];
using CheckCc = int[c.c];
constexpr A a{};
using CheckAa = int[1];
using CheckAa = int[a.a];

clang/test/AST/Interp/void_cond.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
// expected-no-diagnostics
constexpr void f(int *a) {
*a = 5;
}
constexpr void g(int *a) {
*a = 6;
}
constexpr int test(bool cond) {
int a = 0;
cond ? f(&a) : g(&a);
return a;
}
static_assert(test(true) == 5);
static_assert(test(false) == 6);

clang/test/AST/Interp/vtable.cpp

  • This file was added.
// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
// expected-no-diagnostics
class Base {
public:
virtual constexpr int f() const = 0;
};
class A : public Base {
public:
int x = 1;
constexpr int f() const override { return x; }
};
class B : public Base {
public:
int x = 2;
virtual constexpr int f() const override { return x; }
};
class C : public B {
public:
int x = 3;
constexpr int f() const override { return x; }
};
class D : public B {
public:
int x = 4;
constexpr int f() const override { return x; }
};
static_assert(A().f() == 1);
static_assert(B().f() == 2);
static_assert(C().f() == 3);
static_assert(D().f() == 4);
constexpr int call(const Base &b) {
return b.f();
}
static_assert(call(A{}) == 1);
static_assert(call(B{}) == 2);
static_assert(call(C{}) == 3);
static_assert(call(D{}) == 4);