backend.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "backend.h"


PString cpp_licenceSaveStr(){
        PString body("");
        body += "/***************************************\n";
        body += "\tAuteur : Pierre Aubert\n";
        body += "\tMail : pierre.aubert@lapp.in2p3.fr\n";
        body += "\tLicence : CeCILL-C\n";
        body += "****************************************/\n\n\n";
        
        body += "//Warning : this file has been generated automatically by the phoenix_hpc_proxy program\n";
        body += "//You can find it at https://gitlab.in2p3.fr/CTA-LAPP/PHOENIX_LIBS/PhoenixHPCProxy\n";
        body += "//Do NOT modify it\n\n\n";
        return body;
}


PString getHandleFunction(const PString & functionName){
        return "handle_" + functionName;
}


PString getHandleFunctionType(const PString & functionName){
        return "FunctionTypehandle_" + functionName;
}


PString getUpdateFunction(const PPath & fileName){
        return "update_" + fileName.eraseExtension();
}


PString cpp_backendTableHeaderInline(PFunction & function){
        if(function.getOtherCode() != ""){return function.getOtherCode();}
        PString body("");
        if(function.getDocString() != ""){body += function.getDocString();}
        if(function.getTemplateDef() != ""){body += function.getTemplateDef();}
        body += "inline " + function.getOutputType() + " " + function.getName() + "(";
        bool isComma(false);
        PVecArgument & vecArg = function.getVecArgument();
        for(PVecArgument::iterator it(vecArg.begin()); it != vecArg.end(); ++it){
                if(isComma){body += ", ";}
                body += it->getType() + " ";
                if(it->getPtrRef() != ""){body += it->getPtrRef() + " ";}
                body += it->getName();
                if(it->getDefaultValue() != ""){body += " = " + it->getDefaultValue();}
                isComma = true;
        }
        body += "){\n";
        isComma = false;
        body += "\t"+getHandleFunction(function.getName())+"(";
        for(PVecArgument::iterator it(vecArg.begin()); it != vecArg.end(); ++it){
                if(isComma){body += ", ";}
                body += it->getName();
                isComma = true;
        }
        body += ");\n";
        body += "}\n\n";
        return body;
}


PString cpp_backendTableHeaderHandleType(PFunction & function){
        if(!repr_isFunction(function)){return "";}
        PString body("");
        body += "typedef " + function.getOutputType() + "(*" + getHandleFunctionType(function.getName()) + ")(";
        bool isComma(false);
        PVecArgument & vecArg = function.getVecArgument();
        for(PVecArgument::iterator it(vecArg.begin()); it != vecArg.end(); ++it){
                if(isComma){body += ", ";}
                body += it->getType();
                if(it->getPtrRef() != ""){body +=  " " + it->getPtrRef();}
                isComma = true;
        }
        body += ");\n";
        return body;
}


PString cpp_backendHeader(PSource & source){
        PString body(cpp_licenceSaveStr());
        PString baseMacro("__" + source.getName().eraseExtension().toUpper() + "_PROXY_H__");
        body += "#ifndef " + baseMacro + "\n";
        body += "#define " + baseMacro + "\n\n";
        body += "#include <iostream>\n\n\n";
        PVecFunction & vecFunction = source.getVecFunction();
        for(PVecFunction::iterator it(vecFunction.begin()); it != vecFunction.end(); ++it){
                body += cpp_backendTableHeaderHandleType(*it);
        }
        body += "\n\n";
        for(PVecFunction::iterator it(vecFunction.begin()); it != vecFunction.end(); ++it){
                if(!repr_isFunction(*it)){continue;}
                body += "extern " + getHandleFunctionType(it->getName()) + " " + getHandleFunction(it->getName()) + ";\n";
        }
        body += "\n\n";
        for(PVecFunction::iterator it(vecFunction.begin()); it != vecFunction.end(); ++it){
                body += cpp_backendTableHeaderInline(*it);
        }
        body += "void " + getUpdateFunction(source.getName()) + "(void * handle);\n\n";
        
        body += "#endif\n\n";
        return body;
}


PString getMangleFunctionName(const PString & libraryName, const PString & functionName){
        if(libraryName == ""){return functionName;}
        PPath outputTmpFile(".mangledFunctionName.txt");
        PString command("objdump --syms "+libraryName+" | grep \".text\" | sed -e \"s/ /\\n/g\" | grep "+functionName+" | head -n 1 > "+outputTmpFile);
        if(system(command.c_str()) != 0){
                return functionName;
        }
        PString fullFileContent(outputTmpFile.loadFileContent());
        std::cerr << "getMangleFunctionName : full file content mangle function '"<<functionName<<"' : " << fullFileContent << std::endl;
        PString mangleFunction(fullFileContent.eraseChar("\n\t "));
        if(remove(outputTmpFile.c_str()) != 0){
                std::cerr << "DPS::LibraryHandle::mangleFunctionName : cannot remove file '"<<outputTmpFile<<"'" << std::endl;
        }
        return mangleFunction;
}


PString cpp_backendSource(PSource & source, const PString & libName){
        PString body(cpp_licenceSaveStr());
        body += "#include <stdio.h>\n";
        body += "#include <stdlib.h>\n";
        body += "#include <dlfcn.h>\n\n";
        body += "#include \""+source.getName().eraseExtension()+".h\"\n\n";
        
        PVecFunction & vecFunction = source.getVecFunction();
        for(PVecFunction::iterator it(vecFunction.begin()); it != vecFunction.end(); ++it){
                if(!repr_isFunction(*it)){continue;}
                body += getHandleFunctionType(it->getName()) + " " + getHandleFunction(it->getName()) + ";\n";
        }
        body += "\n\n";
        body += "///Update the all the function handles of the file\n";
        body += "/**\t@param handle : pointer to loaded library\n";
        body += "*/\n";
        body += "void " + getUpdateFunction(source.getName()) + "(void * handle){\n";
        for(PVecFunction::iterator it(vecFunction.begin()); it != vecFunction.end(); ++it){
                if(!repr_isFunction(*it)){continue;}
                PString mangleFunction(getMangleFunctionName(libName, it->getName()));
                body += "\t"+getHandleFunction(it->getName())+" = ("+getHandleFunctionType(it->getName())+")(dlsym(handle,  \""+mangleFunction+"\"));\n";
        }
        body += "}\n\n";
        return body;
}


bool cpp_backend(PSource & source, const PString & libName, const PPath & outputDir){
        PString headerSrc(cpp_backendHeader(source));
        PString sourceSrc(cpp_backendSource(source, libName));
        PPath baseFileName(source.getName().eraseExtension());
        PPath outputHeaderFile(outputDir / baseFileName + PString(".h"));
        PPath outputSourceFile(outputDir / baseFileName + PString(".cpp"));
        if(!outputHeaderFile.saveFileContent(headerSrc)){
                std::cerr << "cpp_backend : cannot save header file '"<<outputHeaderFile<<"'" << std::endl;
                return false;
        }
        std::cout << "cpp_backend : create header file '"<<outputHeaderFile<<"'" <<std::endl;
        if(!outputSourceFile.saveFileContent(sourceSrc)){
                std::cerr << "cpp_backend : cannot save source file '"<<outputSourceFile<<"'" << std::endl;
                return false;
        }
        std::cout << "cpp_backend : create source file '"<<outputSourceFile<<"'" <<std::endl;
        return true;
}


bool cpp_backend(PVecSource & vecSource, const PString & libName, const PPath & outputDir){
        bool b(true);
        for(PVecSource::iterator it(vecSource.begin()); it != vecSource.end(); ++it){
                b &= cpp_backend(*it, libName, outputDir);
        }
        return b;
}