Revert [Clang Interpreter] Initial patch for the constexpr interpreter

This reverts r370584 (git commit afcb3de117265a69d21e5673356e925a454d7d02)

llvm-svn: 370588

1 files changed, 0 insertions, 148 deletions

diff --git a/clang/lib/AST/Interp/Context.cpp b/clang/lib/AST/Interp/Context.cpp
deleted file mode 100644
index 85d8626c382..00000000000
--- a/clang/lib/AST/Interp/Context.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-//===--- Context.cpp - Context for the constexpr VM -------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "Context.h"
-#include "ByteCodeExprGen.h"
-#include "ByteCodeStmtGen.h"
-#include "EvalEmitter.h"
-#include "Interp.h"
-#include "InterpFrame.h"
-#include "InterpStack.h"
-#include "ByteCodeEmitter.h"
-#include "Program.h"
-#include "Type.h"
-#include "clang/AST/Expr.h"
-
-using namespace clang;
-using namespace clang::interp;
-
-Context::Context(ASTContext &Ctx)
-    : Ctx(Ctx), ForceInterp(getLangOpts().ForceNewConstInterp),
-      P(new Program(*this)) {}
-
-Context::~Context() {}
-
-InterpResult Context::isPotentialConstantExpr(State &Parent,
-                                              const FunctionDecl *FD) {
-  Function *Func = P->getFunction(FD);
-  if (!Func) {
-    if (auto R = ByteCodeStmtGen<ByteCodeEmitter>(*this, *P).compileFunc(FD)) {
-      Func = *R;
-    } else if (ForceInterp) {
-      handleAllErrors(R.takeError(), [&Parent](ByteCodeGenError &Err) {
-        Parent.FFDiag(Err.getLoc(), diag::err_experimental_clang_interp_failed);
-      });
-      return InterpResult::Fail;
-    } else {
-      consumeError(R.takeError());
-      return InterpResult::Bail;
-    }
-  }
-
-  if (!Func->isConstexpr())
-    return InterpResult::Fail;
-
-  APValue Dummy;
-  return Run(Parent, Func, Dummy);
-}
-
-InterpResult Context::evaluateAsRValue(State &Parent, const Expr *E,
-                                       APValue &Result) {
-  ByteCodeExprGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
-  return Check(Parent, C.interpretExpr(E));
-}
-
-InterpResult Context::evaluateAsInitializer(State &Parent, const VarDecl *VD,
-                                            APValue &Result) {
-  ByteCodeExprGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
-  return Check(Parent, C.interpretDecl(VD));
-}
-
-const LangOptions &Context::getLangOpts() const { return Ctx.getLangOpts(); }
-
-llvm::Optional<PrimType> Context::classify(QualType T) {
-  if (T->isReferenceType() || T->isPointerType()) {
-    return PT_Ptr;
-  }
-
-  if (T->isBooleanType())
-    return PT_Bool;
-
-  if (T->isSignedIntegerOrEnumerationType()) {
-    switch (Ctx.getIntWidth(T)) {
-    case 64:
-      return PT_Sint64;
-    case 32:
-      return PT_Sint32;
-    case 16:
-      return PT_Sint16;
-    case 8:
-      return PT_Sint8;
-    default:
-      return {};
-    }
-  }
-
-  if (T->isUnsignedIntegerOrEnumerationType()) {
-    switch (Ctx.getIntWidth(T)) {
-    case 64:
-      return PT_Uint64;
-    case 32:
-      return PT_Uint32;
-    case 16:
-      return PT_Uint16;
-    case 8:
-      return PT_Uint8;
-    default:
-      return {};
-    }
-  }
-
-  if (T->isNullPtrType())
-    return PT_Ptr;
-
-  if (auto *AT = dyn_cast<AtomicType>(T))
-    return classify(AT->getValueType());
-
-  return {};
-}
-
-unsigned Context::getCharBit() const {
-  return Ctx.getTargetInfo().getCharWidth();
-}
-
-InterpResult Context::Run(State &Parent, Function *Func, APValue &Result) {
-  InterpResult Flag;
-  {
-    InterpState State(Parent, *P, Stk, *this);
-    State.Current = new InterpFrame(State, Func, nullptr, {}, {});
-    if (Interpret(State, Result)) {
-      Flag = InterpResult::Success;
-    } else {
-      Flag = InterpResult::Fail;
-    }
-  }
-
-  if (Flag != InterpResult::Success)
-    Stk.clear();
-  return Flag;
-}
-
-InterpResult Context::Check(State &Parent, llvm::Expected<bool> &&R) {
-  if (R) {
-    return *R ? InterpResult::Success : InterpResult::Fail;
-  } else if (ForceInterp) {
-    handleAllErrors(R.takeError(), [&Parent](ByteCodeGenError &Err) {
-      Parent.FFDiag(Err.getLoc(), diag::err_experimental_clang_interp_failed);
-    });
-    return InterpResult::Fail;
-  } else {
-    consumeError(R.takeError());
-    return InterpResult::Bail;
-  }
-}