1//===--- InterpFrame.cpp - Call Frame implementation 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#include "InterpFrame.h" 10#include "Boolean.h" 11#include "Floating.h" 12#include "Function.h" 13#include "InterpStack.h" 14#include "InterpState.h" 15#include "Pointer.h" 16#include "PrimType.h" 17#include "Program.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/DeclCXX.h" 20 21using namespace clang; 22using namespace clang::interp; 23 24InterpFrame::InterpFrame(InterpState &S, const Function *Func, 25 InterpFrame *Caller, CodePtr RetPC) 26 : Caller(Caller), S(S), Depth(Caller ? Caller->Depth + 1 : 0), Func(Func), 27 RetPC(RetPC), ArgSize(Func ? Func->getArgSize() : 0), 28 Args(static_cast<char *>(S.Stk.top())), FrameOffset(S.Stk.size()) { 29 if (!Func) 30 return; 31 32 unsigned FrameSize = Func->getFrameSize(); 33 if (FrameSize == 0) 34 return; 35 36 Locals = std::make_unique<char[]>(FrameSize); 37 for (auto &Scope : Func->scopes()) { 38 for (auto &Local : Scope.locals()) { 39 Block *B = new (localBlock(Local.Offset)) Block(Local.Desc); 40 B->invokeCtor(); 41 InlineDescriptor *ID = localInlineDesc(Local.Offset); 42 ID->Desc = Local.Desc; 43 ID->IsActive = true; 44 ID->Offset = sizeof(InlineDescriptor); 45 ID->IsBase = false; 46 ID->IsFieldMutable = false; 47 ID->IsConst = false; 48 ID->IsInitialized = false; 49 } 50 } 51} 52 53InterpFrame::InterpFrame(InterpState &S, const Function *Func, CodePtr RetPC) 54 : InterpFrame(S, Func, S.Current, RetPC) { 55 // As per our calling convention, the this pointer is 56 // part of the ArgSize. 57 // If the function has RVO, the RVO pointer is first. 58 // If the fuction has a This pointer, that one is next. 59 // Then follow the actual arguments (but those are handled 60 // in getParamPointer()). 61 if (Func->hasRVO()) 62 RVOPtr = stackRef<Pointer>(0); 63 64 if (Func->hasThisPointer()) { 65 if (Func->hasRVO()) 66 This = stackRef<Pointer>(sizeof(Pointer)); 67 else 68 This = stackRef<Pointer>(0); 69 } 70} 71 72InterpFrame::~InterpFrame() { 73 for (auto &Param : Params) 74 S.deallocate(reinterpret_cast<Block *>(Param.second.get())); 75 76 // When destroying the InterpFrame, call the Dtor for all block 77 // that haven't been destroyed via a destroy() op yet. 78 // This happens when the execution is interruped midway-through. 79 if (Func) { 80 for (auto &Scope : Func->scopes()) { 81 for (auto &Local : Scope.locals()) { 82 Block *B = localBlock(Local.Offset); 83 if (B->isInitialized()) 84 B->invokeDtor(); 85 } 86 } 87 } 88} 89 90void InterpFrame::destroy(unsigned Idx) { 91 for (auto &Local : Func->getScope(Idx).locals()) { 92 S.deallocate(localBlock(Local.Offset)); 93 } 94} 95 96void InterpFrame::popArgs() { 97 for (PrimType Ty : Func->args_reverse()) 98 TYPE_SWITCH(Ty, S.Stk.discard<T>()); 99} 100 101template <typename T> 102static void print(llvm::raw_ostream &OS, const T &V, ASTContext &, QualType) { 103 OS << V; 104} 105 106template <> 107void print(llvm::raw_ostream &OS, const Pointer &P, ASTContext &Ctx, 108 QualType Ty) { 109 if (P.isZero()) { 110 OS << "nullptr"; 111 return; 112 } 113 114 auto printDesc = [&OS, &Ctx](const Descriptor *Desc) { 115 if (const auto *D = Desc->asDecl()) { 116 // Subfields or named values. 117 if (const auto *VD = dyn_cast<ValueDecl>(D)) { 118 OS << *VD; 119 return; 120 } 121 // Base classes. 122 if (isa<RecordDecl>(D)) 123 return; 124 } 125 // Temporary expression. 126 if (const auto *E = Desc->asExpr()) { 127 E->printPretty(OS, nullptr, Ctx.getPrintingPolicy()); 128 return; 129 } 130 llvm_unreachable("Invalid descriptor type"); 131 }; 132 133 if (!Ty->isReferenceType()) 134 OS << "&"; 135 llvm::SmallVector<Pointer, 2> Levels; 136 for (Pointer F = P; !F.isRoot(); ) { 137 Levels.push_back(F); 138 F = F.isArrayElement() ? F.getArray().expand() : F.getBase(); 139 } 140 141 // Drop the first pointer since we print it unconditionally anyway. 142 if (!Levels.empty()) 143 Levels.erase(Levels.begin()); 144 145 printDesc(P.getDeclDesc()); 146 for (const auto &It : Levels) { 147 if (It.inArray()) { 148 OS << "[" << It.expand().getIndex() << "]"; 149 continue; 150 } 151 if (auto Index = It.getIndex()) { 152 OS << " + " << Index; 153 continue; 154 } 155 OS << "."; 156 printDesc(It.getFieldDesc()); 157 } 158} 159 160void InterpFrame::describe(llvm::raw_ostream &OS) const { 161 const FunctionDecl *F = getCallee(); 162 if (const auto *M = dyn_cast<CXXMethodDecl>(F); 163 M && M->isInstance() && !isa<CXXConstructorDecl>(F)) { 164 print(OS, This, S.getCtx(), S.getCtx().getRecordType(M->getParent())); 165 OS << "->"; 166 } 167 OS << *F << "("; 168 unsigned Off = 0; 169 170 Off += Func->hasRVO() ? primSize(PT_Ptr) : 0; 171 Off += Func->hasThisPointer() ? primSize(PT_Ptr) : 0; 172 173 for (unsigned I = 0, N = F->getNumParams(); I < N; ++I) { 174 QualType Ty = F->getParamDecl(I)->getType(); 175 176 PrimType PrimTy = S.Ctx.classify(Ty).value_or(PT_Ptr); 177 178 TYPE_SWITCH(PrimTy, print(OS, stackRef<T>(Off), S.getCtx(), Ty)); 179 Off += align(primSize(PrimTy)); 180 if (I + 1 != N) 181 OS << ", "; 182 } 183 OS << ")"; 184} 185 186Frame *InterpFrame::getCaller() const { 187 if (Caller->Caller) 188 return Caller; 189 return S.getSplitFrame(); 190} 191 192SourceRange InterpFrame::getCallRange() const { 193 if (!Caller->Func) 194 return S.getRange(nullptr, {}); 195 return S.getRange(Caller->Func, RetPC - sizeof(uintptr_t)); 196} 197 198const FunctionDecl *InterpFrame::getCallee() const { 199 return Func->getDecl(); 200} 201 202Pointer InterpFrame::getLocalPointer(unsigned Offset) const { 203 assert(Offset < Func->getFrameSize() && "Invalid local offset."); 204 return Pointer(localBlock(Offset), sizeof(InlineDescriptor)); 205} 206 207Pointer InterpFrame::getParamPointer(unsigned Off) { 208 // Return the block if it was created previously. 209 auto Pt = Params.find(Off); 210 if (Pt != Params.end()) { 211 return Pointer(reinterpret_cast<Block *>(Pt->second.get())); 212 } 213 214 // Allocate memory to store the parameter and the block metadata. 215 const auto &Desc = Func->getParamDescriptor(Off); 216 size_t BlockSize = sizeof(Block) + Desc.second->getAllocSize(); 217 auto Memory = std::make_unique<char[]>(BlockSize); 218 auto *B = new (Memory.get()) Block(Desc.second); 219 220 // Copy the initial value. 221 TYPE_SWITCH(Desc.first, new (B->data()) T(stackRef<T>(Off))); 222 223 // Record the param. 224 Params.insert({Off, std::move(Memory)}); 225 return Pointer(B); 226} 227 228SourceInfo InterpFrame::getSource(CodePtr PC) const { 229 // Implicitly created functions don't have any code we could point at, 230 // so return the call site. 231 if (Func && (!Func->hasBody() || Func->getDecl()->isImplicit()) && Caller) 232 return Caller->getSource(RetPC); 233 234 return S.getSource(Func, PC); 235} 236 237const Expr *InterpFrame::getExpr(CodePtr PC) const { 238 return S.getExpr(Func, PC); 239} 240 241SourceLocation InterpFrame::getLocation(CodePtr PC) const { 242 return S.getLocation(Func, PC); 243} 244 245SourceRange InterpFrame::getRange(CodePtr PC) const { 246 if (Func && (!Func->hasBody() || Func->getDecl()->isImplicit()) && Caller) 247 return Caller->getRange(RetPC); 248 249 return S.getRange(Func, PC); 250} 251