Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/Interp_8cpp_source.html below:

clang: lib/AST/ByteCode/Interp.cpp Source File

;

llvm::report_fatal_error(

);

(S.Stk.pop<

>()) {

(!S.Stk.pop<

>()) {

S.FFDiag(

, diag::note_constexpr_var_init_unknown, 1) << VD;

(isa<ParmVarDecl>(

)) {

(

->getType()->isReferenceType())

S.FFDiag(

, diag::note_constexpr_function_param_value_unknown) <<

;

(!

->getType().isConstQualified()) {

}

(

*VD = dyn_cast<VarDecl>(

)) {

(!VD->getAnyInitializer()) {

S.FFDiag(

, diag::note_constexpr_var_init_non_constant, 1) << VD;

S.Note(VD->getLocation(), diag::note_declared_at);

(

*VarD = dyn_cast<VarDecl>(VD);

VarD && VarD->getType().isConstQualified() &&

!VarD->getAnyInitializer()) {

(isa<ObjCIvarDecl>(VD))

S.FFDiag(

, diag::note_constexpr_ltor_non_const_int, 1) << VD;

S.Note(VD->

(), diag::note_declared_at);

S.

().CPlusPlus11 ? diag::note_constexpr_ltor_non_constexpr

: diag::note_constexpr_ltor_non_integral,

S.Note(VD->

(), diag::note_declared_at);

(!

.isRoot() &&

.inUnion() && !

.isActive()) {

assert(

.isField());

*InactiveField =

.getField();

assert(InactiveField);

(!

.getFieldDesc()->isUnion())

*R =

.getRecord();

assert(R && R->

() &&

);

(

Record::Field &F : R->

()) {

&Field =

.atField(F.Offset);

(Field.isActive()) {

ActiveField = Field.getField();

S.FFDiag(

, diag::note_constexpr_access_inactive_union_member)

<< AK << InactiveField << !ActiveField << ActiveField;

*MTE = dyn_cast_if_present<MaterializeTemporaryExpr>(

(!MTE->isUsableInConstantExpressions(S.

()) &&

S.FFDiag(

, diag::note_constexpr_access_static_temporary, 1) << AK;

S.Note(Ptr.

(), diag::note_constexpr_temporary_here);

(S.P.getCurrentDecl() == ID)

S.FFDiag(S.Current->getLocation(OpPC), diag::note_constexpr_modify_global);

(

->isUnevaluatedBuiltin())

(

BID =

->getBuiltinID();

cast<CallExpr>(S.Current->Caller->getExpr(S.Current->getRetPC()));

(int32_t I = CE->getNumArgs() - 1; I >= 0; --I) {

*A = CE->getArg(I);

(S.Current->Caller &&

->isVariadic()) {

*

*Args =

;

NumArgs = 0;

*CallSite = S.Current->Caller->getExpr(S.Current->getRetPC());

(

*CE = dyn_cast<CallExpr>(CallSite)) {

Args = CE->getArgs();

NumArgs = CE->getNumArgs();

}

(

*CE = dyn_cast<CXXConstructExpr>(CallSite)) {

Args = CE->getArgs();

NumArgs = CE->getNumArgs();

assert(

&&

);

assert(NumArgs >=

->getNumWrittenParams());

NumVarArgs = NumArgs - (

->getNumWrittenParams() +

isa<CXXOperatorCallExpr>(CallSite));

(

I = 0; I != NumVarArgs; ++I) {

*A = Args[NumArgs - 1 - I];

(!S.checkingPotentialConstantExpression() && S.

().CPlusPlus) {

S.FFDiag(

, diag::note_constexpr_unsized_array_indexed);

&Src = S.Current->getSource(OpPC);

S.FFDiag(Src, diag::note_constexpr_null_subobject) <<

;

S.FFDiag(Src, diag::note_constexpr_access_null) << AK;

&Src = S.Current->getSource(OpPC);

S.FFDiag(Src, diag::note_constexpr_access_deleted_object) << AK;

}

(!S.checkingPotentialConstantExpression()) {

S.FFDiag(Src, diag::note_constexpr_lifetime_ended, 1) << AK << !IsTemp;

S.Note(Ptr.

(), diag::note_constexpr_temporary_here);

S.Note(Ptr.

(), diag::note_declared_at);

(!

|| !

->hasGlobalStorage())

(

== S.EvaluatingDecl)

(

->isConstexpr())

(

*VD = dyn_cast_if_present<VarDecl>(S.EvaluatingDecl);

S.CCEDiag(S.Current->getLocation(OpPC),

? diag::note_constexpr_ltor_non_constexpr

: diag::note_constexpr_ltor_non_integral,

S.CCEDiag(S.Current->getLocation(OpPC));

S.FFDiag(

, diag::note_constexpr_null_subobject)

<< CSK << S.Current->getRange(OpPC);

S.FFDiag(

, diag::note_constexpr_access_past_end)

<< AK << S.Current->getRange(OpPC);

S.FFDiag(

, diag::note_constexpr_past_end_subobject)

<< CSK << S.Current->getRange(OpPC);

S.FFDiag(

, diag::note_constexpr_past_end_subobject)

<< CSK << S.Current->getRange(OpPC);

(Offset < PtrOffset && (PtrOffset - Offset) >= MinOffset)

*

= cast<CastExpr>(S.Current->getExpr(OpPC));

S.CCEDiag(

, diag::note_constexpr_invalid_downcast)

<< MostDerivedQT << TargetQT;

assert(Ptr.

() &&

);

(S.Current->getFunction()) {

&& (

->isConstructor() ||

->isDestructor()) &&

S.FFDiag(

, diag::note_constexpr_modify_const_type) << Ty;

assert(Ptr.

() &&

);

S.FFDiag(

, diag::note_constexpr_access_mutable, 1) <<

<< Field;

S.Note(Field->getLocation(), diag::note_declared_at);

S.FFDiag(

, diag::note_constexpr_access_volatile_type) << AK << PtrType;

VD && (VD->isConstexpr() || VD->hasGlobalStorage())) {

(VD->getAnyInitializer()) {

S.FFDiag(

, diag::note_constexpr_var_init_non_constant, 1) << VD;

S.Note(VD->getLocation(), diag::note_declared_at);

(!S.checkingPotentialConstantExpression()) {

S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_uninit)

<< AK <<

<< S.Current->getRange(OpPC);

((!VD->hasConstantInitialization() &&

VD->mightBeUsableInConstantExpressions(S.

())) ||

S.FFDiag(

, diag::note_constexpr_var_init_non_constant, 1) << VD;

S.Note(VD->getLocation(), diag::note_declared_at);

S.FFDiag(S.Current->getLocation(OpPC), diag::note_constexpr_var_init_weak)

S.Note(VD->getLocation(), diag::note_declared_at);

S.CCEDiag(

, diag::note_constexpr_virtual_call);

*CD = dyn_cast<CXXConstructorDecl>(DiagDecl);

(CD && CD->isInheritingConstructor()) {

*Inherited = CD->getInheritedConstructor().getConstructor();

(!Inherited->isConstexpr())

DiagDecl = CD = Inherited;

(CD && CD->isInheritingConstructor()) {

S.FFDiag(

, diag::note_constexpr_invalid_inhctor, 1)

<< CD->getInheritedConstructor().getConstructor()->getParent();

S.Note(DiagDecl->

(), diag::note_declared_at);

S.checkingPotentialConstantExpression())

S.FFDiag(

, diag::note_constexpr_invalid_function, 1)

diag::note_declared_at);

S.Note(DiagDecl->

(), diag::note_declared_at);

S.FFDiag(

, diag::note_invalid_subexpr_in_const_expr);

((S.Current->getDepth() + 1) > S.

().ConstexprCallDepth) {

S.FFDiag(S.Current->getSource(OpPC),

diag::note_constexpr_depth_limit_exceeded)

(!

.isZero())

IsImplicit =

;

(

*

= dyn_cast_if_present<CXXThisExpr>(

.asExpr()))

IsImplicit =

->isImplicit();

S.FFDiag(

, diag::note_constexpr_this) << IsImplicit;

S.FFDiag(

, diag::note_constexpr_pure_virtual_call, 1) << MD;

S.Note(MD->

(), diag::note_declared_at);

APFloat::opStatus Status,

FPO) {

S.CCEDiag(

, diag::note_constexpr_float_arithmetic)

<<

<< S.Current->getRange(OpPC);

S.noteUndefinedBehavior();

(S.inConstantContext())

((Status & APFloat::opInexact) &&

S.FFDiag(

, diag::note_constexpr_dynamic_rounding);

((Status != APFloat::opOK) &&

FPO.getAllowFEnvAccess())) {

S.FFDiag(

, diag::note_constexpr_float_arithmetic_strict);

((Status & APFloat::opStatus::opInvalidOp) &&

S.CCEDiag(

, diag::note_constexpr_new);

*NewExpr) {

(AllocForm == DeleteForm)

(

->isArray()) {

ElemQT =

->getType()->getPointeeType();

ElemQT,

(64,

uint64_t

(

->getNumElems()),

),

TypeToDiagnose =

->getType()->getPointeeType();

S.FFDiag(

, diag::note_constexpr_new_delete_mismatch)

<<

(DeleteForm) <<

(AllocForm)

S.Note(NewExpr->

(), diag::note_constexpr_dynamic_alloc_here)

(isa_and_nonnull<CXXNewExpr>(Source))

(

*CE = dyn_cast_if_present<CallExpr>(Source);

CE && CE->getBuiltinCallee() == Builtin::BI__builtin_operator_new)

(

*MCE = dyn_cast_if_present<CXXMemberCallExpr>(Source);

MCE && MCE->getMethodDecl()->

()->isStr(

))

S.FFDiag(

, diag::note_constexpr_delete_not_heap_alloc)

S.Note(Ptr.

(), diag::note_constexpr_temporary_here);

S.Note(Ptr.

(), diag::note_declared_at);

S.FFDiag(

, diag::note_constexpr_modify_global);

*CE,

ArgSize) {

(

*Arg : Args) {

(NonNullArgs[Index] && Arg->getType()->isPointerType()) {

S.CCEDiag(

, diag::note_non_null_attribute_failed);

S.FFDiag(

, diag::note_constexpr_double_destroy);

*DtorFunc = S.getContext().getOrCreateFunction(Dtor);

S.Stk.push<

>(BasePtr);

(!

(S, OpPC, DtorFunc, 0))

(

I = 0; I != Desc->

(); ++I) {

DD->isVirtual();

IsGlobalDelete) {

*Source =

;

*BlockToDelete =

;

(!DeleteIsArrayForm && Ptr.

() != InitialType &&

S.FFDiag(S.Current->getSource(OpPC),

diag::note_constexpr_delete_base_nonvirt_dtor)

<< InitialType << Ptr.

();

S.FFDiag(

, diag::note_constexpr_delete_subobject)

BlockToDelete = Ptr.

();

(!DeleteIsArrayForm && !IsGlobalDelete) {

DD->isVirtual() ? DD->getOperatorDelete() :

;

S.FFDiag(S.Current->getSource(OpPC),

diag::note_constexpr_new_non_replaceable)

<< isa<CXXMethodDecl>(VirtualDelete) << VirtualDelete;

assert(BlockToDelete);

std::optional<DynamicAllocator::Form> AllocForm =

Allocator.getAllocationForm(Source);

(!Allocator.deallocate(Source, BlockToDelete, S)) {

S.FFDiag(

, diag::note_constexpr_double_delete);

(S.EvaluatingDecl && !S.EvaluatingDecl->isConstexpr())

S.CCEDiag(

, diag::note_constexpr_unscoped_enum_out_of_range)

<< llvm::toString(

, 10) <<

.getSExtValue() <<

.getSExtValue()

S.CCEDiag(

, diag::note_constexpr_unscoped_enum_out_of_range)

<< llvm::toString(

, 10) <<

.getZExtValue() <<

.getZExtValue()

(S.Current->getFunction() && S.Current->getFunction()->isConstructor() &&

S.Current->getThis().getDeclDesc()->asDecl() == S.EvaluatingDecl) {

*

= S.Current->getExpr(OpPC);

S.FFDiag(

, diag::note_constexpr_nonliteral) <<

->

();

S.FFDiag(

, diag::note_invalid_subexpr_in_const_expr);

(S.

().CPlusPlus && S.inConstantContext() &&

S.FFDiag(S.Current->getSource(OpPC),

diag::note_constexpr_access_unreadable_object)

&Ptr = S.Stk.peek<

>();

(S, OpPC, Ptr, Off);

&Ptr = S.Stk.pop<

>();

(S, OpPC, Ptr, Off);

assert(

->isConstructor());

(!

->ElemRecord)

(

->ElemRecord->getNumVirtualBases() == 0)

S.FFDiag(S.Current->getLocation(OpPC), diag::note_constexpr_virtual_base)

<<

->getParentDecl();

uint32_t VarArgSize) {

(

->hasThisPointer()) {

ArgSize =

->getArgSize() + VarArgSize;

(!(S.Current->getFunction() &&

S.Current->getFunction()->isLambdaStaticInvoker() &&

->isLambdaCallOperator())) {

(S.checkingPotentialConstantExpression())

NewFrame = std::make_unique<InterpFrame>(S,

, OpPC, VarArgSize);

S.Current = NewFrame.get();

assert(S.Current == FrameBefore);

S.Current = FrameBefore;

uint32_t VarArgSize) {

cleanup = [&]() ->

{

(

->hasThisPointer()) {

ArgSize =

->getArgSize() + VarArgSize;

(ThisPtr.isDummy() &&

->isVirtual())

(S.Current->getFunction() &&

S.Current->getFunction()->isLambdaStaticInvoker() &&

->isLambdaCallOperator()) {

assert(ThisPtr.isZero());

(

->hasThisPointer() && S.checkingPotentialConstantExpression() &&

!

->isConstructor())

NewFrame = std::make_unique<InterpFrame>(S,

, OpPC, VarArgSize);

S.Current = NewFrame.get();

assert(S.Current == FrameBefore);

S.Current = FrameBefore;

uint32_t VarArgSize) {

assert(

->hasThisPointer());

assert(

->isVirtual());

ArgSize =

->getArgSize() + VarArgSize;

TypePtr = TypePtr.

();

DynamicDecl =

->getPointeeCXXRecordDecl();

assert(DynamicDecl);

*StaticDecl = cast<CXXRecordDecl>(

->getParentDecl());

*InitialFunction = cast<CXXMethodDecl>(

->getDecl());

*Overrider = S.getContext().getOverridingFunction(

DynamicDecl, StaticDecl, InitialFunction);

(Overrider != InitialFunction) {

*

= S.Current->getExpr(OpPC);

S.CCEDiag(

, diag::note_constexpr_virtual_call) <<

->

();

= S.getContext().getOrCreateFunction(Overrider);

ThisPtr.getFieldDesc()->getType()->getAsCXXRecordDecl();

(

->getParentDecl()->isDerivedFrom(ThisFieldDecl)) {

(ThisPtr.isBaseClass())

ThisPtr = ThisPtr.getBase();

(!

(S, OpPC,

, VarArgSize))

(Overrider != InitialFunction &&

InitialFunction->getReturnType()->isPointerOrReferenceType()) {

Offset = S.getContext().collectBaseOffset(

*CE, uint32_t BuiltinID) {

(BuiltinID == Builtin::BI__builtin_operator_new &&

S.checkingPotentialConstantExpression())

NewFrame = std::make_unique<InterpFrame>(S,

, OpPC);

S.Current = NewFrame.get();

assert(S.Current == FrameBefore);

S.Current = FrameBefore;

*

= cast<CallExpr>(S.Current->getExpr(OpPC));

S.FFDiag(

, diag::note_constexpr_null_callee)

(!FuncPtr.

() || !F->getDecl())

(S.Ctx.classify(F->getDecl()->getReturnType()) !=

S.Ctx.classify(CE->

()))

(F->hasNonNullAttr()) {

assert(ArgSize >= F->getWrittenArgSize());

uint32_t VarArgSize = ArgSize - F->getWrittenArgSize();

(F->isThisPointerExplicit())

(S, OpPC, F, VarArgSize);

(S, OpPC, F, VarArgSize);

std::optional<uint64_t> ArraySize) {

*NewExpr = cast<CXXNewExpr>(

);

NewExpr->getAllocatedType(),

(64,

uint64_t

(*ArraySize),

),

,

AllocType = NewExpr->getAllocatedType();

StorageSize = 1;

AllocSize = 1;

(

*CAT = dyn_cast<ConstantArrayType>(AllocType))

AllocSize = CAT->getZExtSize();

(

*CAT = dyn_cast<ConstantArrayType>(StorageType))

StorageSize = CAT->getZExtSize();

(AllocSize > StorageSize ||

S.FFDiag(S.Current->getLocation(OpPC),

diag::note_constexpr_placement_new_wrong_type)

<< StorageType << AllocType;

&

= S.Current->getSource(OpPC);

(

*NewExpr = dyn_cast<CXXNewExpr>(

)) {

*OperatorNew = NewExpr->getOperatorNew();

(!S.

().CPlusPlus26 && NewExpr->getNumPlacementArgs() > 0) {

(S.Current->isStdFunction())

S.FFDiag(

, diag::note_constexpr_new_placement)

}

(NewExpr->getNumPlacementArgs() == 1 &&

!OperatorNew->isReservedGlobalPlacementOperator()) {

S.FFDiag(

, diag::note_constexpr_new_placement)

}

(!OperatorNew->isReplaceableGlobalAllocationFunction()) {

S.FFDiag(

, diag::note_constexpr_new_non_replaceable)

<< isa<CXXMethodDecl>(OperatorNew) << OperatorNew;

*DeleteExpr = cast<CXXDeleteExpr>(

);

*OperatorDelete = DeleteExpr->getOperatorDelete();

(!OperatorDelete->isReplaceableGlobalAllocationFunction()) {

S.FFDiag(

, diag::note_constexpr_new_non_replaceable)

<< isa<CXXMethodDecl>(OperatorDelete) << OperatorDelete;

*

= S.Current->getExpr(OpPC);

(S.checkingForUndefinedBehavior()) {

->

(), diag::warn_fixedpoint_constant_overflow)

S.CCEDiag(

, diag::note_constexpr_overflow)

S.noteUndefinedBehavior();

diag::err_shufflevector_minus_one_is_undefined_behavior_constexpr)

&Ptr,

BitWidth) {

&

= S.Current->getSource(OpPC);

S.CCEDiag(

, diag::note_constexpr_invalid_cast)

<< 2 << S.

().CPlusPlus << S.Current->getRange(OpPC);

TargetIsUCharOrByte) {

(!HasIndeterminateBits)

(TargetIsUCharOrByte)

*

= S.Current->getExpr(OpPC);

S.FFDiag(

, diag::note_constexpr_bit_cast_indet_dest)

*TypeInfoType) {

S.Stk.push<

>(TypePtr, TypeInfoType);

&

= S.Stk.pop<

>();

(!

.isBlockPointer())

S.Stk.push<

>(

.getType().getTypePtr(), TypeInfoType);

*

= cast<CXXTypeidExpr>(S.Current->getExpr(OpPC));

S.CCEDiag(

, diag::note_constexpr_typeid_polymorphic)

<<

->getExprOperand()->

()

, off)

assert(!S.Current->isRoot());

PC = S.Current->getPC();

, on)

Defines the clang::ASTContext interface.

Defines the clang::Expr interface and subclasses for C++ expressions.

static const FunctionDecl * getVirtualOperatorDelete(QualType T)

static bool Jmp(InterpState &S, CodePtr &PC, int32_t Offset)

static bool CheckActive(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)

static bool CheckGlobal(InterpState &S, CodePtr OpPC, const Pointer &Ptr)

static bool CheckTemporary(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)

static bool Jt(InterpState &S, CodePtr &PC, int32_t Offset)

static void diagnoseNonConstVariable(InterpState &S, CodePtr OpPC, const ValueDecl *VD)

static bool diagnoseUnknownDecl(InterpState &S, CodePtr OpPC, const ValueDecl *D)

static bool Jf(InterpState &S, CodePtr &PC, int32_t Offset)

static void diagnoseMissingInitializer(InterpState &S, CodePtr OpPC, const ValueDecl *VD)

static bool RetValue(InterpState &S, CodePtr &Pt)

static StringRef getIdentifier(const Token &Tok)

#define TYPE_SWITCH(Expr, B)

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

Builtin::Context & BuiltinInfo

QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const

Return the unique reference to the type for a constant array of the specified element type.

QualType getBaseElementType(const ArrayType *VAT) const

Return the innermost element type of an array type.

bool hasSimilarType(QualType T1, QualType T2) const

Determine if two types are similar, according to the C++ rules.

DiagnosticsEngine & getDiagnostics() const

const TargetInfo & getTargetInfo() const

bool hasCustomTypechecking(unsigned ID) const

Determines whether this builtin has custom typechecking.

Represents a C++ destructor within a class.

Represents a static or instance method of a struct/union/class.

Represents a C++ struct/union/class.

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

unsigned getNumArgs() const

getNumArgs - Return the number of actual arguments to this call.

Expr ** getArgs()

Retrieve the call arguments.

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

bool isInvalidDecl() const

SourceLocation getLocation() const

virtual SourceRange getSourceRange() const LLVM_READONLY

Source range that this declaration covers.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

unsigned getNumNegativeBits() const

Returns the width in bits required to store all the negative enumerators of this enum.

void getValueRange(llvm::APInt &Max, llvm::APInt &Min) const

Calculates the [Min,Max) values the enum can store based on the NumPositiveBits and NumNegativeBits.

This represents one expression.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

LangOptions::FPExceptionModeKind getExceptionMode() const

RoundingMode getRoundingMode() const

Represents a member of a struct/union/class.

Represents a function declaration or definition.

QualType getReturnType() const

bool isTrivial() const

Whether this function is "trivial" in some specialized C++ senses.

StorageClass getStorageClass() const

Returns the storage class as written in the source.

bool isConstexpr() const

Whether this is a (C++11) constexpr function or constexpr constructor.

bool isPureVirtual() const

Whether this virtual function is pure, i.e.

FunctionDecl * getDefinition()

Get the definition for this declaration.

bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const

Determines whether this function is one of the replaceable global allocation functions: void *operato...

bool hasBody(const FunctionDecl *&Definition) const

Returns true if the function has a body.

bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const

Returns true if the function has a definition that does not need to be instantiated.

@ FPE_Ignore

Assume that floating-point exceptions are masked.

A (possibly-)qualified type.

bool isVolatileQualified() const

Determine whether this type is volatile-qualified.

bool isConstant(const ASTContext &Ctx) const

ASTContext & getASTContext() const

const LangOptions & getLangOpts() const

Encodes a location in the source.

SourceRange getSourceRange() const LLVM_READONLY

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

uint64_t getPointerWidth(LangAS AddrSpace) const

Return the width of pointers on this target, for the specified address space.

The base class of the type hierarchy.

CXXRecordDecl * getAsCXXRecordDecl() const

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

bool isPointerType() const

QualType getPointeeType() const

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

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

bool isPointerOrReferenceType() const

RecordDecl * getAsRecordDecl() const

Retrieves the RecordDecl this type refers to.

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

A memory block, either on the stack or in the heap.

unsigned getSize() const

Returns the size of the block.

const Descriptor * getDescriptor() const

Returns the block's descriptor.

unsigned getEvalID() const

The Evaluation ID this block was created in.

Pointer into the code segment.

std::enable_if_t<!std::is_pointer< T >::value, T > read()

Reads data and advances the pointer.

Manages dynamic memory allocations done during bytecode interpretation.

Wrapper around fixed point types.

std::string toDiagnosticString(const ASTContext &Ctx) const

Base class for stack frames, shared between VM and walker.

const Function * getFunction() const

bool isVirtual() const

Checks if the function is virtual.

const FunctionDecl * getDecl() const

Returns the original FunctionDecl.

bool hasBody() const

Checks if the function already has a body attached.

bool isConstexpr() const

Checks if the function is valid to call in constexpr.

bool isLambdaStaticInvoker() const

Returns whether this function is a lambda static invoker, which we generate custom byte code for.

static IntegralAP from(T Value, unsigned NumBits=0)

Frame storing local variables.

A pointer to a memory block, live or dead.

Pointer narrow() const

Restricts the scope of an array element pointer.

bool isInitialized() const

Checks if an object was initialized.

bool isStatic() const

Checks if the storage is static.

bool isDynamic() const

Checks if the storage has been dynamically allocated.

Pointer atIndex(uint64_t Idx) const

Offsets a pointer inside an array.

bool isDummy() const

Checks if the pointer points to a dummy value.

bool isExtern() const

Checks if the storage is extern.

bool isActive() const

Checks if the object is active.

bool isConst() const

Checks if an object or a subfield is mutable.

Pointer atField(unsigned Off) const

Creates a pointer to a field.

bool isMutable() const

Checks if the field is mutable.

bool isUnknownSizeArray() const

Checks if the structure is an array of unknown size.

bool isIntegralPointer() const

QualType getType() const

Returns the type of the innermost field.

bool isArrayElement() const

Checks if the pointer points to an array.

bool isLive() const

Checks if the pointer is live.

bool isStaticTemporary() const

Checks if the storage is a static temporary.

Pointer getBase() const

Returns a pointer to the object of which this pointer is a field.

uint64_t getByteOffset() const

Returns the byte offset from the start.

std::string toDiagnosticString(const ASTContext &Ctx) const

Converts the pointer to a string usable in diagnostics.

bool isZero() const

Checks if the pointer is null.

const IntPointer & asIntPointer() const

bool isRoot() const

Pointer points directly to a block.

const Descriptor * getDeclDesc() const

Accessor for information about the declaration site.

static bool pointToSameBlock(const Pointer &A, const Pointer &B)

Checks if both given pointers point to the same block.

bool isOnePastEnd() const

Checks if the index is one past end.

uint64_t getIntegerRepresentation() const

const FieldDecl * getField() const

Returns the field information.

bool isElementPastEnd() const

Checks if the pointer is an out-of-bounds element pointer.

bool isBlockPointer() const

bool isTemporary() const

Checks if the storage is temporary.

SourceLocation getDeclLoc() const

const Block * block() const

Pointer getDeclPtr() const

const Descriptor * getFieldDesc() const

Accessors for information about the innermost field.

std::optional< unsigned > getDeclID() const

Returns the declaration ID.

bool isBaseClass() const

Checks if a structure is a base class.

bool isField() const

Checks if the item is a field in an object.

const Record * getRecord() const

Returns the record descriptor of a class.

Structure/Class descriptor.

bool isUnion() const

Checks if the record is a union.

const CXXDestructorDecl * getDestructor() const

Returns the destructor of the record, if any.

llvm::iterator_range< const_field_iter > fields() const

Describes the statement/declaration an opcode was generated from.

Defines the clang::TargetInfo interface.

bool GetPtrFieldPop(InterpState &S, CodePtr OpPC, uint32_t Off)

bool GetPtrBasePop(InterpState &S, CodePtr OpPC, uint32_t Off)

bool CastPointerIntegralAPS(InterpState &S, CodePtr OpPC, uint32_t BitWidth)

static bool CheckVolatile(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)

bool CastPointerIntegralAP(InterpState &S, CodePtr OpPC, uint32_t BitWidth)

bool CheckInit(InterpState &S, CodePtr OpPC, const Pointer &Ptr)

Checks if a value can be initialized.

static bool runRecordDestructor(InterpState &S, CodePtr OpPC, const Pointer &BasePtr, const Descriptor *Desc)

bool GetTypeidPtr(InterpState &S, CodePtr OpPC, const Type *TypeInfoType)

bool CheckDowncast(InterpState &S, CodePtr OpPC, const Pointer &Ptr, uint32_t Offset)

Checks if the dowcast using the given offset is possible with the given pointer.

bool CheckNewDeleteForms(InterpState &S, CodePtr OpPC, DynamicAllocator::Form AllocForm, DynamicAllocator::Form DeleteForm, const Descriptor *D, const Expr *NewExpr)

Diagnose mismatched new[]/delete or new/delete[] pairs.

bool CheckDeclRef(InterpState &S, CodePtr OpPC, const DeclRefExpr *DR)

We aleady know the given DeclRefExpr is invalid for some reason, now figure out why and print appropr...

bool GetTypeid(InterpState &S, CodePtr OpPC, const Type *TypePtr, const Type *TypeInfoType)

Typeid support.

bool CheckCallDepth(InterpState &S, CodePtr OpPC)

Checks if calling the currently active function would exceed the allowed call depth.

bool CheckThis(InterpState &S, CodePtr OpPC, const Pointer &This)

Checks the 'this' pointer.

bool CheckConstant(InterpState &S, CodePtr OpPC, const Descriptor *Desc)

Checks if the Descriptor is of a constexpr or const global variable.

bool CheckPointerToIntegralCast(InterpState &S, CodePtr OpPC, const Pointer &Ptr, unsigned BitWidth)

static bool RunDestructors(InterpState &S, CodePtr OpPC, const Block *B)

bool GetPtrField(InterpState &S, CodePtr OpPC, uint32_t Off)

1) Peeks a Pointer 2) Pushes Pointer.atField(Off) on the stack

bool CheckMutable(InterpState &S, CodePtr OpPC, const Pointer &Ptr)

Checks if a pointer points to a mutable field.

bool CheckSubobject(InterpState &S, CodePtr OpPC, const Pointer &Ptr, CheckSubobjectKind CSK)

Checks if Ptr is a one-past-the-end pointer.

bool handleFixedPointOverflow(InterpState &S, CodePtr OpPC, const FixedPoint &FP)

static bool getField(InterpState &S, CodePtr OpPC, const Pointer &Ptr, uint32_t Off)

static bool hasVirtualDestructor(QualType T)

bool CheckLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)

Checks if a value can be loaded from a block.

bool CheckInitialized(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)

constexpr size_t align(size_t Size)

Aligns a size to the pointer alignment.

bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)

Checks if a pointer is in range.

bool CheckPure(InterpState &S, CodePtr OpPC, const CXXMethodDecl *MD)

Checks if a method is pure virtual.

bool This(InterpState &S, CodePtr OpPC)

bool CheckDynamicMemoryAllocation(InterpState &S, CodePtr OpPC)

Checks if dynamic memory allocation is available in the current language mode.

bool CheckLive(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)

Checks if a pointer is live and accessible.

bool DiagTypeid(InterpState &S, CodePtr OpPC)

bool CheckFinalLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr)

This is not used by any of the opcodes directly.

bool CheckBitCast(InterpState &S, CodePtr OpPC, bool HasIndeterminateBits, bool TargetIsUCharOrByte)

static void popArg(InterpState &S, const Expr *Arg)

static bool checkConstructor(InterpState &S, CodePtr OpPC, const Function *Func, const Pointer &ThisPtr)

void diagnoseEnumValue(InterpState &S, CodePtr OpPC, const EnumDecl *ED, const APSInt &Value)

PrimType

Enumeration of the primitive types of the VM.

bool CheckStore(InterpState &S, CodePtr OpPC, const Pointer &Ptr)

Checks if a value can be stored in a block.

bool CheckNull(InterpState &S, CodePtr OpPC, const Pointer &Ptr, CheckSubobjectKind CSK)

Checks if a pointer is null.

bool CheckDeleteSource(InterpState &S, CodePtr OpPC, const Expr *Source, const Pointer &Ptr)

Check the source of the pointer passed to delete/delete[] has actually been heap allocated by us.

bool CheckFloatResult(InterpState &S, CodePtr OpPC, const Floating &Result, APFloat::opStatus Status, FPOptions FPO)

Checks if the result of a floating-point operation is valid in the current context.

bool CallVar(InterpState &S, CodePtr OpPC, const Function *Func, uint32_t VarArgSize)

bool InvalidShuffleVectorIndex(InterpState &S, CodePtr OpPC, uint32_t Index)

bool CheckNewTypeMismatch(InterpState &S, CodePtr OpPC, const Expr *E, std::optional< uint64_t > ArraySize)

Check if the initializer and storage types of a placement-new expression match.

bool CheckLiteralType(InterpState &S, CodePtr OpPC, const Type *T)

bool CheckArray(InterpState &S, CodePtr OpPC, const Pointer &Ptr)

Checks if the array is offsetable.

bool CheckGlobalInitialized(InterpState &S, CodePtr OpPC, const Pointer &Ptr)

Check if a global variable is initialized.

bool CheckNonNullArgs(InterpState &S, CodePtr OpPC, const Function *F, const CallExpr *CE, unsigned ArgSize)

Checks if all the arguments annotated as 'nonnull' are in fact not null.

bool CheckDummy(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)

Checks if a pointer is a dummy pointer.

static bool CheckWeak(InterpState &S, CodePtr OpPC, const Pointer &Ptr)

void cleanupAfterFunctionCall(InterpState &S, CodePtr OpPC, const Function *Func)

llvm::BitVector collectNonNullArgs(const FunctionDecl *F, const llvm::ArrayRef< const Expr * > &Args)

size_t primSize(PrimType Type)

Returns the size of a primitive type in bytes.

bool CallBI(InterpState &S, CodePtr OpPC, const Function *Func, const CallExpr *CE, uint32_t BuiltinID)

bool Free(InterpState &S, CodePtr OpPC, bool DeleteIsArrayForm, bool IsGlobalDelete)

bool InvalidNewDeleteExpr(InterpState &S, CodePtr OpPC, const Expr *E)

bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const Function *F, const CallExpr *Call, uint32_t BuiltinID)

Interpret a builtin function.

bool CheckExtern(InterpState &S, CodePtr OpPC, const Pointer &Ptr)

Checks if the variable has externally defined storage.

bool CheckCallable(InterpState &S, CodePtr OpPC, const Function *F)

Checks if a method can be called.

bool CallPtr(InterpState &S, CodePtr OpPC, uint32_t ArgSize, const CallExpr *CE)

bool CallVirt(InterpState &S, CodePtr OpPC, const Function *Func, uint32_t VarArgSize)

bool CheckConst(InterpState &S, CodePtr OpPC, const Pointer &Ptr)

Checks if a pointer points to const storage.

bool Interpret(InterpState &S)

Interpreter entry point.

bool CheckInvoke(InterpState &S, CodePtr OpPC, const Pointer &Ptr)

Checks if a method can be invoked on an object.

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

CheckSubobjectKind

The order of this enum is important for diagnostics.

@ Result

The result type of a method or function.

AccessKinds

Kinds of access we can perform on an object, for diagnostics.

const FunctionProtoType * T

Describes a memory block created by an allocation site.

unsigned getNumElems() const

Returns the number of elements stored in the block.

bool isPrimitive() const

Checks if the descriptor is of a primitive.

bool isCompositeArray() const

Checks if the descriptor is of an array of composites.

const ValueDecl * asValueDecl() const

const Descriptor *const ElemDesc

Descriptor of the array element.

unsigned getMetadataSize() const

Returns the size of the metadata.

bool isPrimitiveArray() const

Checks if the descriptor is of an array of primitives.

const VarDecl * asVarDecl() const

bool isRecord() const

Checks if the descriptor is of a record.

const Record *const ElemRecord

Pointer to the record, if block contains records.

const Expr * asExpr() const

IntPointer atOffset(const ASTContext &ASTCtx, unsigned Offset) const

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4