diff --git a/core/clingutils/src/TClingUtils.cxx b/core/clingutils/src/TClingUtils.cxx
index b4043a4f3d5bb4cdb3ff281bdae8d4f9be81cf81..83990b1cc7e7ff390368d2d69eb44b771205ca63 100644
--- a/core/clingutils/src/TClingUtils.cxx
+++ b/core/clingutils/src/TClingUtils.cxx
@@ -3383,11 +3383,6 @@ void ROOT::TMetaUtils::GetFullyQualifiedTypeName(std::string &typenamestr,
const clang::QualType &qtype,
const cling::Interpreter &interpreter)
{
- // We need this barrior because GetFullyQualifiedTypeName is triggering deserialization
- // This calling the same name function GetFullyQualifiedTypeName, but this should stay here because
- // callee doesn't have an interpreter pointer
- cling::Interpreter::PushTransactionRAII RAII(const_cast<cling::Interpreter*>(&interpreter));
-
GetFullyQualifiedTypeName(typenamestr,
qtype,
interpreter.getCI()->getASTContext());
diff --git a/core/metacling/src/TCling.cxx b/core/metacling/src/TCling.cxx
index 27014324c6183044b3009d788d1da82201f753ea..ba5fafe01d9fff8a868303a19a04c448652861e7 100644
--- a/core/metacling/src/TCling.cxx
+++ b/core/metacling/src/TCling.cxx
@@ -113,6 +113,9 @@ clang/LLVM technology.
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Process.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Object/SymbolicFile.h"
#include <algorithm>
#include <iostream>
@@ -129,6 +132,7 @@ clang/LLVM technology.
#include <unordered_map>
#include <utility>
#include <vector>
+#include <functional>
#ifndef R__WIN32
#include <cxxabi.h>
@@ -430,10 +434,6 @@ static void TCling__UpdateClassInfo(const NamedDecl* TD)
void TCling::UpdateEnumConstants(TEnum* enumObj, TClass* cl) const {
const clang::Decl* D = static_cast<const clang::Decl*>(enumObj->GetDeclId());
if(const clang::EnumDecl* ED = dyn_cast<clang::EnumDecl>(D)) {
-
- // clang::EnumDecl::enumerator_begin can triggering deserialization
- cling::Interpreter::PushTransactionRAII deserRAII(fInterpreter);
-
// Add the constants to the enum type.
for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin(),
EDE = ED->enumerator_end(); EDI != EDE; ++EDI) {
@@ -632,27 +632,6 @@ extern "C" int TCling__AutoLoadCallback(const char* className)
return ((TCling*)gCling)->AutoLoad(className);
}
-extern "C" int TCling__AutoLoadLibraryForModules(const char* StemName)
-{
- // FIXME: We're excluding some libraries from autoloading. Adding annotations to
- // pcms from LinkDef files would fix this workaround.
- static constexpr std::array<const char*, 4> excludelibs = { {"RooStats",
- "RooFitCore", "RooFit", "HistFactory"} };
- for (const char* exLibs : excludelibs)
- if (strcmp(exLibs, StemName) == 0)
- return -1;
-
- // Add lib prefix
- TString LibName("lib" + std::string(StemName));
- // Construct the actual library name from the stem name.
- // Eg. FindDynamicLibrary("libCore") returns "/path/to/libCore.so"
- const char *Name = gSystem->FindDynamicLibrary(LibName, kTRUE);
-
- if (!Name || ((TCling*)gCling)->IsLoaded(Name)) return 1;
-
- return ((TCling*)gCling)->Load(Name);
-}
-
extern "C" int TCling__AutoParseCallback(const char* className)
{
return ((TCling*)gCling)->AutoParse(className);
@@ -1969,10 +1948,7 @@ void TCling::RegisterModule(const char* modulename,
}
}
- // Don't do "PCM" optimization with runtime modules because we are loading libraries
- // at decl deserialization time and it triggers infinite deserialization chain.
- // In short, this optimization leads to infinite loop.
- if (!hasCxxModule && gIgnoredPCMNames.find(modulename) == gIgnoredPCMNames.end()) {
+ if (gIgnoredPCMNames.find(modulename) == gIgnoredPCMNames.end()) {
if (!LoadPCM(pcmFileName, headers, triggerFunc)) {
::Error("TCling::RegisterModule", "cannot find dictionary module %s",
ROOT::TMetaUtils::GetModuleFileName(modulename).c_str());
@@ -5891,11 +5867,106 @@ Int_t TCling::AutoParse(const char *cls)
return nHheadersParsed > 0 ? 1 : 0;
}
+static void* LazyFunctionCreatorAutoloadForModule(const std::string& mangled_name,
+ cling::Interpreter *fInterpreter) {
+ using namespace llvm::object;
+ using namespace llvm::sys::path;
+ using namespace llvm::sys::fs;
+
+ static constexpr std::hash<std::string> hash_fn;
+ // size_t is a hashed mangled_name and libs[(uint8_t)mname_lib_table.second] = library's
+ // name in string.
+ static std::unordered_map<size_t, uint8_t> mname_lib_table;
+ static std::vector<std::string> libs;
+ // Initialize library table at first run
+ static bool fFirstRun = true;
+
+ R__LOCKGUARD(gInterpreterMutex);
+
+ // Initialize the table
+ if (fFirstRun) {
+ clang::Preprocessor &PP = fInterpreter->getCI()->getPreprocessor();
+ const HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
+ auto ModulePaths(HSOpts.PrebuiltModulePaths);
+
+ // sort and eliminate dupicate path
+ std::sort(ModulePaths.begin(), ModulePaths.end());
+ auto last = std::unique(ModulePaths.begin(), ModulePaths.end());
+ ModulePaths.erase(last, ModulePaths.end());
+
+ cling::DynamicLibraryManager* dyLibManager = fInterpreter->getDynamicLibraryManager();
+
+ int cur_lib = 0;
+ // Take path here eg. "/home/foo/module-release/lib/"
+ for (auto Path : ModulePaths) {
+ StringRef DirPath(Path);
+ if (DirPath.empty() || !is_directory(DirPath) || Path == ".")
+ continue;
+
+ // Check this not a random system directory (should contain pcm)
+ std::error_code EC;
+ bool is_build = false;
+ for (llvm::sys::fs::directory_iterator DirIt(DirPath, EC), DirEnd;
+ DirIt != DirEnd && !EC; DirIt.increment(EC)) {
+ std::string FileName(DirIt->path());
+ if (extension(FileName) == ".pcm") {
+ is_build = true;
+ break;
+ }
+ }
+
+ if (!is_build)
+ continue;
+
+ // Iterate over files under this path. We want to get each ".so" files
+ for (llvm::sys::fs::directory_iterator DirIt(DirPath, EC), DirEnd;
+ DirIt != DirEnd && !EC; DirIt.increment(EC)) {
+ std::string LibName(DirIt->path());
+ if (llvm::sys::fs::is_directory(LibName) || extension(LibName) != ".so")
+ continue;
+
+ // TCling::IsLoaded is incredibly slow!
+ if (dyLibManager->isLibraryLoaded(LibName.c_str()))
+ continue;
+
+ libs.push_back(LibName);
+ auto SoFile = ObjectFile::createObjectFile(LibName);
+ if (SoFile) {
+ auto RealSoFile = SoFile.get().getBinary();
+ auto Symbols = RealSoFile->symbols();
+ for (auto S : Symbols) {
+ // DO NOT insert to table if symbol was weak or undefined
+ if (S.getFlags() == SymbolRef::SF_Weak || S.getFlags() == SymbolRef::SF_Undefined) continue;
+
+ // Put into map
+ mname_lib_table.insert(std::make_pair(hash_fn(S.getName().get()), cur_lib));
+ }
+ }
+ cur_lib++;
+ }
+ }
+ fFirstRun = false;
+ }
+
+ auto key = mname_lib_table.find(hash_fn(mangled_name));
+ if (key != mname_lib_table.end()) {
+ std::string LoadedLibName = libs[key->second];
+ if (!LoadedLibName.empty() && (gSystem->Load(LoadedLibName.c_str(), "", false) < 0))
+ Error("LazyFunctionCreatorAutoloadForModule", "Failed to load library %s", LoadedLibName.c_str());
+ }
+
+ void* addr = llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(mangled_name.c_str());
+ return addr;
+}
////////////////////////////////////////////////////////////////////////////////
/// Autoload a library based on a missing symbol.
void* TCling::LazyFunctionCreatorAutoload(const std::string& mangled_name) {
+#ifdef R__USE_CXXMODULES
+ return LazyFunctionCreatorAutoloadForModule(mangled_name, fInterpreter);
+#endif
+
// First see whether the symbol is in the library that we are currently
// loading. It will have access to the symbols of its dependent libraries,
// thus checking "back()" is sufficient.
diff --git a/core/metacling/src/TClingBaseClassInfo.cxx b/core/metacling/src/TClingBaseClassInfo.cxx
index 9991a9682e626474d0e40e4d34aaacf590e011e5..1bba75265638c6ca937c74a15e4470a709179963 100644
--- a/core/metacling/src/TClingBaseClassInfo.cxx
+++ b/core/metacling/src/TClingBaseClassInfo.cxx
@@ -110,8 +110,6 @@ TClingBaseClassInfo::TClingBaseClassInfo(cling::Interpreter* interp,
//CRD->isDerivedFrom(BaseCRD, Paths);
// Check that base derives from derived.
clang::CXXBasePaths Paths;
- // isDerivedFrom can trigger deserialization
- cling::Interpreter::PushTransactionRAII RAII(fInterp);
if (!CRD->isDerivedFrom(BaseCRD, Paths)) {
//Not valid fBaseInfo = 0.
return;
@@ -260,11 +258,6 @@ int TClingBaseClassInfo::InternalNext(int onlyDirect)
(fIter == llvm::dyn_cast<clang::CXXRecordDecl>(fDecl)->bases_end())) {
return 0;
}
-
- // getASTRecordLayout() can trigger deserialization, and this should stay here
- // instead of inside the while loop
- cling::Interpreter::PushTransactionRAII RAII(fInterp);
-
// Advance to the next valid base.
while (1) {
// Advance the iterator.
@@ -276,6 +269,8 @@ int TClingBaseClassInfo::InternalNext(int onlyDirect)
// We previously processed a base class which itself has bases,
// now we process the bases of that base class.
+ // At least getASTRecordLayout() might deserialize.
+ cling::Interpreter::PushTransactionRAII RAII(fInterp);
fDescend = false;
const clang::RecordType *Ty = fIter->getType()->
getAs<clang::RecordType>();
@@ -509,10 +504,6 @@ long TClingBaseClassInfo::Property() const
clang::CXXBasePaths Paths(/*FindAmbiguities=*/false, /*RecordPaths=*/true,
/*DetectVirtual=*/true);
-
- // isDerivedFrom can trigger deserialization
- cling::Interpreter::PushTransactionRAII RAII(fInterp);
-
if (!CRD->isDerivedFrom(BaseCRD, Paths)) {
// Error really unexpected here, because construction / iteration guarantees
//inheritance;
diff --git a/core/metacling/src/TClingCallbacks.cxx b/core/metacling/src/TClingCallbacks.cxx
index 9b18677c242ee80547ab36ab72548c50974cb40b..5a034cc5bdcac48bac7ff13e92774b4a6b1ef8ba 100644
--- a/core/metacling/src/TClingCallbacks.cxx
+++ b/core/metacling/src/TClingCallbacks.cxx
@@ -50,7 +50,6 @@ extern "C" {
Decl* TCling__GetObjectDecl(TObject *obj);
int TCling__AutoLoadCallback(const char* className);
int TCling__AutoParseCallback(const char* className);
- void TCling__AutoLoadLibraryForModules(const char* StemName);
const char* TCling__GetClassSharedLibs(const char* className);
// int TCling__IsAutoLoadNamespaceCandidate(const char* name);
int TCling__IsAutoLoadNamespaceCandidate(const clang::NamespaceDecl* name);
@@ -750,29 +749,6 @@ void TClingCallbacks::TransactionCommitted(const Transaction &T) {
TCling__UpdateListsOnCommitted(T, m_Interpreter);
}
-// Collect modules and put them into fPendingCxxModules at first run. Interpreter is not yet initialized at first run
-// but we need to use interpreter services when loading libraries.
-void TClingCallbacks::beforeExecuteTransaction(const Transaction &T) {
-
- const std::vector<clang::Module*> &modules = T.getClangModules();
-
- if (fFirstRun) {
- for (auto M : modules)
- fPendingCxxModules.push_back(M);
- return;
- }
-
- if (!fPendingCxxModules.empty()) {
- for (auto M : fPendingCxxModules)
- TCling__AutoLoadLibraryForModules(M->Name.c_str());
- fPendingCxxModules.clear();
- return;
- }
-
- for (auto M : modules)
- TCling__AutoLoadLibraryForModules(M->Name.c_str());
-}
-
// The callback is used to update the list of globals in ROOT.
//
void TClingCallbacks::TransactionUnloaded(const Transaction &T) {
diff --git a/core/metacling/src/TClingCallbacks.h b/core/metacling/src/TClingCallbacks.h
index 55caae110e87fba6a216191154007525d98b4ab9..a4524e4fdd29da6204c60e631e07b1ef73c8178f 100644
--- a/core/metacling/src/TClingCallbacks.h
+++ b/core/metacling/src/TClingCallbacks.h
@@ -12,7 +12,6 @@
#include "cling/Interpreter/InterpreterCallbacks.h"
#include <stack>
-#include <vector>
namespace clang {
class Decl;
@@ -28,7 +27,6 @@ namespace clang {
namespace cling {
class Interpreter;
class Transaction;
- class Module;
}
namespace llvm {
@@ -47,9 +45,6 @@ private:
bool fIsAutoParsingSuspended;
bool fPPOldFlag;
bool fPPChanged;
- // This vector holds a clang cxxmodules where corresponding library should be loaded in Transaction
- // afterwards.
- std::vector<clang::Module*> fPendingCxxModules;
public:
TClingCallbacks(cling::Interpreter* interp);
@@ -88,8 +83,6 @@ public:
//
virtual void TransactionCommitted(const cling::Transaction &T);
- virtual void beforeExecuteTransaction(const cling::Transaction &T);
-
// The callback is used to update the list of globals in ROOT.
//
virtual void TransactionUnloaded(const cling::Transaction &T);
diff --git a/core/metacling/src/TClingClassInfo.cxx b/core/metacling/src/TClingClassInfo.cxx
index 8d8e3cbac6d226d7b6a1bfdafde5a2699d454c44..35845964922e1fffc58a5c4959a7d12cd25852c2 100644
--- a/core/metacling/src/TClingClassInfo.cxx
+++ b/core/metacling/src/TClingClassInfo.cxx
@@ -1267,10 +1267,6 @@ const char *TClingClassInfo::Name() const
if (const NamedDecl* ND = llvm::dyn_cast<NamedDecl>(fDecl)) {
PrintingPolicy Policy(fDecl->getASTContext().getPrintingPolicy());
llvm::raw_string_ostream stream(buf);
-
- // getNameForDiagnostic can trigger deserialization
- cling::Interpreter::PushTransactionRAII RAII(fInterp);
-
ND->getNameForDiagnostic(stream, Policy, /*Qualified=*/false);
}
return buf.c_str();
diff --git a/core/metacling/src/TClingDataMemberInfo.cxx b/core/metacling/src/TClingDataMemberInfo.cxx
index 21c6a82f670b2db71c47c64d9e9d3a3da5ff7090..9c8fa9980f42f5052b863d97f660ff57a3310cc5 100644
--- a/core/metacling/src/TClingDataMemberInfo.cxx
+++ b/core/metacling/src/TClingDataMemberInfo.cxx
@@ -308,9 +308,6 @@ long TClingDataMemberInfo::Offset()
const Decl *D = GetDecl();
ASTContext& C = D->getASTContext();
if (const FieldDecl *FldD = dyn_cast<FieldDecl>(D)) {
- // getASTRecordLayout can trigger deserialization
- cling::Interpreter::PushTransactionRAII RAII(fInterp);
-
// The current member is a non-static data member.
const clang::RecordDecl *RD = FldD->getParent();
const clang::ASTRecordLayout &Layout = C.getASTRecordLayout(RD);
diff --git a/core/metacling/src/TClingTypeInfo.cxx b/core/metacling/src/TClingTypeInfo.cxx
index f718dbd54b2e39d3680e0659857092ed286f1ac8..10e5cc58465dd11b654ad6f8bfc28d5bddc3a272 100644
--- a/core/metacling/src/TClingTypeInfo.cxx
+++ b/core/metacling/src/TClingTypeInfo.cxx
@@ -168,10 +168,6 @@ long TClingTypeInfo::Property() const
// Note: Now we have class, struct, union only.
const clang::CXXRecordDecl *CRD =
llvm::dyn_cast<clang::CXXRecordDecl>(TD);
-
- // isAbstract can trigger deserialization
- cling::Interpreter::PushTransactionRAII RAII(fInterp);
-
if (CRD->isClass()) {
property |= kIsClass;
}
diff --git a/interpreter/cling/include/cling/Interpreter/InterpreterCallbacks.h b/interpreter/cling/include/cling/Interpreter/InterpreterCallbacks.h
index 2103d5a335b88d780dbccd333275330539c75100..602bd016d657d3e05d33b23f3b2c9331b023bf9f 100644
--- a/interpreter/cling/include/cling/Interpreter/InterpreterCallbacks.h
+++ b/interpreter/cling/include/cling/Interpreter/InterpreterCallbacks.h
@@ -132,13 +132,6 @@ namespace cling {
///
virtual void TransactionCommitted(const Transaction&) {}
- ///\brief This callback is invoked before a transaction is executed.
- /// This event happens after a transaction was committed and LLVM IR was produced.
- ///
- ///\param[in] - The transaction to be executed.
- ///
- virtual void beforeExecuteTransaction(const Transaction&) {}
-
///\brief This callback is invoked whenever interpreter has reverted a
/// transaction that has been fully committed.
///
diff --git a/interpreter/cling/include/cling/Interpreter/Transaction.h b/interpreter/cling/include/cling/Interpreter/Transaction.h
index 680543d021991389b8c755e70424507b313e573a..454ec7986e6e869a2e652019e1971e65075cb2cb 100644
--- a/interpreter/cling/include/cling/Interpreter/Transaction.h
+++ b/interpreter/cling/include/cling/Interpreter/Transaction.h
@@ -31,7 +31,6 @@ namespace clang {
class Preprocessor;
struct PrintingPolicy;
class Sema;
- class Module;
}
namespace llvm {
@@ -116,11 +115,6 @@ namespace cling {
typedef llvm::SmallVector<DelayCallInfo, 64> DeclQueue;
typedef llvm::SmallVector<Transaction*, 2> NestedTransactions;
- ///\brief The list of cxxmodules, which is collected by DeserializationListener
- /// and will be used to load corresponding libraries.
- ///
- std::vector<clang::Module*> m_CxxModules;
-
///\brief All seen declarations, except the deserialized ones.
/// If we collect the declarations by walking the clang::DeclContext we
/// will miss the injected onces (eg. template instantiations).
@@ -274,17 +268,6 @@ namespace cling {
return const_reverse_nested_iterator(0);
}
- void addClangModule(clang::Module* M) {
- assert(M && "addClangModules: passed clang::Module pointer is null");
-
- if (std::find(m_CxxModules.rbegin(), m_CxxModules.rend(), M) == m_CxxModules.rend())
- m_CxxModules.push_back(M);
- }
-
- const std::vector<clang::Module*> &getClangModules() const {
- return m_CxxModules;
- }
-
/// Macro iteration
typedef MacroDirectiveInfoQueue::iterator macros_iterator;
typedef MacroDirectiveInfoQueue::const_iterator const_macros_iterator;
diff --git a/interpreter/cling/lib/Interpreter/DeclCollector.cpp b/interpreter/cling/lib/Interpreter/DeclCollector.cpp
index 5275feb5ce8ab5569d5603cc6113c34fd9c998a8..24f43aa372c42d0e8dac39b01f1ad9d6c6b1c2a0 100644
--- a/interpreter/cling/lib/Interpreter/DeclCollector.cpp
+++ b/interpreter/cling/lib/Interpreter/DeclCollector.cpp
@@ -321,17 +321,4 @@ namespace cling {
m_Consumer->HandleCXXStaticMemberVarInstantiation(D);
}
- void DeclCollector::DeclRead(clang::serialization::DeclID, const clang::Decl *D) {
- assertHasTransaction(m_CurTransaction);
-
- assert(D && "Decl doesn't exist!");
- if (!D->hasOwningModule()) return;
-
- clang::Module *M = D->getOwningModule();
- M = M->getTopLevelModule();
-
- // Add interesting module to Transaction's m_cxxmodules; Corresponding library will be loaded.
- m_CurTransaction->addClangModule(M);
- }
-
} // namespace cling
diff --git a/interpreter/cling/lib/Interpreter/DeclCollector.h b/interpreter/cling/lib/Interpreter/DeclCollector.h
index c60c11d039b1ecf2c6132b519344669c9e7ccec4..476f49d5fea54efd5723e08345c2e29c89e9e8c8 100644
--- a/interpreter/cling/lib/Interpreter/DeclCollector.h
+++ b/interpreter/cling/lib/Interpreter/DeclCollector.h
@@ -11,7 +11,6 @@
#define CLING_DECL_COLLECTOR_H
#include "clang/AST/ASTConsumer.h"
-#include "clang/Serialization/ASTDeserializationListener.h"
#include "ASTTransformer.h"
@@ -25,7 +24,6 @@ namespace clang {
class DeclGroupRef;
class Preprocessor;
class Token;
- class Module;
}
namespace cling {
@@ -42,7 +40,7 @@ namespace cling {
/// cling::DeclCollector is responsible for appending all the declarations
/// seen by clang.
///
- class DeclCollector : public clang::ASTConsumer , public clang::ASTDeserializationListener {
+ class DeclCollector : public clang::ASTConsumer {
/// \brief PPCallbacks overrides/ Macro support
class PPAdapter;
@@ -118,11 +116,6 @@ namespace cling {
// dyn_cast/isa support
static bool classof(const clang::ASTConsumer*) { return true; }
- static bool classof(const clang::ASTDeserializationListener*) { return true; }
-
- ///\brief ASTDeserializationListener function which gets callback when a decl is deserialized
- void DeclRead(clang::serialization::DeclID, const clang::Decl *D) final;
-
};
} // namespace cling
diff --git a/interpreter/cling/lib/Interpreter/IncrementalParser.cpp b/interpreter/cling/lib/Interpreter/IncrementalParser.cpp
index ce322cc2de22fa938bd1176bbddd22af0d3f9004..6353f7b558cb6d06091f8263dff74720a10884ee 100644
--- a/interpreter/cling/lib/Interpreter/IncrementalParser.cpp
+++ b/interpreter/cling/lib/Interpreter/IncrementalParser.cpp
@@ -44,7 +44,6 @@
#include "clang/Sema/Sema.h"
#include "clang/Sema/SemaDiagnostic.h"
#include "clang/Serialization/ASTWriter.h"
-#include "clang/Serialization/ASTReader.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
@@ -227,13 +226,6 @@ namespace cling {
Preprocessor& PP = m_CI->getPreprocessor();
DiagnosticsEngine& Diags = m_CI->getSema().getDiagnostics();
- ASTReader* Reader = m_CI->getModuleManager().get();
- assert(isa<ASTDeserializationListener>(m_Consumer));
- ASTDeserializationListener* Listener = cast<ASTDeserializationListener>(m_Consumer);
- // FIXME: We should create a multiplexing deserialization listener if there is one already attached.
- if (Reader && Listener && !Reader->getDeserializationListener())
- Reader->setDeserializationListener(Listener);
-
// Pull in PCH.
const std::string& PCHFileName
= m_CI->getInvocation().getPreprocessorOpts().ImplicitPCHInclude;
diff --git a/interpreter/cling/lib/Interpreter/Interpreter.cpp b/interpreter/cling/lib/Interpreter/Interpreter.cpp
index 56c5c3ecf2d1dcb6c0834548f9159ce0702fdf1c..22016dc626067e46de5ef820088d1d460f4d3151 100644
--- a/interpreter/cling/lib/Interpreter/Interpreter.cpp
+++ b/interpreter/cling/lib/Interpreter/Interpreter.cpp
@@ -1529,9 +1529,6 @@ namespace cling {
assert(!isInSyntaxOnlyMode() && "Running on what?");
assert(T.getState() == Transaction::kCommitted && "Must be committed");
- if (InterpreterCallbacks* callbacks = getCallbacks())
- callbacks->beforeExecuteTransaction(T);
-
const std::shared_ptr<llvm::Module>& M = T.getModule();
if (!M)
return Interpreter::kExeNoModule;
diff --git a/interpreter/cling/lib/Interpreter/LookupHelper.cpp b/interpreter/cling/lib/Interpreter/LookupHelper.cpp
index b8fc0cd3eb3ca6f3e5fc0cf7c26bce1e6f092e30..4df32ba572a0fe6188bb88a3cf4d8594caa01b86 100644
--- a/interpreter/cling/lib/Interpreter/LookupHelper.cpp
+++ b/interpreter/cling/lib/Interpreter/LookupHelper.cpp
@@ -1452,9 +1452,9 @@ namespace cling {
DigestArgsInput inputEval;
llvm::SmallVector<Expr*, 4> GivenArgs;
- Interpreter::PushTransactionRAII pushedT(Interp);
if (!inputEval(GivenArgs,funcArgs,diagOnOff,P,Interp)) return 0;
+ Interpreter::PushTransactionRAII pushedT(Interp);
return findFunction(foundDC,
funcName, GivenArgs, objectIsConst,
Context, Interp, functionSelector,
diff --git a/interpreter/cling/lib/Interpreter/MultiplexInterpreterCallbacks.h b/interpreter/cling/lib/Interpreter/MultiplexInterpreterCallbacks.h
index 3d98ae0418985e16404421fb97cecef2c742715d..40f6754e60235b59d6824f4371ed3dd9f068ebfb 100644
--- a/interpreter/cling/lib/Interpreter/MultiplexInterpreterCallbacks.h
+++ b/interpreter/cling/lib/Interpreter/MultiplexInterpreterCallbacks.h
@@ -77,12 +77,6 @@ namespace cling {
}
}
- void beforeExecuteTransaction(const Transaction& T) override {
- for (auto&& cb : m_Callbacks) {
- cb->beforeExecuteTransaction(T);
- }
- }
-
void TransactionUnloaded(const Transaction& T) override {
for (auto&& cb : m_Callbacks) {
cb->TransactionUnloaded(T);
diff --git a/interpreter/llvm/src/tools/clang/include/clang/Serialization/ASTReader.h b/interpreter/llvm/src/tools/clang/include/clang/Serialization/ASTReader.h
index f515756bf29015457c8f17c4c23f8db6d6ebff16..ab6f4f00436c2a28c45f28d6e8ace16ba704528f 100644
--- a/interpreter/llvm/src/tools/clang/include/clang/Serialization/ASTReader.h
+++ b/interpreter/llvm/src/tools/clang/include/clang/Serialization/ASTReader.h
@@ -1555,10 +1555,6 @@ public:
void setDeserializationListener(ASTDeserializationListener *Listener,
bool TakeOwnership = false);
- ASTDeserializationListener *getDeserializationListener() {
- return DeserializationListener;
- };
-
/// \brief Determine whether this AST reader has a global index.
bool hasGlobalIndex() const { return (bool)GlobalIndex; }