clang 22.0.0git
Interp.cpp
Go to the documentation of this file.
1//===------- Interp.cpp - Interpreter for the constexpr VM ------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "Interp.h"
10#include "Compiler.h"
11#include "Function.h"
12#include "InterpFrame.h"
13#include "InterpShared.h"
14#include "InterpStack.h"
15#include "Opcode.h"
16#include "PrimType.h"
17#include "Program.h"
18#include "State.h"
21#include "clang/AST/DeclObjC.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/ExprCXX.h"
26#include "llvm/ADT/StringExtras.h"
27
28using namespace clang;
29using namespace clang::interp;
30
31static bool RetValue(InterpState &S, CodePtr &Pt) {
32 llvm::report_fatal_error("Interpreter cannot return values");
33}
34
35//===----------------------------------------------------------------------===//
36// Jmp, Jt, Jf
37//===----------------------------------------------------------------------===//
38
39static bool Jmp(InterpState &S, CodePtr &PC, int32_t Offset) {
40 PC += Offset;
41 return true;
42}
43
44static bool Jt(InterpState &S, CodePtr &PC, int32_t Offset) {
45 if (S.Stk.pop<bool>()) {
46 PC += Offset;
47 }
48 return true;
49}
50
51static bool Jf(InterpState &S, CodePtr &PC, int32_t Offset) {
52 if (!S.Stk.pop<bool>()) {
53 PC += Offset;
54 }
55 return true;
56}
57
58// https://github.com/llvm/llvm-project/issues/102513
59#if defined(_MSC_VER) && !defined(__clang__) && !defined(NDEBUG)
60#pragma optimize("", off)
61#endif
62// FIXME: We have the large switch over all opcodes here again, and in
63// Interpret().
64static bool BCP(InterpState &S, CodePtr &RealPC, int32_t Offset, PrimType PT) {
65 [[maybe_unused]] CodePtr PCBefore = RealPC;
66 size_t StackSizeBefore = S.Stk.size();
67
68 auto SpeculativeInterp = [&S, RealPC]() -> bool {
69 const InterpFrame *StartFrame = S.Current;
70 CodePtr PC = RealPC;
71
72 for (;;) {
73 auto Op = PC.read<Opcode>();
74 if (Op == OP_EndSpeculation)
75 return true;
76 CodePtr OpPC = PC;
77
78 switch (Op) {
79#define GET_INTERP
80#include "Opcodes.inc"
81#undef GET_INTERP
82 }
83 }
84 llvm_unreachable("We didn't see an EndSpeculation op?");
85 };
86
87 if (SpeculativeInterp()) {
88 if (PT == PT_Ptr) {
89 const auto &Ptr = S.Stk.pop<Pointer>();
90 assert(S.Stk.size() == StackSizeBefore);
93 } else {
94 // Pop the result from the stack and return success.
95 TYPE_SWITCH(PT, S.Stk.pop<T>(););
96 assert(S.Stk.size() == StackSizeBefore);
98 }
99 } else {
100 if (!S.inConstantContext())
101 return Invalid(S, RealPC);
102
103 S.Stk.clearTo(StackSizeBefore);
105 }
106
107 // RealPC should not have been modified.
108 assert(*RealPC == *PCBefore);
109
110 // Jump to end label. This is a little tricker than just RealPC += Offset
111 // because our usual jump instructions don't have any arguments, to the offset
112 // we get is a little too much and we need to subtract the size of the
113 // bool and PrimType arguments again.
114 int32_t ParamSize = align(sizeof(PrimType));
115 assert(Offset >= ParamSize);
116 RealPC += Offset - ParamSize;
117
118 [[maybe_unused]] CodePtr PCCopy = RealPC;
119 assert(PCCopy.read<Opcode>() == OP_EndSpeculation);
120
121 return true;
122}
123// https://github.com/llvm/llvm-project/issues/102513
124#if defined(_MSC_VER) && !defined(__clang__) && !defined(NDEBUG)
125#pragma optimize("", on)
126#endif
127
129 const ValueDecl *VD) {
130 const SourceInfo &E = S.Current->getSource(OpPC);
131 S.FFDiag(E, diag::note_constexpr_var_init_unknown, 1) << VD;
132 S.Note(VD->getLocation(), diag::note_declared_at) << VD->getSourceRange();
133}
134
135static void diagnoseNonConstVariable(InterpState &S, CodePtr OpPC,
136 const ValueDecl *VD);
138 const ValueDecl *D) {
139 // This function tries pretty hard to produce a good diagnostic. Just skip
140 // tha if nobody will see it anyway.
141 if (!S.diagnosing())
142 return false;
143
144 if (isa<ParmVarDecl>(D)) {
145 if (D->getType()->isReferenceType()) {
146 if (S.inConstantContext() && S.getLangOpts().CPlusPlus &&
147 !S.getLangOpts().CPlusPlus11)
148 diagnoseNonConstVariable(S, OpPC, D);
149 return false;
150 }
151
152 const SourceInfo &Loc = S.Current->getSource(OpPC);
153 if (S.getLangOpts().CPlusPlus11) {
154 S.FFDiag(Loc, diag::note_constexpr_function_param_value_unknown) << D;
155 S.Note(D->getLocation(), diag::note_declared_at) << D->getSourceRange();
156 } else {
157 S.FFDiag(Loc);
158 }
159 return false;
160 }
161
162 if (!D->getType().isConstQualified()) {
163 diagnoseNonConstVariable(S, OpPC, D);
164 } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
165 if (!VD->getAnyInitializer()) {
166 diagnoseMissingInitializer(S, OpPC, VD);
167 } else {
168 const SourceInfo &Loc = S.Current->getSource(OpPC);
169 S.FFDiag(Loc, diag::note_constexpr_var_init_non_constant, 1) << VD;
170 S.Note(VD->getLocation(), diag::note_declared_at);
171 }
172 }
173
174 return false;
175}
176
178 const ValueDecl *VD) {
179 if (!S.diagnosing())
180 return;
181
182 const SourceInfo &Loc = S.Current->getSource(OpPC);
183 if (!S.getLangOpts().CPlusPlus) {
184 S.FFDiag(Loc);
185 return;
186 }
187
188 if (const auto *VarD = dyn_cast<VarDecl>(VD);
189 VarD && VarD->getType().isConstQualified() &&
190 !VarD->getAnyInitializer()) {
191 diagnoseMissingInitializer(S, OpPC, VD);
192 return;
193 }
194
195 // Rather random, but this is to match the diagnostic output of the current
196 // interpreter.
197 if (isa<ObjCIvarDecl>(VD))
198 return;
199
201 S.FFDiag(Loc, diag::note_constexpr_ltor_non_const_int, 1) << VD;
202 S.Note(VD->getLocation(), diag::note_declared_at);
203 return;
204 }
205
206 S.FFDiag(Loc,
207 S.getLangOpts().CPlusPlus11 ? diag::note_constexpr_ltor_non_constexpr
208 : diag::note_constexpr_ltor_non_integral,
209 1)
210 << VD << VD->getType();
211 S.Note(VD->getLocation(), diag::note_declared_at);
212}
213
214static bool CheckTemporary(InterpState &S, CodePtr OpPC, const Block *B,
215 AccessKinds AK) {
216 if (B->getDeclID()) {
217 if (!(B->isStatic() && B->isTemporary()))
218 return true;
219
220 const auto *MTE = dyn_cast_if_present<MaterializeTemporaryExpr>(
221 B->getDescriptor()->asExpr());
222 if (!MTE)
223 return true;
224
225 // FIXME(perf): Since we do this check on every Load from a static
226 // temporary, it might make sense to cache the value of the
227 // isUsableInConstantExpressions call.
228 if (B->getEvalID() != S.Ctx.getEvalID() &&
229 !MTE->isUsableInConstantExpressions(S.getASTContext())) {
230 const SourceInfo &E = S.Current->getSource(OpPC);
231 S.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK;
233 diag::note_constexpr_temporary_here);
234 return false;
235 }
236 }
237 return true;
238}
239
240static bool CheckGlobal(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
241 if (auto ID = Ptr.getDeclID()) {
242 if (!Ptr.isStatic())
243 return true;
244
245 if (S.P.getCurrentDecl() == ID)
246 return true;
247
248 S.FFDiag(S.Current->getLocation(OpPC), diag::note_constexpr_modify_global);
249 return false;
250 }
251 return true;
252}
253
254namespace clang {
255namespace interp {
256static void popArg(InterpState &S, const Expr *Arg) {
258 TYPE_SWITCH(Ty, S.Stk.discard<T>());
259}
260
262 const Function *Func) {
263 assert(S.Current);
264 assert(Func);
265
266 if (S.Current->Caller && Func->isVariadic()) {
267 // CallExpr we're look for is at the return PC of the current function, i.e.
268 // in the caller.
269 // This code path should be executed very rarely.
270 unsigned NumVarArgs;
271 const Expr *const *Args = nullptr;
272 unsigned NumArgs = 0;
273 const Expr *CallSite = S.Current->Caller->getExpr(S.Current->getRetPC());
274 if (const auto *CE = dyn_cast<CallExpr>(CallSite)) {
275 Args = CE->getArgs();
276 NumArgs = CE->getNumArgs();
277 } else if (const auto *CE = dyn_cast<CXXConstructExpr>(CallSite)) {
278 Args = CE->getArgs();
279 NumArgs = CE->getNumArgs();
280 } else
281 assert(false && "Can't get arguments from that expression type");
282
283 assert(NumArgs >= Func->getNumWrittenParams());
284 NumVarArgs = NumArgs - (Func->getNumWrittenParams() +
285 isa<CXXOperatorCallExpr>(CallSite));
286 for (unsigned I = 0; I != NumVarArgs; ++I) {
287 const Expr *A = Args[NumArgs - 1 - I];
288 popArg(S, A);
289 }
290 }
291
292 // And in any case, remove the fixed parameters (the non-variadic ones)
293 // at the end.
294 for (PrimType Ty : Func->args_reverse())
295 TYPE_SWITCH(Ty, S.Stk.discard<T>());
296}
297
299 if (!P.isBlockPointer())
300 return false;
301
302 if (P.isDummy())
303 return isa_and_nonnull<ParmVarDecl>(P.getDeclDesc()->asValueDecl());
304
306}
307
308bool CheckBCPResult(InterpState &S, const Pointer &Ptr) {
309 if (Ptr.isDummy())
310 return false;
311 if (Ptr.isZero())
312 return true;
313 if (Ptr.isFunctionPointer())
314 return false;
315 if (Ptr.isIntegralPointer())
316 return true;
317 if (Ptr.isTypeidPointer())
318 return true;
319
320 if (Ptr.getType()->isAnyComplexType())
321 return true;
322
323 if (const Expr *Base = Ptr.getDeclDesc()->asExpr())
324 return isa<StringLiteral>(Base) && Ptr.getIndex() == 0;
325 return false;
326}
327
328bool CheckActive(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
329 AccessKinds AK) {
330 if (Ptr.isActive())
331 return true;
332
333 assert(Ptr.inUnion());
334
335 Pointer U = Ptr.getBase();
336 Pointer C = Ptr;
337 while (!U.isRoot() && !U.isActive()) {
338 // A little arbitrary, but this is what the current interpreter does.
339 // See the AnonymousUnion test in test/AST/ByteCode/unions.cpp.
340 // GCC's output is more similar to what we would get without
341 // this condition.
342 if (U.getRecord() && U.getRecord()->isAnonymousUnion())
343 break;
344
345 C = U;
346 U = U.getBase();
347 }
348 assert(C.isField());
349
350 // Consider:
351 // union U {
352 // struct {
353 // int x;
354 // int y;
355 // } a;
356 // }
357 //
358 // When activating x, we will also activate a. If we now try to read
359 // from y, we will get to CheckActive, because y is not active. In that
360 // case, our U will be a (not a union). We return here and let later code
361 // handle this.
362 if (!U.getFieldDesc()->isUnion())
363 return true;
364
365 // Get the inactive field descriptor.
366 assert(!C.isActive());
367 const FieldDecl *InactiveField = C.getField();
368 assert(InactiveField);
369
370 // Find the active field of the union.
371 const Record *R = U.getRecord();
372 assert(R && R->isUnion() && "Not a union");
373
374 const FieldDecl *ActiveField = nullptr;
375 for (const Record::Field &F : R->fields()) {
376 const Pointer &Field = U.atField(F.Offset);
377 if (Field.isActive()) {
378 ActiveField = Field.getField();
379 break;
380 }
381 }
382
383 const SourceInfo &Loc = S.Current->getSource(OpPC);
384 S.FFDiag(Loc, diag::note_constexpr_access_inactive_union_member)
385 << AK << InactiveField << !ActiveField << ActiveField;
386 return false;
387}
388
389bool CheckExtern(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
390 if (!Ptr.isExtern())
391 return true;
392
393 if (Ptr.isInitialized() ||
394 (Ptr.getDeclDesc()->asVarDecl() == S.EvaluatingDecl))
395 return true;
396
397 if (S.checkingPotentialConstantExpression() && S.getLangOpts().CPlusPlus &&
398 Ptr.isConst())
399 return false;
400
401 const auto *VD = Ptr.getDeclDesc()->asValueDecl();
402 diagnoseNonConstVariable(S, OpPC, VD);
403 return false;
404}
405
406bool CheckArray(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
407 if (!Ptr.isUnknownSizeArray())
408 return true;
409 const SourceInfo &E = S.Current->getSource(OpPC);
410 S.FFDiag(E, diag::note_constexpr_unsized_array_indexed);
411 return false;
412}
413
414bool CheckLive(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
415 AccessKinds AK) {
416 if (Ptr.isZero()) {
417 const auto &Src = S.Current->getSource(OpPC);
418
419 if (Ptr.isField())
420 S.FFDiag(Src, diag::note_constexpr_null_subobject) << CSK_Field;
421 else
422 S.FFDiag(Src, diag::note_constexpr_access_null) << AK;
423
424 return false;
425 }
426
427 if (!Ptr.isLive()) {
428 const auto &Src = S.Current->getSource(OpPC);
429
430 if (Ptr.isDynamic()) {
431 S.FFDiag(Src, diag::note_constexpr_access_deleted_object) << AK;
432 } else if (!S.checkingPotentialConstantExpression()) {
433 bool IsTemp = Ptr.isTemporary();
434 S.FFDiag(Src, diag::note_constexpr_lifetime_ended, 1) << AK << !IsTemp;
435
436 if (IsTemp)
437 S.Note(Ptr.getDeclLoc(), diag::note_constexpr_temporary_here);
438 else
439 S.Note(Ptr.getDeclLoc(), diag::note_declared_at);
440 }
441
442 return false;
443 }
444
445 return true;
446}
447
448bool CheckConstant(InterpState &S, CodePtr OpPC, const Descriptor *Desc) {
449 assert(Desc);
450
451 const auto *D = Desc->asVarDecl();
452 if (!D || D == S.EvaluatingDecl || D->isConstexpr())
453 return true;
454
455 // If we're evaluating the initializer for a constexpr variable in C23, we may
456 // only read other contexpr variables. Abort here since this one isn't
457 // constexpr.
458 if (const auto *VD = dyn_cast_if_present<VarDecl>(S.EvaluatingDecl);
459 VD && VD->isConstexpr() && S.getLangOpts().C23)
460 return Invalid(S, OpPC);
461
462 QualType T = D->getType();
463 bool IsConstant = T.isConstant(S.getASTContext());
464 if (T->isIntegralOrEnumerationType()) {
465 if (!IsConstant) {
466 diagnoseNonConstVariable(S, OpPC, D);
467 return false;
468 }
469 return true;
470 }
471
472 if (IsConstant) {
473 if (S.getLangOpts().CPlusPlus) {
474 S.CCEDiag(S.Current->getLocation(OpPC),
475 S.getLangOpts().CPlusPlus11
476 ? diag::note_constexpr_ltor_non_constexpr
477 : diag::note_constexpr_ltor_non_integral,
478 1)
479 << D << T;
480 S.Note(D->getLocation(), diag::note_declared_at);
481 } else {
482 S.CCEDiag(S.Current->getLocation(OpPC));
483 }
484 return true;
485 }
486
487 if (T->isPointerOrReferenceType()) {
488 if (!T->getPointeeType().isConstant(S.getASTContext()) ||
489 !S.getLangOpts().CPlusPlus11) {
490 diagnoseNonConstVariable(S, OpPC, D);
491 return false;
492 }
493 return true;
494 }
495
496 diagnoseNonConstVariable(S, OpPC, D);
497 return false;
498}
499
500static bool CheckConstant(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
501 if (!Ptr.isStatic() || !Ptr.isBlockPointer())
502 return true;
503 if (!Ptr.getDeclID())
504 return true;
505 return CheckConstant(S, OpPC, Ptr.getDeclDesc());
506}
507
508bool CheckNull(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
509 CheckSubobjectKind CSK) {
510 if (!Ptr.isZero())
511 return true;
512 const SourceInfo &Loc = S.Current->getSource(OpPC);
513 S.FFDiag(Loc, diag::note_constexpr_null_subobject)
514 << CSK << S.Current->getRange(OpPC);
515
516 return false;
517}
518
519bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
520 AccessKinds AK) {
521 if (!Ptr.isOnePastEnd() && !Ptr.isZeroSizeArray())
522 return true;
523 if (S.getLangOpts().CPlusPlus) {
524 const SourceInfo &Loc = S.Current->getSource(OpPC);
525 S.FFDiag(Loc, diag::note_constexpr_access_past_end)
526 << AK << S.Current->getRange(OpPC);
527 }
528 return false;
529}
530
531bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
532 CheckSubobjectKind CSK) {
533 if (!Ptr.isElementPastEnd() && !Ptr.isZeroSizeArray())
534 return true;
535 const SourceInfo &Loc = S.Current->getSource(OpPC);
536 S.FFDiag(Loc, diag::note_constexpr_past_end_subobject)
537 << CSK << S.Current->getRange(OpPC);
538 return false;
539}
540
541bool CheckSubobject(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
542 CheckSubobjectKind CSK) {
543 if (!Ptr.isOnePastEnd())
544 return true;
545
546 const SourceInfo &Loc = S.Current->getSource(OpPC);
547 S.FFDiag(Loc, diag::note_constexpr_past_end_subobject)
548 << CSK << S.Current->getRange(OpPC);
549 return false;
550}
551
552bool CheckDowncast(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
553 uint32_t Offset) {
554 uint32_t MinOffset = Ptr.getDeclDesc()->getMetadataSize();
555 uint32_t PtrOffset = Ptr.getByteOffset();
556
557 // We subtract Offset from PtrOffset. The result must be at least
558 // MinOffset.
559 if (Offset < PtrOffset && (PtrOffset - Offset) >= MinOffset)
560 return true;
561
562 const auto *E = cast<CastExpr>(S.Current->getExpr(OpPC));
563 QualType TargetQT = E->getType()->getPointeeType();
564 QualType MostDerivedQT = Ptr.getDeclPtr().getType();
565
566 S.CCEDiag(E, diag::note_constexpr_invalid_downcast)
567 << MostDerivedQT << TargetQT;
568
569 return false;
570}
571
572bool CheckConst(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
573 assert(Ptr.isLive() && "Pointer is not live");
574 if (!Ptr.isConst())
575 return true;
576
577 if (Ptr.isMutable() && !Ptr.isConstInMutable())
578 return true;
579
580 if (!Ptr.isBlockPointer())
581 return false;
582
583 // The This pointer is writable in constructors and destructors,
584 // even if isConst() returns true.
585 if (llvm::is_contained(S.InitializingBlocks, Ptr.block()))
586 return true;
587
588 const QualType Ty = Ptr.getType();
589 const SourceInfo &Loc = S.Current->getSource(OpPC);
590 S.FFDiag(Loc, diag::note_constexpr_modify_const_type) << Ty;
591 return false;
592}
593
594bool CheckMutable(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
595 assert(Ptr.isLive() && "Pointer is not live");
596 if (!Ptr.isMutable())
597 return true;
598
599 // In C++14 onwards, it is permitted to read a mutable member whose
600 // lifetime began within the evaluation.
601 if (S.getLangOpts().CPlusPlus14 &&
602 Ptr.block()->getEvalID() == S.Ctx.getEvalID()) {
603 // FIXME: This check is necessary because (of the way) we revisit
604 // variables in Compiler.cpp:visitDeclRef. Revisiting a so far
605 // unknown variable will get the same EvalID and we end up allowing
606 // reads from mutable members of it.
607 if (!S.inConstantContext() && isConstexprUnknown(Ptr))
608 return false;
609 return true;
610 }
611
612 const SourceInfo &Loc = S.Current->getSource(OpPC);
613 const FieldDecl *Field = Ptr.getField();
614 S.FFDiag(Loc, diag::note_constexpr_access_mutable, 1) << AK_Read << Field;
615 S.Note(Field->getLocation(), diag::note_declared_at);
616 return false;
617}
618
619static bool CheckVolatile(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
620 AccessKinds AK) {
621 assert(Ptr.isLive());
622
623 if (!Ptr.isVolatile())
624 return true;
625
626 if (!S.getLangOpts().CPlusPlus)
627 return Invalid(S, OpPC);
628
629 // The reason why Ptr is volatile might be further up the hierarchy.
630 // Find that pointer.
631 Pointer P = Ptr;
632 while (!P.isRoot()) {
634 break;
635 P = P.getBase();
636 }
637
638 const NamedDecl *ND = nullptr;
639 int DiagKind;
640 SourceLocation Loc;
641 if (const auto *F = P.getField()) {
642 DiagKind = 2;
643 Loc = F->getLocation();
644 ND = F;
645 } else if (auto *VD = P.getFieldDesc()->asValueDecl()) {
646 DiagKind = 1;
647 Loc = VD->getLocation();
648 ND = VD;
649 } else {
650 DiagKind = 0;
651 if (const auto *E = P.getFieldDesc()->asExpr())
652 Loc = E->getExprLoc();
653 }
654
655 S.FFDiag(S.Current->getLocation(OpPC),
656 diag::note_constexpr_access_volatile_obj, 1)
657 << AK << DiagKind << ND;
658 S.Note(Loc, diag::note_constexpr_volatile_here) << DiagKind;
659 return false;
660}
661
663 AccessKinds AK) {
664 assert(Ptr.isLive());
665 assert(!Ptr.isInitialized());
666 return DiagnoseUninitialized(S, OpPC, Ptr.isExtern(), Ptr.getDeclDesc(), AK);
667}
668
669bool DiagnoseUninitialized(InterpState &S, CodePtr OpPC, bool Extern,
670 const Descriptor *Desc, AccessKinds AK) {
671 if (Extern && S.checkingPotentialConstantExpression())
672 return false;
673
674 if (const auto *VD = Desc->asVarDecl();
675 VD && (VD->isConstexpr() || VD->hasGlobalStorage())) {
676
677 if (VD == S.EvaluatingDecl &&
678 !(S.getLangOpts().CPlusPlus23 && VD->getType()->isReferenceType())) {
679 if (!S.getLangOpts().CPlusPlus14 &&
680 !VD->getType().isConstant(S.getASTContext())) {
681 // Diagnose as non-const read.
682 diagnoseNonConstVariable(S, OpPC, VD);
683 } else {
684 const SourceInfo &Loc = S.Current->getSource(OpPC);
685 // Diagnose as "read of object outside its lifetime".
686 S.FFDiag(Loc, diag::note_constexpr_access_uninit)
687 << AK << /*IsIndeterminate=*/false;
688 }
689 return false;
690 }
691
692 if (VD->getAnyInitializer()) {
693 const SourceInfo &Loc = S.Current->getSource(OpPC);
694 S.FFDiag(Loc, diag::note_constexpr_var_init_non_constant, 1) << VD;
695 S.Note(VD->getLocation(), diag::note_declared_at);
696 } else {
697 diagnoseMissingInitializer(S, OpPC, VD);
698 }
699 return false;
700 }
701
703 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_uninit)
704 << AK << /*uninitialized=*/true << S.Current->getRange(OpPC);
705 }
706 return false;
707}
708
710 AccessKinds AK) {
711 if (LT == Lifetime::Started)
712 return true;
713
715 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_uninit)
716 << AK << /*uninitialized=*/false << S.Current->getRange(OpPC);
717 }
718 return false;
719}
720
721static bool CheckWeak(InterpState &S, CodePtr OpPC, const Block *B) {
722 if (!B->isWeak())
723 return true;
724
725 const auto *VD = B->getDescriptor()->asVarDecl();
726 assert(VD);
727 S.FFDiag(S.Current->getLocation(OpPC), diag::note_constexpr_var_init_weak)
728 << VD;
729 S.Note(VD->getLocation(), diag::note_declared_at);
730
731 return false;
732}
733
734// The list of checks here is just the one from CheckLoad, but with the
735// ones removed that are impossible on primitive global values.
736// For example, since those can't be members of structs, they also can't
737// be mutable.
738bool CheckGlobalLoad(InterpState &S, CodePtr OpPC, const Block *B) {
739 const auto &Desc =
740 *reinterpret_cast<const GlobalInlineDescriptor *>(B->rawData());
741 if (!B->isAccessible()) {
742 if (!CheckExtern(S, OpPC, Pointer(const_cast<Block *>(B))))
743 return false;
744 if (!CheckDummy(S, OpPC, B, AK_Read))
745 return false;
746 return CheckWeak(S, OpPC, B);
747 }
748
749 if (!CheckConstant(S, OpPC, B->getDescriptor()))
750 return false;
751 if (Desc.InitState != GlobalInitState::Initialized)
752 return DiagnoseUninitialized(S, OpPC, B->isExtern(), B->getDescriptor(),
753 AK_Read);
754 if (!CheckTemporary(S, OpPC, B, AK_Read))
755 return false;
756 if (B->getDescriptor()->IsVolatile) {
757 if (!S.getLangOpts().CPlusPlus)
758 return Invalid(S, OpPC);
759
760 const ValueDecl *D = B->getDescriptor()->asValueDecl();
761 S.FFDiag(S.Current->getLocation(OpPC),
762 diag::note_constexpr_access_volatile_obj, 1)
763 << AK_Read << 1 << D;
764 S.Note(D->getLocation(), diag::note_constexpr_volatile_here) << 1;
765 return false;
766 }
767 return true;
768}
769
770// Similarly, for local loads.
771bool CheckLocalLoad(InterpState &S, CodePtr OpPC, const Block *B) {
772 assert(!B->isExtern());
773 const auto &Desc = *reinterpret_cast<const InlineDescriptor *>(B->rawData());
774 if (!CheckLifetime(S, OpPC, Desc.LifeState, AK_Read))
775 return false;
776 if (!Desc.IsInitialized)
777 return DiagnoseUninitialized(S, OpPC, /*Extern=*/false, B->getDescriptor(),
778 AK_Read);
779 if (B->getDescriptor()->IsVolatile) {
780 if (!S.getLangOpts().CPlusPlus)
781 return Invalid(S, OpPC);
782
783 const ValueDecl *D = B->getDescriptor()->asValueDecl();
784 S.FFDiag(S.Current->getLocation(OpPC),
785 diag::note_constexpr_access_volatile_obj, 1)
786 << AK_Read << 1 << D;
787 S.Note(D->getLocation(), diag::note_constexpr_volatile_here) << 1;
788 return false;
789 }
790 return true;
791}
792
793bool CheckLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
794 AccessKinds AK) {
795 if (Ptr.isZero()) {
796 const auto &Src = S.Current->getSource(OpPC);
797
798 if (Ptr.isField())
799 S.FFDiag(Src, diag::note_constexpr_null_subobject) << CSK_Field;
800 else
801 S.FFDiag(Src, diag::note_constexpr_access_null) << AK;
802 return false;
803 }
804 // Block pointers are the only ones we can actually read from.
805 if (!Ptr.isBlockPointer())
806 return false;
807
808 if (!Ptr.block()->isAccessible()) {
809 if (!CheckLive(S, OpPC, Ptr, AK))
810 return false;
811 if (!CheckExtern(S, OpPC, Ptr))
812 return false;
813 if (!CheckDummy(S, OpPC, Ptr.block(), AK))
814 return false;
815 return CheckWeak(S, OpPC, Ptr.block());
816 }
817
818 if (!CheckConstant(S, OpPC, Ptr))
819 return false;
820 if (!CheckRange(S, OpPC, Ptr, AK))
821 return false;
822 if (!CheckActive(S, OpPC, Ptr, AK))
823 return false;
824 if (!CheckLifetime(S, OpPC, Ptr.getLifetime(), AK))
825 return false;
826 if (!Ptr.isInitialized())
827 return DiagnoseUninitialized(S, OpPC, Ptr, AK);
828 if (!CheckTemporary(S, OpPC, Ptr.block(), AK))
829 return false;
830
831 if (!CheckMutable(S, OpPC, Ptr))
832 return false;
833 if (!CheckVolatile(S, OpPC, Ptr, AK))
834 return false;
835 return true;
836}
837
838/// This is not used by any of the opcodes directly. It's used by
839/// EvalEmitter to do the final lvalue-to-rvalue conversion.
840bool CheckFinalLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
841 assert(!Ptr.isZero());
842 if (!Ptr.isBlockPointer())
843 return false;
844
845 if (!Ptr.block()->isAccessible()) {
846 if (!CheckLive(S, OpPC, Ptr, AK_Read))
847 return false;
848 if (!CheckExtern(S, OpPC, Ptr))
849 return false;
850 if (!CheckDummy(S, OpPC, Ptr.block(), AK_Read))
851 return false;
852 return CheckWeak(S, OpPC, Ptr.block());
853 }
854
855 if (!CheckConstant(S, OpPC, Ptr))
856 return false;
857
858 if (!CheckActive(S, OpPC, Ptr, AK_Read))
859 return false;
860 if (!CheckLifetime(S, OpPC, Ptr.getLifetime(), AK_Read))
861 return false;
862 if (!Ptr.isInitialized())
863 return DiagnoseUninitialized(S, OpPC, Ptr, AK_Read);
864 if (!CheckTemporary(S, OpPC, Ptr.block(), AK_Read))
865 return false;
866 if (!CheckMutable(S, OpPC, Ptr))
867 return false;
868 return true;
869}
870
871bool CheckStore(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
872 if (!Ptr.isBlockPointer() || Ptr.isZero())
873 return false;
874
875 if (!Ptr.block()->isAccessible()) {
876 if (!CheckLive(S, OpPC, Ptr, AK_Assign))
877 return false;
878 if (!CheckExtern(S, OpPC, Ptr))
879 return false;
880 return CheckDummy(S, OpPC, Ptr.block(), AK_Assign);
881 }
882 if (!CheckLifetime(S, OpPC, Ptr.getLifetime(), AK_Assign))
883 return false;
884 if (!CheckRange(S, OpPC, Ptr, AK_Assign))
885 return false;
886 if (!CheckActive(S, OpPC, Ptr, AK_Assign))
887 return false;
888 if (!CheckGlobal(S, OpPC, Ptr))
889 return false;
890 if (!CheckConst(S, OpPC, Ptr))
891 return false;
892 if (!CheckVolatile(S, OpPC, Ptr, AK_Assign))
893 return false;
894 if (!S.inConstantContext() && isConstexprUnknown(Ptr))
895 return false;
896 return true;
897}
898
899static bool CheckInvoke(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
900 if (!CheckLive(S, OpPC, Ptr, AK_MemberCall))
901 return false;
902 if (!Ptr.isDummy()) {
903 if (!CheckExtern(S, OpPC, Ptr))
904 return false;
905 if (!CheckRange(S, OpPC, Ptr, AK_MemberCall))
906 return false;
907 }
908 return true;
909}
910
911bool CheckInit(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
912 if (!CheckLive(S, OpPC, Ptr, AK_Assign))
913 return false;
914 if (!CheckRange(S, OpPC, Ptr, AK_Assign))
915 return false;
916 return true;
917}
918
919static bool CheckCallable(InterpState &S, CodePtr OpPC, const Function *F) {
920
921 if (F->isVirtual() && !S.getLangOpts().CPlusPlus20) {
922 const SourceLocation &Loc = S.Current->getLocation(OpPC);
923 S.CCEDiag(Loc, diag::note_constexpr_virtual_call);
924 return false;
925 }
926
928 return false;
929
930 if (F->isValid() && F->hasBody() && F->isConstexpr())
931 return true;
932
933 // Implicitly constexpr.
934 if (F->isLambdaStaticInvoker())
935 return true;
936
937 // Bail out if the function declaration itself is invalid. We will
938 // have produced a relevant diagnostic while parsing it, so just
939 // note the problematic sub-expression.
940 if (F->getDecl()->isInvalidDecl())
941 return Invalid(S, OpPC);
942
943 // Diagnose failed assertions specially.
944 if (S.Current->getLocation(OpPC).isMacroID() &&
945 F->getDecl()->getIdentifier()) {
946 // FIXME: Instead of checking for an implementation-defined function,
947 // check and evaluate the assert() macro.
948 StringRef Name = F->getDecl()->getName();
949 bool AssertFailed =
950 Name == "__assert_rtn" || Name == "__assert_fail" || Name == "_wassert";
951 if (AssertFailed) {
952 S.FFDiag(S.Current->getLocation(OpPC),
953 diag::note_constexpr_assert_failed);
954 return false;
955 }
956 }
957
958 if (S.getLangOpts().CPlusPlus11) {
959 const FunctionDecl *DiagDecl = F->getDecl();
960
961 // Invalid decls have been diagnosed before.
962 if (DiagDecl->isInvalidDecl())
963 return false;
964
965 // If this function is not constexpr because it is an inherited
966 // non-constexpr constructor, diagnose that directly.
967 const auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl);
968 if (CD && CD->isInheritingConstructor()) {
969 const auto *Inherited = CD->getInheritedConstructor().getConstructor();
970 if (!Inherited->isConstexpr())
971 DiagDecl = CD = Inherited;
972 }
973
974 // Silently reject constructors of invalid classes. The invalid class
975 // has been rejected elsewhere before.
976 if (CD && CD->getParent()->isInvalidDecl())
977 return false;
978
979 // FIXME: If DiagDecl is an implicitly-declared special member function
980 // or an inheriting constructor, we should be much more explicit about why
981 // it's not constexpr.
982 if (CD && CD->isInheritingConstructor()) {
983 S.FFDiag(S.Current->getLocation(OpPC),
984 diag::note_constexpr_invalid_inhctor, 1)
985 << CD->getInheritedConstructor().getConstructor()->getParent();
986 S.Note(DiagDecl->getLocation(), diag::note_declared_at);
987 } else {
988 // Don't emit anything if the function isn't defined and we're checking
989 // for a constant expression. It might be defined at the point we're
990 // actually calling it.
991 bool IsExtern = DiagDecl->getStorageClass() == SC_Extern;
992 bool IsDefined = F->isDefined();
993 if (!IsDefined && !IsExtern && DiagDecl->isConstexpr() &&
995 return false;
996
997 // If the declaration is defined, declared 'constexpr' _and_ has a body,
998 // the below diagnostic doesn't add anything useful.
999 if (DiagDecl->isDefined() && DiagDecl->isConstexpr() &&
1000 DiagDecl->hasBody())
1001 return false;
1002
1003 S.FFDiag(S.Current->getLocation(OpPC),
1004 diag::note_constexpr_invalid_function, 1)
1005 << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
1006
1007 if (DiagDecl->getDefinition())
1008 S.Note(DiagDecl->getDefinition()->getLocation(),
1009 diag::note_declared_at);
1010 else
1011 S.Note(DiagDecl->getLocation(), diag::note_declared_at);
1012 }
1013 } else {
1014 S.FFDiag(S.Current->getLocation(OpPC),
1015 diag::note_invalid_subexpr_in_const_expr);
1016 }
1017
1018 return false;
1019}
1020
1021static bool CheckCallDepth(InterpState &S, CodePtr OpPC) {
1022 if ((S.Current->getDepth() + 1) > S.getLangOpts().ConstexprCallDepth) {
1023 S.FFDiag(S.Current->getSource(OpPC),
1024 diag::note_constexpr_depth_limit_exceeded)
1025 << S.getLangOpts().ConstexprCallDepth;
1026 return false;
1027 }
1028
1029 return true;
1030}
1031
1033 if (S.Current->hasThisPointer())
1034 return true;
1035
1036 const Expr *E = S.Current->getExpr(OpPC);
1037 if (S.getLangOpts().CPlusPlus11) {
1038 bool IsImplicit = false;
1039 if (const auto *TE = dyn_cast<CXXThisExpr>(E))
1040 IsImplicit = TE->isImplicit();
1041 S.FFDiag(E, diag::note_constexpr_this) << IsImplicit;
1042 } else {
1043 S.FFDiag(E);
1044 }
1045
1046 return false;
1047}
1048
1050 APFloat::opStatus Status, FPOptions FPO) {
1051 // [expr.pre]p4:
1052 // If during the evaluation of an expression, the result is not
1053 // mathematically defined [...], the behavior is undefined.
1054 // FIXME: C++ rules require us to not conform to IEEE 754 here.
1055 if (Result.isNan()) {
1056 const SourceInfo &E = S.Current->getSource(OpPC);
1057 S.CCEDiag(E, diag::note_constexpr_float_arithmetic)
1058 << /*NaN=*/true << S.Current->getRange(OpPC);
1059 return S.noteUndefinedBehavior();
1060 }
1061
1062 // In a constant context, assume that any dynamic rounding mode or FP
1063 // exception state matches the default floating-point environment.
1064 if (S.inConstantContext())
1065 return true;
1066
1067 if ((Status & APFloat::opInexact) &&
1068 FPO.getRoundingMode() == llvm::RoundingMode::Dynamic) {
1069 // Inexact result means that it depends on rounding mode. If the requested
1070 // mode is dynamic, the evaluation cannot be made in compile time.
1071 const SourceInfo &E = S.Current->getSource(OpPC);
1072 S.FFDiag(E, diag::note_constexpr_dynamic_rounding);
1073 return false;
1074 }
1075
1076 if ((Status != APFloat::opOK) &&
1077 (FPO.getRoundingMode() == llvm::RoundingMode::Dynamic ||
1079 FPO.getAllowFEnvAccess())) {
1080 const SourceInfo &E = S.Current->getSource(OpPC);
1081 S.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);
1082 return false;
1083 }
1084
1085 if ((Status & APFloat::opStatus::opInvalidOp) &&
1087 const SourceInfo &E = S.Current->getSource(OpPC);
1088 // There is no usefully definable result.
1089 S.FFDiag(E);
1090 return false;
1091 }
1092
1093 return true;
1094}
1095
1097 if (S.getLangOpts().CPlusPlus20)
1098 return true;
1099
1100 const SourceInfo &E = S.Current->getSource(OpPC);
1101 S.CCEDiag(E, diag::note_constexpr_new);
1102 return true;
1103}
1104
1106 DynamicAllocator::Form AllocForm,
1107 DynamicAllocator::Form DeleteForm, const Descriptor *D,
1108 const Expr *NewExpr) {
1109 if (AllocForm == DeleteForm)
1110 return true;
1111
1112 QualType TypeToDiagnose = D->getDataType(S.getASTContext());
1113
1114 const SourceInfo &E = S.Current->getSource(OpPC);
1115 S.FFDiag(E, diag::note_constexpr_new_delete_mismatch)
1116 << static_cast<int>(DeleteForm) << static_cast<int>(AllocForm)
1117 << TypeToDiagnose;
1118 S.Note(NewExpr->getExprLoc(), diag::note_constexpr_dynamic_alloc_here)
1119 << NewExpr->getSourceRange();
1120 return false;
1121}
1122
1123bool CheckDeleteSource(InterpState &S, CodePtr OpPC, const Expr *Source,
1124 const Pointer &Ptr) {
1125 // Regular new type(...) call.
1126 if (isa_and_nonnull<CXXNewExpr>(Source))
1127 return true;
1128 // operator new.
1129 if (const auto *CE = dyn_cast_if_present<CallExpr>(Source);
1130 CE && CE->getBuiltinCallee() == Builtin::BI__builtin_operator_new)
1131 return true;
1132 // std::allocator.allocate() call
1133 if (const auto *MCE = dyn_cast_if_present<CXXMemberCallExpr>(Source);
1134 MCE && MCE->getMethodDecl()->getIdentifier()->isStr("allocate"))
1135 return true;
1136
1137 // Whatever this is, we didn't heap allocate it.
1138 const SourceInfo &Loc = S.Current->getSource(OpPC);
1139 S.FFDiag(Loc, diag::note_constexpr_delete_not_heap_alloc)
1141
1142 if (Ptr.isTemporary())
1143 S.Note(Ptr.getDeclLoc(), diag::note_constexpr_temporary_here);
1144 else
1145 S.Note(Ptr.getDeclLoc(), diag::note_declared_at);
1146 return false;
1147}
1148
1149/// We aleady know the given DeclRefExpr is invalid for some reason,
1150/// now figure out why and print appropriate diagnostics.
1151bool CheckDeclRef(InterpState &S, CodePtr OpPC, const DeclRefExpr *DR) {
1152 const ValueDecl *D = DR->getDecl();
1153 return diagnoseUnknownDecl(S, OpPC, D);
1154}
1155
1156bool CheckDummy(InterpState &S, CodePtr OpPC, const Block *B, AccessKinds AK) {
1157 if (!B->isDummy())
1158 return true;
1159
1160 const ValueDecl *D = B->getDescriptor()->asValueDecl();
1161 if (!D)
1162 return false;
1163
1164 if (AK == AK_Read || AK == AK_Increment || AK == AK_Decrement)
1165 return diagnoseUnknownDecl(S, OpPC, D);
1166
1167 if (AK == AK_Destroy || S.getLangOpts().CPlusPlus14) {
1168 const SourceInfo &E = S.Current->getSource(OpPC);
1169 S.FFDiag(E, diag::note_constexpr_modify_global);
1170 }
1171 return false;
1172}
1173
1174static bool CheckNonNullArgs(InterpState &S, CodePtr OpPC, const Function *F,
1175 const CallExpr *CE, unsigned ArgSize) {
1176 auto Args = ArrayRef(CE->getArgs(), CE->getNumArgs());
1177 auto NonNullArgs = collectNonNullArgs(F->getDecl(), Args);
1178 unsigned Offset = 0;
1179 unsigned Index = 0;
1180 for (const Expr *Arg : Args) {
1181 if (NonNullArgs[Index] && Arg->getType()->isPointerType()) {
1182 const Pointer &ArgPtr = S.Stk.peek<Pointer>(ArgSize - Offset);
1183 if (ArgPtr.isZero()) {
1184 const SourceLocation &Loc = S.Current->getLocation(OpPC);
1185 S.CCEDiag(Loc, diag::note_non_null_attribute_failed);
1186 return false;
1187 }
1188 }
1189
1190 Offset += align(primSize(S.Ctx.classify(Arg).value_or(PT_Ptr)));
1191 ++Index;
1192 }
1193 return true;
1194}
1195
1197 const Pointer &BasePtr,
1198 const Descriptor *Desc) {
1199 assert(Desc->isRecord());
1200 const Record *R = Desc->ElemRecord;
1201 assert(R);
1202
1204 Pointer::pointToSameBlock(BasePtr, S.Current->getThis())) {
1205 const SourceInfo &Loc = S.Current->getSource(OpPC);
1206 S.FFDiag(Loc, diag::note_constexpr_double_destroy);
1207 return false;
1208 }
1209
1210 // Destructor of this record.
1211 const CXXDestructorDecl *Dtor = R->getDestructor();
1212 assert(Dtor);
1213 assert(!Dtor->isTrivial());
1214 const Function *DtorFunc = S.getContext().getOrCreateFunction(Dtor);
1215 if (!DtorFunc)
1216 return false;
1217
1218 S.Stk.push<Pointer>(BasePtr);
1219 return Call(S, OpPC, DtorFunc, 0);
1220}
1221
1222static bool RunDestructors(InterpState &S, CodePtr OpPC, const Block *B) {
1223 assert(B);
1224 const Descriptor *Desc = B->getDescriptor();
1225
1226 if (Desc->isPrimitive() || Desc->isPrimitiveArray())
1227 return true;
1228
1229 assert(Desc->isRecord() || Desc->isCompositeArray());
1230
1231 if (Desc->hasTrivialDtor())
1232 return true;
1233
1234 if (Desc->isCompositeArray()) {
1235 unsigned N = Desc->getNumElems();
1236 if (N == 0)
1237 return true;
1238 const Descriptor *ElemDesc = Desc->ElemDesc;
1239 assert(ElemDesc->isRecord());
1240
1241 Pointer RP(const_cast<Block *>(B));
1242 for (int I = static_cast<int>(N) - 1; I >= 0; --I) {
1243 if (!runRecordDestructor(S, OpPC, RP.atIndex(I).narrow(), ElemDesc))
1244 return false;
1245 }
1246 return true;
1247 }
1248
1249 assert(Desc->isRecord());
1250 return runRecordDestructor(S, OpPC, Pointer(const_cast<Block *>(B)), Desc);
1251}
1252
1254 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1255 if (const CXXDestructorDecl *DD = RD->getDestructor())
1256 return DD->isVirtual();
1257 return false;
1258}
1259
1260bool Free(InterpState &S, CodePtr OpPC, bool DeleteIsArrayForm,
1261 bool IsGlobalDelete) {
1262 if (!CheckDynamicMemoryAllocation(S, OpPC))
1263 return false;
1264
1265 DynamicAllocator &Allocator = S.getAllocator();
1266
1267 const Expr *Source = nullptr;
1268 const Block *BlockToDelete = nullptr;
1269 {
1270 // Extra scope for this so the block doesn't have this pointer
1271 // pointing to it when we destroy it.
1272 Pointer Ptr = S.Stk.pop<Pointer>();
1273
1274 // Deleteing nullptr is always fine.
1275 if (Ptr.isZero())
1276 return true;
1277
1278 // Remove base casts.
1279 QualType InitialType = Ptr.getType();
1280 while (Ptr.isBaseClass())
1281 Ptr = Ptr.getBase();
1282
1283 Source = Ptr.getDeclDesc()->asExpr();
1284 BlockToDelete = Ptr.block();
1285
1286 // Check that new[]/delete[] or new/delete were used, not a mixture.
1287 const Descriptor *BlockDesc = BlockToDelete->getDescriptor();
1288 if (std::optional<DynamicAllocator::Form> AllocForm =
1289 Allocator.getAllocationForm(Source)) {
1290 DynamicAllocator::Form DeleteForm =
1291 DeleteIsArrayForm ? DynamicAllocator::Form::Array
1293 if (!CheckNewDeleteForms(S, OpPC, *AllocForm, DeleteForm, BlockDesc,
1294 Source))
1295 return false;
1296 }
1297
1298 // For the non-array case, the types must match if the static type
1299 // does not have a virtual destructor.
1300 if (!DeleteIsArrayForm && Ptr.getType() != InitialType &&
1301 !hasVirtualDestructor(InitialType)) {
1302 S.FFDiag(S.Current->getSource(OpPC),
1303 diag::note_constexpr_delete_base_nonvirt_dtor)
1304 << InitialType << Ptr.getType();
1305 return false;
1306 }
1307
1308 if (!Ptr.isRoot() || (Ptr.isOnePastEnd() && !Ptr.isZeroSizeArray()) ||
1309 (Ptr.isArrayElement() && Ptr.getIndex() != 0)) {
1310 const SourceInfo &Loc = S.Current->getSource(OpPC);
1311 S.FFDiag(Loc, diag::note_constexpr_delete_subobject)
1312 << Ptr.toDiagnosticString(S.getASTContext()) << Ptr.isOnePastEnd();
1313 return false;
1314 }
1315
1316 if (!CheckDeleteSource(S, OpPC, Source, Ptr))
1317 return false;
1318
1319 // For a class type with a virtual destructor, the selected operator delete
1320 // is the one looked up when building the destructor.
1321 if (!DeleteIsArrayForm && !IsGlobalDelete) {
1322 QualType AllocType = Ptr.getType();
1323 auto getVirtualOperatorDelete = [](QualType T) -> const FunctionDecl * {
1324 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1325 if (const CXXDestructorDecl *DD = RD->getDestructor())
1326 return DD->isVirtual() ? DD->getOperatorDelete() : nullptr;
1327 return nullptr;
1328 };
1329
1330 if (const FunctionDecl *VirtualDelete =
1331 getVirtualOperatorDelete(AllocType);
1332 VirtualDelete &&
1333 !VirtualDelete
1335 S.FFDiag(S.Current->getSource(OpPC),
1336 diag::note_constexpr_new_non_replaceable)
1337 << isa<CXXMethodDecl>(VirtualDelete) << VirtualDelete;
1338 return false;
1339 }
1340 }
1341 }
1342 assert(Source);
1343 assert(BlockToDelete);
1344
1345 // Invoke destructors before deallocating the memory.
1346 if (!RunDestructors(S, OpPC, BlockToDelete))
1347 return false;
1348
1349 if (!Allocator.deallocate(Source, BlockToDelete, S)) {
1350 // Nothing has been deallocated, this must be a double-delete.
1351 const SourceInfo &Loc = S.Current->getSource(OpPC);
1352 S.FFDiag(Loc, diag::note_constexpr_double_delete);
1353 return false;
1354 }
1355
1356 return true;
1357}
1358
1360 const APSInt &Value) {
1362 return;
1363
1364 llvm::APInt Min;
1365 llvm::APInt Max;
1366 ED->getValueRange(Max, Min);
1367 --Max;
1368
1369 if (ED->getNumNegativeBits() &&
1370 (Max.slt(Value.getSExtValue()) || Min.sgt(Value.getSExtValue()))) {
1371 const SourceLocation &Loc = S.Current->getLocation(OpPC);
1372 S.CCEDiag(Loc, diag::note_constexpr_unscoped_enum_out_of_range)
1373 << llvm::toString(Value, 10) << Min.getSExtValue() << Max.getSExtValue()
1374 << ED;
1375 } else if (!ED->getNumNegativeBits() && Max.ult(Value.getZExtValue())) {
1376 const SourceLocation &Loc = S.Current->getLocation(OpPC);
1377 S.CCEDiag(Loc, diag::note_constexpr_unscoped_enum_out_of_range)
1378 << llvm::toString(Value, 10) << Min.getZExtValue() << Max.getZExtValue()
1379 << ED;
1380 }
1381}
1382
1384 assert(T);
1385 assert(!S.getLangOpts().CPlusPlus23);
1386
1387 // C++1y: A constant initializer for an object o [...] may also invoke
1388 // constexpr constructors for o and its subobjects even if those objects
1389 // are of non-literal class types.
1390 //
1391 // C++11 missed this detail for aggregates, so classes like this:
1392 // struct foo_t { union { int i; volatile int j; } u; };
1393 // are not (obviously) initializable like so:
1394 // __attribute__((__require_constant_initialization__))
1395 // static const foo_t x = {{0}};
1396 // because "i" is a subobject with non-literal initialization (due to the
1397 // volatile member of the union). See:
1398 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1677
1399 // Therefore, we use the C++1y behavior.
1400
1401 if (S.Current->getFunction() && S.Current->getFunction()->isConstructor() &&
1403 return true;
1404 }
1405
1406 const Expr *E = S.Current->getExpr(OpPC);
1407 if (S.getLangOpts().CPlusPlus11)
1408 S.FFDiag(E, diag::note_constexpr_nonliteral) << E->getType();
1409 else
1410 S.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
1411 return false;
1412}
1413
1414static bool getField(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
1415 uint32_t Off) {
1416 if (S.getLangOpts().CPlusPlus && S.inConstantContext() &&
1417 !CheckNull(S, OpPC, Ptr, CSK_Field))
1418 return false;
1419
1420 if (!CheckRange(S, OpPC, Ptr, CSK_Field))
1421 return false;
1422 if (!CheckArray(S, OpPC, Ptr))
1423 return false;
1424 if (!CheckSubobject(S, OpPC, Ptr, CSK_Field))
1425 return false;
1426
1427 if (Ptr.isIntegralPointer()) {
1428 S.Stk.push<Pointer>(Ptr.asIntPointer().atOffset(S.getASTContext(), Off));
1429 return true;
1430 }
1431
1432 if (!Ptr.isBlockPointer()) {
1433 // FIXME: The only time we (seem to) get here is when trying to access a
1434 // field of a typeid pointer. In that case, we're supposed to diagnose e.g.
1435 // `typeid(int).name`, but we currently diagnose `&typeid(int)`.
1436 S.FFDiag(S.Current->getSource(OpPC),
1437 diag::note_constexpr_access_unreadable_object)
1439 return false;
1440 }
1441
1442 if ((Ptr.getByteOffset() + Off) >= Ptr.block()->getSize())
1443 return false;
1444
1445 S.Stk.push<Pointer>(Ptr.atField(Off));
1446 return true;
1447}
1448
1449bool GetPtrField(InterpState &S, CodePtr OpPC, uint32_t Off) {
1450 const auto &Ptr = S.Stk.peek<Pointer>();
1451 return getField(S, OpPC, Ptr, Off);
1452}
1453
1454bool GetPtrFieldPop(InterpState &S, CodePtr OpPC, uint32_t Off) {
1455 const auto &Ptr = S.Stk.pop<Pointer>();
1456 return getField(S, OpPC, Ptr, Off);
1457}
1458
1459static bool checkConstructor(InterpState &S, CodePtr OpPC, const Function *Func,
1460 const Pointer &ThisPtr) {
1461 assert(Func->isConstructor());
1462
1463 if (Func->getParentDecl()->isInvalidDecl())
1464 return false;
1465
1466 const Descriptor *D = ThisPtr.getFieldDesc();
1467 // FIXME: I think this case is not 100% correct. E.g. a pointer into a
1468 // subobject of a composite array.
1469 if (!D->ElemRecord)
1470 return true;
1471
1472 if (D->ElemRecord->getNumVirtualBases() == 0)
1473 return true;
1474
1475 S.FFDiag(S.Current->getLocation(OpPC), diag::note_constexpr_virtual_base)
1476 << Func->getParentDecl();
1477 return false;
1478}
1479
1480bool CheckDestructor(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
1481 if (!CheckLive(S, OpPC, Ptr, AK_Destroy))
1482 return false;
1483 if (!CheckTemporary(S, OpPC, Ptr.block(), AK_Destroy))
1484 return false;
1485 if (!CheckRange(S, OpPC, Ptr, AK_Destroy))
1486 return false;
1487
1488 // Can't call a dtor on a global variable.
1489 if (Ptr.block()->isStatic()) {
1490 const SourceInfo &E = S.Current->getSource(OpPC);
1491 S.FFDiag(E, diag::note_constexpr_modify_global);
1492 return false;
1493 }
1494 return CheckActive(S, OpPC, Ptr, AK_Destroy);
1495}
1496
1497static void compileFunction(InterpState &S, const Function *Func) {
1498 const FunctionDecl *Definition = Func->getDecl()->getDefinition();
1499 if (!Definition)
1500 return;
1501
1503 .compileFunc(Definition, const_cast<Function *>(Func));
1504}
1505
1507 uint32_t VarArgSize) {
1508 if (Func->hasThisPointer()) {
1509 size_t ArgSize = Func->getArgSize() + VarArgSize;
1510 size_t ThisOffset = ArgSize - (Func->hasRVO() ? primSize(PT_Ptr) : 0);
1511 const Pointer &ThisPtr = S.Stk.peek<Pointer>(ThisOffset);
1512
1513 // If the current function is a lambda static invoker and
1514 // the function we're about to call is a lambda call operator,
1515 // skip the CheckInvoke, since the ThisPtr is a null pointer
1516 // anyway.
1517 if (!(S.Current->getFunction() &&
1519 Func->isLambdaCallOperator())) {
1520 if (!CheckInvoke(S, OpPC, ThisPtr))
1521 return false;
1522 }
1523
1525 return false;
1526 }
1527
1528 if (!Func->isFullyCompiled())
1530
1531 if (!CheckCallable(S, OpPC, Func))
1532 return false;
1533
1534 if (!CheckCallDepth(S, OpPC))
1535 return false;
1536
1537 auto NewFrame = std::make_unique<InterpFrame>(S, Func, OpPC, VarArgSize);
1538 InterpFrame *FrameBefore = S.Current;
1539 S.Current = NewFrame.get();
1540
1541 // Note that we cannot assert(CallResult.hasValue()) here since
1542 // Ret() above only sets the APValue if the curent frame doesn't
1543 // have a caller set.
1544 if (Interpret(S)) {
1545 NewFrame.release(); // Frame was delete'd already.
1546 assert(S.Current == FrameBefore);
1547 return true;
1548 }
1549
1550 // Interpreting the function failed somehow. Reset to
1551 // previous state.
1552 S.Current = FrameBefore;
1553 return false;
1554}
1555bool Call(InterpState &S, CodePtr OpPC, const Function *Func,
1556 uint32_t VarArgSize) {
1557 assert(Func);
1558 auto cleanup = [&]() -> bool {
1560 return false;
1561 };
1562
1563 if (Func->hasThisPointer()) {
1564 size_t ArgSize = Func->getArgSize() + VarArgSize;
1565 size_t ThisOffset = ArgSize - (Func->hasRVO() ? primSize(PT_Ptr) : 0);
1566
1567 const Pointer &ThisPtr = S.Stk.peek<Pointer>(ThisOffset);
1568
1569 // C++23 [expr.const]p5.6
1570 // an invocation of a virtual function ([class.virtual]) for an object whose
1571 // dynamic type is constexpr-unknown;
1572 if (ThisPtr.isDummy() && Func->isVirtual())
1573 return false;
1574
1575 // If the current function is a lambda static invoker and
1576 // the function we're about to call is a lambda call operator,
1577 // skip the CheckInvoke, since the ThisPtr is a null pointer
1578 // anyway.
1579 if (S.Current->getFunction() &&
1581 Func->isLambdaCallOperator()) {
1582 assert(ThisPtr.isZero());
1583 } else {
1584 if (!CheckInvoke(S, OpPC, ThisPtr))
1585 return cleanup();
1586 if (!Func->isConstructor() && !Func->isDestructor() &&
1587 !CheckActive(S, OpPC, ThisPtr, AK_MemberCall))
1588 return false;
1589 }
1590
1591 if (Func->isConstructor() && !checkConstructor(S, OpPC, Func, ThisPtr))
1592 return false;
1593 if (Func->isDestructor() && !CheckDestructor(S, OpPC, ThisPtr))
1594 return false;
1595
1596 if (Func->isConstructor() || Func->isDestructor())
1597 S.InitializingBlocks.push_back(ThisPtr.block());
1598 }
1599
1600 if (!Func->isFullyCompiled())
1602
1603 if (!CheckCallable(S, OpPC, Func))
1604 return cleanup();
1605
1606 // FIXME: The isConstructor() check here is not always right. The current
1607 // constant evaluator is somewhat inconsistent in when it allows a function
1608 // call when checking for a constant expression.
1609 if (Func->hasThisPointer() && S.checkingPotentialConstantExpression() &&
1610 !Func->isConstructor())
1611 return cleanup();
1612
1613 if (!CheckCallDepth(S, OpPC))
1614 return cleanup();
1615
1616 auto NewFrame = std::make_unique<InterpFrame>(S, Func, OpPC, VarArgSize);
1617 InterpFrame *FrameBefore = S.Current;
1618 S.Current = NewFrame.get();
1619
1620 InterpStateCCOverride CCOverride(S, Func->isImmediate());
1621 // Note that we cannot assert(CallResult.hasValue()) here since
1622 // Ret() above only sets the APValue if the curent frame doesn't
1623 // have a caller set.
1624 bool Success = Interpret(S);
1625 // Remove initializing block again.
1626 if (Func->isConstructor() || Func->isDestructor())
1627 S.InitializingBlocks.pop_back();
1628
1629 if (!Success) {
1630 // Interpreting the function failed somehow. Reset to
1631 // previous state.
1632 S.Current = FrameBefore;
1633 return false;
1634 }
1635
1636 NewFrame.release(); // Frame was delete'd already.
1637 assert(S.Current == FrameBefore);
1638 return true;
1639}
1640
1641static bool GetDynamicDecl(InterpState &S, CodePtr OpPC, Pointer TypePtr,
1642 const CXXRecordDecl *&DynamicDecl) {
1643 while (TypePtr.isBaseClass())
1644 TypePtr = TypePtr.getBase();
1645
1646 QualType DynamicType = TypePtr.getType();
1647 if (TypePtr.isStatic() || TypePtr.isConst()) {
1648 const VarDecl *VD = TypePtr.getDeclDesc()->asVarDecl();
1649 if (!VD->isConstexpr()) {
1650 const Expr *E = S.Current->getExpr(OpPC);
1651 APValue V = TypePtr.toAPValue(S.getASTContext());
1653 S.FFDiag(E, diag::note_constexpr_polymorphic_unknown_dynamic_type)
1654 << AccessKinds::AK_MemberCall << V.getAsString(S.getASTContext(), TT);
1655 return false;
1656 }
1657 }
1658
1659 if (DynamicType->isPointerType() || DynamicType->isReferenceType()) {
1660 DynamicDecl = DynamicType->getPointeeCXXRecordDecl();
1661 } else if (DynamicType->isArrayType()) {
1662 const Type *ElemType = DynamicType->getPointeeOrArrayElementType();
1663 assert(ElemType);
1664 DynamicDecl = ElemType->getAsCXXRecordDecl();
1665 } else {
1666 DynamicDecl = DynamicType->getAsCXXRecordDecl();
1667 }
1668 return true;
1669}
1670
1672 uint32_t VarArgSize) {
1673 assert(Func->hasThisPointer());
1674 assert(Func->isVirtual());
1675 size_t ArgSize = Func->getArgSize() + VarArgSize;
1676 size_t ThisOffset = ArgSize - (Func->hasRVO() ? primSize(PT_Ptr) : 0);
1677 Pointer &ThisPtr = S.Stk.peek<Pointer>(ThisOffset);
1678 const FunctionDecl *Callee = Func->getDecl();
1679
1680 if (!Func->isFullyCompiled())
1682
1683 // C++2a [class.abstract]p6:
1684 // the effect of making a virtual call to a pure virtual function [...] is
1685 // undefined
1686 if (Callee->isPureVirtual()) {
1687 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_pure_virtual_call,
1688 1)
1689 << Callee;
1690 S.Note(Callee->getLocation(), diag::note_declared_at);
1691 return false;
1692 }
1693
1694 const CXXRecordDecl *DynamicDecl = nullptr;
1695 if (!GetDynamicDecl(S, OpPC, ThisPtr, DynamicDecl))
1696 return false;
1697 assert(DynamicDecl);
1698
1699 const auto *StaticDecl = cast<CXXRecordDecl>(Func->getParentDecl());
1700 const auto *InitialFunction = cast<CXXMethodDecl>(Callee);
1701 const CXXMethodDecl *Overrider;
1702
1703 if (StaticDecl != DynamicDecl) {
1704 if (!DynamicDecl->isDerivedFrom(StaticDecl))
1705 return false;
1706 Overrider = S.getContext().getOverridingFunction(DynamicDecl, StaticDecl,
1707 InitialFunction);
1708
1709 } else {
1710 Overrider = InitialFunction;
1711 }
1712
1713 if (Overrider != InitialFunction) {
1714 // DR1872: An instantiated virtual constexpr function can't be called in a
1715 // constant expression (prior to C++20). We can still constant-fold such a
1716 // call.
1717 if (!S.getLangOpts().CPlusPlus20 && Overrider->isVirtual()) {
1718 const Expr *E = S.Current->getExpr(OpPC);
1719 S.CCEDiag(E, diag::note_constexpr_virtual_call) << E->getSourceRange();
1720 }
1721
1722 Func = S.getContext().getOrCreateFunction(Overrider);
1723
1724 const CXXRecordDecl *ThisFieldDecl =
1725 ThisPtr.getFieldDesc()->getType()->getAsCXXRecordDecl();
1726 if (Func->getParentDecl()->isDerivedFrom(ThisFieldDecl)) {
1727 // If the function we call is further DOWN the hierarchy than the
1728 // FieldDesc of our pointer, just go up the hierarchy of this field
1729 // the furthest we can go.
1730 while (ThisPtr.isBaseClass())
1731 ThisPtr = ThisPtr.getBase();
1732 }
1733 }
1734
1735 if (!Call(S, OpPC, Func, VarArgSize))
1736 return false;
1737
1738 // Covariant return types. The return type of Overrider is a pointer
1739 // or reference to a class type.
1740 if (Overrider != InitialFunction &&
1741 Overrider->getReturnType()->isPointerOrReferenceType() &&
1742 InitialFunction->getReturnType()->isPointerOrReferenceType()) {
1743 QualType OverriderPointeeType =
1744 Overrider->getReturnType()->getPointeeType();
1745 QualType InitialPointeeType =
1746 InitialFunction->getReturnType()->getPointeeType();
1747 // We've called Overrider above, but calling code expects us to return what
1748 // InitialFunction returned. According to the rules for covariant return
1749 // types, what InitialFunction returns needs to be a base class of what
1750 // Overrider returns. So, we need to do an upcast here.
1751 unsigned Offset = S.getContext().collectBaseOffset(
1752 InitialPointeeType->getAsRecordDecl(),
1753 OverriderPointeeType->getAsRecordDecl());
1754 return GetPtrBasePop(S, OpPC, Offset, /*IsNullOK=*/true);
1755 }
1756
1757 return true;
1758}
1759
1760bool CallBI(InterpState &S, CodePtr OpPC, const CallExpr *CE,
1761 uint32_t BuiltinID) {
1762 // A little arbitrary, but the current interpreter allows evaluation
1763 // of builtin functions in this mode, with some exceptions.
1764 if (BuiltinID == Builtin::BI__builtin_operator_new &&
1766 return false;
1767
1768 return InterpretBuiltin(S, OpPC, CE, BuiltinID);
1769}
1770
1771bool CallPtr(InterpState &S, CodePtr OpPC, uint32_t ArgSize,
1772 const CallExpr *CE) {
1773 const Pointer &Ptr = S.Stk.pop<Pointer>();
1774
1775 if (Ptr.isZero()) {
1776 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_null_callee)
1777 << const_cast<Expr *>(CE->getCallee()) << CE->getSourceRange();
1778 return false;
1779 }
1780
1781 if (!Ptr.isFunctionPointer())
1782 return Invalid(S, OpPC);
1783
1784 const FunctionPointer &FuncPtr = Ptr.asFunctionPointer();
1785 const Function *F = FuncPtr.getFunction();
1786 assert(F);
1787 // Don't allow calling block pointers.
1788 if (!F->getDecl())
1789 return Invalid(S, OpPC);
1790
1791 // This happens when the call expression has been cast to
1792 // something else, but we don't support that.
1793 if (S.Ctx.classify(F->getDecl()->getReturnType()) !=
1795 return false;
1796
1797 // Check argument nullability state.
1798 if (F->hasNonNullAttr()) {
1799 if (!CheckNonNullArgs(S, OpPC, F, CE, ArgSize))
1800 return false;
1801 }
1802
1803 // Can happen when casting function pointers around.
1804 QualType CalleeType = CE->getCallee()->getType();
1805 if (CalleeType->isPointerType() &&
1807 F->getDecl()->getType(), CalleeType->getPointeeType())) {
1808 return false;
1809 }
1810
1811 assert(ArgSize >= F->getWrittenArgSize());
1812 uint32_t VarArgSize = ArgSize - F->getWrittenArgSize();
1813
1814 // We need to do this explicitly here since we don't have the necessary
1815 // information to do it automatically.
1816 if (F->isThisPointerExplicit())
1817 VarArgSize -= align(primSize(PT_Ptr));
1818
1819 if (F->isVirtual())
1820 return CallVirt(S, OpPC, F, VarArgSize);
1821
1822 return Call(S, OpPC, F, VarArgSize);
1823}
1824
1825static void startLifetimeRecurse(const Pointer &Ptr) {
1826 if (const Record *R = Ptr.getRecord()) {
1827 Ptr.startLifetime();
1828 for (const Record::Field &Fi : R->fields())
1829 startLifetimeRecurse(Ptr.atField(Fi.Offset));
1830 return;
1831 }
1832
1833 if (const Descriptor *FieldDesc = Ptr.getFieldDesc();
1834 FieldDesc->isCompositeArray()) {
1835 assert(Ptr.getLifetime() == Lifetime::Started);
1836 for (unsigned I = 0; I != FieldDesc->getNumElems(); ++I)
1838 return;
1839 }
1840
1841 Ptr.startLifetime();
1842}
1843
1845 const auto &Ptr = S.Stk.peek<Pointer>();
1846 if (Ptr.isBlockPointer() && !CheckDummy(S, OpPC, Ptr.block(), AK_Destroy))
1847 return false;
1848 startLifetimeRecurse(Ptr.narrow());
1849 return true;
1850}
1851
1852// FIXME: It might be better to the recursing as part of the generated code for
1853// a destructor?
1854static void endLifetimeRecurse(const Pointer &Ptr) {
1855 if (const Record *R = Ptr.getRecord()) {
1856 Ptr.endLifetime();
1857 for (const Record::Field &Fi : R->fields())
1858 endLifetimeRecurse(Ptr.atField(Fi.Offset));
1859 return;
1860 }
1861
1862 if (const Descriptor *FieldDesc = Ptr.getFieldDesc();
1863 FieldDesc->isCompositeArray()) {
1864 // No endLifetime() for array roots.
1865 assert(Ptr.getLifetime() == Lifetime::Started);
1866 for (unsigned I = 0; I != FieldDesc->getNumElems(); ++I)
1868 return;
1869 }
1870
1871 Ptr.endLifetime();
1872}
1873
1874/// Ends the lifetime of the peek'd pointer.
1876 const auto &Ptr = S.Stk.peek<Pointer>();
1877 if (Ptr.isBlockPointer() && !CheckDummy(S, OpPC, Ptr.block(), AK_Destroy))
1878 return false;
1879
1880 // FIXME: We need per-element lifetime information for primitive arrays.
1881 if (Ptr.isArrayElement())
1882 return true;
1883
1884 endLifetimeRecurse(Ptr.narrow());
1885 return true;
1886}
1887
1888/// Ends the lifetime of the pop'd pointer.
1890 const auto &Ptr = S.Stk.pop<Pointer>();
1891 if (Ptr.isBlockPointer() && !CheckDummy(S, OpPC, Ptr.block(), AK_Destroy))
1892 return false;
1893
1894 // FIXME: We need per-element lifetime information for primitive arrays.
1895 if (Ptr.isArrayElement())
1896 return true;
1897
1898 endLifetimeRecurse(Ptr.narrow());
1899 return true;
1900}
1901
1903 std::optional<uint64_t> ArraySize) {
1904 const Pointer &Ptr = S.Stk.peek<Pointer>();
1905
1906 if (Ptr.inUnion() && Ptr.getBase().getRecord()->isUnion())
1907 Ptr.activate();
1908
1909 if (!Ptr.isBlockPointer())
1910 return false;
1911
1912 // Similar to CheckStore(), but with the additional CheckTemporary() call and
1913 // the AccessKinds are different.
1914
1915 if (!Ptr.block()->isAccessible()) {
1916 if (!CheckExtern(S, OpPC, Ptr))
1917 return false;
1918 if (!CheckLive(S, OpPC, Ptr, AK_Construct))
1919 return false;
1920 return CheckDummy(S, OpPC, Ptr.block(), AK_Construct);
1921 }
1922 if (!CheckTemporary(S, OpPC, Ptr.block(), AK_Construct))
1923 return false;
1924
1925 // CheckLifetime for this and all base pointers.
1926 for (Pointer P = Ptr;;) {
1927 if (!CheckLifetime(S, OpPC, P.getLifetime(), AK_Construct))
1928 return false;
1929
1930 if (P.isRoot())
1931 break;
1932 P = P.getBase();
1933 }
1934
1935 if (!CheckRange(S, OpPC, Ptr, AK_Construct))
1936 return false;
1937 if (!CheckGlobal(S, OpPC, Ptr))
1938 return false;
1939 if (!CheckConst(S, OpPC, Ptr))
1940 return false;
1941 if (!S.inConstantContext() && isConstexprUnknown(Ptr))
1942 return false;
1943
1944 if (!InvalidNewDeleteExpr(S, OpPC, E))
1945 return false;
1946
1947 const auto *NewExpr = cast<CXXNewExpr>(E);
1948 QualType StorageType = Ptr.getFieldDesc()->getDataType(S.getASTContext());
1949 const ASTContext &ASTCtx = S.getASTContext();
1950 QualType AllocType;
1951 if (ArraySize) {
1952 AllocType = ASTCtx.getConstantArrayType(
1953 NewExpr->getAllocatedType(),
1954 APInt(64, static_cast<uint64_t>(*ArraySize), false), nullptr,
1956 } else {
1957 AllocType = NewExpr->getAllocatedType();
1958 }
1959
1960 unsigned StorageSize = 1;
1961 unsigned AllocSize = 1;
1962 if (const auto *CAT = dyn_cast<ConstantArrayType>(AllocType))
1963 AllocSize = CAT->getZExtSize();
1964 if (const auto *CAT = dyn_cast<ConstantArrayType>(StorageType))
1965 StorageSize = CAT->getZExtSize();
1966
1967 if (AllocSize > StorageSize ||
1968 !ASTCtx.hasSimilarType(ASTCtx.getBaseElementType(AllocType),
1969 ASTCtx.getBaseElementType(StorageType))) {
1970 S.FFDiag(S.Current->getLocation(OpPC),
1971 diag::note_constexpr_placement_new_wrong_type)
1972 << StorageType << AllocType;
1973 return false;
1974 }
1975
1976 // Can't activate fields in a union, unless the direct base is the union.
1977 if (Ptr.inUnion() && !Ptr.isActive() && !Ptr.getBase().getRecord()->isUnion())
1978 return CheckActive(S, OpPC, Ptr, AK_Construct);
1979
1980 return true;
1981}
1982
1984 assert(E);
1985
1986 if (const auto *NewExpr = dyn_cast<CXXNewExpr>(E)) {
1987 const FunctionDecl *OperatorNew = NewExpr->getOperatorNew();
1988
1989 if (NewExpr->getNumPlacementArgs() > 0) {
1990 // This is allowed pre-C++26, but only an std function.
1991 if (S.getLangOpts().CPlusPlus26 || S.Current->isStdFunction())
1992 return true;
1993 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_new_placement)
1994 << /*C++26 feature*/ 1 << E->getSourceRange();
1995 } else if (
1996 !OperatorNew
1997 ->isUsableAsGlobalAllocationFunctionInConstantEvaluation()) {
1998 S.FFDiag(S.Current->getSource(OpPC),
1999 diag::note_constexpr_new_non_replaceable)
2000 << isa<CXXMethodDecl>(OperatorNew) << OperatorNew;
2001 return false;
2002 } else if (!S.getLangOpts().CPlusPlus26 &&
2003 NewExpr->getNumPlacementArgs() == 1 &&
2004 !OperatorNew->isReservedGlobalPlacementOperator()) {
2005 if (!S.getLangOpts().CPlusPlus26) {
2006 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_new_placement)
2007 << /*Unsupported*/ 0 << E->getSourceRange();
2008 return false;
2009 }
2010 return true;
2011 }
2012 } else {
2013 const auto *DeleteExpr = cast<CXXDeleteExpr>(E);
2014 const FunctionDecl *OperatorDelete = DeleteExpr->getOperatorDelete();
2015 if (!OperatorDelete
2016 ->isUsableAsGlobalAllocationFunctionInConstantEvaluation()) {
2017 S.FFDiag(S.Current->getSource(OpPC),
2018 diag::note_constexpr_new_non_replaceable)
2019 << isa<CXXMethodDecl>(OperatorDelete) << OperatorDelete;
2020 return false;
2021 }
2022 }
2023
2024 return false;
2025}
2026
2028 const FixedPoint &FP) {
2029 const Expr *E = S.Current->getExpr(OpPC);
2032 E->getExprLoc(), diag::warn_fixedpoint_constant_overflow)
2033 << FP.toDiagnosticString(S.getASTContext()) << E->getType();
2034 }
2035 S.CCEDiag(E, diag::note_constexpr_overflow)
2036 << FP.toDiagnosticString(S.getASTContext()) << E->getType();
2037 return S.noteUndefinedBehavior();
2038}
2039
2040bool InvalidShuffleVectorIndex(InterpState &S, CodePtr OpPC, uint32_t Index) {
2041 const SourceInfo &Loc = S.Current->getSource(OpPC);
2042 S.FFDiag(Loc,
2043 diag::err_shufflevector_minus_one_is_undefined_behavior_constexpr)
2044 << Index;
2045 return false;
2046}
2047
2049 const Pointer &Ptr, unsigned BitWidth) {
2050 if (Ptr.isDummy())
2051 return false;
2052 if (Ptr.isFunctionPointer())
2053 return true;
2054
2055 const SourceInfo &E = S.Current->getSource(OpPC);
2056 S.CCEDiag(E, diag::note_constexpr_invalid_cast)
2057 << 2 << S.getLangOpts().CPlusPlus << S.Current->getRange(OpPC);
2058
2059 if (Ptr.isBlockPointer() && !Ptr.isZero()) {
2060 // Only allow based lvalue casts if they are lossless.
2062 BitWidth)
2063 return Invalid(S, OpPC);
2064 }
2065 return true;
2066}
2067
2068bool CastPointerIntegralAP(InterpState &S, CodePtr OpPC, uint32_t BitWidth) {
2069 const Pointer &Ptr = S.Stk.pop<Pointer>();
2070
2071 if (!CheckPointerToIntegralCast(S, OpPC, Ptr, BitWidth))
2072 return false;
2073
2074 auto Result = S.allocAP<IntegralAP<false>>(BitWidth);
2075 Result.copy(APInt(BitWidth, Ptr.getIntegerRepresentation()));
2076
2078 return true;
2079}
2080
2081bool CastPointerIntegralAPS(InterpState &S, CodePtr OpPC, uint32_t BitWidth) {
2082 const Pointer &Ptr = S.Stk.pop<Pointer>();
2083
2084 if (!CheckPointerToIntegralCast(S, OpPC, Ptr, BitWidth))
2085 return false;
2086
2087 auto Result = S.allocAP<IntegralAP<true>>(BitWidth);
2088 Result.copy(APInt(BitWidth, Ptr.getIntegerRepresentation()));
2089
2091 return true;
2092}
2093
2094bool CheckBitCast(InterpState &S, CodePtr OpPC, bool HasIndeterminateBits,
2095 bool TargetIsUCharOrByte) {
2096 // This is always fine.
2097 if (!HasIndeterminateBits)
2098 return true;
2099
2100 // Indeterminate bits can only be bitcast to unsigned char or std::byte.
2101 if (TargetIsUCharOrByte)
2102 return true;
2103
2104 const Expr *E = S.Current->getExpr(OpPC);
2105 QualType ExprType = E->getType();
2106 S.FFDiag(E, diag::note_constexpr_bit_cast_indet_dest)
2107 << ExprType << S.getLangOpts().CharIsSigned << E->getSourceRange();
2108 return false;
2109}
2110
2111bool GetTypeid(InterpState &S, CodePtr OpPC, const Type *TypePtr,
2112 const Type *TypeInfoType) {
2113 S.Stk.push<Pointer>(TypePtr, TypeInfoType);
2114 return true;
2115}
2116
2117bool GetTypeidPtr(InterpState &S, CodePtr OpPC, const Type *TypeInfoType) {
2118 const auto &P = S.Stk.pop<Pointer>();
2119
2120 if (!P.isBlockPointer())
2121 return false;
2122
2123 // Pick the most-derived type.
2124 CanQualType T = P.getDeclPtr().getType()->getCanonicalTypeUnqualified();
2125 // ... unless we're currently constructing this object.
2126 // FIXME: We have a similar check to this in more places.
2127 if (S.Current->getFunction()) {
2128 for (const InterpFrame *Frame = S.Current; Frame; Frame = Frame->Caller) {
2129 if (const Function *Func = Frame->getFunction();
2130 Func && (Func->isConstructor() || Func->isDestructor()) &&
2131 P.block() == Frame->getThis().block()) {
2133 Func->getParentDecl());
2134 break;
2135 }
2136 }
2137 }
2138
2139 S.Stk.push<Pointer>(T->getTypePtr(), TypeInfoType);
2140 return true;
2141}
2142
2144 const auto *E = cast<CXXTypeidExpr>(S.Current->getExpr(OpPC));
2145 S.CCEDiag(E, diag::note_constexpr_typeid_polymorphic)
2146 << E->getExprOperand()->getType()
2147 << E->getExprOperand()->getSourceRange();
2148 return false;
2149}
2150
2152 const Pointer &RHS) {
2153 unsigned LHSOffset = LHS.isOnePastEnd() ? LHS.getNumElems() : LHS.getIndex();
2154 unsigned RHSOffset = RHS.isOnePastEnd() ? RHS.getNumElems() : RHS.getIndex();
2155 unsigned LHSLength = (LHS.getNumElems() - 1) * LHS.elemSize();
2156 unsigned RHSLength = (RHS.getNumElems() - 1) * RHS.elemSize();
2157
2158 StringRef LHSStr((const char *)LHS.atIndex(0).getRawAddress(), LHSLength);
2159 StringRef RHSStr((const char *)RHS.atIndex(0).getRawAddress(), RHSLength);
2160 int32_t IndexDiff = RHSOffset - LHSOffset;
2161 if (IndexDiff < 0) {
2162 if (static_cast<int32_t>(LHSLength) < -IndexDiff)
2163 return false;
2164 LHSStr = LHSStr.drop_front(-IndexDiff);
2165 } else {
2166 if (static_cast<int32_t>(RHSLength) < IndexDiff)
2167 return false;
2168 RHSStr = RHSStr.drop_front(IndexDiff);
2169 }
2170
2171 unsigned ShorterCharWidth;
2172 StringRef Shorter;
2173 StringRef Longer;
2174 if (LHSLength < RHSLength) {
2175 ShorterCharWidth = LHS.elemSize();
2176 Shorter = LHSStr;
2177 Longer = RHSStr;
2178 } else {
2179 ShorterCharWidth = RHS.elemSize();
2180 Shorter = RHSStr;
2181 Longer = LHSStr;
2182 }
2183
2184 // The null terminator isn't included in the string data, so check for it
2185 // manually. If the longer string doesn't have a null terminator where the
2186 // shorter string ends, they aren't potentially overlapping.
2187 for (unsigned NullByte : llvm::seq(ShorterCharWidth)) {
2188 if (Shorter.size() + NullByte >= Longer.size())
2189 break;
2190 if (Longer[Shorter.size() + NullByte])
2191 return false;
2192 }
2193 return Shorter == Longer.take_front(Shorter.size());
2194}
2195
2196static void copyPrimitiveMemory(InterpState &S, const Pointer &Ptr,
2197 PrimType T) {
2198
2199 if (T == PT_IntAPS) {
2200 auto &Val = Ptr.deref<IntegralAP<true>>();
2201 if (!Val.singleWord()) {
2202 uint64_t *NewMemory = new (S.P) uint64_t[Val.numWords()];
2203 Val.take(NewMemory);
2204 }
2205 } else if (T == PT_IntAP) {
2206 auto &Val = Ptr.deref<IntegralAP<false>>();
2207 if (!Val.singleWord()) {
2208 uint64_t *NewMemory = new (S.P) uint64_t[Val.numWords()];
2209 Val.take(NewMemory);
2210 }
2211 } else if (T == PT_Float) {
2212 auto &Val = Ptr.deref<Floating>();
2213 if (!Val.singleWord()) {
2214 uint64_t *NewMemory = new (S.P) uint64_t[Val.numWords()];
2215 Val.take(NewMemory);
2216 }
2217 }
2218}
2219
2220template <typename T>
2221static void copyPrimitiveMemory(InterpState &S, const Pointer &Ptr) {
2222 assert(needsAlloc<T>());
2223 auto &Val = Ptr.deref<T>();
2224 if (!Val.singleWord()) {
2225 uint64_t *NewMemory = new (S.P) uint64_t[Val.numWords()];
2226 Val.take(NewMemory);
2227 }
2228}
2229
2230static void finishGlobalRecurse(InterpState &S, const Pointer &Ptr) {
2231 if (const Record *R = Ptr.getRecord()) {
2232 for (const Record::Field &Fi : R->fields()) {
2233 if (Fi.Desc->isPrimitive()) {
2234 TYPE_SWITCH_ALLOC(Fi.Desc->getPrimType(), {
2235 copyPrimitiveMemory<T>(S, Ptr.atField(Fi.Offset));
2236 });
2237 copyPrimitiveMemory(S, Ptr.atField(Fi.Offset), Fi.Desc->getPrimType());
2238 } else
2239 finishGlobalRecurse(S, Ptr.atField(Fi.Offset));
2240 }
2241 return;
2242 }
2243
2244 if (const Descriptor *D = Ptr.getFieldDesc(); D && D->isArray()) {
2245 unsigned NumElems = D->getNumElems();
2246 if (NumElems == 0)
2247 return;
2248
2249 if (D->isPrimitiveArray()) {
2250 PrimType PT = D->getPrimType();
2251 if (!needsAlloc(PT))
2252 return;
2253 assert(NumElems >= 1);
2254 const Pointer EP = Ptr.atIndex(0);
2255 bool AllSingleWord = true;
2256 TYPE_SWITCH_ALLOC(PT, {
2257 if (!EP.deref<T>().singleWord()) {
2259 AllSingleWord = false;
2260 }
2261 });
2262 if (AllSingleWord)
2263 return;
2264 for (unsigned I = 1; I != D->getNumElems(); ++I) {
2265 const Pointer EP = Ptr.atIndex(I);
2266 copyPrimitiveMemory(S, EP, PT);
2267 }
2268 } else {
2269 assert(D->isCompositeArray());
2270 for (unsigned I = 0; I != D->getNumElems(); ++I) {
2271 const Pointer EP = Ptr.atIndex(I).narrow();
2272 finishGlobalRecurse(S, EP);
2273 }
2274 }
2275 }
2276}
2277
2279 const Pointer &Ptr = S.Stk.pop<Pointer>();
2280
2281 finishGlobalRecurse(S, Ptr);
2282 if (Ptr.canBeInitialized()) {
2283 Ptr.initialize();
2284 Ptr.activate();
2285 }
2286
2287 return true;
2288}
2289
2290// https://github.com/llvm/llvm-project/issues/102513
2291#if defined(_MSC_VER) && !defined(__clang__) && !defined(NDEBUG)
2292#pragma optimize("", off)
2293#endif
2295 // The current stack frame when we started Interpret().
2296 // This is being used by the ops to determine wheter
2297 // to return from this function and thus terminate
2298 // interpretation.
2299 const InterpFrame *StartFrame = S.Current;
2300 assert(!S.Current->isRoot());
2301 CodePtr PC = S.Current->getPC();
2302
2303 // Empty program.
2304 if (!PC)
2305 return true;
2306
2307 for (;;) {
2308 auto Op = PC.read<Opcode>();
2309 CodePtr OpPC = PC;
2310
2311 switch (Op) {
2312#define GET_INTERP
2313#include "Opcodes.inc"
2314#undef GET_INTERP
2315 }
2316 }
2317}
2318// https://github.com/llvm/llvm-project/issues/102513
2319#if defined(_MSC_VER) && !defined(__clang__) && !defined(NDEBUG)
2320#pragma optimize("", on)
2321#endif
2322
2323} // namespace interp
2324} // namespace clang
Defines the clang::ASTContext interface.
#define V(N, I)
Defines the clang::Expr interface and subclasses for C++ expressions.
static const FunctionDecl * getVirtualOperatorDelete(QualType T)
tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName="<stdin>")
Clean up any erroneous/redundant code in the given Ranges in Code.
static bool Jmp(InterpState &S, CodePtr &PC, int32_t Offset)
Definition Interp.cpp:39
static bool CheckTemporary(InterpState &S, CodePtr OpPC, const Block *B, AccessKinds AK)
Definition Interp.cpp:214
static bool BCP(InterpState &S, CodePtr &RealPC, int32_t Offset, PrimType PT)
Definition Interp.cpp:64
static bool CheckGlobal(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Definition Interp.cpp:240
static bool Jt(InterpState &S, CodePtr &PC, int32_t Offset)
Definition Interp.cpp:44
static void diagnoseNonConstVariable(InterpState &S, CodePtr OpPC, const ValueDecl *VD)
Definition Interp.cpp:177
static bool diagnoseUnknownDecl(InterpState &S, CodePtr OpPC, const ValueDecl *D)
Definition Interp.cpp:137
static bool Jf(InterpState &S, CodePtr &PC, int32_t Offset)
Definition Interp.cpp:51
static void diagnoseMissingInitializer(InterpState &S, CodePtr OpPC, const ValueDecl *VD)
Definition Interp.cpp:128
static bool RetValue(InterpState &S, CodePtr &Pt)
Definition Interp.cpp:31
static StringRef getIdentifier(const Token &Tok)
#define TYPE_SWITCH_ALLOC(Expr, B)
Definition PrimType.h:265
#define TYPE_SWITCH(Expr, B)
Definition PrimType.h:207
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition APValue.h:122
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition ASTContext.h:220
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U) const
Determine whether two function types are the same, ignoring exception specifications in cases where t...
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
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
Definition ASTContext.h:891
CanQualType getCanonicalTagType(const TagDecl *TD) const
Represents a C++ destructor within a class.
Definition DeclCXX.h:2869
Represents a static or instance method of a struct/union/class.
Definition DeclCXX.h:2129
bool isVirtual() const
Definition DeclCXX.h:2184
Represents a C++ struct/union/class.
Definition DeclCXX.h:258
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition Expr.h:2877
Expr * getCallee()
Definition Expr.h:3024
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition Expr.h:3068
Expr ** getArgs()
Retrieve the call arguments.
Definition Expr.h:3071
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
Definition Expr.cpp:1599
A reference to a declared variable, function, enum, etc.
Definition Expr.h:1270
ValueDecl * getDecl()
Definition Expr.h:1338
bool isInvalidDecl() const
Definition DeclBase.h:588
SourceLocation getLocation() const
Definition DeclBase.h:439
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition DeclBase.h:427
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Represents an enum.
Definition Decl.h:4007
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
Definition Decl.h:4208
void getValueRange(llvm::APInt &Max, llvm::APInt &Min) const
Calculates the [Min,Max) values the enum can store based on the NumPositiveBits and NumNegativeBits.
Definition Decl.cpp:5115
This represents one expression.
Definition Expr.h:112
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition Expr.cpp:273
QualType getType() const
Definition Expr.h:144
LangOptions::FPExceptionModeKind getExceptionMode() const
RoundingMode getRoundingMode() const
Represents a member of a struct/union/class.
Definition Decl.h:3160
Represents a function declaration or definition.
Definition Decl.h:2000
QualType getReturnType() const
Definition Decl.h:2845
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition Decl.h:2377
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition Decl.h:2888
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition Decl.h:2470
bool isUsableAsGlobalAllocationFunctionInConstantEvaluation(UnsignedOrNone *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions described in i...
Definition Decl.cpp:3414
FunctionDecl * getDefinition()
Get the definition for this declaration.
Definition Decl.h:2282
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Definition Decl.cpp:3191
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
Definition Decl.cpp:3238
@ FPE_Ignore
Assume that floating-point exceptions are masked.
This represents a decl that may have a name.
Definition Decl.h:274
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition Decl.h:295
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition Decl.h:301
A (possibly-)qualified type.
Definition TypeBase.h:937
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition TypeBase.h:8374
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition TypeBase.h:8363
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...
Definition Stmt.cpp:334
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition TargetInfo.h:486
The base class of the type hierarchy.
Definition TypeBase.h:1833
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition Type.h:26
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Definition Type.h:41
bool isPointerType() const
Definition TypeBase.h:8527
bool isReferenceType() const
Definition TypeBase.h:8551
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition Type.cpp:752
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition TypeBase.h:9001
bool isAnyComplexType() const
Definition TypeBase.h:8662
bool isPointerOrReferenceType() const
Definition TypeBase.h:8531
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition Decl.h:712
QualType getType() const
Definition Decl.h:723
Represents a variable declaration or definition.
Definition Decl.h:926
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition Decl.h:1569
A memory block, either on the stack or in the heap.
Definition InterpBlock.h:44
unsigned getSize() const
Returns the size of the block.
Definition InterpBlock.h:87
bool isExtern() const
Checks if the block is extern.
Definition InterpBlock.h:77
const Descriptor * getDescriptor() const
Returns the block's descriptor.
Definition InterpBlock.h:73
bool isStatic() const
Checks if the block has static storage duration.
Definition InterpBlock.h:79
bool isTemporary() const
Checks if the block is temporary.
Definition InterpBlock.h:81
std::byte * rawData()
Returns a pointer to the raw data, including metadata.
UnsignedOrNone getDeclID() const
Returns the declaration ID.
Definition InterpBlock.h:89
bool isDummy() const
Definition InterpBlock.h:84
unsigned getEvalID() const
The Evaluation ID this block was created in.
Definition InterpBlock.h:94
bool isWeak() const
Definition InterpBlock.h:82
bool isAccessible() const
Pointer into the code segment.
Definition Source.h:30
std::enable_if_t<!std::is_pointer< T >::value, T > read()
Reads data and advances the pointer.
Definition Source.h:56
Compilation context for expressions.
Definition Compiler.h:110
unsigned collectBaseOffset(const RecordDecl *BaseDecl, const RecordDecl *DerivedDecl) const
Definition Context.cpp:635
const Function * getOrCreateFunction(const FunctionDecl *FuncDecl)
Definition Context.cpp:497
ASTContext & getASTContext() const
Returns the AST context.
Definition Context.h:79
OptPrimType classify(QualType T) const
Classifies a type.
Definition Context.cpp:360
const CXXMethodDecl * getOverridingFunction(const CXXRecordDecl *DynamicDecl, const CXXRecordDecl *StaticDecl, const CXXMethodDecl *InitialFunction) const
Definition Context.cpp:461
unsigned getEvalID() const
Definition Context.h:145
Manages dynamic memory allocations done during bytecode interpretation.
bool deallocate(const Expr *Source, const Block *BlockToDelete, InterpState &S)
Deallocate the given source+block combination.
std::optional< Form > getAllocationForm(const Expr *Source) const
Checks whether the allocation done at the given source is an array allocation.
Wrapper around fixed point types.
Definition FixedPoint.h:23
std::string toDiagnosticString(const ASTContext &Ctx) const
Definition FixedPoint.h:81
If a Floating is constructed from Memory, it DOES NOT OWN THAT MEMORY.
Definition Floating.h:35
Base class for stack frames, shared between VM and walker.
Definition Frame.h:25
const Function * getFunction() const
Bytecode function.
Definition Function.h:86
bool isDestructor() const
Checks if the function is a destructor.
Definition Function.h:164
bool isVirtual() const
Checks if the function is virtual.
Definition Function.h:157
bool isDefined() const
Checks if the function is defined.
Definition Function.h:199
bool hasNonNullAttr() const
Definition Function.h:131
bool isConstructor() const
Checks if the function is a constructor.
Definition Function.h:162
const FunctionDecl * getDecl() const
Returns the original FunctionDecl.
Definition Function.h:109
bool hasBody() const
Checks if the function already has a body attached.
Definition Function.h:196
bool isConstexpr() const
Definition Function.h:159
bool isThisPointerExplicit() const
Definition Function.h:215
unsigned getWrittenArgSize() const
Definition Function.h:211
bool isLambdaStaticInvoker() const
Returns whether this function is a lambda static invoker, which we generate custom byte code for.
Definition Function.h:172
bool isValid() const
Checks if the function is valid to call.
Definition Function.h:154
If an IntegralAP is constructed from Memory, it DOES NOT OWN THAT MEMORY.
Definition IntegralAP.h:36
Wrapper around numeric types.
Definition Integral.h:66
static Integral from(ValT Value)
Definition Integral.h:206
Frame storing local variables.
Definition InterpFrame.h:27
const Expr * getExpr(CodePtr PC) const
InterpFrame * Caller
The frame of the previous function.
Definition InterpFrame.h:30
SourceInfo getSource(CodePtr PC) const
Map a location to a source.
CodePtr getRetPC() const
Returns the return address of the frame.
CodePtr getPC() const
Returns the PC of the frame's code start.
SourceLocation getLocation(CodePtr PC) const
const Pointer & getThis() const
Returns the 'this' pointer.
const Function * getFunction() const
Returns the current function.
Definition InterpFrame.h:72
SourceRange getRange(CodePtr PC) const
bool isRoot() const
Checks if the frame is a root frame - return should quit the interpreter.
unsigned getDepth() const
void clearTo(size_t NewSize)
T pop()
Returns the value from the top of the stack and removes it.
Definition InterpStack.h:39
void push(Tys &&...Args)
Constructs a value in place on the top of the stack.
Definition InterpStack.h:33
size_t size() const
Returns the size of the stack in bytes.
Definition InterpStack.h:77
void discard()
Discards the top value from the stack.
Definition InterpStack.h:50
T & peek() const
Returns a reference to the value on the top of the stack.
Definition InterpStack.h:62
Interpreter context.
Definition InterpState.h:43
Context & getContext() const
bool noteUndefinedBehavior() override
Definition InterpState.h:82
DynamicAllocator & getAllocator()
Context & Ctx
Interpreter Context.
llvm::SmallVector< const Block * > InitializingBlocks
List of blocks we're currently running either constructors or destructors for.
ASTContext & getASTContext() const override
Definition InterpState.h:70
InterpStack & Stk
Temporary stack.
const VarDecl * EvaluatingDecl
Declaration we're initializing/evaluting, if any.
InterpFrame * Current
The current frame.
T allocAP(unsigned BitWidth)
const LangOptions & getLangOpts() const
Definition InterpState.h:71
Program & P
Reference to the module containing all bytecode.
PrimType value_or(PrimType PT) const
Definition PrimType.h:68
A pointer to a memory block, live or dead.
Definition Pointer.h:91
Pointer narrow() const
Restricts the scope of an array element pointer.
Definition Pointer.h:188
UnsignedOrNone getDeclID() const
Returns the declaration ID.
Definition Pointer.h:576
bool isVolatile() const
Checks if an object or a subfield is volatile.
Definition Pointer.h:569
bool isInitialized() const
Checks if an object was initialized.
Definition Pointer.cpp:440
bool isStatic() const
Checks if the storage is static.
Definition Pointer.h:494
bool isDynamic() const
Checks if the storage has been dynamically allocated.
Definition Pointer.h:509
bool inUnion() const
Definition Pointer.h:402
bool isZeroSizeArray() const
Checks if the pointer is pointing to a zero-size array.
Definition Pointer.h:654
Pointer atIndex(uint64_t Idx) const
Offsets a pointer inside an array.
Definition Pointer.h:156
bool isDummy() const
Checks if the pointer points to a dummy value.
Definition Pointer.h:547
bool isExtern() const
Checks if the storage is extern.
Definition Pointer.h:488
int64_t getIndex() const
Returns the index into an array.
Definition Pointer.h:612
bool isActive() const
Checks if the object is active.
Definition Pointer.h:536
bool isConst() const
Checks if an object or a subfield is mutable.
Definition Pointer.h:557
Pointer atField(unsigned Off) const
Creates a pointer to a field.
Definition Pointer.h:173
T & deref() const
Dereferences the pointer, if it's live.
Definition Pointer.h:663
bool isMutable() const
Checks if the field is mutable.
Definition Pointer.h:520
bool isConstInMutable() const
Definition Pointer.h:562
unsigned getNumElems() const
Returns the number of elements.
Definition Pointer.h:596
bool isUnknownSizeArray() const
Checks if the structure is an array of unknown size.
Definition Pointer.h:415
void activate() const
Activats a field.
Definition Pointer.cpp:576
bool isIntegralPointer() const
Definition Pointer.h:469
QualType getType() const
Returns the type of the innermost field.
Definition Pointer.h:336
bool isArrayElement() const
Checks if the pointer points to an array.
Definition Pointer.h:421
bool isLive() const
Checks if the pointer is live.
Definition Pointer.h:268
Pointer getBase() const
Returns a pointer to the object of which this pointer is a field.
Definition Pointer.h:307
uint64_t getByteOffset() const
Returns the byte offset from the start.
Definition Pointer.h:585
bool isTypeidPointer() const
Definition Pointer.h:471
std::string toDiagnosticString(const ASTContext &Ctx) const
Converts the pointer to a string usable in diagnostics.
Definition Pointer.cpp:427
bool isZero() const
Checks if the pointer is null.
Definition Pointer.h:254
const IntPointer & asIntPointer() const
Definition Pointer.h:455
bool isRoot() const
Pointer points directly to a block.
Definition Pointer.h:437
const Descriptor * getDeclDesc() const
Accessor for information about the declaration site.
Definition Pointer.h:282
static bool pointToSameBlock(const Pointer &A, const Pointer &B)
Checks if both given pointers point to the same block.
Definition Pointer.cpp:652
APValue toAPValue(const ASTContext &ASTCtx) const
Converts the pointer to an APValue.
Definition Pointer.cpp:171
void endLifetime() const
Definition Pointer.h:732
bool isOnePastEnd() const
Checks if the index is one past end.
Definition Pointer.h:629
uint64_t getIntegerRepresentation() const
Definition Pointer.h:143
const FieldDecl * getField() const
Returns the field information.
Definition Pointer.h:481
bool isElementPastEnd() const
Checks if the pointer is an out-of-bounds element pointer.
Definition Pointer.h:651
void startLifetime() const
Definition Pointer.h:740
bool isBlockPointer() const
Definition Pointer.h:468
bool isTemporary() const
Checks if the storage is temporary.
Definition Pointer.h:501
const FunctionPointer & asFunctionPointer() const
Definition Pointer.h:459
SourceLocation getDeclLoc() const
Definition Pointer.h:292
const Block * block() const
Definition Pointer.h:602
bool isFunctionPointer() const
Definition Pointer.h:470
Pointer getDeclPtr() const
Definition Pointer.h:355
const Descriptor * getFieldDesc() const
Accessors for information about the innermost field.
Definition Pointer.h:326
bool isBaseClass() const
Checks if a structure is a base class.
Definition Pointer.h:542
size_t elemSize() const
Returns the element size of the innermost field.
Definition Pointer.h:358
bool canBeInitialized() const
If this pointer has an InlineDescriptor we can use to initialize.
Definition Pointer.h:444
Lifetime getLifetime() const
Definition Pointer.h:724
void initialize() const
Initializes a field.
Definition Pointer.cpp:493
const std::byte * getRawAddress() const
If backed by actual data (i.e.
Definition Pointer.h:606
bool isField() const
Checks if the item is a field in an object.
Definition Pointer.h:274
const Record * getRecord() const
Returns the record descriptor of a class.
Definition Pointer.h:474
UnsignedOrNone getCurrentDecl() const
Returns the current declaration ID.
Definition Program.h:159
Structure/Class descriptor.
Definition Record.h:25
bool isUnion() const
Checks if the record is a union.
Definition Record.h:57
const CXXDestructorDecl * getDestructor() const
Returns the destructor of the record, if any.
Definition Record.h:73
unsigned getNumVirtualBases() const
Definition Record.h:107
llvm::iterator_range< const_field_iter > fields() const
Definition Record.h:84
Describes the statement/declaration an opcode was generated from.
Definition Source.h:73
bool checkingForUndefinedBehavior() const
Are we checking an expression for overflow?
Definition State.h:103
OptionalDiagnostic Note(SourceLocation Loc, diag::kind DiagId)
Add a note to a prior diagnostic.
Definition State.cpp:63
OptionalDiagnostic FFDiag(SourceLocation Loc, diag::kind DiagId=diag::note_invalid_subexpr_in_const_expr, unsigned ExtraNotes=0)
Diagnose that the evaluation could not be folded (FF => FoldFailure)
Definition State.cpp:21
OptionalDiagnostic CCEDiag(SourceLocation Loc, diag::kind DiagId=diag::note_invalid_subexpr_in_const_expr, unsigned ExtraNotes=0)
Diagnose that the evaluation does not produce a C++11 core constant expression.
Definition State.cpp:42
bool checkingPotentialConstantExpression() const
Are we checking whether the expression is a potential constant expression?
Definition State.h:99
Defines the clang::TargetInfo interface.
bool arePotentiallyOverlappingStringLiterals(const Pointer &LHS, const Pointer &RHS)
Definition Interp.cpp:2151
bool GetPtrFieldPop(InterpState &S, CodePtr OpPC, uint32_t Off)
Definition Interp.cpp:1454
static bool CheckCallDepth(InterpState &S, CodePtr OpPC)
Definition Interp.cpp:1021
static void startLifetimeRecurse(const Pointer &Ptr)
Definition Interp.cpp:1825
bool CastPointerIntegralAPS(InterpState &S, CodePtr OpPC, uint32_t BitWidth)
Definition Interp.cpp:2081
static bool CheckLifetime(InterpState &S, CodePtr OpPC, Lifetime LT, AccessKinds AK)
Definition Interp.cpp:709
static bool CheckVolatile(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)
Definition Interp.cpp:619
bool CastPointerIntegralAP(InterpState &S, CodePtr OpPC, uint32_t BitWidth)
Definition Interp.cpp:2068
bool CheckInit(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Checks if a value can be initialized.
Definition Interp.cpp:911
bool EndLifetimePop(InterpState &S, CodePtr OpPC)
Ends the lifetime of the pop'd pointer.
Definition Interp.cpp:1889
static bool CheckCallable(InterpState &S, CodePtr OpPC, const Function *F)
Definition Interp.cpp:919
static bool runRecordDestructor(InterpState &S, CodePtr OpPC, const Pointer &BasePtr, const Descriptor *Desc)
Definition Interp.cpp:1196
bool GetTypeidPtr(InterpState &S, CodePtr OpPC, const Type *TypeInfoType)
Definition Interp.cpp:2117
bool LT(InterpState &S, CodePtr OpPC)
Definition Interp.h:1267
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.
Definition Interp.cpp:552
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.
Definition Interp.cpp:1105
bool CheckGlobalLoad(InterpState &S, CodePtr OpPC, const Block *B)
Checks a direct load of a primitive value from a global or local variable.
Definition Interp.cpp:738
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...
Definition Interp.cpp:1151
bool EndLifetime(InterpState &S, CodePtr OpPC)
Ends the lifetime of the peek'd pointer.
Definition Interp.cpp:1875
bool GetTypeid(InterpState &S, CodePtr OpPC, const Type *TypePtr, const Type *TypeInfoType)
Typeid support.
Definition Interp.cpp:2111
static bool CheckWeak(InterpState &S, CodePtr OpPC, const Block *B)
Definition Interp.cpp:721
bool CheckConstant(InterpState &S, CodePtr OpPC, const Descriptor *Desc)
Checks if the Descriptor is of a constexpr or const global variable.
Definition Interp.cpp:448
bool CheckPointerToIntegralCast(InterpState &S, CodePtr OpPC, const Pointer &Ptr, unsigned BitWidth)
Definition Interp.cpp:2048
static bool RunDestructors(InterpState &S, CodePtr OpPC, const Block *B)
Definition Interp.cpp:1222
bool GetPtrField(InterpState &S, CodePtr OpPC, uint32_t Off)
1) Peeks a Pointer 2) Pushes Pointer.atField(Off) on the stack
Definition Interp.cpp:1449
static bool CheckNonNullArgs(InterpState &S, CodePtr OpPC, const Function *F, const CallExpr *CE, unsigned ArgSize)
Definition Interp.cpp:1174
bool CheckMutable(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Checks if a pointer points to a mutable field.
Definition Interp.cpp:594
static void finishGlobalRecurse(InterpState &S, const Pointer &Ptr)
Definition Interp.cpp:2230
bool CheckSubobject(InterpState &S, CodePtr OpPC, const Pointer &Ptr, CheckSubobjectKind CSK)
Checks if Ptr is a one-past-the-end pointer.
Definition Interp.cpp:541
bool handleFixedPointOverflow(InterpState &S, CodePtr OpPC, const FixedPoint &FP)
Definition Interp.cpp:2027
static bool getField(InterpState &S, CodePtr OpPC, const Pointer &Ptr, uint32_t Off)
Definition Interp.cpp:1414
static bool hasVirtualDestructor(QualType T)
Definition Interp.cpp:1253
bool CheckLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)
Checks if a value can be loaded from a block.
Definition Interp.cpp:793
constexpr size_t align(size_t Size)
Aligns a size to the pointer alignment.
Definition PrimType.h:185
bool CheckBCPResult(InterpState &S, const Pointer &Ptr)
Definition Interp.cpp:308
bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)
Checks if a pointer is in range.
Definition Interp.cpp:519
bool CheckDynamicMemoryAllocation(InterpState &S, CodePtr OpPC)
Checks if dynamic memory allocation is available in the current language mode.
Definition Interp.cpp:1096
bool CheckLive(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)
Checks if a pointer is live and accessible.
Definition Interp.cpp:414
bool DiagTypeid(InterpState &S, CodePtr OpPC)
Definition Interp.cpp:2143
bool CheckFinalLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
This is not used by any of the opcodes directly.
Definition Interp.cpp:840
bool CheckBitCast(InterpState &S, CodePtr OpPC, bool HasIndeterminateBits, bool TargetIsUCharOrByte)
Definition Interp.cpp:2094
static void popArg(InterpState &S, const Expr *Arg)
Definition Interp.cpp:256
static bool checkConstructor(InterpState &S, CodePtr OpPC, const Function *Func, const Pointer &ThisPtr)
Definition Interp.cpp:1459
llvm::APInt APInt
Definition FixedPoint.h:19
void diagnoseEnumValue(InterpState &S, CodePtr OpPC, const EnumDecl *ED, const APSInt &Value)
Definition Interp.cpp:1359
bool StartLifetime(InterpState &S, CodePtr OpPC)
Definition Interp.cpp:1844
bool CheckStore(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Checks if a value can be stored in a block.
Definition Interp.cpp:871
bool CheckNull(InterpState &S, CodePtr OpPC, const Pointer &Ptr, CheckSubobjectKind CSK)
Checks if a pointer is null.
Definition Interp.cpp:508
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.
Definition Interp.cpp:1123
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.
Definition Interp.cpp:1049
PrimType
Enumeration of the primitive types of the VM.
Definition PrimType.h:34
static bool GetDynamicDecl(InterpState &S, CodePtr OpPC, Pointer TypePtr, const CXXRecordDecl *&DynamicDecl)
Definition Interp.cpp:1641
bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const CallExpr *Call, uint32_t BuiltinID)
Interpret a builtin function.
bool CallVar(InterpState &S, CodePtr OpPC, const Function *Func, uint32_t VarArgSize)
Definition Interp.cpp:1506
constexpr bool needsAlloc()
Definition PrimType.h:125
bool InvalidShuffleVectorIndex(InterpState &S, CodePtr OpPC, uint32_t Index)
Definition Interp.cpp:2040
bool CheckDummy(InterpState &S, CodePtr OpPC, const Block *B, AccessKinds AK)
Checks if a pointer is a dummy pointer.
Definition Interp.cpp:1156
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.
Definition Interp.cpp:1902
bool CheckLiteralType(InterpState &S, CodePtr OpPC, const Type *T)
Definition Interp.cpp:1383
bool CheckArray(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Checks if the array is offsetable.
Definition Interp.cpp:406
static void compileFunction(InterpState &S, const Function *Func)
Definition Interp.cpp:1497
bool CheckThis(InterpState &S, CodePtr OpPC)
Checks the 'this' pointer.
Definition Interp.cpp:1032
bool FinishInitGlobal(InterpState &S, CodePtr OpPC)
Definition Interp.cpp:2278
bool CheckActive(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)
Definition Interp.cpp:328
void cleanupAfterFunctionCall(InterpState &S, CodePtr OpPC, const Function *Func)
Definition Interp.cpp:261
static void copyPrimitiveMemory(InterpState &S, const Pointer &Ptr, PrimType T)
Definition Interp.cpp:2196
size_t primSize(PrimType Type)
Returns the size of a primitive type in bytes.
Definition PrimType.cpp:23
bool Free(InterpState &S, CodePtr OpPC, bool DeleteIsArrayForm, bool IsGlobalDelete)
Definition Interp.cpp:1260
bool InvalidNewDeleteExpr(InterpState &S, CodePtr OpPC, const Expr *E)
Definition Interp.cpp:1983
bool CallBI(InterpState &S, CodePtr OpPC, const CallExpr *CE, uint32_t BuiltinID)
Definition Interp.cpp:1760
bool CheckLocalLoad(InterpState &S, CodePtr OpPC, const Block *B)
Definition Interp.cpp:771
static bool CheckInvoke(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Definition Interp.cpp:899
bool CheckExtern(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Checks if the variable has externally defined storage.
Definition Interp.cpp:389
bool isConstexprUnknown(const Pointer &P)
Definition Interp.cpp:298
bool GetPtrBasePop(InterpState &S, CodePtr OpPC, uint32_t Off, bool NullOK)
Definition Interp.h:1814
bool DiagnoseUninitialized(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK)
Definition Interp.cpp:662
llvm::BitVector collectNonNullArgs(const FunctionDecl *F, ArrayRef< const Expr * > Args)
bool CallPtr(InterpState &S, CodePtr OpPC, uint32_t ArgSize, const CallExpr *CE)
Definition Interp.cpp:1771
bool CallVirt(InterpState &S, CodePtr OpPC, const Function *Func, uint32_t VarArgSize)
Definition Interp.cpp:1671
static void endLifetimeRecurse(const Pointer &Ptr)
Definition Interp.cpp:1854
bool CheckConst(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Checks if a pointer points to const storage.
Definition Interp.cpp:572
bool Interpret(InterpState &S)
Interpreter entry point.
Definition Interp.cpp:2294
llvm::APSInt APSInt
Definition FixedPoint.h:20
bool CheckDestructor(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Definition Interp.cpp:1480
The JSON file list parser is used to communicate input to InstallAPI.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
bool isa(CodeGen::Address addr)
Definition Address.h:330
@ Success
Annotation was successful.
Definition Parser.h:65
@ SC_Extern
Definition Specifiers.h:251
CheckSubobjectKind
The order of this enum is important for diagnostics.
Definition State.h:42
@ CSK_Field
Definition State.h:45
@ Result
The result type of a method or function.
Definition TypeBase.h:905
AccessKinds
Kinds of access we can perform on an object, for diagnostics.
Definition State.h:26
@ AK_Construct
Definition State.h:35
@ AK_Increment
Definition State.h:30
@ AK_Read
Definition State.h:27
@ AK_Assign
Definition State.h:29
@ AK_MemberCall
Definition State.h:32
@ AK_Destroy
Definition State.h:36
@ AK_Decrement
Definition State.h:31
const FunctionProtoType * T
U cast(CodeGen::Address addr)
Definition Address.h:327
Describes a memory block created by an allocation site.
Definition Descriptor.h:122
unsigned getNumElems() const
Returns the number of elements stored in the block.
Definition Descriptor.h:249
bool isPrimitive() const
Checks if the descriptor is of a primitive.
Definition Descriptor.h:263
bool hasTrivialDtor() const
Whether variables of this descriptor need their destructor called or not.
bool isCompositeArray() const
Checks if the descriptor is of an array of composites.
Definition Descriptor.h:256
const ValueDecl * asValueDecl() const
Definition Descriptor.h:214
QualType getType() const
const Decl * asDecl() const
Definition Descriptor.h:210
const Descriptor *const ElemDesc
Descriptor of the array element.
Definition Descriptor.h:155
unsigned getMetadataSize() const
Returns the size of the metadata.
Definition Descriptor.h:246
SourceLocation getLocation() const
QualType getDataType(const ASTContext &Ctx) const
bool isPrimitiveArray() const
Checks if the descriptor is of an array of primitives.
Definition Descriptor.h:254
const VarDecl * asVarDecl() const
Definition Descriptor.h:218
bool isRecord() const
Checks if the descriptor is of a record.
Definition Descriptor.h:268
const Record *const ElemRecord
Pointer to the record, if block contains records.
Definition Descriptor.h:153
const Expr * asExpr() const
Definition Descriptor.h:211
bool isArray() const
Checks if the descriptor is of an array.
Definition Descriptor.h:266
Descriptor used for global variables.
Definition Descriptor.h:51
Inline descriptor embedded in structures and arrays.
Definition Descriptor.h:67