1//===--- State.h - State chain for the VM and AST Walker --------*- 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// Defines the base class of the interpreter and evaluator state.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_INTERP_STATE_H
14#define LLVM_CLANG_AST_INTERP_STATE_H
15
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/ASTDiagnostic.h"
18#include "clang/AST/Expr.h"
19#include "clang/AST/OptionalDiagnostic.h"
20
21namespace clang {
22class SemaProxy;
23
24/// Kinds of access we can perform on an object, for diagnostics. Note that
25/// we consider a member function call to be a kind of access, even though
26/// it is not formally an access of the object, because it has (largely) the
27/// same set of semantic restrictions.
28enum AccessKinds {
29 AK_Read,
30 AK_ReadObjectRepresentation,
31 AK_Assign,
32 AK_Increment,
33 AK_Decrement,
34 AK_MemberCall,
35 AK_DynamicCast,
36 AK_TypeId,
37 AK_Construct,
38 AK_Destroy,
39 AK_IsWithinLifetime,
40 AK_Dereference
41};
42
43/// The order of this enum is important for diagnostics.
44enum CheckSubobjectKind {
45 CSK_Base,
46 CSK_Derived,
47 CSK_Field,
48 CSK_ArrayToPointer,
49 CSK_ArrayIndex,
50 CSK_Real,
51 CSK_Imag,
52 CSK_VectorElement
53};
54
55enum class EvaluationMode {
56 /// Evaluate as a constant expression. Stop if we find that the expression
57 /// is not a constant expression.
58 ConstantExpression,
59
60 /// Evaluate as a constant expression. Stop if we find that the expression
61 /// is not a constant expression. Some expressions can be retried in the
62 /// optimizer if we don't constant fold them here, but in an unevaluated
63 /// context we try to fold them immediately since the optimizer never
64 /// gets a chance to look at it.
65 ConstantExpressionUnevaluated,
66
67 /// Fold the expression to a constant. Stop if we hit a side-effect that
68 /// we can't model.
69 ConstantFold,
70
71 /// Evaluate in any way we know how. Don't worry about side-effects that
72 /// can't be modeled.
73 IgnoreSideEffects,
74};
75
76namespace interp {
77class Frame;
78class SourceInfo;
79
80/// Interface for the VM to interact with the AST walker's context.
81class State {
82public:
83 State(ASTContext &ASTCtx, SemaProxy *SProxy, Expr::EvalStatus &EvalStatus)
84 : Ctx(ASTCtx), SProxy(SProxy), EvalStatus(EvalStatus) {}
85 virtual ~State();
86
87 virtual const Frame *getCurrentFrame() = 0;
88 virtual unsigned getCallStackDepth() = 0;
89 virtual bool stepsLeft() const = 0;
90
91 Expr::EvalStatus &getEvalStatus() const { return EvalStatus; }
92 ASTContext &getASTContext() const { return Ctx; }
93 SemaProxy *getSemaProxy() const { return SProxy; }
94 const LangOptions &getLangOpts() const { return Ctx.getLangOpts(); }
95
96 /// If \c DiagId should be relaxed as per the current evaluation settings,
97 /// emit it as a warning instead of an error. Returns \c true if a relaxed
98 /// diagnostic was emitted, \c false otherwise.
99 bool emitRelaxedDiag(SourceLocation Loc, diag::kind DiagId);
100
101 /// Note that we have had a side-effect, and determine whether we should
102 /// keep evaluating.
103 bool noteSideEffect() const {
104 EvalStatus.HasSideEffects = true;
105 return keepEvaluatingAfterSideEffect();
106 }
107
108 /// Should we continue evaluation as much as possible after encountering a
109 /// construct which can't be reduced to a value?
110 bool keepEvaluatingAfterFailure() const;
111 /// Should we continue evaluation after encountering a side-effect that we
112 /// couldn't model?
113 bool keepEvaluatingAfterSideEffect() const;
114
115 /// Note that we hit something that was technically undefined behavior, but
116 /// that we can evaluate past it (such as signed overflow or floating-point
117 /// division by zero.)
118 bool noteUndefinedBehavior() const {
119 EvalStatus.HasUndefinedBehavior = true;
120 return keepEvaluatingAfterUndefinedBehavior();
121 }
122
123 /// Are we checking whether the expression is a potential constant
124 /// expression?
125 bool checkingPotentialConstantExpression() const {
126 return CheckingPotentialConstantExpression;
127 }
128 /// Are we checking an expression for overflow?
129 bool checkingForUndefinedBehavior() const {
130 return CheckingForUndefinedBehavior;
131 }
132
133 /// Diagnose that the evaluation could not be folded (FF => FoldFailure)
134 OptionalDiagnostic
135 FFDiag(SourceLocation Loc,
136 diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
137 unsigned ExtraNotes = 0);
138
139 OptionalDiagnostic
140 FFDiag(const Expr *E,
141 diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
142 unsigned ExtraNotes = 0);
143
144 OptionalDiagnostic
145 FFDiag(SourceInfo SI,
146 diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
147 unsigned ExtraNotes = 0);
148
149 /// Diagnose that the evaluation does not produce a C++11 core constant
150 /// expression.
151 ///
152 /// FIXME: Stop evaluating if we're in EM_ConstantExpression or
153 /// EM_PotentialConstantExpression mode and we produce one of these.
154 OptionalDiagnostic
155 CCEDiag(SourceLocation Loc,
156 diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
157 unsigned ExtraNotes = 0);
158
159 OptionalDiagnostic
160 CCEDiag(const Expr *E,
161 diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
162 unsigned ExtraNotes = 0);
163
164 OptionalDiagnostic
165 CCEDiag(SourceInfo SI,
166 diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
167 unsigned ExtraNotes = 0);
168
169 /// Add a note to a prior diagnostic.
170 OptionalDiagnostic Note(SourceLocation Loc, diag::kind DiagId);
171 OptionalDiagnostic Note(SourceInfo Loc, diag::kind DiagId);
172
173 /// Directly reports a diagnostic message.
174 DiagnosticBuilder report(SourceLocation Loc, diag::kind DiagId);
175
176 /// Whether or not we're in a context where the front end requires a
177 /// constant value.
178 bool InConstantContext = false;
179
180 /// Whether we're checking that an expression is a potential constant
181 /// expression. If so, do not fail on constructs that could become constant
182 /// later on (such as a use of an undefined global).
183 bool CheckingPotentialConstantExpression = false;
184
185 /// Whether we're checking for an expression that has undefined behavior.
186 /// If so, we will produce warnings if we encounter an operation that is
187 /// always undefined.
188 ///
189 /// Note that we still need to evaluate the expression normally when this
190 /// is set; this is used when evaluating ICEs in C.
191 bool CheckingForUndefinedBehavior = false;
192
193 EvaluationMode EvalMode;
194 ASTContext &Ctx;
195 SemaProxy *SProxy;
196 Expr::EvalStatus &EvalStatus;
197
198private:
199 /// HasActiveDiagnostic - Was the previous diagnostic stored? If so, further
200 /// notes attached to it will also be stored, otherwise they will not be.
201 bool HasActiveDiagnostic = false;
202
203 /// Have we emitted a diagnostic explaining why we couldn't constant
204 /// fold (not just why it's not strictly a constant expression)?
205 bool HasFoldFailureDiagnostic = false;
206
207 void addCallStack(unsigned Limit);
208
209 PartialDiagnostic &addDiag(SourceLocation Loc, diag::kind DiagId);
210
211 void addExtendedDiag(SourceLocation Loc, diag::kind DiagId);
212
213 OptionalDiagnostic diag(SourceLocation Loc, diag::kind DiagId,
214 unsigned ExtraNotes, bool IsFFDiag);
215
216 /// Should we continue evaluation after encountering undefined behavior?
217 bool keepEvaluatingAfterUndefinedBehavior() const;
218
219 // If we have a prior diagnostic, it will be noting that the expression
220 // isn't a constant expression. This diagnostic is more important,
221 // unless we require this evaluation to produce a constant expression.
222 //
223 // FIXME: We might want to show both diagnostics to the user in
224 // EvaluationMode::ConstantFold mode.
225 bool hasPriorDiagnostic();
226
227 void setFoldFailureDiagnostic(bool Flag) { HasFoldFailureDiagnostic = Flag; };
228 void setActiveDiagnostic(bool Flag) { HasActiveDiagnostic = Flag; };
229 bool hasActiveDiagnostic() const { return HasActiveDiagnostic; }
230};
231
232} // namespace interp
233} // namespace clang
234
235#endif
236