Home | History | Annotate | Line # | Download | only in Interp 
      1 //===--- Context.cpp - Context for the constexpr 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 "Context.h"
     10 #include "ByteCodeEmitter.h"
     11 #include "ByteCodeExprGen.h"
     12 #include "ByteCodeStmtGen.h"
     13 #include "EvalEmitter.h"
     14 #include "Interp.h"
     15 #include "InterpFrame.h"
     16 #include "InterpStack.h"
     17 #include "PrimType.h"
     18 #include "Program.h"
     19 #include "clang/AST/Expr.h"
     20 #include "clang/Basic/TargetInfo.h"
     21 
     22 using namespace clang;
     23 using namespace clang::interp;
     24 
     25 Context::Context(ASTContext &Ctx) : Ctx(Ctx), P(new Program(*this)) {}
     26 
     27 Context::~Context() {}
     28 
     29 bool Context::isPotentialConstantExpr(State &Parent, const FunctionDecl *FD) {
     30   Function *Func = P->getFunction(FD);
     31   if (!Func) {
     32     if (auto R = ByteCodeStmtGen<ByteCodeEmitter>(*this, *P).compileFunc(FD)) {
     33       Func = *R;
     34     } else {
     35       handleAllErrors(R.takeError(), [&Parent](ByteCodeGenError &Err) {
     36         Parent.FFDiag(Err.getLoc(), diag::err_experimental_clang_interp_failed);
     37       });
     38       return false;
     39     }
     40   }
     41 
     42   if (!Func->isConstexpr())
     43     return false;
     44 
     45   APValue Dummy;
     46   return Run(Parent, Func, Dummy);
     47 }
     48 
     49 bool Context::evaluateAsRValue(State &Parent, const Expr *E, APValue &Result) {
     50   ByteCodeExprGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
     51   return Check(Parent, C.interpretExpr(E));
     52 }
     53 
     54 bool Context::evaluateAsInitializer(State &Parent, const VarDecl *VD,
     55                                     APValue &Result) {
     56   ByteCodeExprGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
     57   return Check(Parent, C.interpretDecl(VD));
     58 }
     59 
     60 const LangOptions &Context::getLangOpts() const { return Ctx.getLangOpts(); }
     61 
     62 llvm::Optional<PrimType> Context::classify(QualType T) {
     63   if (T->isReferenceType() || T->isPointerType()) {
     64     return PT_Ptr;
     65   }
     66 
     67   if (T->isBooleanType())
     68     return PT_Bool;
     69 
     70   if (T->isSignedIntegerOrEnumerationType()) {
     71     switch (Ctx.getIntWidth(T)) {
     72     case 64:
     73       return PT_Sint64;
     74     case 32:
     75       return PT_Sint32;
     76     case 16:
     77       return PT_Sint16;
     78     case 8:
     79       return PT_Sint8;
     80     default:
     81       return {};
     82     }
     83   }
     84 
     85   if (T->isUnsignedIntegerOrEnumerationType()) {
     86     switch (Ctx.getIntWidth(T)) {
     87     case 64:
     88       return PT_Uint64;
     89     case 32:
     90       return PT_Uint32;
     91     case 16:
     92       return PT_Uint16;
     93     case 8:
     94       return PT_Uint8;
     95     default:
     96       return {};
     97     }
     98   }
     99 
    100   if (T->isNullPtrType())
    101     return PT_Ptr;
    102 
    103   if (auto *AT = dyn_cast<AtomicType>(T))
    104     return classify(AT->getValueType());
    105 
    106   return {};
    107 }
    108 
    109 unsigned Context::getCharBit() const {
    110   return Ctx.getTargetInfo().getCharWidth();
    111 }
    112 
    113 bool Context::Run(State &Parent, Function *Func, APValue &Result) {
    114   InterpState State(Parent, *P, Stk, *this);
    115   State.Current = new InterpFrame(State, Func, nullptr, {}, {});
    116   if (Interpret(State, Result))
    117     return true;
    118   Stk.clear();
    119   return false;
    120 }
    121 
    122 bool Context::Check(State &Parent, llvm::Expected<bool> &&Flag) {
    123   if (Flag)
    124     return *Flag;
    125   handleAllErrors(Flag.takeError(), [&Parent](ByteCodeGenError &Err) {
    126     Parent.FFDiag(Err.getLoc(), diag::err_experimental_clang_interp_failed);
    127   });
    128   return false;
    129 }
    130