VuoCompilerType.cc

Go to the documentation of this file.

 
#include <sstream>
#include "VuoCompilerBitcodeParser.hh"
#include "VuoCompilerCodeGenUtilities.hh"
#include "VuoCompilerException.hh"
#include "VuoCompilerIssue.hh"
#include "VuoCompilerType.hh"
#include "VuoType.hh"
 
VuoCompilerType::VuoCompilerType(string typeName, Module *module)
    : VuoBaseDetail<VuoType>("VuoCompilerType", new VuoType(typeName)),
      VuoCompilerModule(getBase(), module)
{
    getBase()->setCompiler(this);
 
    makeFromJsonFunction = NULL;
    getJsonFunction = NULL;
    getInterprocessJsonFunction = NULL;
    makeFromStringFunction = NULL;
    getStringFunction = NULL;
    getInterprocessStringFunction = NULL;
    getSummaryFunction = NULL;
    areEqualFunction = NULL;
    isLessThanFunction = NULL;
    retainFunction = NULL;
    releaseFunction = NULL;
    llvmArgumentType              = nullptr;
    llvmSecondArgumentType        = nullptr;
    llvmReturnType                = nullptr;
    isReturnPassedAsArgument      = false;
 
    parse();
}
 
VuoCompilerType * VuoCompilerType::newType(string typeName, Module *module)
{
    if (! isType(typeName, module))
        return NULL;
 
    return new VuoCompilerType(typeName, module);
}
 
bool VuoCompilerType::isType(string typeName, Module *module)
{
    return (module->getNamedValue(typeName + "_makeFromJson") != NULL);
}
 
void VuoCompilerType::parse(void)
{
    VuoCompilerModule::parse();
 
    string typeName = getBase()->getModuleKey();
    makeFromJsonFunction = parser->getFunction(typeName + "_makeFromJson");
    getJsonFunction = parser->getFunction(typeName + "_getJson");
    getInterprocessJsonFunction = parser->getFunction(typeName + "_getInterprocessJson");
    getSummaryFunction = parser->getFunction(typeName + "_getSummary");
    areEqualFunction = parser->getFunction(typeName + "_areEqual");
    isLessThanFunction = parser->getFunction(typeName + "_isLessThan");
 
    if (! makeFromJsonFunction)
        VUserLog("Error: Couldn't find %s_makeFromJson() function.", typeName.c_str());
    if (! getJsonFunction)
        VUserLog("Error: Couldn't find %s_getJson() function.", typeName.c_str());
    if (! getSummaryFunction)
        VUserLog("Error: Couldn't find %s_getSummary() function.", typeName.c_str());
 
    llvmArgumentType = getJsonFunction->getFunctionType()->getParamType(0);
    if (getJsonFunction->getFunctionType()->getNumParams() == 2)
        llvmSecondArgumentType = getJsonFunction->getFunctionType()->getParamType(1);
    else if (getJsonFunction->getFunctionType()->getNumParams() != 1)
    {
        string s;
        raw_string_ostream oss(s);
        oss << "Expected a function with 1 or 2 parameters, got " << getJsonFunction->getFunctionType()->getNumParams() << " for function `";
        getJsonFunction->getFunctionType()->print(oss);
        oss << "`.";
        VuoCompilerIssue issue(VuoCompilerIssue::Error, "compiling composition", "", "Unsupported port data type", oss.str());
        throw VuoCompilerException(issue);
    }
 
    llvmReturnType = makeFromJsonFunction->getReturnType();
    if (llvmReturnType->isVoidTy())
    {
        isReturnPassedAsArgument = true;
        llvmReturnType = makeFromJsonFunction->arg_begin()->getType();
    }
 
    parseOrGenerateValueFromStringFunction();
    parseOrGenerateStringFromValueFunction(false);
    if (getInterprocessJsonFunction)
        parseOrGenerateStringFromValueFunction(true);
 
    parseOrGenerateRetainOrReleaseFunction(true);
    parseOrGenerateRetainOrReleaseFunction(false);
}
 
set<string> VuoCompilerType::globalsToRename(void)
{
    set<string> globals = VuoCompilerModule::globalsToRename();
    return globals;
}
 
void VuoCompilerType::parseOrGenerateValueFromStringFunction(void)
{
    string functionName = (getBase()->getModuleKey() + "_makeFromString").c_str();
    Function *function = parser->getFunction(functionName);
 
    bool isReturnInParam = VuoCompilerCodeGenUtilities::isFunctionReturningStructViaParameter(makeFromJsonFunction);
 
    if (! function)
    {
        PointerType *pointerToCharType = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
        FunctionType *makeFromJsonFunctionType = makeFromJsonFunction->getFunctionType();
 
        Type *returnType = makeFromJsonFunctionType->getReturnType();
 
        vector<Type *> functionParams;
        if (isReturnInParam)
            functionParams.push_back(makeFromJsonFunctionType->getParamType(0));
        functionParams.push_back(pointerToCharType);
 
        FunctionType *functionType = FunctionType::get(returnType, functionParams, false);
        function = Function::Create(functionType, GlobalValue::ExternalLinkage, functionName, module);
 
        if (isReturnInParam)
            VuoCompilerCodeGenUtilities::copyParameterAttributes(makeFromJsonFunction, function);
    }
 
    if (function->isDeclaration())
    {
        BasicBlock *block = BasicBlock::Create(module->getContext(), "", function);
 
        Function::arg_iterator args = function->arg_begin();
        Value *result = NULL;
        if (isReturnInParam)
        {
            result = args++;
            result->setName("result");
        }
        Value *str = args++;
        str->setName("str");
 
        Function *jsonTokenerParseFunction = VuoCompilerCodeGenUtilities::getJsonTokenerParseFunction(module);
        Function *jsonObjectPutFunction = VuoCompilerCodeGenUtilities::getJsonObjectPutFunction(module);
 
        CallInst *jsonTokenerParseReturn = CallInst::Create(jsonTokenerParseFunction, str, "", block);
 
        vector<Value *> makeFromJsonArgs;
        if (isReturnInParam)
            makeFromJsonArgs.push_back(result);
        makeFromJsonArgs.push_back(jsonTokenerParseReturn);
        Value *makeFromJsonReturn = CallInst::Create(makeFromJsonFunction, makeFromJsonArgs, "", block);
 
        CallInst::Create(jsonObjectPutFunction, jsonTokenerParseReturn, "", block);
 
        Value *returnValue = (isReturnInParam ? NULL : makeFromJsonReturn);
        ReturnInst::Create(module->getContext(), returnValue, block);
    }
 
    makeFromStringFunction = function;
}
 
void VuoCompilerType::parseOrGenerateStringFromValueFunction(bool isInterprocess)
{
    string functionName = (getBase()->getModuleKey() + (isInterprocess ? "_getInterprocessString" : "_getString")).c_str();
    Function *function = parser->getFunction(functionName);
 
    Function *chosenJsonFromValueFunction = (isInterprocess ? getInterprocessJsonFunction : getJsonFunction);
 
    if (! function)
    {
        PointerType *pointerToCharType = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
        FunctionType *getJsonFunctionType = chosenJsonFromValueFunction->getFunctionType();
 
        Type *returnType = pointerToCharType;
 
        vector<Type *> functionParams;
        for (int i = 0; i < getJsonFunctionType->getNumParams(); ++i)
            functionParams.push_back(getJsonFunctionType->getParamType(i));
 
        FunctionType *functionType = FunctionType::get(returnType, functionParams, false);
        function = Function::Create(functionType, GlobalValue::ExternalLinkage, functionName, module);
 
        copyFunctionParameterAttributes(function);
    }
 
    if (function->isDeclaration())
    {
        BasicBlock *block = BasicBlock::Create(module->getContext(), "", function);
 
        int argIndex = 0;
        for (Function::arg_iterator args = function->arg_begin(); args != function->arg_end(); ++args, ++argIndex)
        {
            Value *value = args;
            ostringstream argName;
            argName << "value" << argIndex;
            value->setName(argName.str().c_str());
        }
 
        Function *jsonObjectToJsonStringExtFunction = VuoCompilerCodeGenUtilities::getJsonObjectToJsonStringExtFunction(module);
        Function *strdupFunction = VuoCompilerCodeGenUtilities::getStrdupFunction(module);
        Function *jsonObjectPutFunction = VuoCompilerCodeGenUtilities::getJsonObjectPutFunction(module);
 
        vector<Value *> getJsonArgs;
        for (Function::arg_iterator args = function->arg_begin(); args != function->arg_end(); ++args)
        {
            Value *value = args;
            getJsonArgs.push_back(value);
        }
        CallInst *getJsonReturn = CallInst::Create(chosenJsonFromValueFunction, getJsonArgs, "", block);
 
        vector<Value *> jsonObjectToJsonStringExtArgs;
        jsonObjectToJsonStringExtArgs.push_back(getJsonReturn);
        jsonObjectToJsonStringExtArgs.push_back(ConstantInt::get(module->getContext(), APInt(32, JSON_C_TO_STRING_PLAIN)));
        CallInst *jsonObjectToJsonStringExtReturn = CallInst::Create(jsonObjectToJsonStringExtFunction, jsonObjectToJsonStringExtArgs, "", block);
 
        CallInst *strdupReturn = CallInst::Create(strdupFunction, jsonObjectToJsonStringExtReturn, "", block);
 
        CallInst::Create(jsonObjectPutFunction, getJsonReturn, "", block);
 
        ReturnInst::Create(module->getContext(), strdupReturn, block);
    }
 
    if (isInterprocess)
        getInterprocessStringFunction = function;
    else
        getStringFunction = function;
}
 
void VuoCompilerType::parseOrGenerateRetainOrReleaseFunction(bool isRetain)
{
    string functionName = (getBase()->getModuleKey() + (isRetain ? "_retain" : "_release")).c_str();
    Function *function = parser->getFunction(functionName);
 
    if (! function)
    {
        vector<Type *> functionParams;
        functionParams.push_back(llvmArgumentType);
        if (llvmSecondArgumentType)
            functionParams.push_back(llvmSecondArgumentType);
 
        FunctionType *functionType = FunctionType::get(Type::getVoidTy(module->getContext()), functionParams, false);
        function = Function::Create(functionType, GlobalValue::ExternalLinkage, functionName, module);
 
        copyFunctionParameterAttributes(function);
    }
 
    if (function->isDeclaration())
    {
        BasicBlock *block = BasicBlock::Create(module->getContext(), "", function);
 
        Function::arg_iterator args = function->arg_begin();
        Value *arg = args++;
 
        if (!llvmSecondArgumentType)
        {
            if (isReturnPassedAsArgument && VuoCompilerCodeGenUtilities::isPointerToStruct(arg->getType()))
            {
                // The data type is a struct that is passed by reference (LLVM's `byval` attribute on x86_64).
                arg = new LoadInst(arg, "unloweredStruct", false, block);
            }
 
            VuoCompilerCodeGenUtilities::generateRetainOrReleaseCall(module, block, arg, isRetain);
        }
        else
        {
            if (llvmArgumentType->isPointerTy())
            {
                // The data type is a struct with pointer field(s), lowered to 2 arguments, the 1st of which is a pointer.
                VuoCompilerCodeGenUtilities::generateRetainOrReleaseCall(module, block, arg, isRetain);
            }
 
            if (llvmSecondArgumentType->isPointerTy())
            {
                // The data type is a struct with pointer field(s), lowered to 2 arguments, the 2nd of which is a pointer.
                Value *secondArg = args++;
                VuoCompilerCodeGenUtilities::generateRetainOrReleaseCall(module, block, secondArg, isRetain);
            }
        }
 
        ReturnInst::Create(module->getContext(), block);
    }
 
    if (isRetain)
        retainFunction = function;
    else
        releaseFunction = function;
}
 
Value * VuoCompilerType::generateValueFromStringFunctionCall(Module *module, BasicBlock *block, Value *arg)
{
    Function *function = declareFunctionInModule(module, makeFromStringFunction);
 
    if (isReturnPassedAsArgument)
    {
        vector<Value *> functionArgs;
        functionArgs.push_back(arg);
        Value *returnVariable = VuoCompilerCodeGenUtilities::callFunctionWithStructReturn(function, functionArgs, block);
        return new BitCastInst(returnVariable, llvmReturnType, "valueFromString", block);
    }
    else
    {
        Value *returnValue = CallInst::Create(function, arg, "valueFromString", block);
        return VuoCompilerCodeGenUtilities::generatePointerToValue(block, returnValue);
    }
}
 
Value * VuoCompilerType::generateStringFromValueFunctionCall(Module *module, BasicBlock *block, Value *arg)
{
    return generateFunctionCallWithTypeParameter(module, block, arg, getStringFunction);
}
 
Value * VuoCompilerType::generateInterprocessStringFromValueFunctionCall(Module *module, BasicBlock *block, Value *arg)
{
    if (getInterprocessStringFunction)
        return generateFunctionCallWithTypeParameter(module, block, arg, getInterprocessStringFunction);
    else
        return generateStringFromValueFunctionCall(module, block, arg);
}
 
Value * VuoCompilerType::generateSummaryFromValueFunctionCall(Module *module, BasicBlock *block, Value *arg)
{
    return generateFunctionCallWithTypeParameter(module, block, arg, getSummaryFunction);
}
 
void VuoCompilerType::generateRetainCall(Module *module, BasicBlock *block, Value *arg)
{
    if (isRetainOrReleaseNeeded())
        generateFunctionCallWithTypeParameter(module, block, arg, retainFunction);
}
 
void VuoCompilerType::generateReleaseCall(Module *module, BasicBlock *block, Value *arg)
{
    if (isRetainOrReleaseNeeded())
        generateFunctionCallWithTypeParameter(module, block, arg, releaseFunction);
}
 
vector<Value *> VuoCompilerType::convertPortDataToArgs(Module *module, BasicBlock *block, Value *arg, FunctionType *functionType, int parameterIndex,
                                                       bool isUnloweredStructPointerParameter)
{
    vector<Value *> args;
    if (!llvmSecondArgumentType)
    {
        Type *parameterType = functionType->getParamType(parameterIndex);
 
        if (!isReturnPassedAsArgument)
        {
            bool isLoweredAsUsual = true;
            if (parameterType->isPointerTy() && !llvmArgumentType->isPointerTy())
                isLoweredAsUsual = false;
 
            if (isLoweredAsUsual)
            {
                // The data type is either not lowered or lowered to 1 parameter.
                arg = new BitCastInst(arg, PointerType::getUnqual(parameterType), "dataPointerCasted", block);
                arg = new LoadInst(arg, "data", false, block);
            }
            else
            {
                // The data type is normally lowered to 1 parameter, but here is passed by reference ('byval').
                arg = new BitCastInst(arg, parameterType, "dataCasted", block);
            }
        }
        else
        {
            // The data type is a struct that is passed by reference (LLVM's `byval` attribute on x86_64).
            arg = new BitCastInst(arg, parameterType, "dataCasted", block);
        }
 
        args.push_back(arg);
    }
    else
    {
        if (! isUnloweredStructPointerParameter)
        {
            // The data type is lowered to 2 parameters.
            arg = new BitCastInst(arg, PointerType::getUnqual(llvmReturnType), "dataStructCasted", block);
            for (int i = 0; i < 2; ++i)
            {
                Value *currArg = VuoCompilerCodeGenUtilities::generateGetStructPointerElement(module, block, arg, i);
                if (currArg->getType()->isPointerTy())
                {
                    Type *parameterType = functionType->getParamType(parameterIndex + i);
                    currArg = new BitCastInst(currArg, parameterType, "dataCasted", block);
                }
                args.push_back(currArg);
            }
        }
        else
        {
            // The data type is normally lowered to 2 parameters, but here is a struct passed by reference (`byval`).
            Type *parameterType = functionType->getParamType(parameterIndex);
            arg = new BitCastInst(arg, parameterType, "dataCasted", block);
            args.push_back(arg);
        }
    }
 
    return args;
}
 
Value * VuoCompilerType::convertArgsToPortData(Module *module, BasicBlock *block, Function *function, int parameterIndex)
{
    vector<Value *> args;
    args.push_back( VuoCompilerCodeGenUtilities::getArgumentAtIndex(function, parameterIndex) );
    if (llvmSecondArgumentType)
        args.push_back( VuoCompilerCodeGenUtilities::getArgumentAtIndex(function, parameterIndex+1) );
 
    if (!llvmSecondArgumentType)
    {
        if (!isReturnPassedAsArgument)
        {
            Value *argPointer = VuoCompilerCodeGenUtilities::generatePointerToValue(block, args[0]);
            return new BitCastInst(argPointer, PointerType::getUnqual(llvmReturnType), "dataPointerCasted", block);
        }
        else
            return args[0];
    }
    else
    {
        size_t totalArgByteCount = 0;
        for (auto arg : args)
            totalArgByteCount += module->getDataLayout().getTypeStoreSize(arg->getType());
 
        size_t dataByteCount = getSize(module);
 
        Value *dataPointer = new AllocaInst(llvmReturnType, 0, "dataPointer", block);
        Value *dataPointerAsBytePointer = new BitCastInst(dataPointer, PointerType::getUnqual(IntegerType::get(module->getContext(), 8)), "dataBytePointer", block);
 
        size_t argByteOffset = 0;
        for (auto arg : args)
        {
            Value *argPointer        = VuoCompilerCodeGenUtilities::generatePointerToValue(block, arg);
            Value *offsetValue       = ConstantInt::get(module->getContext(), APInt(64, argByteOffset));
            Value *offsetDataPointer = GetElementPtrInst::Create(nullptr, dataPointerAsBytePointer, offsetValue, "", block);
            size_t argByteCount      = module->getDataLayout().getTypeStoreSize(arg->getType());
            size_t copyByteCount     = max(argByteCount, argByteCount - (dataByteCount - (argByteOffset + argByteCount)));
            VuoCompilerCodeGenUtilities::generateMemoryCopy(module, block, argPointer, offsetDataPointer, copyByteCount);
            argByteOffset += argByteCount;
        }
 
        return dataPointer;
    }
}
 
Value * VuoCompilerType::generateFunctionCallWithTypeParameter(Module *module, BasicBlock *block, Value *arg, Function *sourceFunction)
{
    Function *function = declareFunctionInModule(module, sourceFunction);
    vector<Value *> args = convertPortDataToArgs(module, block, arg, function->getFunctionType(), 0, false);
    return CallInst::Create(function, args, "", block);
}
 
size_t VuoCompilerType::getSize(Module *module)
{
    Type *type = llvmReturnType;
    if (isReturnPassedAsArgument)
        type = static_cast<PointerType *>(llvmReturnType)->getElementType();
 
    size_t size = module->getDataLayout().getTypeStoreSize(type);
    return size;
}
 
Value * VuoCompilerType::convertToPortData(BasicBlock *block, Value *voidPointer)
{
    Type *type = PointerType::getUnqual(llvmReturnType);
    if (isReturnPassedAsArgument)
        type = llvmReturnType;
 
    return new BitCastInst(voidPointer, type, "", block);
}
 
bool VuoCompilerType::isRetainOrReleaseNeeded()
{
    return llvmReturnType->isPointerTy() || llvmReturnType->isStructTy();
}
 
vector<Type *> VuoCompilerType::getFunctionParameterTypes(void)
{
    vector<Type *> types;
    types.push_back(llvmArgumentType);
    if (llvmSecondArgumentType)
        types.push_back(llvmSecondArgumentType);
    return types;
}
 
PointerType * VuoCompilerType::getFunctionParameterPointerType(void)
{
    return PointerType::getUnqual(llvmReturnType);
}
 
AttributeList VuoCompilerType::getFunctionAttributes(void)
{
    return getJsonFunction->getAttributes();
}
 
void VuoCompilerType::copyFunctionParameterAttributes(Function *dstFunction)
{
    VuoCompilerCodeGenUtilities::copyParameterAttributes(getJsonFunction, dstFunction);
}
 
void VuoCompilerType::copyFunctionParameterAttributes(Module *module, CallInst *dstCall)
{
    VuoCompilerCodeGenUtilities::copyParameterAttributes(module, getJsonFunction, dstCall);
}
 
bool VuoCompilerType::isListType(VuoCompilerType *type)
{
    if (! type)
        return false;
 
    return VuoType::isListTypeName(type->getBase()->getModuleKey());
}
 
bool VuoCompilerType::hasInterprocessStringFunction(void)
{
    return getInterprocessStringFunction != NULL;
}
 
bool VuoCompilerType::supportsComparison(void)
{
    return areEqualFunction != NULL && isLessThanFunction != NULL;
}