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 20 namespace clang { 21 namespace interp { 22 class EvalEmitter; 23 class 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. 32 class EvaluationResult final { 33 public: 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 44 private: 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 assert(empty()); 60 assert(!V.isLValue()); 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 assert(empty()); 76 Kind = Invalid; 77 } 78 void setValid() { 79 assert(empty()); 80 Kind = Valid; 81 } 82 83 public: 84 EvaluationResult(const Context *Ctx) : Ctx(Ctx) {} 85 86 bool empty() const { return Kind == Empty; } 87 bool isInvalid() const { return Kind == Invalid; } 88 bool isLValue() const { return Kind == LValue; } 89 bool isRValue() const { return Kind == RValue; } 90 91 /// Returns an APValue for the evaluation result. The returned 92 /// APValue might be an LValue or RValue. 93 APValue toAPValue() const; 94 95 /// If the result is an LValue, convert that to an RValue 96 /// and return it. This may fail, e.g. if the result is an 97 /// LValue and we can't read from it. 98 std::optional<APValue> toRValue() const; 99 100 bool checkFullyInitialized(InterpState &S) const; 101 102 /// Dump to stderr. 103 void dump() const; 104 105 friend class EvalEmitter; 106 }; 107 108 } // namespace interp 109 } // namespace clang 110 111 #endif 112