1 //===--- Function.h - Bytecode function 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 // Defines the Function class which holds all bytecode function-specific data. 10 // 11 // The scope class which describes local variables is also defined here. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_CLANG_AST_INTERP_FUNCTION_H 16 #define LLVM_CLANG_AST_INTERP_FUNCTION_H 17 18 #include "Pointer.h" 19 #include "Source.h" 20 #include "clang/AST/Decl.h" 21 #include "llvm/Support/raw_ostream.h" 22 23 namespace clang { 24 namespace interp { 25 class Program; 26 class ByteCodeEmitter; 27 enum PrimType : uint32_t; 28 29 /// Describes a scope block. 30 /// 31 /// The block gathers all the descriptors of the locals defined in this block. 32 class Scope { 33 public: 34 /// Information about a local's storage. 35 struct Local { 36 /// Offset of the local in frame. 37 unsigned Offset; 38 /// Descriptor of the local. 39 Descriptor *Desc; 40 }; 41 42 using LocalVectorTy = llvm::SmallVector<Local, 8>; 43 44 Scope(LocalVectorTy &&Descriptors) : Descriptors(std::move(Descriptors)) {} 45 46 llvm::iterator_range<LocalVectorTy::iterator> locals() { 47 return llvm::make_range(Descriptors.begin(), Descriptors.end()); 48 } 49 50 private: 51 /// Object descriptors in this block. 52 LocalVectorTy Descriptors; 53 }; 54 55 /// Bytecode function. 56 /// 57 /// Contains links to the bytecode of the function, as well as metadata 58 /// describing all arguments and stack-local variables. 59 class Function { 60 public: 61 using ParamDescriptor = std::pair<PrimType, Descriptor *>; 62 63 /// Returns the size of the function's local stack. 64 unsigned getFrameSize() const { return FrameSize; } 65 /// Returns the size of the argument stackx 66 unsigned getArgSize() const { return ArgSize; } 67 68 /// Returns a pointer to the start of the code. 69 CodePtr getCodeBegin() const; 70 /// Returns a pointer to the end of the code. 71 CodePtr getCodeEnd() const; 72 73 /// Returns the original FunctionDecl. 74 const FunctionDecl *getDecl() const { return F; } 75 76 /// Returns the location. 77 SourceLocation getLoc() const { return Loc; } 78 79 /// Returns a parameter descriptor. 80 ParamDescriptor getParamDescriptor(unsigned Offset) const; 81 82 /// Checks if the first argument is a RVO pointer. 83 bool hasRVO() const { return ParamTypes.size() != Params.size(); } 84 85 /// Range over the scope blocks. 86 llvm::iterator_range<llvm::SmallVector<Scope, 2>::iterator> scopes() { 87 return llvm::make_range(Scopes.begin(), Scopes.end()); 88 } 89 90 /// Range over argument types. 91 using arg_reverse_iterator = SmallVectorImpl<PrimType>::reverse_iterator; 92 llvm::iterator_range<arg_reverse_iterator> args_reverse() { 93 return llvm::make_range(ParamTypes.rbegin(), ParamTypes.rend()); 94 } 95 96 /// Returns a specific scope. 97 Scope &getScope(unsigned Idx) { return Scopes[Idx]; } 98 99 /// Returns the source information at a given PC. 100 SourceInfo getSource(CodePtr PC) const; 101 102 /// Checks if the function is valid to call in constexpr. 103 bool isConstexpr() const { return IsValid; } 104 105 /// Checks if the function is virtual. 106 bool isVirtual() const; 107 108 /// Checks if the function is a constructor. 109 bool isConstructor() const { return isa<CXXConstructorDecl>(F); } 110 111 private: 112 /// Construct a function representing an actual function. 113 Function(Program &P, const FunctionDecl *F, unsigned ArgSize, 114 llvm::SmallVector<PrimType, 8> &&ParamTypes, 115 llvm::DenseMap<unsigned, ParamDescriptor> &&Params); 116 117 /// Sets the code of a function. 118 void setCode(unsigned NewFrameSize, std::vector<char> &&NewCode, SourceMap &&NewSrcMap, 119 llvm::SmallVector<Scope, 2> &&NewScopes) { 120 FrameSize = NewFrameSize; 121 Code = std::move(NewCode); 122 SrcMap = std::move(NewSrcMap); 123 Scopes = std::move(NewScopes); 124 IsValid = true; 125 } 126 127 private: 128 friend class Program; 129 friend class ByteCodeEmitter; 130 131 /// Program reference. 132 Program &P; 133 /// Location of the executed code. 134 SourceLocation Loc; 135 /// Declaration this function was compiled from. 136 const FunctionDecl *F; 137 /// Local area size: storage + metadata. 138 unsigned FrameSize; 139 /// Size of the argument stack. 140 unsigned ArgSize; 141 /// Program code. 142 std::vector<char> Code; 143 /// Opcode-to-expression mapping. 144 SourceMap SrcMap; 145 /// List of block descriptors. 146 llvm::SmallVector<Scope, 2> Scopes; 147 /// List of argument types. 148 llvm::SmallVector<PrimType, 8> ParamTypes; 149 /// Map from byte offset to parameter descriptor. 150 llvm::DenseMap<unsigned, ParamDescriptor> Params; 151 /// Flag to indicate if the function is valid. 152 bool IsValid = false; 153 154 public: 155 /// Dumps the disassembled bytecode to \c llvm::errs(). 156 void dump() const; 157 void dump(llvm::raw_ostream &OS) const; 158 }; 159 160 } // namespace interp 161 } // namespace clang 162 163 #endif 164