1//===------ EvaluationResult.h - Result class for the 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#ifndef LLVM_CLANG_AST_INTERP_EVALUATION_RESULT_H
10#define LLVM_CLANG_AST_INTERP_EVALUATION_RESULT_H
11
12#include "FunctionPointer.h"
13#include "Pointer.h"
14#include "clang/AST/APValue.h"
15#include "clang/AST/Decl.h"
16#include "clang/AST/Expr.h"
17#include <optional>
18#include <variant>
19
20namespace clang {
21namespace interp {
22class EvalEmitter;
23class Context;
24
25/// Defines the result of an evaluation.
26///
27/// The result might be in different forms--one of the pointer types,
28/// an APValue, or nothing.
29///
30/// We use this class to inspect and diagnose the result, as well as
31/// convert it to the requested form.
32class EvaluationResult final {
33public:
34 enum ResultKind {
35 Empty, // Initial state.
36 LValue, // Result is an lvalue/pointer.
37 RValue, // Result is an rvalue.
38 Invalid, // Result is invalid.
39 Valid, // Result is valid and empty.
40 };
41
42 using DeclTy = llvm::PointerUnion<const Decl *, const Expr *>;
43
44private:
45 const Context *Ctx = nullptr;
46 std::variant<std::monostate, Pointer, FunctionPointer, APValue> Value;
47 ResultKind Kind = Empty;
48 DeclTy Source = nullptr; // Currently only needed for dump().
49
50 EvaluationResult(ResultKind Kind) : Kind(Kind) {
51 // Leave everything empty. Can be used as an
52 // error marker or for void return values.
53 assert(Kind == Valid || Kind == Invalid);
54 }
55
56 void setSource(DeclTy D) { Source = D; }
57
58 void setValue(const APValue &V) {
59 // V could still be an LValue.
60 assert(empty());
61 Value = std::move(V);
62 Kind = RValue;
63 }
64 void setPointer(const Pointer P) {
65 assert(empty());
66 Value = P;
67 Kind = LValue;
68 }
69 void setFunctionPointer(const FunctionPointer &P) {
70 assert(empty());
71 Value = P;
72 Kind = LValue;
73 }
74 void setInvalid() {
75 // We are NOT asserting empty() here, since setting it to invalid
76 // is allowed even if there is already a result.
77 Kind = Invalid;
78 }
79 void setValid() {
80 assert(empty());
81 Kind = Valid;
82 }
83
84public:
85 EvaluationResult(const Context *Ctx) : Ctx(Ctx) {}
86
87 bool empty() const { return Kind == Empty; }
88 bool isInvalid() const { return Kind == Invalid; }
89 bool isLValue() const { return Kind == LValue; }
90 bool isRValue() const { return Kind == RValue; }
91
92 /// Returns an APValue for the evaluation result. The returned
93 /// APValue might be an LValue or RValue.
94 APValue toAPValue() const;
95
96 /// If the result is an LValue, convert that to an RValue
97 /// and return it. This may fail, e.g. if the result is an
98 /// LValue and we can't read from it.
99 std::optional<APValue> toRValue() const;
100
101 /// Check that all subobjects of the given pointer have been initialized.
102 bool checkFullyInitialized(InterpState &S, const Pointer &Ptr) const;
103 /// Check that none of the blocks the given pointer (transitively) points
104 /// to are dynamically allocated.
105 bool checkReturnValue(InterpState &S, const Context &Ctx, const Pointer &Ptr,
106 const SourceInfo &Info);
107
108 QualType getSourceType() const {
109 if (const auto *D =
110 dyn_cast_if_present<ValueDecl>(Val: Source.dyn_cast<const Decl *>()))
111 return D->getType();
112 else if (const auto *E = Source.dyn_cast<const Expr *>())
113 return E->getType();
114 return QualType();
115 }
116
117 /// Dump to stderr.
118 void dump() const;
119
120 friend class EvalEmitter;
121 friend class InterpState;
122};
123
124} // namespace interp
125} // namespace clang
126
127#endif
128