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 if (!Ptr.isConst() && !S.inConstantContext() && isConstexprUnknown(Ptr))
836 return false;
837 return true;
838}
839
840/// This is not used by any of the opcodes directly. It's used by
841/// EvalEmitter to do the final lvalue-to-rvalue conversion.
842bool CheckFinalLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
843 assert(!Ptr.isZero());
844 if (!Ptr.isBlockPointer())
845 return false;
846
847 if (!Ptr.block()->isAccessible()) {
848 if (!CheckLive(S, OpPC, Ptr, AK_Read))
849 return false;
850 if (!CheckExtern(S, OpPC, Ptr))
851 return false;
852 if (!CheckDummy(S, OpPC, Ptr.block(), AK_Read))
853 return false;
854 return CheckWeak(S, OpPC, Ptr.block());
855 }
856
857 if (!CheckConstant(S, OpPC, Ptr))
858 return false;
859
860 if (!CheckActive(S, OpPC, Ptr, AK_Read))
861 return false;
862 if (!CheckLifetime(S, OpPC, Ptr.getLifetime(), AK_Read))
863 return false;
864 if (!Ptr.isInitialized())
865 return DiagnoseUninitialized(S, OpPC, Ptr, AK_Read);
866 if (!CheckTemporary(S, OpPC, Ptr.block(), AK_Read))
867 return false;
868 if (!CheckMutable(S, OpPC, Ptr))
869 return false;
870 return true;
871}
872
873bool CheckStore(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
874 bool WillBeActivated) {
875 if (!Ptr.isBlockPointer() || Ptr.isZero())
876 return false;
877
878 if (!Ptr.block()->isAccessible()) {
879 if (!CheckLive(S, OpPC, Ptr, AK_Assign))
880 return false;
881 if (!CheckExtern(S, OpPC, Ptr))
882 return false;
883 return CheckDummy(S, OpPC, Ptr.block(), AK_Assign);
884 }
885 if (!CheckLifetime(S, OpPC, Ptr.getLifetime(), AK_Assign))
886 return false;
887 if (!CheckRange(S, OpPC, Ptr, AK_Assign))
888 return false;
889 if (!WillBeActivated && !CheckActive(S, OpPC, Ptr, AK_Assign))
890 return false;
891 if (!CheckGlobal(S, OpPC, Ptr))
892 return false;
893 if (!CheckConst(S, OpPC, Ptr))
894 return false;
895 if (!CheckVolatile(S, OpPC, Ptr, AK_Assign))
896 return false;
897 if (!S.inConstantContext() && isConstexprUnknown(Ptr))
898 return false;
899 return true;
900}
901
902static bool CheckInvoke(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
903 if (!CheckLive(S, OpPC, Ptr, AK_MemberCall))
904 return false;
905 if (!Ptr.isDummy()) {
906 if (!CheckExtern(S, OpPC, Ptr))
907 return false;
908 if (!CheckRange(S, OpPC, Ptr, AK_MemberCall))
909 return false;
910 }
911 return true;
912}
913
914bool CheckInit(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
915 if (!CheckLive(S, OpPC, Ptr, AK_Assign))
916 return false;
917 if (!CheckRange(S, OpPC, Ptr, AK_Assign))
918 return false;
919 return true;
920}
921
922static bool CheckCallable(InterpState &S, CodePtr OpPC, const Function *F) {
923
924 if (F->isVirtual() && !S.getLangOpts().CPlusPlus20) {
925 const SourceLocation &Loc = S.Current->getLocation(OpPC);
926 S.CCEDiag(Loc, diag::note_constexpr_virtual_call);
927 return false;
928 }
929
931 return false;
932
933 if (F->isValid() && F->hasBody() && F->isConstexpr())
934 return true;
935
936 const FunctionDecl *DiagDecl = F->getDecl();
937 const FunctionDecl *Definition = nullptr;
938 DiagDecl->getBody(Definition);
939
941 DiagDecl->isConstexpr()) {
942 return false;
943 }
944
945 // Implicitly constexpr.
946 if (F->isLambdaStaticInvoker())
947 return true;
948
949 // Bail out if the function declaration itself is invalid. We will
950 // have produced a relevant diagnostic while parsing it, so just
951 // note the problematic sub-expression.
952 if (DiagDecl->isInvalidDecl())
953 return Invalid(S, OpPC);
954
955 // Diagnose failed assertions specially.
956 if (S.Current->getLocation(OpPC).isMacroID() &&
957 F->getDecl()->getIdentifier()) {
958 // FIXME: Instead of checking for an implementation-defined function,
959 // check and evaluate the assert() macro.
960 StringRef Name = F->getDecl()->getName();
961 bool AssertFailed =
962 Name == "__assert_rtn" || Name == "__assert_fail" || Name == "_wassert";
963 if (AssertFailed) {
964 S.FFDiag(S.Current->getLocation(OpPC),
965 diag::note_constexpr_assert_failed);
966 return false;
967 }
968 }
969
970 if (!S.getLangOpts().CPlusPlus11) {
971 S.FFDiag(S.Current->getLocation(OpPC),
972 diag::note_invalid_subexpr_in_const_expr);
973 return false;
974 }
975
976 // Invalid decls have been diagnosed before.
977 if (DiagDecl->isInvalidDecl())
978 return false;
979
980 // If this function is not constexpr because it is an inherited
981 // non-constexpr constructor, diagnose that directly.
982 const auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl);
983 if (CD && CD->isInheritingConstructor()) {
984 const auto *Inherited = CD->getInheritedConstructor().getConstructor();
985 if (!Inherited->isConstexpr())
986 DiagDecl = CD = Inherited;
987 }
988
989 // Silently reject constructors of invalid classes. The invalid class
990 // has been rejected elsewhere before.
991 if (CD && CD->getParent()->isInvalidDecl())
992 return false;
993
994 // FIXME: If DiagDecl is an implicitly-declared special member function
995 // or an inheriting constructor, we should be much more explicit about why
996 // it's not constexpr.
997 if (CD && CD->isInheritingConstructor()) {
998 S.FFDiag(S.Current->getLocation(OpPC), diag::note_constexpr_invalid_inhctor,
999 1)
1000 << CD->getInheritedConstructor().getConstructor()->getParent();
1001 S.Note(DiagDecl->getLocation(), diag::note_declared_at);
1002 } else {
1003 // Don't emit anything if the function isn't defined and we're checking
1004 // for a constant expression. It might be defined at the point we're
1005 // actually calling it.
1006 bool IsExtern = DiagDecl->getStorageClass() == SC_Extern;
1007 bool IsDefined = F->isDefined();
1008 if (!IsDefined && !IsExtern && DiagDecl->isConstexpr() &&
1010 return false;
1011
1012 // If the declaration is defined, declared 'constexpr' _and_ has a body,
1013 // the below diagnostic doesn't add anything useful.
1014 if (DiagDecl->isDefined() && DiagDecl->isConstexpr() && DiagDecl->hasBody())
1015 return false;
1016
1017 S.FFDiag(S.Current->getLocation(OpPC),
1018 diag::note_constexpr_invalid_function, 1)
1019 << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
1020
1021 if (DiagDecl->getDefinition())
1022 S.Note(DiagDecl->getDefinition()->getLocation(), diag::note_declared_at);
1023 else
1024 S.Note(DiagDecl->getLocation(), diag::note_declared_at);
1025 }
1026
1027 return false;
1028}
1029
1030static bool CheckCallDepth(InterpState &S, CodePtr OpPC) {
1031 if ((S.Current->getDepth() + 1) > S.getLangOpts().ConstexprCallDepth) {
1032 S.FFDiag(S.Current->getSource(OpPC),
1033 diag::note_constexpr_depth_limit_exceeded)
1034 << S.getLangOpts().ConstexprCallDepth;
1035 return false;
1036 }
1037
1038 return true;
1039}
1040
1042 if (S.Current->hasThisPointer())
1043 return true;
1044
1045 const Expr *E = S.Current->getExpr(OpPC);
1046 if (S.getLangOpts().CPlusPlus11) {
1047 bool IsImplicit = false;
1048 if (const auto *TE = dyn_cast<CXXThisExpr>(E))
1049 IsImplicit = TE->isImplicit();
1050 S.FFDiag(E, diag::note_constexpr_this) << IsImplicit;
1051 } else {
1052 S.FFDiag(E);
1053 }
1054
1055 return false;
1056}
1057
1059 APFloat::opStatus Status, FPOptions FPO) {
1060 // [expr.pre]p4:
1061 // If during the evaluation of an expression, the result is not
1062 // mathematically defined [...], the behavior is undefined.
1063 // FIXME: C++ rules require us to not conform to IEEE 754 here.
1064 if (Result.isNan()) {
1065 const SourceInfo &E = S.Current->getSource(OpPC);
1066 S.CCEDiag(E, diag::note_constexpr_float_arithmetic)
1067 << /*NaN=*/true << S.Current->getRange(OpPC);
1068 return S.noteUndefinedBehavior();
1069 }
1070
1071 // In a constant context, assume that any dynamic rounding mode or FP
1072 // exception state matches the default floating-point environment.
1073 if (S.inConstantContext())
1074 return true;
1075
1076 if ((Status & APFloat::opInexact) &&
1077 FPO.getRoundingMode() == llvm::RoundingMode::Dynamic) {
1078 // Inexact result means that it depends on rounding mode. If the requested
1079 // mode is dynamic, the evaluation cannot be made in compile time.
1080 const SourceInfo &E = S.Current->getSource(OpPC);
1081 S.FFDiag(E, diag::note_constexpr_dynamic_rounding);
1082 return false;
1083 }
1084
1085 if ((Status != APFloat::opOK) &&
1086 (FPO.getRoundingMode() == llvm::RoundingMode::Dynamic ||
1088 FPO.getAllowFEnvAccess())) {
1089 const SourceInfo &E = S.Current->getSource(OpPC);
1090 S.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);
1091 return false;
1092 }
1093
1094 if ((Status & APFloat::opStatus::opInvalidOp) &&
1096 const SourceInfo &E = S.Current->getSource(OpPC);
1097 // There is no usefully definable result.
1098 S.FFDiag(E);
1099 return false;
1100 }
1101
1102 return true;
1103}
1104
1106 if (S.getLangOpts().CPlusPlus20)
1107 return true;
1108
1109 const SourceInfo &E = S.Current->getSource(OpPC);
1110 S.CCEDiag(E, diag::note_constexpr_new);
1111 return true;
1112}
1113
1115 DynamicAllocator::Form AllocForm,
1116 DynamicAllocator::Form DeleteForm, const Descriptor *D,
1117 const Expr *NewExpr) {
1118 if (AllocForm == DeleteForm)
1119 return true;
1120
1121 QualType TypeToDiagnose = D->getDataType(S.getASTContext());
1122
1123 const SourceInfo &E = S.Current->getSource(OpPC);
1124 S.FFDiag(E, diag::note_constexpr_new_delete_mismatch)
1125 << static_cast<int>(DeleteForm) << static_cast<int>(AllocForm)
1126 << TypeToDiagnose;
1127 S.Note(NewExpr->getExprLoc(), diag::note_constexpr_dynamic_alloc_here)
1128 << NewExpr->getSourceRange();
1129 return false;
1130}
1131
1132bool CheckDeleteSource(InterpState &S, CodePtr OpPC, const Expr *Source,
1133 const Pointer &Ptr) {
1134 // Regular new type(...) call.
1135 if (isa_and_nonnull<CXXNewExpr>(Source))
1136 return true;
1137 // operator new.
1138 if (const auto *CE = dyn_cast_if_present<CallExpr>(Source);
1139 CE && CE->getBuiltinCallee() == Builtin::BI__builtin_operator_new)
1140 return true;
1141 // std::allocator.allocate() call
1142 if (const auto *MCE = dyn_cast_if_present<CXXMemberCallExpr>(Source);
1143 MCE && MCE->getMethodDecl()->getIdentifier()->isStr("allocate"))
1144 return true;
1145
1146 // Whatever this is, we didn't heap allocate it.
1147 const SourceInfo &Loc = S.Current->getSource(OpPC);
1148 S.FFDiag(Loc, diag::note_constexpr_delete_not_heap_alloc)
1150
1151 if (Ptr.isTemporary())
1152 S.Note(Ptr.getDeclLoc(), diag::note_constexpr_temporary_here);
1153 else
1154 S.Note(Ptr.getDeclLoc(), diag::note_declared_at);
1155 return false;
1156}
1157
1158/// We aleady know the given DeclRefExpr is invalid for some reason,
1159/// now figure out why and print appropriate diagnostics.
1160bool CheckDeclRef(InterpState &S, CodePtr OpPC, const DeclRefExpr *DR) {
1161 const ValueDecl *D = DR->getDecl();
1162 return diagnoseUnknownDecl(S, OpPC, D);
1163}
1164
1165bool CheckDummy(InterpState &S, CodePtr OpPC, const Block *B, AccessKinds AK) {
1166 if (!B->isDummy())
1167 return true;
1168
1169 const ValueDecl *D = B->getDescriptor()->asValueDecl();
1170 if (!D)
1171 return false;
1172
1173 if (AK == AK_Read || AK == AK_Increment || AK == AK_Decrement)
1174 return diagnoseUnknownDecl(S, OpPC, D);
1175
1176 if (AK == AK_Destroy || S.getLangOpts().CPlusPlus14) {
1177 const SourceInfo &E = S.Current->getSource(OpPC);
1178 S.FFDiag(E, diag::note_constexpr_modify_global);
1179 }
1180 return false;
1181}
1182
1183static bool CheckNonNullArgs(InterpState &S, CodePtr OpPC, const Function *F,
1184 const CallExpr *CE, unsigned ArgSize) {
1185 auto Args = ArrayRef(CE->getArgs(), CE->getNumArgs());
1186 auto NonNullArgs = collectNonNullArgs(F->getDecl(), Args);
1187 unsigned Offset = 0;
1188 unsigned Index = 0;
1189 for (const Expr *Arg : Args) {
1190 if (NonNullArgs[Index] && Arg->getType()->isPointerType()) {
1191 const Pointer &ArgPtr = S.Stk.peek<Pointer>(ArgSize - Offset);
1192 if (ArgPtr.isZero()) {
1193 const SourceLocation &Loc = S.Current->getLocation(OpPC);
1194 S.CCEDiag(Loc, diag::note_non_null_attribute_failed);
1195 return false;
1196 }
1197 }
1198
1199 Offset += align(primSize(S.Ctx.classify(Arg).value_or(PT_Ptr)));
1200 ++Index;
1201 }
1202 return true;
1203}
1204
1206 const Pointer &BasePtr,
1207 const Descriptor *Desc) {
1208 assert(Desc->isRecord());
1209 const Record *R = Desc->ElemRecord;
1210 assert(R);
1211
1213 Pointer::pointToSameBlock(BasePtr, S.Current->getThis())) {
1214 const SourceInfo &Loc = S.Current->getSource(OpPC);
1215 S.FFDiag(Loc, diag::note_constexpr_double_destroy);
1216 return false;
1217 }
1218
1219 // Destructor of this record.
1220 const CXXDestructorDecl *Dtor = R->getDestructor();
1221 assert(Dtor);
1222 assert(!Dtor->isTrivial());
1223 const Function *DtorFunc = S.getContext().getOrCreateFunction(Dtor);
1224 if (!DtorFunc)
1225 return false;
1226
1227 S.Stk.push<Pointer>(BasePtr);
1228 return Call(S, OpPC, DtorFunc, 0);
1229}
1230
1231static bool RunDestructors(InterpState &S, CodePtr OpPC, const Block *B) {
1232 assert(B);
1233 const Descriptor *Desc = B->getDescriptor();
1234
1235 if (Desc->isPrimitive() || Desc->isPrimitiveArray())
1236 return true;
1237
1238 assert(Desc->isRecord() || Desc->isCompositeArray());
1239
1240 if (Desc->hasTrivialDtor())
1241 return true;
1242
1243 if (Desc->isCompositeArray()) {
1244 unsigned N = Desc->getNumElems();
1245 if (N == 0)
1246 return true;
1247 const Descriptor *ElemDesc = Desc->ElemDesc;
1248 assert(ElemDesc->isRecord());
1249
1250 Pointer RP(const_cast<Block *>(B));
1251 for (int I = static_cast<int>(N) - 1; I >= 0; --I) {
1252 if (!runRecordDestructor(S, OpPC, RP.atIndex(I).narrow(), ElemDesc))
1253 return false;
1254 }
1255 return true;
1256 }
1257
1258 assert(Desc->isRecord());
1259 return runRecordDestructor(S, OpPC, Pointer(const_cast<Block *>(B)), Desc);
1260}
1261
1263 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1264 if (const CXXDestructorDecl *DD = RD->getDestructor())
1265 return DD->isVirtual();
1266 return false;
1267}
1268
1269bool Free(InterpState &S, CodePtr OpPC, bool DeleteIsArrayForm,
1270 bool IsGlobalDelete) {
1271 if (!CheckDynamicMemoryAllocation(S, OpPC))
1272 return false;
1273
1274 DynamicAllocator &Allocator = S.getAllocator();
1275
1276 const Expr *Source = nullptr;
1277 const Block *BlockToDelete = nullptr;
1278 {
1279 // Extra scope for this so the block doesn't have this pointer
1280 // pointing to it when we destroy it.
1281 Pointer Ptr = S.Stk.pop<Pointer>();
1282
1283 // Deleteing nullptr is always fine.
1284 if (Ptr.isZero())
1285 return true;
1286
1287 // Remove base casts.
1288 QualType InitialType = Ptr.getType();
1289 while (Ptr.isBaseClass())
1290 Ptr = Ptr.getBase();
1291
1292 Source = Ptr.getDeclDesc()->asExpr();
1293 BlockToDelete = Ptr.block();
1294
1295 // Check that new[]/delete[] or new/delete were used, not a mixture.
1296 const Descriptor *BlockDesc = BlockToDelete->getDescriptor();
1297 if (std::optional<DynamicAllocator::Form> AllocForm =
1298 Allocator.getAllocationForm(Source)) {
1299 DynamicAllocator::Form DeleteForm =
1300 DeleteIsArrayForm ? DynamicAllocator::Form::Array
1302 if (!CheckNewDeleteForms(S, OpPC, *AllocForm, DeleteForm, BlockDesc,
1303 Source))
1304 return false;
1305 }
1306
1307 // For the non-array case, the types must match if the static type
1308 // does not have a virtual destructor.
1309 if (!DeleteIsArrayForm && Ptr.getType() != InitialType &&
1310 !hasVirtualDestructor(InitialType)) {
1311 S.FFDiag(S.Current->getSource(OpPC),
1312 diag::note_constexpr_delete_base_nonvirt_dtor)
1313 << InitialType << Ptr.getType();
1314 return false;
1315 }
1316
1317 if (!Ptr.isRoot() || (Ptr.isOnePastEnd() && !Ptr.isZeroSizeArray()) ||
1318 (Ptr.isArrayElement() && Ptr.getIndex() != 0)) {
1319 const SourceInfo &Loc = S.Current->getSource(OpPC);
1320 S.FFDiag(Loc, diag::note_constexpr_delete_subobject)
1321 << Ptr.toDiagnosticString(S.getASTContext()) << Ptr.isOnePastEnd();
1322 return false;
1323 }
1324
1325 if (!CheckDeleteSource(S, OpPC, Source, Ptr))
1326 return false;
1327
1328 // For a class type with a virtual destructor, the selected operator delete
1329 // is the one looked up when building the destructor.
1330 if (!DeleteIsArrayForm && !IsGlobalDelete) {
1331 QualType AllocType = Ptr.getType();
1332 auto getVirtualOperatorDelete = [](QualType T) -> const FunctionDecl * {
1333 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1334 if (const CXXDestructorDecl *DD = RD->getDestructor())
1335 return DD->isVirtual() ? DD->getOperatorDelete() : nullptr;
1336 return nullptr;
1337 };
1338
1339 if (const FunctionDecl *VirtualDelete =
1340 getVirtualOperatorDelete(AllocType);
1341 VirtualDelete &&
1342 !VirtualDelete
1344 S.FFDiag(S.Current->getSource(OpPC),
1345 diag::note_constexpr_new_non_replaceable)
1346 << isa<CXXMethodDecl>(VirtualDelete) << VirtualDelete;
1347 return false;
1348 }
1349 }
1350 }
1351 assert(Source);
1352 assert(BlockToDelete);
1353
1354 // Invoke destructors before deallocating the memory.
1355 if (!RunDestructors(S, OpPC, BlockToDelete))
1356 return false;
1357
1358 if (!Allocator.deallocate(Source, BlockToDelete, S)) {
1359 // Nothing has been deallocated, this must be a double-delete.
1360 const SourceInfo &Loc = S.Current->getSource(OpPC);
1361 S.FFDiag(Loc, diag::note_constexpr_double_delete);
1362 return false;
1363 }
1364
1365 return true;
1366}
1367
1369 const APSInt &Value) {
1370 llvm::APInt Min;
1371 llvm::APInt Max;
1372 ED->getValueRange(Max, Min);
1373 --Max;
1374
1375 if (ED->getNumNegativeBits() &&
1376 (Max.slt(Value.getSExtValue()) || Min.sgt(Value.getSExtValue()))) {
1377 const SourceLocation &Loc = S.Current->getLocation(OpPC);
1378 S.CCEDiag(Loc, diag::note_constexpr_unscoped_enum_out_of_range)
1379 << llvm::toString(Value, 10) << Min.getSExtValue() << Max.getSExtValue()
1380 << ED;
1381 } else if (!ED->getNumNegativeBits() && Max.ult(Value.getZExtValue())) {
1382 const SourceLocation &Loc = S.Current->getLocation(OpPC);
1383 S.CCEDiag(Loc, diag::note_constexpr_unscoped_enum_out_of_range)
1384 << llvm::toString(Value, 10) << Min.getZExtValue() << Max.getZExtValue()
1385 << ED;
1386 }
1387}
1388
1390 assert(T);
1391 assert(!S.getLangOpts().CPlusPlus23);
1392
1393 // C++1y: A constant initializer for an object o [...] may also invoke
1394 // constexpr constructors for o and its subobjects even if those objects
1395 // are of non-literal class types.
1396 //
1397 // C++11 missed this detail for aggregates, so classes like this:
1398 // struct foo_t { union { int i; volatile int j; } u; };
1399 // are not (obviously) initializable like so:
1400 // __attribute__((__require_constant_initialization__))
1401 // static const foo_t x = {{0}};
1402 // because "i" is a subobject with non-literal initialization (due to the
1403 // volatile member of the union). See:
1404 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1677
1405 // Therefore, we use the C++1y behavior.
1406
1407 if (S.Current->getFunction() && S.Current->getFunction()->isConstructor() &&
1409 return true;
1410 }
1411
1412 const Expr *E = S.Current->getExpr(OpPC);
1413 if (S.getLangOpts().CPlusPlus11)
1414 S.FFDiag(E, diag::note_constexpr_nonliteral) << E->getType();
1415 else
1416 S.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
1417 return false;
1418}
1419
1420static bool getField(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
1421 uint32_t Off) {
1422 if (S.getLangOpts().CPlusPlus && S.inConstantContext() &&
1423 !CheckNull(S, OpPC, Ptr, CSK_Field))
1424 return false;
1425
1426 if (!CheckRange(S, OpPC, Ptr, CSK_Field))
1427 return false;
1428 if (!CheckArray(S, OpPC, Ptr))
1429 return false;
1430 if (!CheckSubobject(S, OpPC, Ptr, CSK_Field))
1431 return false;
1432
1433 if (Ptr.isIntegralPointer()) {
1434 S.Stk.push<Pointer>(Ptr.asIntPointer().atOffset(S.getASTContext(), Off));
1435 return true;
1436 }
1437
1438 if (!Ptr.isBlockPointer()) {
1439 // FIXME: The only time we (seem to) get here is when trying to access a
1440 // field of a typeid pointer. In that case, we're supposed to diagnose e.g.
1441 // `typeid(int).name`, but we currently diagnose `&typeid(int)`.
1442 S.FFDiag(S.Current->getSource(OpPC),
1443 diag::note_constexpr_access_unreadable_object)
1445 return false;
1446 }
1447
1448 if ((Ptr.getByteOffset() + Off) >= Ptr.block()->getSize())
1449 return false;
1450
1451 S.Stk.push<Pointer>(Ptr.atField(Off));
1452 return true;
1453}
1454
1455bool GetPtrField(InterpState &S, CodePtr OpPC, uint32_t Off) {
1456 const auto &Ptr = S.Stk.peek<Pointer>();
1457 return getField(S, OpPC, Ptr, Off);
1458}
1459
1460bool GetPtrFieldPop(InterpState &S, CodePtr OpPC, uint32_t Off) {
1461 const auto &Ptr = S.Stk.pop<Pointer>();
1462 return getField(S, OpPC, Ptr, Off);
1463}
1464
1465static bool checkConstructor(InterpState &S, CodePtr OpPC, const Function *Func,
1466 const Pointer &ThisPtr) {
1467 assert(Func->isConstructor());
1468
1469 if (Func->getParentDecl()->isInvalidDecl())
1470 return false;
1471
1472 const Descriptor *D = ThisPtr.getFieldDesc();
1473 // FIXME: I think this case is not 100% correct. E.g. a pointer into a
1474 // subobject of a composite array.
1475 if (!D->ElemRecord)
1476 return true;
1477
1478 if (D->ElemRecord->getNumVirtualBases() == 0)
1479 return true;
1480
1481 S.FFDiag(S.Current->getLocation(OpPC), diag::note_constexpr_virtual_base)
1482 << Func->getParentDecl();
1483 return false;
1484}
1485
1486bool CheckDestructor(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
1487 if (!CheckLive(S, OpPC, Ptr, AK_Destroy))
1488 return false;
1489 if (!CheckTemporary(S, OpPC, Ptr.block(), AK_Destroy))
1490 return false;
1491 if (!CheckRange(S, OpPC, Ptr, AK_Destroy))
1492 return false;
1493
1494 // Can't call a dtor on a global variable.
1495 if (Ptr.block()->isStatic()) {
1496 const SourceInfo &E = S.Current->getSource(OpPC);
1497 S.FFDiag(E, diag::note_constexpr_modify_global);
1498 return false;
1499 }
1500 return CheckActive(S, OpPC, Ptr, AK_Destroy);
1501}
1502
1503static void compileFunction(InterpState &S, const Function *Func) {
1504 const FunctionDecl *Definition = Func->getDecl()->getDefinition();
1505 if (!Definition)
1506 return;
1507
1509 .compileFunc(Definition, const_cast<Function *>(Func));
1510}
1511
1513 uint32_t VarArgSize) {
1514 if (Func->hasThisPointer()) {
1515 size_t ArgSize = Func->getArgSize() + VarArgSize;
1516 size_t ThisOffset = ArgSize - (Func->hasRVO() ? primSize(PT_Ptr) : 0);
1517 const Pointer &ThisPtr = S.Stk.peek<Pointer>(ThisOffset);
1518
1519 // If the current function is a lambda static invoker and
1520 // the function we're about to call is a lambda call operator,
1521 // skip the CheckInvoke, since the ThisPtr is a null pointer
1522 // anyway.
1523 if (!(S.Current->getFunction() &&
1525 Func->isLambdaCallOperator())) {
1526 if (!CheckInvoke(S, OpPC, ThisPtr))
1527 return false;
1528 }
1529
1531 return false;
1532 }
1533
1534 if (!Func->isFullyCompiled())
1536
1537 if (!CheckCallable(S, OpPC, Func))
1538 return false;
1539
1540 if (!CheckCallDepth(S, OpPC))
1541 return false;
1542
1543 auto NewFrame = std::make_unique<InterpFrame>(S, Func, OpPC, VarArgSize);
1544 InterpFrame *FrameBefore = S.Current;
1545 S.Current = NewFrame.get();
1546
1547 // Note that we cannot assert(CallResult.hasValue()) here since
1548 // Ret() above only sets the APValue if the curent frame doesn't
1549 // have a caller set.
1550 if (Interpret(S)) {
1551 NewFrame.release(); // Frame was delete'd already.
1552 assert(S.Current == FrameBefore);
1553 return true;
1554 }
1555
1556 // Interpreting the function failed somehow. Reset to
1557 // previous state.
1558 S.Current = FrameBefore;
1559 return false;
1560}
1561bool Call(InterpState &S, CodePtr OpPC, const Function *Func,
1562 uint32_t VarArgSize) {
1563 assert(Func);
1564 auto cleanup = [&]() -> bool {
1566 return false;
1567 };
1568
1569 if (Func->hasThisPointer()) {
1570 size_t ArgSize = Func->getArgSize() + VarArgSize;
1571 size_t ThisOffset = ArgSize - (Func->hasRVO() ? primSize(PT_Ptr) : 0);
1572
1573 const Pointer &ThisPtr = S.Stk.peek<Pointer>(ThisOffset);
1574
1575 // C++23 [expr.const]p5.6
1576 // an invocation of a virtual function ([class.virtual]) for an object whose
1577 // dynamic type is constexpr-unknown;
1578 if (ThisPtr.isDummy() && Func->isVirtual())
1579 return false;
1580
1581 // If the current function is a lambda static invoker and
1582 // the function we're about to call is a lambda call operator,
1583 // skip the CheckInvoke, since the ThisPtr is a null pointer
1584 // anyway.
1585 if (S.Current->getFunction() &&
1587 Func->isLambdaCallOperator()) {
1588 assert(ThisPtr.isZero());
1589 } else {
1590 if (!CheckInvoke(S, OpPC, ThisPtr))
1591 return cleanup();
1592 if (!Func->isConstructor() && !Func->isDestructor() &&
1593 !CheckActive(S, OpPC, ThisPtr, AK_MemberCall))
1594 return false;
1595 }
1596
1597 if (Func->isConstructor() && !checkConstructor(S, OpPC, Func, ThisPtr))
1598 return false;
1599 if (Func->isDestructor() && !CheckDestructor(S, OpPC, ThisPtr))
1600 return false;
1601
1602 if (Func->isConstructor() || Func->isDestructor())
1603 S.InitializingBlocks.push_back(ThisPtr.block());
1604 }
1605
1606 if (!Func->isFullyCompiled())
1608
1609 if (!CheckCallable(S, OpPC, Func))
1610 return cleanup();
1611
1612 // FIXME: The isConstructor() check here is not always right. The current
1613 // constant evaluator is somewhat inconsistent in when it allows a function
1614 // call when checking for a constant expression.
1615 if (Func->hasThisPointer() && S.checkingPotentialConstantExpression() &&
1616 !Func->isConstructor())
1617 return cleanup();
1618
1619 if (!CheckCallDepth(S, OpPC))
1620 return cleanup();
1621
1622 auto NewFrame = std::make_unique<InterpFrame>(S, Func, OpPC, VarArgSize);
1623 InterpFrame *FrameBefore = S.Current;
1624 S.Current = NewFrame.get();
1625
1626 InterpStateCCOverride CCOverride(S, Func->isImmediate());
1627 // Note that we cannot assert(CallResult.hasValue()) here since
1628 // Ret() above only sets the APValue if the curent frame doesn't
1629 // have a caller set.
1630 bool Success = Interpret(S);
1631 // Remove initializing block again.
1632 if (Func->isConstructor() || Func->isDestructor())
1633 S.InitializingBlocks.pop_back();
1634
1635 if (!Success) {
1636 // Interpreting the function failed somehow. Reset to
1637 // previous state.
1638 S.Current = FrameBefore;
1639 return false;
1640 }
1641
1642 NewFrame.release(); // Frame was delete'd already.
1643 assert(S.Current == FrameBefore);
1644 return true;
1645}
1646
1647static bool GetDynamicDecl(InterpState &S, CodePtr OpPC, Pointer TypePtr,
1648 const CXXRecordDecl *&DynamicDecl) {
1649 while (TypePtr.isBaseClass())
1650 TypePtr = TypePtr.getBase();
1651
1652 QualType DynamicType = TypePtr.getType();
1653 if (TypePtr.isStatic() || TypePtr.isConst()) {
1654 if (const VarDecl *VD = TypePtr.getDeclDesc()->asVarDecl();
1655 VD && !VD->isConstexpr()) {
1656 const Expr *E = S.Current->getExpr(OpPC);
1657 APValue V = TypePtr.toAPValue(S.getASTContext());
1659 S.FFDiag(E, diag::note_constexpr_polymorphic_unknown_dynamic_type)
1660 << AccessKinds::AK_MemberCall << V.getAsString(S.getASTContext(), TT);
1661 return false;
1662 }
1663 }
1664
1665 if (DynamicType->isPointerType() || DynamicType->isReferenceType()) {
1666 DynamicDecl = DynamicType->getPointeeCXXRecordDecl();
1667 } else if (DynamicType->isArrayType()) {
1668 const Type *ElemType = DynamicType->getPointeeOrArrayElementType();
1669 assert(ElemType);
1670 DynamicDecl = ElemType->getAsCXXRecordDecl();
1671 } else {
1672 DynamicDecl = DynamicType->getAsCXXRecordDecl();
1673 }
1674 return true;
1675}
1676
1678 uint32_t VarArgSize) {
1679 assert(Func->hasThisPointer());
1680 assert(Func->isVirtual());
1681 size_t ArgSize = Func->getArgSize() + VarArgSize;
1682 size_t ThisOffset = ArgSize - (Func->hasRVO() ? primSize(PT_Ptr) : 0);
1683 Pointer &ThisPtr = S.Stk.peek<Pointer>(ThisOffset);
1684 const FunctionDecl *Callee = Func->getDecl();
1685
1686 const CXXRecordDecl *DynamicDecl = nullptr;
1687 if (!GetDynamicDecl(S, OpPC, ThisPtr, DynamicDecl))
1688 return false;
1689 assert(DynamicDecl);
1690
1691 const auto *StaticDecl = cast<CXXRecordDecl>(Func->getParentDecl());
1692 const auto *InitialFunction = cast<CXXMethodDecl>(Callee);
1693 const CXXMethodDecl *Overrider;
1694
1695 if (StaticDecl != DynamicDecl &&
1696 !llvm::is_contained(S.InitializingBlocks, ThisPtr.block())) {
1697 if (!DynamicDecl->isDerivedFrom(StaticDecl))
1698 return false;
1699 Overrider = S.getContext().getOverridingFunction(DynamicDecl, StaticDecl,
1700 InitialFunction);
1701
1702 } else {
1703 Overrider = InitialFunction;
1704 }
1705
1706 // C++2a [class.abstract]p6:
1707 // the effect of making a virtual call to a pure virtual function [...] is
1708 // undefined
1709 if (Overrider->isPureVirtual()) {
1710 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_pure_virtual_call,
1711 1)
1712 << Callee;
1713 S.Note(Callee->getLocation(), diag::note_declared_at);
1714 return false;
1715 }
1716
1717 if (Overrider != InitialFunction) {
1718 // DR1872: An instantiated virtual constexpr function can't be called in a
1719 // constant expression (prior to C++20). We can still constant-fold such a
1720 // call.
1721 if (!S.getLangOpts().CPlusPlus20 && Overrider->isVirtual()) {
1722 const Expr *E = S.Current->getExpr(OpPC);
1723 S.CCEDiag(E, diag::note_constexpr_virtual_call) << E->getSourceRange();
1724 }
1725
1726 Func = S.getContext().getOrCreateFunction(Overrider);
1727
1728 const CXXRecordDecl *ThisFieldDecl =
1729 ThisPtr.getFieldDesc()->getType()->getAsCXXRecordDecl();
1730 if (Func->getParentDecl()->isDerivedFrom(ThisFieldDecl)) {
1731 // If the function we call is further DOWN the hierarchy than the
1732 // FieldDesc of our pointer, just go up the hierarchy of this field
1733 // the furthest we can go.
1734 while (ThisPtr.isBaseClass())
1735 ThisPtr = ThisPtr.getBase();
1736 }
1737 }
1738
1739 if (!Call(S, OpPC, Func, VarArgSize))
1740 return false;
1741
1742 // Covariant return types. The return type of Overrider is a pointer
1743 // or reference to a class type.
1744 if (Overrider != InitialFunction &&
1745 Overrider->getReturnType()->isPointerOrReferenceType() &&
1746 InitialFunction->getReturnType()->isPointerOrReferenceType()) {
1747 QualType OverriderPointeeType =
1748 Overrider->getReturnType()->getPointeeType();
1749 QualType InitialPointeeType =
1750 InitialFunction->getReturnType()->getPointeeType();
1751 // We've called Overrider above, but calling code expects us to return what
1752 // InitialFunction returned. According to the rules for covariant return
1753 // types, what InitialFunction returns needs to be a base class of what
1754 // Overrider returns. So, we need to do an upcast here.
1755 unsigned Offset = S.getContext().collectBaseOffset(
1756 InitialPointeeType->getAsRecordDecl(),
1757 OverriderPointeeType->getAsRecordDecl());
1758 return GetPtrBasePop(S, OpPC, Offset, /*IsNullOK=*/true);
1759 }
1760
1761 return true;
1762}
1763
1764bool CallBI(InterpState &S, CodePtr OpPC, const CallExpr *CE,
1765 uint32_t BuiltinID) {
1766 // A little arbitrary, but the current interpreter allows evaluation
1767 // of builtin functions in this mode, with some exceptions.
1768 if (BuiltinID == Builtin::BI__builtin_operator_new &&
1770 return false;
1771
1772 return InterpretBuiltin(S, OpPC, CE, BuiltinID);
1773}
1774
1775bool CallPtr(InterpState &S, CodePtr OpPC, uint32_t ArgSize,
1776 const CallExpr *CE) {
1777 const Pointer &Ptr = S.Stk.pop<Pointer>();
1778
1779 if (Ptr.isZero()) {
1780 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_null_callee)
1781 << const_cast<Expr *>(CE->getCallee()) << CE->getSourceRange();
1782 return false;
1783 }
1784
1785 if (!Ptr.isFunctionPointer())
1786 return Invalid(S, OpPC);
1787
1788 const FunctionPointer &FuncPtr = Ptr.asFunctionPointer();
1789 const Function *F = FuncPtr.getFunction();
1790 assert(F);
1791 // Don't allow calling block pointers.
1792 if (!F->getDecl())
1793 return Invalid(S, OpPC);
1794
1795 // This happens when the call expression has been cast to
1796 // something else, but we don't support that.
1797 if (S.Ctx.classify(F->getDecl()->getReturnType()) !=
1799 return false;
1800
1801 // Check argument nullability state.
1802 if (F->hasNonNullAttr()) {
1803 if (!CheckNonNullArgs(S, OpPC, F, CE, ArgSize))
1804 return false;
1805 }
1806
1807 // Can happen when casting function pointers around.
1808 QualType CalleeType = CE->getCallee()->getType();
1809 if (CalleeType->isPointerType() &&
1811 F->getDecl()->getType(), CalleeType->getPointeeType())) {
1812 return false;
1813 }
1814
1815 assert(ArgSize >= F->getWrittenArgSize());
1816 uint32_t VarArgSize = ArgSize - F->getWrittenArgSize();
1817
1818 // We need to do this explicitly here since we don't have the necessary
1819 // information to do it automatically.
1820 if (F->isThisPointerExplicit())
1821 VarArgSize -= align(primSize(PT_Ptr));
1822
1823 if (F->isVirtual())
1824 return CallVirt(S, OpPC, F, VarArgSize);
1825
1826 return Call(S, OpPC, F, VarArgSize);
1827}
1828
1829static void startLifetimeRecurse(const Pointer &Ptr) {
1830 if (const Record *R = Ptr.getRecord()) {
1831 Ptr.startLifetime();
1832 for (const Record::Field &Fi : R->fields())
1833 startLifetimeRecurse(Ptr.atField(Fi.Offset));
1834 return;
1835 }
1836
1837 if (const Descriptor *FieldDesc = Ptr.getFieldDesc();
1838 FieldDesc->isCompositeArray()) {
1839 assert(Ptr.getLifetime() == Lifetime::Started);
1840 for (unsigned I = 0; I != FieldDesc->getNumElems(); ++I)
1842 return;
1843 }
1844
1845 Ptr.startLifetime();
1846}
1847
1849 const auto &Ptr = S.Stk.peek<Pointer>();
1850 if (Ptr.isBlockPointer() && !CheckDummy(S, OpPC, Ptr.block(), AK_Destroy))
1851 return false;
1852 startLifetimeRecurse(Ptr.narrow());
1853 return true;
1854}
1855
1856// FIXME: It might be better to the recursing as part of the generated code for
1857// a destructor?
1858static void endLifetimeRecurse(const Pointer &Ptr) {
1859 if (const Record *R = Ptr.getRecord()) {
1860 Ptr.endLifetime();
1861 for (const Record::Field &Fi : R->fields())
1862 endLifetimeRecurse(Ptr.atField(Fi.Offset));
1863 return;
1864 }
1865
1866 if (const Descriptor *FieldDesc = Ptr.getFieldDesc();
1867 FieldDesc->isCompositeArray()) {
1868 // No endLifetime() for array roots.
1869 assert(Ptr.getLifetime() == Lifetime::Started);
1870 for (unsigned I = 0; I != FieldDesc->getNumElems(); ++I)
1872 return;
1873 }
1874
1875 Ptr.endLifetime();
1876}
1877
1878/// Ends the lifetime of the peek'd pointer.
1880 const auto &Ptr = S.Stk.peek<Pointer>();
1881 if (Ptr.isBlockPointer() && !CheckDummy(S, OpPC, Ptr.block(), AK_Destroy))
1882 return false;
1883
1884 // FIXME: We need per-element lifetime information for primitive arrays.
1885 if (Ptr.isArrayElement())
1886 return true;
1887
1888 endLifetimeRecurse(Ptr.narrow());
1889 return true;
1890}
1891
1892/// Ends the lifetime of the pop'd pointer.
1894 const auto &Ptr = S.Stk.pop<Pointer>();
1895 if (Ptr.isBlockPointer() && !CheckDummy(S, OpPC, Ptr.block(), AK_Destroy))
1896 return false;
1897
1898 // FIXME: We need per-element lifetime information for primitive arrays.
1899 if (Ptr.isArrayElement())
1900 return true;
1901
1902 endLifetimeRecurse(Ptr.narrow());
1903 return true;
1904}
1905
1907 std::optional<uint64_t> ArraySize) {
1908 const Pointer &Ptr = S.Stk.peek<Pointer>();
1909
1910 if (Ptr.inUnion() && Ptr.getBase().getRecord()->isUnion())
1911 Ptr.activate();
1912
1913 if (Ptr.isZero()) {
1914 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_null)
1915 << AK_Construct;
1916 return false;
1917 }
1918
1919 if (!Ptr.isBlockPointer())
1920 return false;
1921
1923
1924 // Similar to CheckStore(), but with the additional CheckTemporary() call and
1925 // the AccessKinds are different.
1926 if (!Ptr.block()->isAccessible()) {
1927 if (!CheckExtern(S, OpPC, Ptr))
1928 return false;
1929 if (!CheckLive(S, OpPC, Ptr, AK_Construct))
1930 return false;
1931 return CheckDummy(S, OpPC, Ptr.block(), AK_Construct);
1932 }
1933 if (!CheckTemporary(S, OpPC, Ptr.block(), AK_Construct))
1934 return false;
1935
1936 // CheckLifetime for this and all base pointers.
1937 for (Pointer P = Ptr;;) {
1938 if (!CheckLifetime(S, OpPC, P.getLifetime(), AK_Construct))
1939 return false;
1940
1941 if (P.isRoot())
1942 break;
1943 P = P.getBase();
1944 }
1945
1946 if (!CheckRange(S, OpPC, Ptr, AK_Construct))
1947 return false;
1948 if (!CheckGlobal(S, OpPC, Ptr))
1949 return false;
1950 if (!CheckConst(S, OpPC, Ptr))
1951 return false;
1952 if (!S.inConstantContext() && isConstexprUnknown(Ptr))
1953 return false;
1954
1955 if (!InvalidNewDeleteExpr(S, OpPC, E))
1956 return false;
1957
1958 const auto *NewExpr = cast<CXXNewExpr>(E);
1959 QualType StorageType = Ptr.getFieldDesc()->getDataType(S.getASTContext());
1960 const ASTContext &ASTCtx = S.getASTContext();
1961 QualType AllocType;
1962 if (ArraySize) {
1963 AllocType = ASTCtx.getConstantArrayType(
1964 NewExpr->getAllocatedType(),
1965 APInt(64, static_cast<uint64_t>(*ArraySize), false), nullptr,
1967 } else {
1968 AllocType = NewExpr->getAllocatedType();
1969 }
1970
1971 unsigned StorageSize = 1;
1972 unsigned AllocSize = 1;
1973 if (const auto *CAT = dyn_cast<ConstantArrayType>(AllocType))
1974 AllocSize = CAT->getZExtSize();
1975 if (const auto *CAT = dyn_cast<ConstantArrayType>(StorageType))
1976 StorageSize = CAT->getZExtSize();
1977
1978 if (AllocSize > StorageSize ||
1979 !ASTCtx.hasSimilarType(ASTCtx.getBaseElementType(AllocType),
1980 ASTCtx.getBaseElementType(StorageType))) {
1981 S.FFDiag(S.Current->getLocation(OpPC),
1982 diag::note_constexpr_placement_new_wrong_type)
1983 << StorageType << AllocType;
1984 return false;
1985 }
1986
1987 // Can't activate fields in a union, unless the direct base is the union.
1988 if (Ptr.inUnion() && !Ptr.isActive() && !Ptr.getBase().getRecord()->isUnion())
1989 return CheckActive(S, OpPC, Ptr, AK_Construct);
1990
1991 return true;
1992}
1993
1995 assert(E);
1996
1997 if (const auto *NewExpr = dyn_cast<CXXNewExpr>(E)) {
1998 const FunctionDecl *OperatorNew = NewExpr->getOperatorNew();
1999
2000 if (NewExpr->getNumPlacementArgs() > 0) {
2001 // This is allowed pre-C++26, but only an std function.
2002 if (S.getLangOpts().CPlusPlus26 || S.Current->isStdFunction())
2003 return true;
2004 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_new_placement)
2005 << /*C++26 feature*/ 1 << E->getSourceRange();
2006 } else if (
2007 !OperatorNew
2008 ->isUsableAsGlobalAllocationFunctionInConstantEvaluation()) {
2009 S.FFDiag(S.Current->getSource(OpPC),
2010 diag::note_constexpr_new_non_replaceable)
2011 << isa<CXXMethodDecl>(OperatorNew) << OperatorNew;
2012 return false;
2013 } else if (!S.getLangOpts().CPlusPlus26 &&
2014 NewExpr->getNumPlacementArgs() == 1 &&
2015 !OperatorNew->isReservedGlobalPlacementOperator()) {
2016 if (!S.getLangOpts().CPlusPlus26) {
2017 S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_new_placement)
2018 << /*Unsupported*/ 0 << E->getSourceRange();
2019 return false;
2020 }
2021 return true;
2022 }
2023 } else {
2024 const auto *DeleteExpr = cast<CXXDeleteExpr>(E);
2025 const FunctionDecl *OperatorDelete = DeleteExpr->getOperatorDelete();
2026 if (!OperatorDelete
2027 ->isUsableAsGlobalAllocationFunctionInConstantEvaluation()) {
2028 S.FFDiag(S.Current->getSource(OpPC),
2029 diag::note_constexpr_new_non_replaceable)
2030 << isa<CXXMethodDecl>(OperatorDelete) << OperatorDelete;
2031 return false;
2032 }
2033 }
2034
2035 return false;
2036}
2037
2039 const FixedPoint &FP) {
2040 const Expr *E = S.Current->getExpr(OpPC);
2043 E->getExprLoc(), diag::warn_fixedpoint_constant_overflow)
2044 << FP.toDiagnosticString(S.getASTContext()) << E->getType();
2045 }
2046 S.CCEDiag(E, diag::note_constexpr_overflow)
2047 << FP.toDiagnosticString(S.getASTContext()) << E->getType();
2048 return S.noteUndefinedBehavior();
2049}
2050
2051bool InvalidShuffleVectorIndex(InterpState &S, CodePtr OpPC, uint32_t Index) {
2052 const SourceInfo &Loc = S.Current->getSource(OpPC);
2053 S.FFDiag(Loc,
2054 diag::err_shufflevector_minus_one_is_undefined_behavior_constexpr)
2055 << Index;
2056 return false;
2057}
2058
2060 const Pointer &Ptr, unsigned BitWidth) {
2061 if (Ptr.isDummy())
2062 return false;
2063 if (Ptr.isFunctionPointer())
2064 return true;
2065
2066 const SourceInfo &E = S.Current->getSource(OpPC);
2067 S.CCEDiag(E, diag::note_constexpr_invalid_cast)
2068 << 2 << S.getLangOpts().CPlusPlus << S.Current->getRange(OpPC);
2069
2070 if (Ptr.isBlockPointer() && !Ptr.isZero()) {
2071 // Only allow based lvalue casts if they are lossless.
2073 BitWidth)
2074 return Invalid(S, OpPC);
2075 }
2076 return true;
2077}
2078
2079bool CastPointerIntegralAP(InterpState &S, CodePtr OpPC, uint32_t BitWidth) {
2080 const Pointer &Ptr = S.Stk.pop<Pointer>();
2081
2082 if (!CheckPointerToIntegralCast(S, OpPC, Ptr, BitWidth))
2083 return false;
2084
2085 auto Result = S.allocAP<IntegralAP<false>>(BitWidth);
2086 Result.copy(APInt(BitWidth, Ptr.getIntegerRepresentation()));
2087
2089 return true;
2090}
2091
2092bool CastPointerIntegralAPS(InterpState &S, CodePtr OpPC, uint32_t BitWidth) {
2093 const Pointer &Ptr = S.Stk.pop<Pointer>();
2094
2095 if (!CheckPointerToIntegralCast(S, OpPC, Ptr, BitWidth))
2096 return false;
2097
2098 auto Result = S.allocAP<IntegralAP<true>>(BitWidth);
2099 Result.copy(APInt(BitWidth, Ptr.getIntegerRepresentation()));
2100
2102 return true;
2103}
2104
2105bool CheckBitCast(InterpState &S, CodePtr OpPC, bool HasIndeterminateBits,
2106 bool TargetIsUCharOrByte) {
2107 // This is always fine.
2108 if (!HasIndeterminateBits)
2109 return true;
2110
2111 // Indeterminate bits can only be bitcast to unsigned char or std::byte.
2112 if (TargetIsUCharOrByte)
2113 return true;
2114
2115 const Expr *E = S.Current->getExpr(OpPC);
2116 QualType ExprType = E->getType();
2117 S.FFDiag(E, diag::note_constexpr_bit_cast_indet_dest)
2118 << ExprType << S.getLangOpts().CharIsSigned << E->getSourceRange();
2119 return false;
2120}
2121
2122bool GetTypeid(InterpState &S, CodePtr OpPC, const Type *TypePtr,
2123 const Type *TypeInfoType) {
2124 S.Stk.push<Pointer>(TypePtr, TypeInfoType);
2125 return true;
2126}
2127
2128bool GetTypeidPtr(InterpState &S, CodePtr OpPC, const Type *TypeInfoType) {
2129 const auto &P = S.Stk.pop<Pointer>();
2130
2131 if (!P.isBlockPointer())
2132 return false;
2133
2134 // Pick the most-derived type.
2135 CanQualType T = P.getDeclPtr().getType()->getCanonicalTypeUnqualified();
2136 // ... unless we're currently constructing this object.
2137 // FIXME: We have a similar check to this in more places.
2138 if (S.Current->getFunction()) {
2139 for (const InterpFrame *Frame = S.Current; Frame; Frame = Frame->Caller) {
2140 if (const Function *Func = Frame->getFunction();
2141 Func && (Func->isConstructor() || Func->isDestructor()) &&
2142 P.block() == Frame->getThis().block()) {
2144 Func->getParentDecl());
2145 break;
2146 }
2147 }
2148 }
2149
2150 S.Stk.push<Pointer>(T->getTypePtr(), TypeInfoType);
2151 return true;
2152}
2153
2155 const auto *E = cast<CXXTypeidExpr>(S.Current->getExpr(OpPC));
2156 S.CCEDiag(E, diag::note_constexpr_typeid_polymorphic)
2157 << E->getExprOperand()->getType()
2158 << E->getExprOperand()->getSourceRange();
2159 return false;
2160}
2161
2163 const Pointer &RHS) {
2164 unsigned LHSOffset = LHS.isOnePastEnd() ? LHS.getNumElems() : LHS.getIndex();
2165 unsigned RHSOffset = RHS.isOnePastEnd() ? RHS.getNumElems() : RHS.getIndex();
2166 unsigned LHSLength = (LHS.getNumElems() - 1) * LHS.elemSize();
2167 unsigned RHSLength = (RHS.getNumElems() - 1) * RHS.elemSize();
2168
2169 StringRef LHSStr((const char *)LHS.atIndex(0).getRawAddress(), LHSLength);
2170 StringRef RHSStr((const char *)RHS.atIndex(0).getRawAddress(), RHSLength);
2171 int32_t IndexDiff = RHSOffset - LHSOffset;
2172 if (IndexDiff < 0) {
2173 if (static_cast<int32_t>(LHSLength) < -IndexDiff)
2174 return false;
2175 LHSStr = LHSStr.drop_front(-IndexDiff);
2176 } else {
2177 if (static_cast<int32_t>(RHSLength) < IndexDiff)
2178 return false;
2179 RHSStr = RHSStr.drop_front(IndexDiff);
2180 }
2181
2182 unsigned ShorterCharWidth;
2183 StringRef Shorter;
2184 StringRef Longer;
2185 if (LHSLength < RHSLength) {
2186 ShorterCharWidth = LHS.elemSize();
2187 Shorter = LHSStr;
2188 Longer = RHSStr;
2189 } else {
2190 ShorterCharWidth = RHS.elemSize();
2191 Shorter = RHSStr;
2192 Longer = LHSStr;
2193 }
2194
2195 // The null terminator isn't included in the string data, so check for it
2196 // manually. If the longer string doesn't have a null terminator where the
2197 // shorter string ends, they aren't potentially overlapping.
2198 for (unsigned NullByte : llvm::seq(ShorterCharWidth)) {
2199 if (Shorter.size() + NullByte >= Longer.size())
2200 break;
2201 if (Longer[Shorter.size() + NullByte])
2202 return false;
2203 }
2204 return Shorter == Longer.take_front(Shorter.size());
2205}
2206
2207static void copyPrimitiveMemory(InterpState &S, const Pointer &Ptr,
2208 PrimType T) {
2209
2210 if (T == PT_IntAPS) {
2211 auto &Val = Ptr.deref<IntegralAP<true>>();
2212 if (!Val.singleWord()) {
2213 uint64_t *NewMemory = new (S.P) uint64_t[Val.numWords()];
2214 Val.take(NewMemory);
2215 }
2216 } else if (T == PT_IntAP) {
2217 auto &Val = Ptr.deref<IntegralAP<false>>();
2218 if (!Val.singleWord()) {
2219 uint64_t *NewMemory = new (S.P) uint64_t[Val.numWords()];
2220 Val.take(NewMemory);
2221 }
2222 } else if (T == PT_Float) {
2223 auto &Val = Ptr.deref<Floating>();
2224 if (!Val.singleWord()) {
2225 uint64_t *NewMemory = new (S.P) uint64_t[Val.numWords()];
2226 Val.take(NewMemory);
2227 }
2228 }
2229}
2230
2231template <typename T>
2232static void copyPrimitiveMemory(InterpState &S, const Pointer &Ptr) {
2233 assert(needsAlloc<T>());
2234 auto &Val = Ptr.deref<T>();
2235 if (!Val.singleWord()) {
2236 uint64_t *NewMemory = new (S.P) uint64_t[Val.numWords()];
2237 Val.take(NewMemory);
2238 }
2239}
2240
2241static void finishGlobalRecurse(InterpState &S, const Pointer &Ptr) {
2242 if (const Record *R = Ptr.getRecord()) {
2243 for (const Record::Field &Fi : R->fields()) {
2244 if (Fi.Desc->isPrimitive()) {
2245 TYPE_SWITCH_ALLOC(Fi.Desc->getPrimType(), {
2246 copyPrimitiveMemory<T>(S, Ptr.atField(Fi.Offset));
2247 });
2248 copyPrimitiveMemory(S, Ptr.atField(Fi.Offset), Fi.Desc->getPrimType());
2249 } else
2250 finishGlobalRecurse(S, Ptr.atField(Fi.Offset));
2251 }
2252 return;
2253 }
2254
2255 if (const Descriptor *D = Ptr.getFieldDesc(); D && D->isArray()) {
2256 unsigned NumElems = D->getNumElems();
2257 if (NumElems == 0)
2258 return;
2259
2260 if (D->isPrimitiveArray()) {
2261 PrimType PT = D->getPrimType();
2262 if (!needsAlloc(PT))
2263 return;
2264 assert(NumElems >= 1);
2265 const Pointer EP = Ptr.atIndex(0);
2266 bool AllSingleWord = true;
2267 TYPE_SWITCH_ALLOC(PT, {
2268 if (!EP.deref<T>().singleWord()) {
2270 AllSingleWord = false;
2271 }
2272 });
2273 if (AllSingleWord)
2274 return;
2275 for (unsigned I = 1; I != D->getNumElems(); ++I) {
2276 const Pointer EP = Ptr.atIndex(I);
2277 copyPrimitiveMemory(S, EP, PT);
2278 }
2279 } else {
2280 assert(D->isCompositeArray());
2281 for (unsigned I = 0; I != D->getNumElems(); ++I) {
2282 const Pointer EP = Ptr.atIndex(I).narrow();
2283 finishGlobalRecurse(S, EP);
2284 }
2285 }
2286 }
2287}
2288
2290 const Pointer &Ptr = S.Stk.pop<Pointer>();
2291
2292 finishGlobalRecurse(S, Ptr);
2293 if (Ptr.canBeInitialized()) {
2294 Ptr.initialize();
2295 Ptr.activate();
2296 }
2297
2298 return true;
2299}
2300
2301// https://github.com/llvm/llvm-project/issues/102513
2302#if defined(_MSC_VER) && !defined(__clang__) && !defined(NDEBUG)
2303#pragma optimize("", off)
2304#endif
2306 // The current stack frame when we started Interpret().
2307 // This is being used by the ops to determine wheter
2308 // to return from this function and thus terminate
2309 // interpretation.
2310 const InterpFrame *StartFrame = S.Current;
2311 assert(!S.Current->isRoot());
2312 CodePtr PC = S.Current->getPC();
2313
2314 // Empty program.
2315 if (!PC)
2316 return true;
2317
2318 for (;;) {
2319 auto Op = PC.read<Opcode>();
2320 CodePtr OpPC = PC;
2321
2322 switch (Op) {
2323#define GET_INTERP
2324#include "Opcodes.inc"
2325#undef GET_INTERP
2326 }
2327 }
2328}
2329// https://github.com/llvm/llvm-project/issues/102513
2330#if defined(_MSC_VER) && !defined(__clang__) && !defined(NDEBUG)
2331#pragma optimize("", on)
2332#endif
2333
2334} // namespace interp
2335} // namespace clang
Defines the clang::ASTContext interface.
#define V(N, I)
Defines the clang::Expr interface and subclasses for C++ expressions.
static const FunctionDecl * getVirtualOperatorDelete(QualType T)
tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName="<stdin>")
Clean up any erroneous/redundant code in the given Ranges in Code.
static bool Jmp(InterpState &S, CodePtr &PC, int32_t Offset)
Definition Interp.cpp:39
static bool CheckTemporary(InterpState &S, CodePtr OpPC, const Block *B, AccessKinds AK)
Definition Interp.cpp:214
static bool BCP(InterpState &S, CodePtr &RealPC, int32_t Offset, PrimType PT)
Definition Interp.cpp:64
static bool CheckGlobal(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Definition Interp.cpp:240
static bool Jt(InterpState &S, CodePtr &PC, int32_t Offset)
Definition Interp.cpp:44
static void diagnoseNonConstVariable(InterpState &S, CodePtr OpPC, const ValueDecl *VD)
Definition Interp.cpp:177
static bool diagnoseUnknownDecl(InterpState &S, CodePtr OpPC, const ValueDecl *D)
Definition Interp.cpp:137
static bool Jf(InterpState &S, CodePtr &PC, int32_t Offset)
Definition Interp.cpp:51
static void diagnoseMissingInitializer(InterpState &S, CodePtr OpPC, const ValueDecl *VD)
Definition Interp.cpp:128
static bool RetValue(InterpState &S, CodePtr &Pt)
Definition Interp.cpp:31
static StringRef getIdentifier(const Token &Tok)
#define TYPE_SWITCH_ALLOC(Expr, B)
Definition PrimType.h:265
#define TYPE_SWITCH(Expr, B)
Definition PrimType.h:207
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition APValue.h:122
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition ASTContext.h:220
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U) const
Determine whether two function types are the same, ignoring exception specifications in cases where t...
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
bool hasSimilarType(QualType T1, QualType T2) const
Determine if two types are similar, according to the C++ rules.
DiagnosticsEngine & getDiagnostics() const
const TargetInfo & getTargetInfo() const
Definition ASTContext.h:891
CanQualType getCanonicalTagType(const TagDecl *TD) const
Represents a C++ destructor within a class.
Definition DeclCXX.h:2869
Represents a static or instance method of a struct/union/class.
Definition DeclCXX.h:2129
bool isVirtual() const
Definition DeclCXX.h:2184
Represents a C++ struct/union/class.
Definition DeclCXX.h:258
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition Expr.h:2877
Expr * getCallee()
Definition Expr.h:3024
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition Expr.h:3068
Expr ** getArgs()
Retrieve the call arguments.
Definition Expr.h:3071
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
Definition Expr.cpp:1599
A reference to a declared variable, function, enum, etc.
Definition Expr.h:1270
ValueDecl * getDecl()
Definition Expr.h:1338
bool isInvalidDecl() const
Definition DeclBase.h:588
SourceLocation getLocation() const
Definition DeclBase.h:439
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition DeclBase.h:427
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Represents an enum.
Definition Decl.h:4007
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
Definition Decl.h:4208
void getValueRange(llvm::APInt &Max, llvm::APInt &Min) const
Calculates the [Min,Max) values the enum can store based on the NumPositiveBits and NumNegativeBits.
Definition Decl.cpp:5116
This represents one expression.
Definition Expr.h:112
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition Expr.cpp:273
QualType getType() const
Definition Expr.h:144
LangOptions::FPExceptionModeKind getExceptionMode() const
RoundingMode getRoundingMode() const
Represents a member of a struct/union/class.
Definition Decl.h:3160
Represents a function declaration or definition.
Definition Decl.h:2000
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition Decl.cpp:3268
QualType getReturnType() const
Definition Decl.h:2845
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition Decl.h:2377
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition Decl.h:2888
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition Decl.h:2470
bool isPureVirtual() const
Whether this virtual function is pure, i.e.
Definition Decl.h:2353
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:3415
FunctionDecl * getDefinition()
Get the definition for this declaration.
Definition Decl.h:2282
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Definition Decl.cpp:3188
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:3235
@ FPE_Ignore
Assume that floating-point exceptions are masked.
This represents a decl that may have a name.
Definition Decl.h:274
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition Decl.h:295
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition Decl.h:301
A (possibly-)qualified type.
Definition TypeBase.h:937
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition TypeBase.h:8362
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition TypeBase.h:8351
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:338
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:8515
bool isReferenceType() const
Definition TypeBase.h:8539
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:8989
bool isAnyComplexType() const
Definition TypeBase.h:8650
bool isPointerOrReferenceType() const
Definition TypeBase.h:8519
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition Decl.h:712
QualType getType() const
Definition Decl.h:723
Represents a variable declaration or definition.
Definition Decl.h:926
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition Decl.h:1569
A memory block, either on the stack or in the heap.
Definition InterpBlock.h:44
unsigned getSize() const
Returns the size of the block.
Definition InterpBlock.h:87
bool isExtern() const
Checks if the block is extern.
Definition InterpBlock.h:77
const Descriptor * getDescriptor() const
Returns the block's descriptor.
Definition InterpBlock.h:73
bool isStatic() const
Checks if the block has static storage duration.
Definition InterpBlock.h:79
bool isTemporary() const
Checks if the block is temporary.
Definition InterpBlock.h:81
std::byte * rawData()
Returns a pointer to the raw data, including metadata.
UnsignedOrNone getDeclID() const
Returns the declaration ID.
Definition InterpBlock.h:89
bool isDummy() const
Definition InterpBlock.h:84
unsigned getEvalID() const
The Evaluation ID this block was created in.
Definition InterpBlock.h:94
bool isWeak() const
Definition InterpBlock.h:82
bool isAccessible() const
Pointer into the code segment.
Definition Source.h:30
std::enable_if_t<!std::is_pointer< T >::value, T > read()
Reads data and advances the pointer.
Definition Source.h:56
Compilation context for expressions.
Definition Compiler.h:110
unsigned collectBaseOffset(const RecordDecl *BaseDecl, const RecordDecl *DerivedDecl) const
Definition Context.cpp:643
const Function * getOrCreateFunction(const FunctionDecl *FuncDecl)
Definition Context.cpp:500
ASTContext & getASTContext() const
Returns the AST context.
Definition Context.h:79
OptPrimType classify(QualType T) const
Classifies a type.
Definition Context.cpp:363
const CXXMethodDecl * getOverridingFunction(const CXXRecordDecl *DynamicDecl, const CXXRecordDecl *StaticDecl, const CXXMethodDecl *InitialFunction) const
Definition Context.cpp:464
unsigned getEvalID() const
Definition Context.h:145
Manages dynamic memory allocations done during bytecode interpretation.
bool deallocate(const Expr *Source, const Block *BlockToDelete, InterpState &S)
Deallocate the given source+block combination.
std::optional< Form > getAllocationForm(const Expr *Source) const
Checks whether the allocation done at the given source is an array allocation.
Wrapper around fixed point types.
Definition FixedPoint.h:23
std::string toDiagnosticString(const ASTContext &Ctx) const
Definition FixedPoint.h:81
If a Floating is constructed from Memory, it DOES NOT OWN THAT MEMORY.
Definition Floating.h:35
Base class for stack frames, shared between VM and walker.
Definition Frame.h:25
const Function * getFunction() const
Bytecode function.
Definition Function.h:86
bool isDestructor() const
Checks if the function is a destructor.
Definition Function.h:164
bool isVirtual() const
Checks if the function is virtual.
Definition Function.h:157
bool isDefined() const
Checks if the function is defined.
Definition Function.h:199
bool hasNonNullAttr() const
Definition Function.h:131
bool isConstructor() const
Checks if the function is a constructor.
Definition Function.h:162
const FunctionDecl * getDecl() const
Returns the original FunctionDecl.
Definition Function.h:109
bool hasBody() const
Checks if the function already has a body attached.
Definition Function.h:196
bool isConstexpr() const
Definition Function.h:159
bool isThisPointerExplicit() const
Definition Function.h:215
unsigned getWrittenArgSize() const
Definition Function.h:211
bool isLambdaStaticInvoker() const
Returns whether this function is a lambda static invoker, which we generate custom byte code for.
Definition Function.h:172
bool isValid() const
Checks if the function is valid to call.
Definition Function.h:154
If an IntegralAP is constructed from Memory, it DOES NOT OWN THAT MEMORY.
Definition IntegralAP.h:36
Wrapper around numeric types.
Definition Integral.h:66
static Integral from(ValT Value)
Definition Integral.h:206
Frame storing local variables.
Definition InterpFrame.h:27
const Expr * getExpr(CodePtr PC) const
InterpFrame * Caller
The frame of the previous function.
Definition InterpFrame.h:30
SourceInfo getSource(CodePtr PC) const
Map a location to a source.
CodePtr getRetPC() const
Returns the return address of the frame.
CodePtr getPC() const
Returns the PC of the frame's code start.
SourceLocation getLocation(CodePtr PC) const
const Pointer & getThis() const
Returns the 'this' pointer.
const Function * getFunction() const
Returns the current function.
Definition InterpFrame.h:72
SourceRange getRange(CodePtr PC) const
bool isRoot() const
Checks if the frame is a root frame - return should quit the interpreter.
unsigned getDepth() const
void clearTo(size_t NewSize)
T pop()
Returns the value from the top of the stack and removes it.
Definition InterpStack.h:39
void push(Tys &&...Args)
Constructs a value in place on the top of the stack.
Definition InterpStack.h:33
size_t size() const
Returns the size of the stack in bytes.
Definition InterpStack.h:77
void discard()
Discards the top value from the stack.
Definition InterpStack.h:50
T & peek() const
Returns a reference to the value on the top of the stack.
Definition InterpStack.h:62
Interpreter context.
Definition InterpState.h:43
Context & getContext() const
bool noteUndefinedBehavior() override
Definition InterpState.h:82
DynamicAllocator & getAllocator()
Context & Ctx
Interpreter Context.
llvm::SmallVector< const Block * > InitializingBlocks
List of blocks we're currently running either constructors or destructors for.
ASTContext & getASTContext() const override
Definition InterpState.h:70
InterpStack & Stk
Temporary stack.
const VarDecl * EvaluatingDecl
Declaration we're initializing/evaluting, if any.
InterpFrame * Current
The current frame.
T allocAP(unsigned BitWidth)
const LangOptions & getLangOpts() const
Definition InterpState.h:71
Program & P
Reference to the module containing all bytecode.
PrimType value_or(PrimType PT) const
Definition PrimType.h:68
A pointer to a memory block, live or dead.
Definition Pointer.h:91
Pointer narrow() const
Restricts the scope of an array element pointer.
Definition Pointer.h:188
UnsignedOrNone getDeclID() const
Returns the declaration ID.
Definition Pointer.h:576
bool isVolatile() const
Checks if an object or a subfield is volatile.
Definition Pointer.h:569
bool isInitialized() const
Checks if an object was initialized.
Definition Pointer.cpp:440
bool isStatic() const
Checks if the storage is static.
Definition Pointer.h:494
bool isDynamic() const
Checks if the storage has been dynamically allocated.
Definition Pointer.h:509
bool inUnion() const
Definition Pointer.h:402
bool isZeroSizeArray() const
Checks if the pointer is pointing to a zero-size array.
Definition Pointer.h:654
Pointer atIndex(uint64_t Idx) const
Offsets a pointer inside an array.
Definition Pointer.h:156
bool isDummy() const
Checks if the pointer points to a dummy value.
Definition Pointer.h:547
bool isExtern() const
Checks if the storage is extern.
Definition Pointer.h:488
int64_t getIndex() const
Returns the index into an array.
Definition Pointer.h:612
bool isActive() const
Checks if the object is active.
Definition Pointer.h:536
bool isConst() const
Checks if an object or a subfield is mutable.
Definition Pointer.h:557
Pointer atField(unsigned Off) const
Creates a pointer to a field.
Definition Pointer.h:173
T & deref() const
Dereferences the pointer, if it's live.
Definition Pointer.h:663
bool isMutable() const
Checks if the field is mutable.
Definition Pointer.h:520
bool isConstInMutable() const
Definition Pointer.h:562
unsigned getNumElems() const
Returns the number of elements.
Definition Pointer.h:596
bool isUnknownSizeArray() const
Checks if the structure is an array of unknown size.
Definition Pointer.h:415
void activate() const
Activats a field.
Definition Pointer.cpp:576
bool isIntegralPointer() const
Definition Pointer.h:469
QualType getType() const
Returns the type of the innermost field.
Definition Pointer.h:336
bool isArrayElement() const
Checks if the pointer points to an array.
Definition Pointer.h:421
bool isLive() const
Checks if the pointer is live.
Definition Pointer.h:268
Pointer getBase() const
Returns a pointer to the object of which this pointer is a field.
Definition Pointer.h:307
uint64_t getByteOffset() const
Returns the byte offset from the start.
Definition Pointer.h:585
bool isTypeidPointer() const
Definition Pointer.h:471
std::string toDiagnosticString(const ASTContext &Ctx) const
Converts the pointer to a string usable in diagnostics.
Definition Pointer.cpp:427
bool isZero() const
Checks if the pointer is null.
Definition Pointer.h:254
const IntPointer & asIntPointer() const
Definition Pointer.h:455
bool isRoot() const
Pointer points directly to a block.
Definition Pointer.h:437
const Descriptor * getDeclDesc() const
Accessor for information about the declaration site.
Definition Pointer.h:282
static bool pointToSameBlock(const Pointer &A, const Pointer &B)
Checks if both given pointers point to the same block.
Definition Pointer.cpp:652
APValue toAPValue(const ASTContext &ASTCtx) const
Converts the pointer to an APValue.
Definition Pointer.cpp:171
void endLifetime() const
Definition Pointer.h:732
bool isOnePastEnd() const
Checks if the index is one past end.
Definition Pointer.h:629
uint64_t getIntegerRepresentation() const
Definition Pointer.h:143
const FieldDecl * getField() const
Returns the field information.
Definition Pointer.h:481
bool isElementPastEnd() const
Checks if the pointer is an out-of-bounds element pointer.
Definition Pointer.h:651
void startLifetime() const
Definition Pointer.h:740
bool isBlockPointer() const
Definition Pointer.h:468
bool isTemporary() const
Checks if the storage is temporary.
Definition Pointer.h:501
const FunctionPointer & asFunctionPointer() const
Definition Pointer.h:459
SourceLocation getDeclLoc() const
Definition Pointer.h:292
const Block * block() const
Definition Pointer.h:602
bool isFunctionPointer() const
Definition Pointer.h:470
Pointer getDeclPtr() const
Definition Pointer.h:355
const Descriptor * getFieldDesc() const
Accessors for information about the innermost field.
Definition Pointer.h:326
bool isBaseClass() const
Checks if a structure is a base class.
Definition Pointer.h:542
size_t elemSize() const
Returns the element size of the innermost field.
Definition Pointer.h:358
bool canBeInitialized() const
If this pointer has an InlineDescriptor we can use to initialize.
Definition Pointer.h:444
Lifetime getLifetime() const
Definition Pointer.h:724
void initialize() const
Initializes a field.
Definition Pointer.cpp:493
const std::byte * getRawAddress() const
If backed by actual data (i.e.
Definition Pointer.h:606
bool isField() const
Checks if the item is a field in an object.
Definition Pointer.h:274
const Record * getRecord() const
Returns the record descriptor of a class.
Definition Pointer.h:474
UnsignedOrNone getCurrentDecl() const
Returns the current declaration ID.
Definition Program.h:159
Structure/Class descriptor.
Definition Record.h:25
bool isUnion() const
Checks if the record is a union.
Definition Record.h:57
const CXXDestructorDecl * getDestructor() const
Returns the destructor of the record, if any.
Definition Record.h:73
unsigned getNumVirtualBases() const
Definition Record.h:107
llvm::iterator_range< const_field_iter > fields() const
Definition Record.h:84
Describes the statement/declaration an opcode was generated from.
Definition Source.h:73
bool checkingForUndefinedBehavior() const
Are we checking an expression for overflow?
Definition State.h:103
OptionalDiagnostic Note(SourceLocation Loc, diag::kind DiagId)
Add a note to a prior diagnostic.
Definition State.cpp:63
OptionalDiagnostic FFDiag(SourceLocation Loc, diag::kind DiagId=diag::note_invalid_subexpr_in_const_expr, unsigned ExtraNotes=0)
Diagnose that the evaluation could not be folded (FF => FoldFailure)
Definition State.cpp:21
OptionalDiagnostic CCEDiag(SourceLocation Loc, diag::kind DiagId=diag::note_invalid_subexpr_in_const_expr, unsigned ExtraNotes=0)
Diagnose that the evaluation does not produce a C++11 core constant expression.
Definition State.cpp:42
bool checkingPotentialConstantExpression() const
Are we checking whether the expression is a potential constant expression?
Definition State.h:99
Defines the clang::TargetInfo interface.
bool arePotentiallyOverlappingStringLiterals(const Pointer &LHS, const Pointer &RHS)
Definition Interp.cpp:2162
bool GetPtrFieldPop(InterpState &S, CodePtr OpPC, uint32_t Off)
Definition Interp.cpp:1460
static bool CheckCallDepth(InterpState &S, CodePtr OpPC)
Definition Interp.cpp:1030
static void startLifetimeRecurse(const Pointer &Ptr)
Definition Interp.cpp:1829
bool CastPointerIntegralAPS(InterpState &S, CodePtr OpPC, uint32_t BitWidth)
Definition Interp.cpp:2092
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:2079
bool CheckInit(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Checks if a value can be initialized.
Definition Interp.cpp:914
bool EndLifetimePop(InterpState &S, CodePtr OpPC)
Ends the lifetime of the pop'd pointer.
Definition Interp.cpp:1893
static bool CheckCallable(InterpState &S, CodePtr OpPC, const Function *F)
Definition Interp.cpp:922
static bool runRecordDestructor(InterpState &S, CodePtr OpPC, const Pointer &BasePtr, const Descriptor *Desc)
Definition Interp.cpp:1205
bool GetTypeidPtr(InterpState &S, CodePtr OpPC, const Type *TypeInfoType)
Definition Interp.cpp:2128
bool LT(InterpState &S, CodePtr OpPC)
Definition Interp.h:1241
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:1114
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:1160
bool EndLifetime(InterpState &S, CodePtr OpPC)
Ends the lifetime of the peek'd pointer.
Definition Interp.cpp:1879
bool GetTypeid(InterpState &S, CodePtr OpPC, const Type *TypePtr, const Type *TypeInfoType)
Typeid support.
Definition Interp.cpp:2122
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:2059
static bool RunDestructors(InterpState &S, CodePtr OpPC, const Block *B)
Definition Interp.cpp:1231
bool GetPtrField(InterpState &S, CodePtr OpPC, uint32_t Off)
1) Peeks a Pointer 2) Pushes Pointer.atField(Off) on the stack
Definition Interp.cpp:1455
static bool CheckNonNullArgs(InterpState &S, CodePtr OpPC, const Function *F, const CallExpr *CE, unsigned ArgSize)
Definition Interp.cpp:1183
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:2241
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:2038
static bool getField(InterpState &S, CodePtr OpPC, const Pointer &Ptr, uint32_t Off)
Definition Interp.cpp:1420
static bool hasVirtualDestructor(QualType T)
Definition Interp.cpp:1262
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:1105
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:2154
bool CheckFinalLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
This is not used by any of the opcodes directly.
Definition Interp.cpp:842
bool CheckBitCast(InterpState &S, CodePtr OpPC, bool HasIndeterminateBits, bool TargetIsUCharOrByte)
Definition Interp.cpp:2105
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:1465
llvm::APInt APInt
Definition FixedPoint.h:19
void diagnoseEnumValue(InterpState &S, CodePtr OpPC, const EnumDecl *ED, const APSInt &Value)
Definition Interp.cpp:1368
bool StartLifetime(InterpState &S, CodePtr OpPC)
Definition Interp.cpp:1848
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:1132
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:1058
PrimType
Enumeration of the primitive types of the VM.
Definition PrimType.h:34
static bool GetDynamicDecl(InterpState &S, CodePtr OpPC, Pointer TypePtr, const CXXRecordDecl *&DynamicDecl)
Definition Interp.cpp:1647
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:1512
constexpr bool needsAlloc()
Definition PrimType.h:125
bool InvalidShuffleVectorIndex(InterpState &S, CodePtr OpPC, uint32_t Index)
Definition Interp.cpp:2051
bool CheckDummy(InterpState &S, CodePtr OpPC, const Block *B, AccessKinds AK)
Checks if a pointer is a dummy pointer.
Definition Interp.cpp:1165
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:1906
bool CheckLiteralType(InterpState &S, CodePtr OpPC, const Type *T)
Definition Interp.cpp:1389
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:1503
bool CheckThis(InterpState &S, CodePtr OpPC)
Checks the 'this' pointer.
Definition Interp.cpp:1041
bool FinishInitGlobal(InterpState &S, CodePtr OpPC)
Definition Interp.cpp:2289
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:2207
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:1269
bool InvalidNewDeleteExpr(InterpState &S, CodePtr OpPC, const Expr *E)
Definition Interp.cpp:1994
bool CallBI(InterpState &S, CodePtr OpPC, const CallExpr *CE, uint32_t BuiltinID)
Definition Interp.cpp:1764
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:902
bool CheckExtern(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Checks if the variable has externally defined storage.
Definition Interp.cpp:389
bool CheckStore(InterpState &S, CodePtr OpPC, const Pointer &Ptr, bool WillBeActivated)
Checks if a value can be stored in a block.
Definition Interp.cpp:873
bool isConstexprUnknown(const Pointer &P)
Definition Interp.cpp:298
bool GetPtrBasePop(InterpState &S, CodePtr OpPC, uint32_t Off, bool NullOK)
Definition Interp.h:1788
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:1775
bool CallVirt(InterpState &S, CodePtr OpPC, const Function *Func, uint32_t VarArgSize)
Definition Interp.cpp:1677
static void endLifetimeRecurse(const Pointer &Ptr)
Definition Interp.cpp:1858
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:2305
llvm::APSInt APSInt
Definition FixedPoint.h:20
bool CheckDestructor(InterpState &S, CodePtr OpPC, const Pointer &Ptr)
Definition Interp.cpp:1486
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