VuoCompilerModule.cc

Go to the documentation of this file.

 
#include "VuoCompilerBitcodeParser.hh"
#include "VuoCompilerNodeClass.hh"
#include "VuoCompilerType.hh"
#include "VuoJsonUtilities.hh"
#include "VuoNodeClass.hh"
#include "VuoStringUtilities.hh"
 
VuoCompilerModule::VuoCompilerModule(VuoModule *base, Module *module)
    : compatibleTargets(nullptr)
{
#if VUO_PRO
    init_Pro();
#endif
    this->base = base;
    this->module = module;
    this->moduleDetails = NULL;
    this->parser = NULL;
    this->builtIn = false;
 
    if (module)
    {
        module->setModuleIdentifier(getPseudoBase()->getModuleKey());
        parse();
    }
}
 
VuoCompilerModule::~VuoCompilerModule(void)
{
#if VUO_PRO
    fini_Pro();
#endif
    delete parser;
    json_object_put(moduleDetails);
}
 
VuoCompilerModule * VuoCompilerModule::newModule(const string &moduleKey, Module *module, const string &modulePath,
                                                 const VuoCompilerCompatibility &moduleCompatibility)
{
    VuoCompilerModule *m = NULL;
 
    if (isModule(module, moduleKey))
    {
        VuoNodeClass *nodeClass = VuoCompilerNodeClass::newNodeClass(moduleKey, module);
        if (nodeClass)
            m = nodeClass->getCompiler();
        else
        {
            VuoCompilerType *type = VuoCompilerType::newType(moduleKey, module);
            if (type)
                m = type;
            else
                m = new VuoCompilerModule(new VuoModule(moduleKey), module);
        }
 
        m->modulePath = modulePath;
        m->compatibleTargets = m->compatibleTargets.intersection(moduleCompatibility);
    }
    else if (moduleKey != "libmodule")
        VUserLog("Warning: No VuoModuleMetadata found in \"%s\" so I'm not going to load it.", moduleKey.c_str());
 
    return m;
}
 
bool VuoCompilerModule::isModule(Module *module, string moduleKey)
{
    return hasOriginalOrMangledGlobal("moduleDetails", module, moduleKey);
}
 
void VuoCompilerModule::parse(void)
{
    parser = new VuoCompilerBitcodeParser(module);
    renameGlobalVarsAndFuncs();
    parseMetadata();
}
 
void VuoCompilerModule::parseMetadata(void)
{
    string moduleDetailsStr = parser->getGlobalString( nameForGlobal("moduleDetails") );
    json_object_put(moduleDetails);
    moduleDetails = json_tokener_parse(moduleDetailsStr.c_str());
 
    if (! moduleDetails)
    {
        VUserLog("Error: Couldn't parse VuoModuleMetadata as JSON: %s", moduleDetailsStr.c_str());
        return;
    }
 
    base->setDefaultTitle(VuoJsonUtilities::parseString(moduleDetails, "title"));
    base->setDescription(VuoJsonUtilities::parseString(moduleDetails, "description"));
    base->setVersion(VuoJsonUtilities::parseString(moduleDetails, "version"));
    base->setKeywords(VuoJsonUtilities::parseArrayOfStrings(moduleDetails, "keywords"));
    vector<string> dependenciesVector = VuoJsonUtilities::parseArrayOfStrings(moduleDetails, "dependencies");
    dependencies = set<string>(dependenciesVector.begin(), dependenciesVector.end());
    compatibleTargets = parseCompatibility(moduleDetails, "compatibility");
}
 
VuoCompilerCompatibility VuoCompilerModule::parseCompatibility(json_object *o, string key)
{
    json_object *compatibilityObject = nullptr;
    if (json_object_object_get_ex(o, key.c_str(), &compatibilityObject))
        return VuoCompilerCompatibility(compatibilityObject);
 
    return VuoCompilerCompatibility::compatibilityWithAnySystem();
}
 
set<string> VuoCompilerModule::globalsToRename(void)
{
    set<string> globals;
    globals.insert("moduleDetails");
    return globals;
}
 
string VuoCompilerModule::nameForGlobal(string genericGlobalVarOrFuncName)
{
    return nameForGlobal(genericGlobalVarOrFuncName, base->getModuleKey());
}
 
string VuoCompilerModule::nameForGlobal(string nameBeforeCompilation, string moduleKey)
{
    return VuoStringUtilities::prefixSymbolName(nameBeforeCompilation, moduleKey);
}
 
bool VuoCompilerModule::hasOriginalOrMangledGlobal(string nameBeforeCompilation, Module *module, string moduleKey)
{
    string nameAfterCompilation = nameForGlobal(nameBeforeCompilation, moduleKey);
    return (module->getNamedValue(nameBeforeCompilation) != NULL || module->getNamedValue(nameAfterCompilation) != NULL);
}
 
void VuoCompilerModule::renameGlobalVarsAndFuncs(void)
{
    set<string> globalsAndFuncsToRename = globalsToRename();
 
    Module::GlobalListType& globals = module->getGlobalList();
 
    // Iterate through global variables
    for (Module::GlobalListType::iterator i = globals.begin(), e = globals.end(); i != e; ++i) {
        string curGlobalVarName = i->getName();
        // If current global variable is in the list of those to rename, do so
        if (globalsAndFuncsToRename.find(curGlobalVarName) != globalsAndFuncsToRename.end()) {
            string newGlobalVarName = nameForGlobal(curGlobalVarName);
            i->setName(newGlobalVarName);
        }
 
    }
 
    Module::FunctionListType& functions = module->getFunctionList();
 
    // Iterate through functions
    for (Module::FunctionListType::iterator i = functions.begin(), e = functions.end(); i != e; ++i) {
        string curFuncName = i->getName();
        // If current function is in the list of those to rename, do so
        if (globalsAndFuncsToRename.find(curFuncName) != globalsAndFuncsToRename.end()) {
            string newFuncName = nameForGlobal(curFuncName);
            i->setName(newFuncName);
        }
 
    }
}
 
Function * VuoCompilerModule::declareFunctionInModule(Module *module, Function *functionSrc)
{
    Function *functionDst = module->getFunction(functionSrc->getName());
    if (! functionDst)
    {
        functionDst = Function::Create(functionSrc->getFunctionType(),
                                       GlobalValue::ExternalLinkage,
                                       functionSrc->getName(),
                                       module);
        functionDst->setAttributes( functionSrc->getAttributes() );
    }
    return functionDst;
}
 
set<string> VuoCompilerModule::getDependencies(void)
{
    return dependencies;
}
 
string VuoCompilerModule::getDependencyName(void)
{
    return base->getModuleKey();
}
 
VuoCompilerCompatibility VuoCompilerModule::getCompatibleTargets(void)
{
    return compatibleTargets;
}
 
Module * VuoCompilerModule::getModule(void)
{
    return module;
}
 
VuoModule * VuoCompilerModule::getPseudoBase(void)
{
    return base;
}
 
bool VuoCompilerModule::isBuiltIn(void)
{
    return builtIn;
}
 
void VuoCompilerModule::setBuiltIn(bool builtIn)
{
    this->builtIn = builtIn;
}
 
string VuoCompilerModule::getModulePath(void)
{
    return modulePath;
}