Thanks to visit codestin.com
Credit goes to clang.llvm.org

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
1642 uint32_t VarArgSize) {
1643 assert(Func->hasThisPointer());
1644 assert(Func->isVirtual());
1645 size_t ArgSize = Func->getArgSize() + VarArgSize;
1646 size_t ThisOffset = ArgSize - (Func->hasRVO() ? primSize(PT_Ptr) : 0);
1647 Pointer &ThisPtr = S.Stk.peek<Pointer>(ThisOffset);
1648 const FunctionDecl *Callee = Func->getDecl();
1649
1650 if (!Func->isFullyCompiled())
1652
1653 // C++2a [class.abstract]p6:
1654 // the effect of making a virtual call to a pure virtual function [...] is
1655 // undefined
1656 if (Callee->isPureVirtual()) {
1657 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_pure_virtual_call,
1658 1)
1659 << Callee;
1660 S.Note(Callee->getLocation(), diag::note_declared_at);
1661 return false;
1662 }
1663
1664 const CXXRecordDecl *DynamicDecl = nullptr;
1665 {
1666 Pointer TypePtr = ThisPtr;
1667 while (TypePtr.isBaseClass())
1668 TypePtr = TypePtr.getBase();
1669
1670 QualType DynamicType = TypePtr.getType();
1671 if (DynamicType->isPointerType() || DynamicType->isReferenceType())
1672 DynamicDecl = DynamicType->getPointeeCXXRecordDecl();
1673 else
1674 DynamicDecl = DynamicType->getAsCXXRecordDecl();
1675 }
1676 assert(DynamicDecl);
1677
1678 const auto *StaticDecl = cast<CXXRecordDecl>(Func->getParentDecl());
1679 const auto *InitialFunction = cast<CXXMethodDecl>(Callee);
1680 const CXXMethodDecl *Overrider;
1681
1682 if (StaticDecl != DynamicDecl) {
1683 if (!DynamicDecl->isDerivedFrom(StaticDecl))
1684 return false;
1685 Overrider = S.getContext().getOverridingFunction(DynamicDecl, StaticDecl,
1686 InitialFunction);
1687
1688 } else {
1689 Overrider = InitialFunction;
1690 }
1691
1692 if (Overrider != InitialFunction) {
1693 // DR1872: An instantiated virtual constexpr function can't be called in a
1694 // constant expression (prior to C++20). We can still constant-fold such a
1695 // call.
1696 if (!S.getLangOpts().CPlusPlus20 && Overrider->isVirtual()) {
1697 const Expr *E = S.Current->getExpr(OpPC);
1698 S.CCEDiag(E, diag::note_constexpr_virtual_call) << E->getSourceRange();
1699 }
1700
1701 Func = S.getContext().getOrCreateFunction(Overrider);
1702
1703 const CXXRecordDecl *ThisFieldDecl =
1704 ThisPtr.getFieldDesc()->getType()->getAsCXXRecordDecl();
1705 if (Func->getParentDecl()->isDerivedFrom(ThisFieldDecl)) {
1706 // If the function we call is further DOWN the hierarchy than the
1707 // FieldDesc of our pointer, just go up the hierarchy of this field
1708 // the furthest we can go.
1709 while (ThisPtr.isBaseClass())
1710 ThisPtr = ThisPtr.getBase();
1711 }
1712 }
1713
1714 if (!Call(S, OpPC, Func, VarArgSize))
1715 return false;
1716
1717 // Covariant return types. The return type of Overrider is a pointer
1718 // or reference to a class type.
1719 if (Overrider != InitialFunction &&
1720 Overrider->getReturnType()->isPointerOrReferenceType() &&
1721 InitialFunction->getReturnType()->isPointerOrReferenceType()) {
1722 QualType OverriderPointeeType =
1723 Overrider->getReturnType()->getPointeeType();
1724 QualType InitialPointeeType =
1725 InitialFunction->getReturnType()->getPointeeType();
1726 // We've called Overrider above, but calling code expects us to return what
1727 // InitialFunction returned. According to the rules for covariant return
1728 // types, what InitialFunction returns needs to be a base class of what
1729 // Overrider returns. So, we need to do an upcast here.
1730 unsigned Offset = S.getContext().collectBaseOffset(
1731 InitialPointeeType->getAsRecordDecl(),
1732 OverriderPointeeType->getAsRecordDecl());
1733 return GetPtrBasePop(S, OpPC, Offset, /*IsNullOK=*/true);
1734 }
1735
1736 return true;
1737}
1738
1739bool CallBI(InterpState &S, CodePtr OpPC, const CallExpr *CE,
1740 uint32_t BuiltinID) {
1741 // A little arbitrary, but the current interpreter allows evaluation
1742 // of builtin functions in this mode, with some exceptions.
1743 if (BuiltinID == Builtin::BI__builtin_operator_new &&
1745 return false;
1746
1747 return InterpretBuiltin(S, OpPC, CE, BuiltinID);
1748}
1749
1750bool CallPtr(InterpState &S, CodePtr OpPC, uint32_t ArgSize,
1751 const CallExpr *CE) {
1752 const Pointer &Ptr = S.Stk.pop<Pointer>();
1753
1754 if (Ptr.isZero()) {
1755 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_null_callee)
1756 << const_cast<Expr *>(CE->getCallee()) << CE->getSourceRange();
1757 return false;
1758 }
1759
1760 if (!Ptr.isFunctionPointer())
1761 return Invalid(S, OpPC);
1762
1763 const FunctionPointer &FuncPtr = Ptr.asFunctionPointer();
1764 const Function *F = FuncPtr.getFunction();
1765 assert(F);
1766 // Don't allow calling block pointers.
1767 if (!F->getDecl())
1768 return Invalid(S, OpPC);
1769
1770 // This happens when the call expression has been cast to
1771 // something else, but we don't support that.
1772 if (S.Ctx.classify(F->getDecl()->getReturnType()) !=
1774 return false;
1775
1776 // Check argument nullability state.
1777 if (F->hasNonNullAttr()) {
1778 if (!CheckNonNullArgs(S, OpPC, F, CE, ArgSize))
1779 return false;
1780 }
1781
1782 // Can happen when casting function pointers around.
1783 QualType CalleeType = CE->getCallee()->getType();
1784 if (CalleeType->isPointerType() &&
1786 F->getDecl()->getType(), CalleeType->getPointeeType())) {
1787 return false;
1788 }
1789
1790 assert(ArgSize >= F->getWrittenArgSize());
1791 uint32_t VarArgSize = ArgSize - F->getWrittenArgSize();
1792
1793 // We need to do this explicitly here since we don't have the necessary
1794 // information to do it automatically.
1795 if (F->isThisPointerExplicit())
1796 VarArgSize -= align(primSize(PT_Ptr));
1797
1798 if (F->isVirtual())
1799 return CallVirt(S, OpPC, F, VarArgSize);
1800
1801 return Call(S, OpPC, F, VarArgSize);
1802}
1803
1804static void startLifetimeRecurse(const Pointer &Ptr) {
1805 if (const Record *R = Ptr.getRecord()) {
1806 Ptr.startLifetime();
1807 for (const Record::Field &Fi : R->fields())
1808 startLifetimeRecurse(Ptr.atField(Fi.Offset));
1809 return;
1810 }
1811
1812 if (const Descriptor *FieldDesc = Ptr.getFieldDesc();
1813 FieldDesc->isCompositeArray()) {
1814 assert(Ptr.getLifetime() == Lifetime::Started);
1815 for (unsigned I = 0; I != FieldDesc->getNumElems(); ++I)
1817 return;
1818 }
1819
1820 Ptr.startLifetime();
1821}
1822
1824 const auto &Ptr = S.Stk.peek<Pointer>();
1825 if (Ptr.isBlockPointer() && !CheckDummy(S, OpPC, Ptr.block(), AK_Destroy))
1826 return false;
1827 startLifetimeRecurse(Ptr.narrow());
1828 return true;
1829}
1830
1831// FIXME: It might be better to the recursing as part of the generated code for
1832// a destructor?
1833static void endLifetimeRecurse(const Pointer &Ptr) {
1834 if (const Record *R = Ptr.getRecord()) {
1835 Ptr.endLifetime();
1836 for (const Record::Field &Fi : R->fields())
1837 endLifetimeRecurse(Ptr.atField(Fi.Offset));
1838 return;
1839 }
1840
1841 if (const Descriptor *FieldDesc = Ptr.getFieldDesc();
1842 FieldDesc->isCompositeArray()) {
1843 // No endLifetime() for array roots.
1844 assert(Ptr.getLifetime() == Lifetime::Started);
1845 for (unsigned I = 0; I != FieldDesc->getNumElems(); ++I)
1847 return;
1848 }
1849
1850 Ptr.endLifetime();
1851}
1852
1853/// Ends the lifetime of the peek'd pointer.
1855 const auto &Ptr = S.Stk.peek<Pointer>();
1856 if (Ptr.isBlockPointer() && !CheckDummy(S, OpPC, Ptr.block(), AK_Destroy))
1857 return false;
1858
1859 // FIXME: We need per-element lifetime information for primitive arrays.
1860 if (Ptr.isArrayElement())
1861 return true;
1862
1863 endLifetimeRecurse(Ptr.narrow());
1864 return true;
1865}
1866
1867/// Ends the lifetime of the pop'd pointer.
1869 const auto &Ptr = S.Stk.pop<Pointer>();
1870 if (Ptr.isBlockPointer() && !CheckDummy(S, OpPC, Ptr.block(), AK_Destroy))
1871 return false;
1872
1873 // FIXME: We need per-element lifetime information for primitive arrays.
1874 if (Ptr.isArrayElement())
1875 return true;
1876
1877 endLifetimeRecurse(Ptr.narrow());
1878 return true;
1879}
1880
1882 std::optional<uint64_t> ArraySize) {
1883 const Pointer &Ptr = S.Stk.peek<Pointer>();
1884
1885 if (Ptr.inUnion() && Ptr.getBase().getRecord()->isUnion())
1886 Ptr.activate();
1887
1888 if (!Ptr.isBlockPointer())
1889 return false;
1890
1891 // Similar to CheckStore(), but with the additional CheckTemporary() call and
1892 // the AccessKinds are different.
1893
1894 if (!Ptr.block()->isAccessible()) {
1895 if (!CheckExtern(S, OpPC, Ptr))
1896 return false;
1897 if (!CheckLive(S, OpPC, Ptr, AK_Construct))
1898 return false;
1899 return CheckDummy(S, OpPC, Ptr.block(), AK_Construct);
1900 }
1901 if (!CheckTemporary(S, OpPC, Ptr.block(), AK_Construct))
1902 return false;
1903
1904 // CheckLifetime for this and all base pointers.
1905 for (Pointer P = Ptr;;) {
1906 if (!CheckLifetime(S, OpPC, P.getLifetime(), AK_Construct))
1907 return false;
1908
1909 if (P.isRoot())
1910 break;
1911 P = P.getBase();
1912 }
1913
1914 if (!CheckRange(S, OpPC, Ptr, AK_Construct))
1915 return false;
1916 if (!CheckGlobal(S, OpPC, Ptr))
1917 return false;
1918 if (!CheckConst(S, OpPC, Ptr))
1919 return false;
1920 if (!S.inConstantContext() && isConstexprUnknown(Ptr))
1921 return false;
1922
1923 if (!InvalidNewDeleteExpr(S, OpPC, E))
1924 return false;
1925
1926 const auto *NewExpr = cast<CXXNewExpr>(E);
1927 QualType StorageType = Ptr.getFieldDesc()->getDataType(S.getASTContext());
1928 const ASTContext &ASTCtx = S.getASTContext();
1929 QualType AllocType;
1930 if (ArraySize) {
1931 AllocType = ASTCtx.getConstantArrayType(
1932 NewExpr->getAllocatedType(),
1933 APInt(64, static_cast<uint64_t>(*ArraySize), false), nullptr,
1935 } else {
1936 AllocType = NewExpr->getAllocatedType();
1937 }
1938
1939 unsigned StorageSize = 1;
1940 unsigned AllocSize = 1;
1941 if (const auto *CAT = dyn_cast<ConstantArrayType>(AllocType))
1942 AllocSize = CAT->getZExtSize();
1943 if (const auto *CAT = dyn_cast<ConstantArrayType>(StorageType))
1944 StorageSize = CAT->getZExtSize();
1945
1946 if (AllocSize > StorageSize ||
1947 !ASTCtx.hasSimilarType(ASTCtx.getBaseElementType(AllocType),
1948 ASTCtx.getBaseElementType(StorageType))) {
1949 S.FFDiag(S.Current->getLocation(OpPC),
1950 diag::note_constexpr_placement_new_wrong_type)
1951 << StorageType << AllocType;
1952 return false;
1953 }
1954
1955 // Can't activate fields in a union, unless the direct base is the union.
1956 if (Ptr.inUnion() && !Ptr.isActive() && !Ptr.getBase().getRecord()->isUnion())
1957 return CheckActive(S, OpPC, Ptr, AK_Construct);
1958
1959 return true;
1960}
1961
1963 assert(E);
1964
1965 if (const auto *NewExpr = dyn_cast<CXXNewExpr>(E)) {
1966 const FunctionDecl *OperatorNew = NewExpr->getOperatorNew();
1967
1968 if (NewExpr->getNumPlacementArgs() > 0) {
1969 // This is allowed pre-C++26, but only an std function.
1970 if (S.getLangOpts().CPlusPlus26 || S.Current->isStdFunction())
1971 return true;
1972 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_new_placement)
1973 << /*C++26 feature*/ 1 << E->getSourceRange();
1974 } else if (
1975 !OperatorNew
1976 ->isUsableAsGlobalAllocationFunctionInConstantEvaluation()) {
1977 S.FFDiag(S.Current->getSource(OpPC),
1978 diag::note_constexpr_new_non_replaceable)
1979 << isa<CXXMethodDecl>(OperatorNew) << OperatorNew;
1980 return false;
1981 } else if (!S.getLangOpts().CPlusPlus26 &&
1982 NewExpr->getNumPlacementArgs() == 1 &&
1983 !OperatorNew->isReservedGlobalPlacementOperator()) {
1984 if (!S.getLangOpts().CPlusPlus26) {
1985 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_new_placement)
1986 << /*Unsupported*/ 0 << E->getSourceRange();
1987 return false;
1988 }
1989 return true;
1990 }
1991 } else {
1992 const auto *DeleteExpr = cast<CXXDeleteExpr>(E);
1993 const FunctionDecl *OperatorDelete = DeleteExpr->getOperatorDelete();
1994 if (!OperatorDelete
1995 ->isUsableAsGlobalAllocationFunctionInConstantEvaluation()) {
1996 S.FFDiag(S.Current->getSource(OpPC),
1997 diag::note_constexpr_new_non_replaceable)
1998 << isa<CXXMethodDecl>(OperatorDelete) << OperatorDelete;
1999 return false;
2000 }
2001 }
2002
2003 return false;
2004}
2005
2007 const FixedPoint &FP) {
2008 const Expr *E = S.Current->getExpr(OpPC);
2011 E->getExprLoc(), diag::warn_fixedpoint_constant_overflow)
2012 << FP.toDiagnosticString(S.getASTContext()) << E->getType();
2013 }
2014 S.CCEDiag(E, diag::note_constexpr_overflow)
2015 << FP.toDiagnosticString(S.getASTContext()) << E->getType();
2016 return S.noteUndefinedBehavior();
2017}
2018
2019bool InvalidShuffleVectorIndex(InterpState &S, CodePtr OpPC, uint32_t Index) {
2020 const SourceInfo &Loc = S.Current->getSource(OpPC);
2021 S.FFDiag(Loc,
2022 diag::err_shufflevector_minus_one_is_undefined_behavior_constexpr)
2023 << Index;
2024 return false;
2025}
2026
2028 const Pointer &Ptr, unsigned BitWidth) {
2029 if (Ptr.isDummy())
2030 return false;
2031 if (Ptr.isFunctionPointer())
2032 return true;
2033
2034 const SourceInfo &E = S.Current->getSource(OpPC);
2035 S.CCEDiag(E, diag::note_constexpr_invalid_cast)
2036 << 2 << S.getLangOpts().CPlusPlus << S.Current->getRange(OpPC);
2037
2038 if (Ptr.isBlockPointer() && !Ptr.isZero()) {
2039 // Only allow based lvalue casts if they are lossless.
2041 BitWidth)
2042 return Invalid(S, OpPC);
2043 }
2044 return true;
2045}
2046
2047bool CastPointerIntegralAP(InterpState &S, CodePtr OpPC, uint32_t BitWidth) {
2048 const Pointer &Ptr = S.Stk.pop<Pointer>();
2049
2050 if (!CheckPointerToIntegralCast(S, OpPC, Ptr, BitWidth))
2051 return false;
2052
2053 auto Result = S.allocAP<IntegralAP<false>>(BitWidth);
2054 Result.copy(APInt(BitWidth, Ptr.getIntegerRepresentation()));
2055
2057 return true;
2058}
2059
2060bool CastPointerIntegralAPS(InterpState &S, CodePtr OpPC, uint32_t BitWidth) {
2061 const Pointer &Ptr = S.Stk.pop<Pointer>();
2062
2063 if (!CheckPointerToIntegralCast(S, OpPC, Ptr, BitWidth))
2064 return false;
2065
2066 auto Result = S.allocAP<IntegralAP<true>>(BitWidth);
2067 Result.copy(APInt(BitWidth, Ptr.getIntegerRepresentation()));
2068
2070 return true;
2071}
2072
2073bool CheckBitCast(InterpState &S, CodePtr OpPC, bool HasIndeterminateBits,
2074 bool TargetIsUCharOrByte) {
2075 // This is always fine.
2076 if (!HasIndeterminateBits)
2077 return true;
2078
2079 // Indeterminate bits can only be bitcast to unsigned char or std::byte.
2080 if (TargetIsUCharOrByte)
2081 return true;
2082
2083 const Expr *E = S.Current->getExpr(OpPC);
2084 QualType ExprType = E->getType();
2085 S.FFDiag(E, diag::note_constexpr_bit_cast_indet_dest)
2086 << ExprType << S.getLangOpts().CharIsSigned << E->getSourceRange();
2087 return false;
2088}
2089
2090bool GetTypeid(InterpState &S, CodePtr OpPC, const Type *TypePtr,
2091 const Type *TypeInfoType) {
2092 S.Stk.push<Pointer>(TypePtr, TypeInfoType);
2093 return true;
2094}
2095
2096bool GetTypeidPtr(InterpState &S, CodePtr OpPC, const Type *TypeInfoType) {
2097 const auto &P = S.Stk.pop<Pointer>();
2098
2099 if (!P.isBlockPointer())
2100 return false;
2101
2102 // Pick the most-derived type.
2103 CanQualType T = P.getDeclPtr().getType()->getCanonicalTypeUnqualified();
2104 // ... unless we're currently constructing this object.
2105 // FIXME: We have a similar check to this in more places.
2106 if (S.Current->getFunction()) {
2107 for (const InterpFrame *Frame = S.Current; Frame; Frame = Frame->Caller) {
2108 if (const Function *Func = Frame->getFunction();
2109 Func && (Func->isConstructor() || Func->isDestructor()) &&
2110 P.block() == Frame->getThis().block()) {
2112 Func->getParentDecl());
2113 break;
2114 }
2115 }
2116 }
2117
2118 S.Stk.push<Pointer>(T->getTypePtr(), TypeInfoType);
2119 return true;
2120}
2121
2123 const auto *E = cast<CXXTypeidExpr>(S.Current->getExpr(OpPC));
2124 S.CCEDiag(E, diag::note_constexpr_typeid_polymorphic)
2125 << E->getExprOperand()->getType()
2126 << E->getExprOperand()->getSourceRange();
2127 return false;
2128}
2129
2131 const Pointer &RHS) {
2132 unsigned LHSOffset = LHS.isOnePastEnd() ? LHS.getNumElems() : LHS.getIndex();
2133 unsigned RHSOffset = RHS.isOnePastEnd() ? RHS.getNumElems() : RHS.getIndex();
2134 unsigned LHSLength = (LHS.getNumElems() - 1) * LHS.elemSize();
2135 unsigned RHSLength = (RHS.getNumElems() - 1) * RHS.elemSize();
2136
2137 StringRef LHSStr((const char *)LHS.atIndex(0).getRawAddress(), LHSLength);
2138 StringRef RHSStr((const char *)RHS.atIndex(0).getRawAddress(), RHSLength);
2139 int32_t IndexDiff = RHSOffset - LHSOffset;
2140 if (IndexDiff < 0) {
2141 if (static_cast<int32_t>(LHSLength) < -IndexDiff)
2142 return false;
2143 LHSStr = LHSStr.drop_front(-IndexDiff);
2144 } else {
2145 if (static_cast<int32_t>(RHSLength) < IndexDiff)
2146 return false;
2147 RHSStr = RHSStr.drop_front(IndexDiff);
2148 }
2149
2150 unsigned ShorterCharWidth;
2151 StringRef Shorter;
2152 StringRef Longer;
2153 if (LHSLength < RHSLength) {
2154 ShorterCharWidth = LHS.elemSize();
2155 Shorter = LHSStr;
2156 Longer = RHSStr;
2157 } else {
2158 ShorterCharWidth = RHS.elemSize();
2159 Shorter = RHSStr;
2160 Longer = LHSStr;
2161 }
2162
2163 // The null terminator isn't included in the string data, so check for it
2164 // manually. If the longer string doesn't have a null terminator where the
2165 // shorter string ends, they aren't potentially overlapping.
2166 for (unsigned NullByte : llvm::seq(ShorterCharWidth)) {
2167 if (Shorter.size() + NullByte >= Longer.size())
2168 break;
2169 if (Longer[Shorter.size() + NullByte])
2170 return false;
2171 }
2172 return Shorter == Longer.take_front(Shorter.size());
2173}
2174
2175static void copyPrimitiveMemory(InterpState &S, const Pointer &Ptr,
2176 PrimType T) {
2177
2178 if (T == PT_IntAPS) {
2179 auto &Val = Ptr.deref<IntegralAP<true>>();
2180 if (!Val.singleWord()) {
2181 uint64_t *NewMemory = new (S.P) uint64_t[Val.numWords()];
2182 Val.take(NewMemory);
2183 }
2184 } else if (T == PT_IntAP) {
2185 auto &Val = Ptr.deref<IntegralAP<false>>();
2186 if (!Val.singleWord()) {
2187 uint64_t *NewMemory = new (S.P) uint64_t[Val.numWords()];
2188 Val.take(NewMemory);
2189 }
2190 } else if (T == PT_Float) {
2191 auto &Val = Ptr.deref<Floating>();
2192 if (!Val.singleWord()) {
2193 uint64_t *NewMemory = new (S.P) uint64_t[Val.numWords()];
2194 Val.take(NewMemory);
2195 }
2196 }
2197}
2198
2199template <typename T>
2200static void copyPrimitiveMemory(InterpState &S, const Pointer &Ptr) {
2201 assert(needsAlloc<T>());
2202 auto &Val = Ptr.deref<T>();
2203 if (!Val.singleWord()) {
2204 uint64_t *NewMemory = new (S.P) uint64_t[Val.numWords()];
2205 Val.take(NewMemory);
2206 }
2207}
2208
2209static void finishGlobalRecurse(InterpState &S, const Pointer &Ptr) {
2210 if (const Record *R = Ptr.getRecord()) {
2211 for (const Record::Field &Fi : R->fields()) {
2212 if (Fi.Desc->isPrimitive()) {
2213 TYPE_SWITCH_ALLOC(Fi.Desc->getPrimType(), {
2214 copyPrimitiveMemory<T>(S, Ptr.atField(Fi.Offset));
2215 });
2216 copyPrimitiveMemory(S, Ptr.atField(Fi.Offset), Fi.Desc->getPrimType());
2217 } else
2218 finishGlobalRecurse(S, Ptr.atField(Fi.Offset));
2219 }
2220 return;
2221 }
2222
2223 if (const Descriptor *D = Ptr.getFieldDesc(); D && D->isArray()) {
2224 unsigned NumElems = D->getNumElems();
2225 if (NumElems == 0)
2226 return;
2227
2228 if (D->isPrimitiveArray()) {
2229 PrimType PT = D->getPrimType();
2230 if (!needsAlloc(PT))
2231 return;
2232 assert(NumElems >= 1);
2233 const Pointer EP = Ptr.atIndex(0);
2234 bool AllSingleWord = true;
2235 TYPE_SWITCH_ALLOC(PT, {
2236 if (!EP.deref<T>().singleWord()) {
2238 AllSingleWord = false;
2239 }
2240 });
2241 if (AllSingleWord)
2242 return;
2243 for (unsigned I = 1; I != D->getNumElems(); ++I) {
2244 const Pointer EP = Ptr.atIndex(I);
2245 copyPrimitiveMemory(S, EP, PT);
2246 }
2247 } else {
2248 assert(D->isCompositeArray());
2249 for (unsigned I = 0; I != D->getNumElems(); ++I) {
2250 const Pointer EP = Ptr.atIndex(I).narrow();
2251 finishGlobalRecurse(S, EP);
2252 }
2253 }
2254 }
2255}
2256
2258 const Pointer &Ptr = S.Stk.pop<Pointer>();
2259
2260 finishGlobalRecurse(S, Ptr);
2261 if (Ptr.canBeInitialized()) {
2262 Ptr.initialize();
2263 Ptr.activate();
2264 }
2265
2266 return true;
2267}
2268
2269// https://github.com/llvm/llvm-project/issues/102513
2270#if defined(_MSC_VER) && !defined(__clang__) && !defined(NDEBUG)
2271#pragma optimize("", off)
2272#endif
2274 // The current stack frame when we started Interpret().
2275 // This is being used by the ops to determine wheter
2276 // to return from this function and thus terminate
2277 // interpretation.
2278 const InterpFrame *StartFrame = S.Current;
2279 assert(!S.Current->isRoot());
2280 CodePtr PC = S.Current->getPC();
2281
2282 // Empty program.
2283 if (!PC)
2284 return true;
2285
2286 for (;;) {
2287 auto Op = PC.read<Opcode>();
2288 CodePtr OpPC = PC;
2289
2290 switch (Op) {
2291#define GET_INTERP
2292#include "Opcodes.inc"
2293#undef GET_INTERP
2294 }
2295 }
2296}
2297// https://github.com/llvm/llvm-project/issues/102513
2298#if defined(_MSC_VER) && !defined(__clang__) && !defined(NDEBUG)
2299#pragma optimize("", on)
2300#endif
2301
2302} // namespace interp
2303} // namespace clang
Defines the clang::ASTContext interface.
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
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 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:4004
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
Definition Decl.h:4205
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:5068
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:3157
Represents a function declaration or definition.
Definition Decl.h:1999
QualType getReturnType() const
Definition Decl.h:2842
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition Decl.h:2376
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition Decl.h:2885
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition Decl.h:2469
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:2281
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:273
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition Decl.h:294
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition Decl.h:300
A (possibly-)qualified type.
Definition TypeBase.h:937
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition TypeBase.h:8371
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition TypeBase.h:8360
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:8524
bool isReferenceType() const
Definition TypeBase.h:8548
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:8998
bool isAnyComplexType() const
Definition TypeBase.h:8659
bool isPointerOrReferenceType() const
Definition TypeBase.h:8528
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition Decl.h:711
QualType getType() const
Definition Decl.h:722
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition Decl.h:1568
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:575
bool isVolatile() const
Checks if an object or a subfield is volatile.
Definition Pointer.h:568
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:493
bool isDynamic() const
Checks if the storage has been dynamically allocated.
Definition Pointer.h:508
bool inUnion() const
Definition Pointer.h:401
bool isZeroSizeArray() const
Checks if the pointer is pointing to a zero-size array.
Definition Pointer.h:653
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:546
bool isExtern() const
Checks if the storage is extern.
Definition Pointer.h:487
int64_t getIndex() const
Returns the index into an array.
Definition Pointer.h:611
bool isActive() const
Checks if the object is active.
Definition Pointer.h:535
bool isConst() const
Checks if an object or a subfield is mutable.
Definition Pointer.h:556
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:662
bool isMutable() const
Checks if the field is mutable.
Definition Pointer.h:519
bool isConstInMutable() const
Definition Pointer.h:561
unsigned getNumElems() const
Returns the number of elements.
Definition Pointer.h:595
bool isUnknownSizeArray() const
Checks if the structure is an array of unknown size.
Definition Pointer.h:414
void activate() const
Activats a field.
Definition Pointer.cpp:576
bool isIntegralPointer() const
Definition Pointer.h:468
QualType getType() const
Returns the type of the innermost field.
Definition Pointer.h:335
bool isArrayElement() const
Checks if the pointer points to an array.
Definition Pointer.h:420
bool isLive() const
Checks if the pointer is live.
Definition Pointer.h:267
Pointer getBase() const
Returns a pointer to the object of which this pointer is a field.
Definition Pointer.h:306
uint64_t getByteOffset() const
Returns the byte offset from the start.
Definition Pointer.h:584
bool isTypeidPointer() const
Definition Pointer.h:470
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:454
bool isRoot() const
Pointer points directly to a block.
Definition Pointer.h:436
const Descriptor * getDeclDesc() const
Accessor for information about the declaration site.
Definition Pointer.h:281
static bool pointToSameBlock(const Pointer &A, const Pointer &B)
Checks if both given pointers point to the same block.
Definition Pointer.cpp:652
void endLifetime() const
Definition Pointer.h:731
bool isOnePastEnd() const
Checks if the index is one past end.
Definition Pointer.h:628
uint64_t getIntegerRepresentation() const
Definition Pointer.h:143
const FieldDecl * getField() const
Returns the field information.
Definition Pointer.h:480
bool isElementPastEnd() const
Checks if the pointer is an out-of-bounds element pointer.
Definition Pointer.h:650
void startLifetime() const
Definition Pointer.h:739
bool isBlockPointer() const
Definition Pointer.h:467
bool isTemporary() const
Checks if the storage is temporary.
Definition Pointer.h:500
const FunctionPointer & asFunctionPointer() const
Definition Pointer.h:458
SourceLocation getDeclLoc() const
Definition Pointer.h:291
const Block * block() const
Definition Pointer.h:601
bool isFunctionPointer() const
Definition Pointer.h:469
Pointer getDeclPtr() const
Definition Pointer.h:354
const Descriptor * getFieldDesc() const
Accessors for information about the innermost field.
Definition Pointer.h:325
bool isBaseClass() const
Checks if a structure is a base class.
Definition Pointer.h:541
size_t elemSize() const
Returns the element size of the innermost field.
Definition Pointer.h:357
bool canBeInitialized() const
If this pointer has an InlineDescriptor we can use to initialize.
Definition Pointer.h:443
Lifetime getLifetime() const
Definition Pointer.h:723
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:605
bool isField() const
Checks if the item is a field in an object.
Definition Pointer.h:273
const Record * getRecord() const
Returns the record descriptor of a class.
Definition Pointer.h:473
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:2130
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:1804
bool CastPointerIntegralAPS(InterpState &S, CodePtr OpPC, uint32_t BitWidth)
Definition Interp.cpp:2060
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:2047
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:1868
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:2096
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:1854
bool GetTypeid(InterpState &S, CodePtr OpPC, const Type *TypePtr, const Type *TypeInfoType)
Typeid support.
Definition Interp.cpp:2090
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:2027
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:2209
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:2006
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:2122
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:2073
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:1823
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
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:2019
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:1881
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:2257
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:2175
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:1962
bool CallBI(InterpState &S, CodePtr OpPC, const CallExpr *CE, uint32_t BuiltinID)
Definition Interp.cpp:1739
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:1750
bool CallVirt(InterpState &S, CodePtr OpPC, const Function *Func, uint32_t VarArgSize)
Definition Interp.cpp:1641
static void endLifetimeRecurse(const Pointer &Ptr)
Definition Interp.cpp:1833
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:2273
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