Skip to content

[cxxmodules] Refactor LoadCoreModules. #1394

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
Teemperor wants to merge 2 commits into from
Closed

[cxxmodules] Refactor LoadCoreModules. #1394

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
37d34a5
[cxxmodules] Only load modules if one was generated
Teemperor Dec 1, 2017
76d87f1
[cxxmodules] Refactor LoadCoreModules.
vgvassilev Nov 25, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 2 additions & 1 deletion core/base/inc/TROOT.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -309,7 +309,8 @@ friend TROOT *ROOT::Internal::GetROOT2();
const char* fwdDeclCode,
void (*triggerFunc)(),
const FwdDeclArgsToKeepCollection_t& fwdDeclsArgToSkip,
const char** classesHeaders);
const char** classesHeaders,
bool hasCxxModule = false);
TObject *Remove(TObject*);
void RemoveClass(TClass *);
void Reset(Option_t *option="");
Expand Down
23 changes: 14 additions & 9 deletions core/base/src/TROOT.cxx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -258,15 +258,17 @@ namespace {
const char* fwdDeclCode,
void (*triggerFunc)(),
const TROOT::FwdDeclArgsToKeepCollection_t& fwdDeclsArgToSkip,
const char** classesHeaders):
const char **classesHeaders,
bool hasCxxModule):
fModuleName(moduleName),
fHeaders(headers),
fPayloadCode(payloadCode),
fFwdDeclCode(fwdDeclCode),
fIncludePaths(includePaths),
fTriggerFunc(triggerFunc),
fClassesHeaders(classesHeaders),
fFwdNargsToKeepColl(fwdDeclsArgToSkip){}
fFwdNargsToKeepColl(fwdDeclsArgToSkip),
fHasCxxModule(hasCxxModule) {}

const char* fModuleName; // module name
const char** fHeaders; // 0-terminated array of header files
Expand All @@ -277,6 +279,7 @@ namespace {
const char** fClassesHeaders; // 0-terminated list of classes and related header files
const TROOT::FwdDeclArgsToKeepCollection_t fFwdNargsToKeepColl; // Collection of
// pairs of template fwd decls and number of
bool fHasCxxModule; // Whether this module has a C++ module alongside it.
};

std::vector<ModuleHeaderInfo_t>& GetModuleHeaderInfoBuffer() {
Expand Down Expand Up @@ -2068,7 +2071,8 @@ void TROOT::InitInterpreter()
li->fTriggerFunc,
li->fFwdNargsToKeepColl,
li->fClassesHeaders,
kTRUE /*lateRegistration*/);
kTRUE /*lateRegistration*/,
li->fHasCxxModule);
}
GetModuleHeaderInfoBuffer().clear();

Expand Down Expand Up @@ -2477,7 +2481,8 @@ void TROOT::RegisterModule(const char* modulename,
const char* fwdDeclCode,
void (*triggerFunc)(),
const TInterpreter::FwdDeclArgsToKeepCollection_t& fwdDeclsArgToSkip,
const char** classesHeaders)
const char** classesHeaders,
bool hasCxxModule)
{

// First a side track to insure proper end of process behavior.
Expand Down Expand Up @@ -2539,12 +2544,12 @@ void TROOT::RegisterModule(const char* modulename,

// Now register with TCling.
if (gCling) {
gCling->RegisterModule(modulename, headers, includePaths, payloadCode, fwdDeclCode,
triggerFunc, fwdDeclsArgToSkip, classesHeaders);
gCling->RegisterModule(modulename, headers, includePaths, payloadCode, fwdDeclCode, triggerFunc,
fwdDeclsArgToSkip, classesHeaders, false, hasCxxModule);
} else {
GetModuleHeaderInfoBuffer()
.push_back(ModuleHeaderInfo_t (modulename, headers, includePaths, payloadCode, fwdDeclCode,
triggerFunc, fwdDeclsArgToSkip,classesHeaders));
GetModuleHeaderInfoBuffer().push_back(ModuleHeaderInfo_t(modulename, headers, includePaths, payloadCode,
fwdDeclCode, triggerFunc, fwdDeclsArgToSkip,
classesHeaders, hasCxxModule));
}
}

Expand Down
2 changes: 1 addition & 1 deletion core/dictgen/src/TModuleGenerator.cxx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -462,7 +462,7 @@ void TModuleGenerator::WriteRegistrationSource(std::ostream &out,
" if (!isInitialized) {\n"
" TROOT::RegisterModule(\"" << GetDemangledDictionaryName() << "\",\n"
" headers, includePaths, payloadCode, fwdDeclCode,\n"
" TriggerDictionaryInitialization_" << GetDictionaryName() << "_Impl, " << fwdDeclnArgsToKeepString << ", classesHeaders);\n"
" TriggerDictionaryInitialization_" << GetDictionaryName() << "_Impl, " << fwdDeclnArgsToKeepString << ", classesHeaders, " << (fCI->getLangOpts().Modules ? "/*has C++ module*/true" : "/*has no C++ module*/false") << ");\n"
" isInitialized = true;\n"
" }\n"
" }\n"
Expand Down
3 changes: 2 additions & 1 deletion core/meta/inc/TInterpreter.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -154,7 +154,8 @@ class TInterpreter : public TNamed {
void (* /*triggerFunc*/)(),
const FwdDeclArgsToKeepCollection_t& fwdDeclArgsToKeep,
const char** classesHeaders,
Bool_t lateRegistration = false) = 0;
Bool_t lateRegistration = false,
Bool_t hasCxxModule = false) = 0;
virtual void RegisterTClassUpdate(TClass *oldcl,DictFuncPtr_t dict) = 0;
virtual void UnRegisterTClassUpdate(const TClass *oldcl) = 0;
virtual Int_t SetClassSharedLibs(const char *cls, const char *libs) = 0;
Expand Down
91 changes: 40 additions & 51 deletions core/metacling/src/TCling.cxx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1065,8 +1065,10 @@ inline bool TCling::TUniqueString::Append(const std::string& str)
return notPresent;
}

////////////////////////////////////////////////////////////////////////////////
///\returns true if the module was loaded.
static bool LoadModule(const std::string &ModuleName, cling::Interpreter &interp) {
static bool LoadModule(const std::string &ModuleName, cling::Interpreter &interp, bool Complain = true)
{
clang::CompilerInstance &CI = *interp.getCI();

assert(CI.getLangOpts().Modules && "Function only relevant when C++ modules are turned on!");
Expand All @@ -1080,57 +1082,30 @@ static bool LoadModule(const std::string &ModuleName, cling::Interpreter &interp
clang::IdentifierInfo *II = PP.getIdentifierInfo(M->Name);
SourceLocation ValidLoc = M->DefinitionLoc;
bool success = !CI.getSema().ActOnModuleImport(ValidLoc, ValidLoc, std::make_pair(II, ValidLoc)).isInvalid();
// Also make the module visible in the preprocessor to export its macros.
PP.makeModuleVisible(M, ValidLoc);
return success;
if (success) {
// Also make the module visible in the preprocessor to export its macros.
PP.makeModuleVisible(M, ValidLoc);
return success;
}
if (Complain) {
if (M->IsSystem)
Error("TCling::LoadModule", "Module %s failed to load", M->Name.c_str());
else
Info("TCling::LoadModule", "Module %s failed to load", M->Name.c_str());
}
}
if (Complain)
Error("TCling::LoadModule", "Module %s not found!", ModuleName.c_str());
return false;
}

////////////////////////////////////////////////////////////////////////////////
/// Loads the basic C++ modules that we require to run any ROOT program.
/// This is just supposed to make the declarations in their headers available
/// to the interpreter.
static void LoadCoreModules(cling::Interpreter &interp)
/// Loads the C++ modules that we require to run any ROOT program. This is just
/// supposed to make a C++ module from a modulemap available to the interpreter.
static void LoadModules(const std::vector<std::string> &modules, cling::Interpreter &interp)
{
clang::CompilerInstance &CI = *interp.getCI();
// Without modules, this function is just a no-op.
if (!CI.getLangOpts().Modules)
return;

clang::HeaderSearch &headerSearch = CI.getPreprocessor().getHeaderSearchInfo();
clang::ModuleMap &moduleMap = headerSearch.getModuleMap();
// List of core modules we can load, but it's ok if they are missing because
// the system doesn't have these modules.
if (clang::Module *LIBCM = moduleMap.findModule("libc"))
if (!LoadModule(LIBCM->Name, interp))
Error("TCling::LoadCoreModules", "Cannot load module %s", LIBCM->Name.c_str());

if (clang::Module *STLM = moduleMap.findModule("stl"))
if (!LoadModule(STLM->Name, interp))
Error("TCling::LoadCoreModules", "Cannot load module %s", STLM->Name.c_str());

// ROOT_Types is a module outside core because we need C and -no-rtti compatibility.
// Preload it as it is an integral part of module Core.
if (!LoadModule(moduleMap.findModule("ROOT_Types")->Name, interp))
Error("TCling::LoadCoreModules", "Cannot load module ROOT_Types");

if (!LoadModule(moduleMap.findModule("Core")->Name, interp))
Error("TCling::LoadCoreModules", "Cannot load module Core");

if (!LoadModule(moduleMap.findModule("RIO")->Name, interp))
Error("TCling::LoadCoreModules", "Cannot load module RIO");

// Check that the gROOT macro was exported by any core module.
assert(interp.getMacro("gROOT") && "Couldn't load gROOT macro?");

// C99 decided that it's a very good idea to name a macro `I` (the letter I).
// This seems to screw up nearly all the template code out there as `I` is
// common template parameter name and iterator variable name.
// Let's follow the GCC recommendation and undefine `I` in case any of the
// core modules have defined it:
// https://www.gnu.org/software/libc/manual/html_node/Complex-Numbers.html
interp.declare("#ifdef I\n #undef I\n #endif\n");
for (const auto &modName : modules)
LoadModule(modName, interp);
}

static bool FileExists(const char *file)
Expand Down Expand Up @@ -1274,6 +1249,22 @@ TCling::TCling(const char *name, const char *title)
static llvm::raw_fd_ostream fMPOuts (STDOUT_FILENO, /*ShouldClose*/false);
fMetaProcessor = new cling::MetaProcessor(*fInterpreter, fMPOuts);

if (fInterpreter->getCI()->getLangOpts().Modules) {
// Setup core C++ modules if we have any to setup.
LoadModules({"libc", "stl", "ROOT_Types", "Core", "RIO"}, *fInterpreter);

// Check that the gROOT macro was exported by any core module.
assert(fInterpreter->getMacro("gROOT") && "Couldn't load gROOT macro?");

// C99 decided that it's a very good idea to name a macro `I` (the letter I).
// This seems to screw up nearly all the template code out there as `I` is
// common template parameter name and iterator variable name.
// Let's follow the GCC recommendation and undefine `I` in case any of the
// core modules have defined it:
// https://www.gnu.org/software/libc/manual/html_node/Complex-Numbers.html
fInterpreter->declare("#ifdef I\n #undef I\n #endif\n");
}

// For the list to also include string, we have to include it now.
// rootcling does parts already if needed, e.g. genreflex does not want using
// namespace std.
Expand All @@ -1293,9 +1284,6 @@ TCling::TCling(const char *name, const char *title)
"#include <cassert>\n");
}

// Setup core C++ modules if we have any to setup.
LoadCoreModules(*fInterpreter);

// We are now ready (enough is loaded) to init the list of opaque typedefs.
fNormalizedCtxt = new ROOT::TMetaUtils::TNormalizedCtxt(fInterpreter->getLookupHelper());
fLookupHelper = new ROOT::TMetaUtils::TClingLookupHelper(*fInterpreter, *fNormalizedCtxt, TClingLookupHelper__ExistingTypeCheck, TClingLookupHelper__AutoParse);
Expand Down Expand Up @@ -1673,7 +1661,8 @@ void TCling::RegisterModule(const char* modulename,
void (*triggerFunc)(),
const FwdDeclArgsToKeepCollection_t& fwdDeclsArgToSkip,
const char** classesHeaders,
Bool_t lateRegistration /*=false*/)
Bool_t lateRegistration /*=false*/,
Bool_t hasCxxModule /*=false*/)
{
const bool fromRootCling = IsFromRootCling();
// We need the dictionary initialization but we don't want to inject the
Expand Down Expand Up @@ -1913,7 +1902,7 @@ void TCling::RegisterModule(const char* modulename,
clang::Sema &TheSema = fInterpreter->getSema();

bool ModuleWasSuccessfullyLoaded = false;
if (TheSema.getLangOpts().Modules) {
if (hasCxxModule) {
std::string ModuleName = llvm::StringRef(modulename).substr(3).str();
ModuleWasSuccessfullyLoaded = LoadModule(ModuleName, *fInterpreter);
if (!ModuleWasSuccessfullyLoaded) {
Expand Down
3 changes: 2 additions & 1 deletion core/metacling/src/TCling.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -205,7 +205,8 @@ class TCling : public TInterpreter {
void (*triggerFunc)(),
const FwdDeclArgsToKeepCollection_t& fwdDeclsArgToSkip,
const char** classesHeaders,
Bool_t lateRegistration = false);
Bool_t lateRegistration = false,
Bool_t hasCxxModule = false);
void RegisterTClassUpdate(TClass *oldcl,DictFuncPtr_t dict);
void UnRegisterTClassUpdate(const TClass *oldcl);

Expand Down